File pidgin-sipe-1.11.2-mob.patch of Package mingw64-pidgin-sipe

Overview Repositories Revisions Requests Users Attributes Meta

File pidgin-sipe-1.11.2-mob.patch of Package mingw64-pidgin-sipe (Revision 374c6ac20e08139a1c2d8f2088846a2d)

Currently displaying revision 374c6ac20e08139a1c2d8f2088846a2d , Show latest

--- pidgin-sipe-1.11.2/configure.ac	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/configure.ac	2011-06-14 14:40:36.000000000 +0200
@@ -83,29 +83,35 @@
 	[enable_quality_check=yes])
 
 AS_IF([test "x$enable_quality_check" = xyes],
-	[QUALITY_CFLAGS="$QUALITY_CFLAGS -Werror -Wall"
-	 ac_save_CFLAGS=$CFLAGS
-
-	 dnl GCC >= 3.4
-	 AC_MSG_CHECKING([if $CC supports -Wextra])
-	 CFLAGS="$QUALITY_CFLAGS -Wextra"
-	 AC_COMPILE_IFELSE(
-		AC_LANG_PROGRAM(),
-		[AC_MSG_RESULT(yes)
-		 QUALITY_CFLAGS="$QUALITY_CFLAGS -Wextra"],
-		[AC_MSG_RESULT(no)]
-	 )
+	[dnl default quality configuration
+ QUALITY_CFLAGS="$QUALITY_CFLAGS -Werror -Wall"
 
-	 dnl declaration-after-statement (ISO C90 behaviour, as on Windows & GCC < 3)
-	 AC_MSG_CHECKING([if $CC supports -Werror=declaration-after-statement])
-	 CFLAGS="$QUALITY_CFLAGS -Werror=declaration-after-statement"
+	 dnl enable warnings supported by the GCC on the build system
+	 for newflag in \
+			"-Wextra" \
+			"-Waggregate-return" \
+			"-Wcast-align" \
+			"-Wdeclaration-after-statement" \
+			"-Winit-self" \
+			"-Wmissing-declarations" \
+			"-Wmissing-prototypes" \
+			"-Wnested-externs" \
+			"-Wpointer-arith" \
+			"-Wundef" \
+			"-Wunused-but-set-variable" \
+	 ; do
+		 ac_save_CFLAGS=$CFLAGS
+		 AC_MSG_CHECKING([if $CC supports $newflag])
+		 CFLAGS="$QUALITY_CFLAGS $newflag"
 	 AC_COMPILE_IFELSE(
-		AC_LANG_PROGRAM(),
+			[AC_LANG_SOURCE([[]])],
 		[AC_MSG_RESULT(yes)
-		 QUALITY_CFLAGS="$QUALITY_CFLAGS -Werror=declaration-after-statement"],
+			 QUALITY_CFLAGS="$QUALITY_CFLAGS $newflag"],
 		[AC_MSG_RESULT(no)]
 	 )
-	 CFLAGS=$ac_save_CFLAGS])
+		 CFLAGS=$ac_save_CFLAGS
+	 done
+	])
 AC_SUBST(QUALITY_CFLAGS)
 
 dnl Check for pkg-config before using it
@@ -191,8 +197,8 @@
 CFLAGS="$GLIB_CFLAGS $QUALITY_CFLAGS"
 dnl note the [[[ quoting: our code contains []!
 AC_RUN_IFELSE(
-	AC_LANG_PROGRAM(
-		[[[
+	[AC_LANG_PROGRAM(
+		[[
 #include <glib.h>
 #include <stdio.h>
 
@@ -205,13 +211,13 @@
 guint8 clock_seq_low;
 guint8 node[6];
 } uuid_t;
-		]]],
-		[if (sizeof(uuid_t) == 16) {
+		]],
+		[[if (sizeof(uuid_t) == 16) {
 			return(0);
 		 } else {
 			printf("\n\nOoops, sizeof(uuid_t) is %" G_GSIZE_FORMAT ".\n\n", sizeof(uuid_t));
 			return(1);
-		 }]),
+		 }]])],
 	[AC_MSG_RESULT(yes)],
 	[AC_MSG_FAILURE([sizeof(uuid_t) is not 16
 
@@ -232,6 +238,16 @@
 	[AC_MSG_WARN([cross compiling: not checking])])
 CFLAGS=$ac_save_CFLAGS
 
+dnl build option: OCS2005 client hack
+AC_ARG_ENABLE([ocs2005-message-hack],
+	[AC_HELP_STRING([--enable-ocs2005-message-hack], [disable message timeout for OCS2005 clients
+							 which causes "false" not delivered error messages
+							 @<:@default=no@:>@])],
+	[AC_DEFINE([ENABLE_OCS2005_MESSAGE_HACK], [1],
+	 [Define to 1 to disable SIP MESSAGE timeout feature.
+		 OCS2005 clients don't seem to acknowledge MESSAGEs and
+		 disabling the timeout suppresses "false" error messages])])
+
 dnl build option: purple backend
 AC_ARG_ENABLE([purple],
 	[AC_HELP_STRING([--enable-purple], [build purple plugin @<:@default=yes@:>@])],
@@ -249,12 +265,12 @@
 		 ac_save_CFLAGS=$CFLAGS
 		 CFLAGS="$PURPLE_CFLAGS $QUALITY_CFLAGS"
 		 AC_COMPILE_IFELSE(
-			AC_LANG_PROGRAM([
+			[AC_LANG_PROGRAM([[
 #include <glib.h>
 #include <cipher.h>
 
 /* Compile some code that has caused trouble in the past */
-void testfunc(unsigned long len)
+static void testfunc(unsigned long len)
 {
 PurpleCipherContext *rc4 = NULL;
 guchar *plaintext = NULL;
@@ -265,8 +281,8 @@
 purple_cipher_context_encrypt(rc4, plaintext, plaintext_length,
 encrypted_text, &dummy);
 }
-					],
-					[testfunc(16);]),
+					]],
+					[[testfunc(16);]])],
 			[AC_MSG_RESULT(none)],
 			[AC_MSG_FAILURE([conflicts found.
 
@@ -286,17 +302,17 @@
 			 ac_save_LIBS=$LIBS
 			 LIBS="$PURPLE_LIBS"
 			 AC_RUN_IFELSE(
-				AC_LANG_PROGRAM([
+				[AC_LANG_PROGRAM([[
 #include <glib.h>
 #include <plugin.h>
 #include <sslconn.h>
-],
-						[
+						]],
+						[[
 	purple_plugins_init();
 	purple_plugins_probe(G_MODULE_SUFFIX);
 	purple_ssl_init();
 	return(purple_ssl_is_supported()?0:1);
-						]),
+						]])],
 				[AC_MSG_RESULT(ok)],
 				[AC_MSG_FAILURE([your purple hasn't been compiled with SSL support.
 ])
@@ -309,19 +325,19 @@
 		 [test "x$with_vv" = xcheck], dnl autodetect
 			 [AC_MSG_CHECKING(for purple voice and video support)
 			 AC_RUN_IFELSE(
-				AC_LANG_PROGRAM(
-					[[[
-#include <libpurple/media.h>
-					]]],
-					[return (purple_media_get_type() == G_TYPE_NONE ? 1 : 0);
-					 purple_media_get_active_local_candidates(NULL, NULL, NULL);
-					 purple_media_get_active_remote_candidates(NULL, NULL, NULL);]
-			 	),
+				[AC_LANG_PROGRAM([[
+#include <media.h>
+					]],
+					[[return (purple_media_get_type() == G_TYPE_NONE ? 1 : 0);]]
+			 	)],
 				[AC_MSG_RESULT(ok)
-				 PKG_CHECK_MODULES(NICE, [nice >= 0.0.14],
-					[PKG_CHECK_MODULES(PURPLE_MEDIA, [purple >= 2.7.0],
+				 PKG_CHECK_MODULES(NICE, [nice >= 0.1.0],
+					dnl sipe-media.c uses g_slist_free_full()
+					[PKG_CHECK_MODULES(_SIPE_MEDIA_RECHECK_PLEASE_IGNORE, [purple >= 2.8.0 glib-2.0 >= 2.28.0],
+						[PKG_CHECK_MODULES(GSTREAMER, [gstreamer-0.10],
 						[with_purple_vv=yes],
-						[AC_MSG_NOTICE(libpurple >= 2.7.0 required: disabling purple voice and video support)])],
+							[AC_MSG_NOTICE(GStreamer required: disabling purple voice and video support)])],
+						[AC_MSG_NOTICE(libpurple >= 2.8.0 glib2 >= 2.28.0 required: disabling purple voice and video support)])],
 					[AC_MSG_NOTICE(libnice required: disabling purple voice and video support)])],
 				[AC_MSG_RESULT(no - your purple hasn't been compiled with voice and video support.)],
 				[AC_MSG_WARN([cross compiling: not checking])])
--- pidgin-sipe-1.11.2/git-snapshot.sh	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/git-snapshot.sh	2011-06-14 14:40:36.000000000 +0200
@@ -10,6 +10,7 @@
 #
 # Configuration
 PROJECT=pidgin-sipe
+REPOSITORY="git+ssh://mob@repo.or.cz/srv/git/siplcs.git"
 BRANCH=mob
 
 # Create clone
@@ -21,8 +22,12 @@
 if [ -n "$1" ]; then
 echo "Using local repository under '$1'."
 fi
+if [ -n "$2" ]; then
+ REPOSITORY=$2
+fi
+echo "Cloning from repository URL '$REPOSITORY'."
 rm -rf $CLONEDIR
-git clone -n $REFERENCE git+ssh://mob@repo.or.cz/srv/git/siplcs.git $CLONEDIR
+git clone -n $REFERENCE $REPOSITORY $CLONEDIR
 cd $CLONEDIR
 git checkout -q -b $CLONEDIR origin/$BRANCH
 
--- pidgin-sipe-1.11.2/po/POTFILES.in	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/po/POTFILES.in	2011-06-14 14:40:36.000000000 +0200
@@ -9,8 +9,16 @@
 src/core/sipe-core.c
 src/core/sipe-domino.c
 src/core/sipe-ft.c
+src/core/sipe-ft-tftp.c
+src/core/sipe-group.c
+src/core/sipe-groupchat.c
+src/core/sipe-im.c
 src/core/sipe-incoming.c
 src/core/sipe-media.c
-src/purple/purple-ft.c
+src/core/sipe-user.c
+src/purple/purple-buddy.c
+src/purple/purple-chat.c
+src/purple/purple-groupchat.c
+src/purple/purple-im.c
 src/purple/purple-plugin.c
 src/purple/purple-transport.c
--- pidgin-sipe-1.11.2/po/transifex-pot-fixup.pl	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/po/transifex-pot-fixup.pl	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,72 @@
+#!/usr/bin/perl -w
+#
+# Fix up pidgin-sipe.pot after an update to make it acceptable for Transifex
+#
+# Transifex update procedure:
+#
+# $ cd po
+# $ intltool-update --pot -g pidgin-sipe # update POT file
+# $ ./transifex-pot-fixup.pl # this script
+# $ cd ..
+# $ tx push -s # update POT file on Transifex
+#
+# [optional: update the languages you know on Transifex]
+#
+# $ tx pull -s # fetch updated translations
+# $ git add -u po/*.po po/*.pot # add files to next commit
+# $ git commit -e
+#
+use 5.008;
+use strict;
+use warnings;
+
+open(my $fh, "+<", "pidgin-sipe.pot")
+ or die "$0: can't open POT file: $!\n";
+
+my $date;
+{
+ my(undef, $min, $hour, $mday, $mon, $year) = gmtime(time());
+ $date = sprintf("%4d-%02d-%02d %02d:%02d+0000",
+		 $year + 1900, $mon + 1, $mday, $hour, $min);
+}
+
+# Must be 19 lines (same as header created by intltool-update)
+my @lines = ( <<"END_OF_HEADER"
+# (English) English User Interface strings for pidgin-sipe.
+# Copyright (C) 2008-2011 SIPE Project <http://sipe.sourceforge.net/>
+# This file is distributed under the same license as the pidgin-sipe package.
+# 
+# 
+# 
+msgid ""
+msgstr ""
+"Project-Id-Version: pidgin sipe\\n"
+"Report-Msgid-Bugs-To: http://sourceforge.net/tracker/?group_id=194563&atid=949931\\n"
+"POT-Creation-Date: 2010-11-30 23:36+0200\\n"
+"PO-Revision-Date: $date\\n"
+"Last-Translator: stefanb <chemobejk\@gmail.com>\\n"
+"Language-Team: English <LL\@li.org>\\n"
+"MIME-Version: 1.0\\n"
+"Content-Type: text/plain; charset=UTF-8\\n"
+"Content-Transfer-Encoding: 8bit\\n"
+"Language: en\\n"
+"Plural-Forms: nplurals=2; plural=(n != 1)\\n"
+END_OF_HEADER
+	 );
+
+while (<$fh>) {
+ # skip header
+ next if $. < 20;
+
+ push(@lines, $_);
+}
+
+# Update pot file
+seek($fh, 0, 0)
+ or die "$0: can't rewind POT file: $!\n";
+print $fh @lines;
+close($fh)
+ or die "$0: can't write to POT file: $!\n";
+
+# That's all folks
+exit 0;
--- pidgin-sipe-1.11.2/src/api/core-depurple.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/api/core-depurple.h	2011-06-14 14:40:36.000000000 +0200
@@ -28,11 +28,8 @@
 void sipe_search_contact_with_cb(PurpleConnection *gc,
 				 PurpleRequestFields *fields);
 GList *sipe_buddy_menu(PurpleBuddy *buddy);
-GList *sipe_chat_menu(PurpleChat *chat);
 void sipe_purple_setup(struct sipe_core_public *sipe_public,
 		 PurpleConnection *gc);
-int sipe_im_send(PurpleConnection *gc, const char *who, const char *what,
-		 PurpleMessageFlags flags);
 void sipe_get_info(PurpleConnection *gc, const char *username);
 void sipe_set_status(PurpleAccount *account, PurpleStatus *status);
 void sipe_set_idle(PurpleConnection *gc, int interval);
@@ -40,9 +37,6 @@
 		 PurpleGroup *group);
 void sipe_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy,
 		 PurpleGroup *group);
-void sipe_chat_leave(PurpleConnection *gc, int id);
-int sipe_chat_send(PurpleConnection *gc, int id, const char *what,
-		 PurpleMessageFlags flags);
 void sipe_group_buddy(PurpleConnection *gc, const char *who,
 		 const char *old_group_name,
 		 const char *new_group_name);
@@ -54,5 +48,6 @@
 /* Convenience macros */
 #define PURPLE_ACCOUNT_TO_SIPE_CORE_PRIVATE ((struct sipe_core_private *)account->gc->proto_data)
 #define PURPLE_BUDDY_TO_SIPE_CORE_PRIVATE ((struct sipe_core_private *)buddy->account->gc->proto_data)
-#define PURPLE_CHAT_TO_SIPE_CORE_PRIVATE ((struct sipe_core_private *)chat->account->gc->proto_data)
 #define PURPLE_GC_TO_SIPE_CORE_PRIVATE ((struct sipe_core_private *)gc->proto_data)
+#define PURPLE_GC_TO_SIPE_CORE_PUBLIC ((struct sipe_core_public *) gc->proto_data)
+
--- pidgin-sipe-1.11.2/src/api/sipe-backend.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/api/sipe-backend.h	2011-06-14 14:40:36.000000000 +0200
@@ -42,7 +42,8 @@
 #endif
 
 /* Forward declarations */
-struct sipe_backend_session;
+struct sipe_backend_chat_session;
+struct sipe_chat_session;
 struct sipe_core_public;
 struct sipe_transport_connection;
 struct sipe_file_transfer;
@@ -108,30 +109,52 @@
 
 /** CHAT *********************************************************************/
 
-//void sipe_backend_chat_(struct sipe_backend_session *backend_session, );
-void sipe_backend_chat_add(struct sipe_backend_session *backend_session,
+void sipe_backend_chat_session_destroy(struct sipe_backend_chat_session *session);
+void sipe_backend_chat_add(struct sipe_backend_chat_session *backend_session,
 			 const gchar *uri,
 			 gboolean is_new);
-void sipe_backend_chat_close(struct sipe_backend_session *backend_session);
-struct sipe_backend_session *sipe_backend_chat_create(struct sipe_core_public *sipe_public,
-						 int id,
+void sipe_backend_chat_close(struct sipe_backend_chat_session *backend_session);
+
+/**
+ * Joined a new chat
+ */
+struct sipe_backend_chat_session *sipe_backend_chat_create(struct sipe_core_public *sipe_public,
+							 struct sipe_chat_session *session,
 						 const gchar *title,
-						 const gchar *nick,
-						 gboolean rejoin);
-gboolean sipe_backend_chat_find(struct sipe_backend_session *backend_session,
+							 const gchar *nick);
+gboolean sipe_backend_chat_find(struct sipe_backend_chat_session *backend_session,
 				const gchar *uri);
-gboolean sipe_backend_chat_is_operator(struct sipe_backend_session *backend_session,
+gboolean sipe_backend_chat_is_operator(struct sipe_backend_chat_session *backend_session,
 				 const gchar *uri);
 void sipe_backend_chat_message(struct sipe_core_public *sipe_public,
-			 int id,
+			 struct sipe_backend_chat_session *backend_session,
 			 const gchar *from,
 			 const gchar *html);
-void sipe_backend_chat_operator(struct sipe_backend_session *backend_session,
+void sipe_backend_chat_operator(struct sipe_backend_chat_session *backend_session,
 				const gchar *uri);
+
+/**
+ * Rejoin an existing chat window after connection re-establishment
+ */
+void sipe_backend_chat_rejoin(struct sipe_core_public *sipe_public,
+			 struct sipe_backend_chat_session *backend_session,
+			 const gchar *nick,
+			 const gchar *title);
+
+/**
+ * Core has completed connection re-establishment.
+ * Should call sipe_core_chat_rejoin() for existing chats.
+ */
 void sipe_backend_chat_rejoin_all(struct sipe_core_public *sipe_public);
-void sipe_backend_chat_remove(struct sipe_backend_session *backend_session,
+void sipe_backend_chat_remove(struct sipe_backend_chat_session *backend_session,
 			 const gchar *uri);
-void sipe_backend_chat_topic(struct sipe_backend_session *backend_session,
+
+/**
+ * Move chat window to the front. Will be called when
+ * a user tries to join an already joined chat again.
+ */
+void sipe_backend_chat_show(struct sipe_backend_chat_session *backend_session);
+void sipe_backend_chat_topic(struct sipe_backend_chat_session *backend_session,
 			 const gchar *topic);
 
 /** CONNECTION ***************************************************************/
@@ -155,12 +178,25 @@
 
 /** DNS QUERY ****************************************************************/
 
-void sipe_backend_dns_query(struct sipe_core_public *sipe_public,
-			 const gchar *protocol,
+typedef void (*sipe_dns_resolved_cb)(gpointer data, const gchar *hostname, guint port);
+
+struct sipe_dns_query *sipe_backend_dns_query_srv(const gchar *protocol,
 			 const gchar *transport,
-			 const gchar *domain);
+						 const gchar *domain,
+						 sipe_dns_resolved_cb callback,
+						 gpointer data);
+
+struct sipe_dns_query *sipe_backend_dns_query_a(const gchar *hostname,
+						int port,
+						sipe_dns_resolved_cb callback,
+						gpointer data);
+
+void sipe_backend_dns_query_cancel(struct sipe_dns_query *query);
 
 /** FILE TRANSFER ************************************************************/
+
+struct sipe_backend_fd;
+
 void sipe_backend_ft_error(struct sipe_file_transfer *ft,
 			 const gchar *errmsg);
 const gchar *sipe_backend_ft_get_error(struct sipe_file_transfer *ft);
@@ -169,7 +205,7 @@
 /**
 * Try to read up to @c size bytes from file transfer connection
 *
- * @param backend_ft backend private file transfer data.
+ * @param ft file transfer data.
 * @param data buffer to read data into.
 * @param size buffer size in bytes.
 *
@@ -183,7 +219,7 @@
 /**
 * Try to write up to @c size bytes to file transfer connection
 *
- * @param backend_ft backend private file transfer data.
+ * @param ft file transfer data.
 * @param data data to write
 * @param size buffer size in bytes.
 *
@@ -203,16 +239,65 @@
 			 const gchar *who,
 			 const gchar *file_name,
 			 gsize file_size);
-gboolean sipe_backend_ft_incoming_accept(struct sipe_file_transfer *ft,
-					 const gchar *ip,
-					 unsigned short port_min,
-					 unsigned short port_max);
+/**
+ * Begins file transfer with remote peer.
+ *
+ * You can provide either opened file descriptor to use for read/write operations
+ * or ip address and port where the backend should connect.
+ *
+ * @param ft file transfer data
+ * @param fd opaque file descriptor pointer or NULL if ip and port are used
+ * @param ip ip address to connect of NULL when file descriptor is used
+ * @param port port to connect or 0 when file descriptor is used
+ */
+void sipe_backend_ft_start(struct sipe_file_transfer *ft,
+			 struct sipe_backend_fd *fd,
+			 const char* ip, unsigned port);
+
+/**
+ * Check whether file transfer is incoming or outgoing
+ *
+ * @param ft file transfer data
+ * @return @c TRUE if @c ft is incoming, otherwise @c FALSE
+ */
+gboolean sipe_backend_ft_is_incoming(struct sipe_file_transfer *ft);
+
+/** GROUP CHAT ***************************************************************/
+
+#define SIPE_GROUPCHAT_ROOM_FILEPOST 0x00000001
+#define SIPE_GROUPCHAT_ROOM_INVITE 0x00000002
+#define SIPE_GROUPCHAT_ROOM_LOGGED 0x00000004
+#define SIPE_GROUPCHAT_ROOM_PRIVATE 0x00000008
+
+/**
+ * Add a room found through room query
+ *
+ * @param uri room URI
+ * @param name human readable name for room
+ * @param description room description
+ * @param users number of users in the room
+ * @param flags SIPE_GROUPCHAT_ROOM_* flags
+ */
+void sipe_backend_groupchat_room_add(struct sipe_core_public *sipe_public,
+				 const gchar *uri,
+				 const gchar *name,
+				 const gchar *description,
+				 guint users,
+				 guint32 flags);
+
+/**
+ * Terminate room query
+ */
+void sipe_backend_groupchat_room_terminate(struct sipe_core_public *sipe_public);
 
 /** IM ***********************************************************************/
 
 void sipe_backend_im_message(struct sipe_core_public *sipe_public,
 			 const gchar *from,
 			 const gchar *html);
+void sipe_backend_im_topic(struct sipe_core_public *sipe_public,
+			 const gchar *with,
+			 const gchar *topic);
 
 /** MARKUP *******************************************************************/
 
@@ -223,6 +308,13 @@
 /** MEDIA ********************************************************************/
 
 typedef enum {
+	SIPE_ICE_NO_ICE,
+	SIPE_ICE_DRAFT_6,
+	SIPE_ICE_RFC_5245
+} SipeIceVersion;
+
+typedef enum {
+	SIPE_CANDIDATE_TYPE_ANY,
 	SIPE_CANDIDATE_TYPE_HOST,
 	SIPE_CANDIDATE_TYPE_RELAY,
 	SIPE_CANDIDATE_TYPE_SRFLX,
@@ -250,18 +342,27 @@
 struct sipe_backend_codec;
 struct sipe_backend_candidate;
 struct sipe_backend_stream;
+struct sipe_backend_media_relays;
 
 struct sipe_media_call {
 	struct sipe_backend_media *backend_private;
 
 	void (*candidates_prepared_cb)(struct sipe_media_call *,
 				 struct sipe_backend_stream *);
-	void (*media_connected_cb)();
+	void (*media_end_cb)(struct sipe_media_call *);
 	void (*call_accept_cb)(struct sipe_media_call *, gboolean local);
 	void (*call_reject_cb)(struct sipe_media_call *, gboolean local);
 	void (*call_hold_cb) (struct sipe_media_call *, gboolean local,
 			 gboolean state);
 	void (*call_hangup_cb)(struct sipe_media_call *, gboolean local);
+	void (*error_cb)(struct sipe_media_call *, gchar *message);
+};
+
+struct sipe_media_relay {
+	gchar		 *hostname;
+	guint		 udp_port;
+	guint		 tcp_port;
+	struct sipe_dns_query *dns_query;
 };
 
 /* Media handling */
@@ -270,11 +371,21 @@
 						 const gchar *participant,
 						 gboolean initiator);
 void sipe_backend_media_free(struct sipe_backend_media *media);
+
+void sipe_backend_media_set_cname(struct sipe_backend_media *media, gchar *cname);
+
+struct sipe_backend_media_relays * sipe_backend_media_relays_convert(GSList *media_relays,
+								 gchar *username,
+								 gchar *password);
+void sipe_backend_media_relays_free(struct sipe_backend_media_relays *media_relays);
+
 struct sipe_backend_stream *sipe_backend_media_add_stream(struct sipe_backend_media *media,
 							 const gchar *id,
 							 const gchar *participant,
-							 SipeMediaType type, gboolean use_nice,
-							 gboolean initiator);
+							 SipeMediaType type,
+							 SipeIceVersion ice_version,
+							 gboolean initiator,
+							 struct sipe_backend_media_relays *media_relays);
 void sipe_backend_media_remove_stream(struct sipe_backend_media *media,
 				 struct sipe_backend_stream *stream);
 GSList *sipe_backend_media_get_streams(struct sipe_backend_media *media);
@@ -286,6 +397,7 @@
 gboolean sipe_backend_media_is_initiator(struct sipe_backend_media *media,
 					 struct sipe_backend_stream *stream);
 gboolean sipe_backend_media_accepted(struct sipe_backend_media *media);
+gboolean sipe_backend_candidates_prepared(struct sipe_backend_media *media);
 GList *sipe_backend_media_get_active_local_candidates(struct sipe_backend_media *media,
 						 struct sipe_backend_stream *stream);
 GList *sipe_backend_media_get_active_remote_candidates(struct sipe_backend_media *media,
@@ -320,7 +432,7 @@
 gboolean sipe_backend_set_remote_codecs(struct sipe_backend_media *media,
 					struct sipe_backend_stream *stream,
 					GList *codecs);
-GList* sipe_backend_get_local_codecs(struct sipe_media_call *call,
+GList* sipe_backend_get_local_codecs(struct sipe_backend_media *media,
 				 struct sipe_backend_stream *stream);
 
 /* Candidate handling */
@@ -328,7 +440,9 @@
 							 SipeComponentType component,
 							 SipeCandidateType type,
 							 SipeNetworkProtocol proto,
-							 const gchar *ip, guint port);
+							 const gchar *ip, guint port,
+							 const gchar *username,
+							 const gchar *password);
 void sipe_backend_candidate_free(struct sipe_backend_candidate *candidate);
 /**
 * @return user name. Will be g_free'd() by the core.
@@ -357,9 +471,6 @@
 SipeComponentType sipe_backend_candidate_get_component_type(struct sipe_backend_candidate *candidate);
 SipeCandidateType sipe_backend_candidate_get_type(struct sipe_backend_candidate *candidate);
 SipeNetworkProtocol sipe_backend_candidate_get_protocol(struct sipe_backend_candidate *candidate);
-void sipe_backend_candidate_set_username_and_pwd(struct sipe_backend_candidate *candidate,
-						 const gchar *username,
-						 const gchar *password);
 GList* sipe_backend_get_local_candidates(struct sipe_backend_media *media,
 					 struct sipe_backend_stream *stream);
 void sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local);
@@ -370,6 +481,34 @@
 
 const gchar *sipe_backend_network_ip_address(void);
 
+struct sipe_backend_listendata;
+
+typedef void (*sipe_listen_start_cb)(unsigned short port, gpointer data);
+typedef void (*sipe_client_connected_cb)(struct sipe_backend_fd *fd, gpointer data);
+
+struct sipe_backend_listendata *
+sipe_backend_network_listen_range(unsigned short port_min,
+				 unsigned short port_max,
+				 sipe_listen_start_cb listen_cb,
+				 sipe_client_connected_cb connect_cb,
+				 gpointer data);
+void sipe_backend_network_listen_cancel(struct sipe_backend_listendata *ldata);
+
+gboolean sipe_backend_fd_is_valid(struct sipe_backend_fd *fd);
+void sipe_backend_fd_free(struct sipe_backend_fd *fd);
+
+/** NOTIFICATIONS *************************************************************/
+
+void sipe_backend_notify_message_error(struct sipe_core_public *sipe_public,
+				 struct sipe_backend_chat_session *backend_session,
+				 const gchar *who,
+				 const gchar *message);
+void sipe_backend_notify_message_info(struct sipe_core_public *sipe_public,
+				 struct sipe_backend_chat_session *backend_session,
+				 const gchar *who,
+				 const gchar *message);
+void sipe_backend_notify_error(const gchar *title, const gchar *msg);
+
 /** SCHEDULE *****************************************************************/
 
 gpointer sipe_backend_schedule_seconds(struct sipe_core_public *sipe_public,
@@ -387,6 +526,7 @@
 SIPE_SETTING_EMAIL_URL = 0,
 SIPE_SETTING_EMAIL_LOGIN,
 SIPE_SETTING_EMAIL_PASSWORD,
+ SIPE_SETTING_GROUPCHAT_USER,
 SIPE_SETTING_USER_AGENT,
 SIPE_SETTING_LAST
 } sipe_setting;
@@ -423,10 +563,247 @@
 void sipe_backend_user_feedback_typing_stop(struct sipe_core_public *sipe_public,
 					 const gchar *from);
 
-/** NOTIFICATIONS *************************************************************/
+/**
+ * Present a query that is to be accepted or declined by the user
+ *
+ * @param sipe_public The handle representing the protocol instance
+ * @param message Text of the query to be shown to user
+ * @param accept_label Label to be displayed on UI control that accepts query
+ * @param decline_label Label to be displayed on UI control that declines query
+ * @param key Opaque handle uniquely identifying the query. Backend
+ * should store it for the case SIPE core requests the
+ * query to be closed prematurely.
+ */
+void sipe_backend_user_ask(struct sipe_core_public *sipe_public,
+			 const gchar *message,
+			 const gchar *accept_label,
+			 const gchar *decline_label,
+			 gpointer key);
 
-void sipe_backend_notify_error(const gchar *title, const gchar *msg);
+/**
+ * Closes the pending user query
+ *
+ * @param key Opaque handle uniquely identifying the query.
+ */
+void sipe_backend_user_close_ask(gpointer key);
+
+/** BUDDIES ******************************************************************/
+
+/* The list of properties a buddy can have */
+typedef enum
+{
+	SIPE_BUDDY_INFO_DISPLAY_NAME,
+	SIPE_BUDDY_INFO_JOB_TITLE,
+	SIPE_BUDDY_INFO_CITY,
+	SIPE_BUDDY_INFO_STATE,
+	SIPE_BUDDY_INFO_OFFICE,
+	SIPE_BUDDY_INFO_DEPARTMENT,
+	SIPE_BUDDY_INFO_COUNTRY,
+	SIPE_BUDDY_INFO_WORK_PHONE,
+	SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY,
+	SIPE_BUDDY_INFO_COMPANY,
+	SIPE_BUDDY_INFO_EMAIL,
+	SIPE_BUDDY_INFO_DEVICE,
+	SIPE_BUDDY_INFO_SITE,
+	SIPE_BUDDY_INFO_ZIPCODE,
+	SIPE_BUDDY_INFO_STREET,
+	SIPE_BUDDY_INFO_MOBILE_PHONE,
+	SIPE_BUDDY_INFO_MOBILE_PHONE_DISPLAY,
+	SIPE_BUDDY_INFO_HOME_PHONE,
+	SIPE_BUDDY_INFO_HOME_PHONE_DISPLAY,
+	SIPE_BUDDY_INFO_OTHER_PHONE,
+	SIPE_BUDDY_INFO_OTHER_PHONE_DISPLAY,
+	SIPE_BUDDY_INFO_CUSTOM1_PHONE,
+	SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY,
+} sipe_buddy_info_fields;
+
+/* Opaque token */
+typedef void* sipe_backend_buddy;
+
+/**
+ * Find a buddy in the given group of the buddy list, or anywhere on the
+ * list if @group_name is empty
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param buddy_name The name of the buddy
+ * @param group_name The name of the group to look in, or NULL for any group
+ * @return opaque handle to the buddy, or NULL if no buddy found
+ */
+sipe_backend_buddy sipe_backend_buddy_find(struct sipe_core_public *sipe_public,
+					 const gchar *buddy_name,
+					 const gchar *group_name);
+
+/*
+ * Find all named buddies in the given group of the buddy list, or anywhere on the
+ * list if @group_name is empty; or all buddies if @name is empty
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param name The name of the buddy
+ * @param group_name The name of the group to look in, or NULL for any group
+ * @return GSList of opaque handles to the buddies
+ */
+GSList* sipe_backend_buddy_find_all(struct sipe_core_public *sipe_public,
+				 const gchar *buddy_name,
+				 const gchar *group_name);
+
+/**
+ * Gets the name of a contact.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param who The opaque handle to the contact as found by find_buddy
+ * @return The name. Must be freed.
+ */
+gchar* sipe_backend_buddy_get_name(struct sipe_core_public *sipe_public,
+				 const sipe_backend_buddy who);
+
+/**
+ * Gets the alias for a contact.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param who The opaque handle to the contact as found by find_buddy
+ * @return The alias. Must be gfree'd.
+ */
+gchar* sipe_backend_buddy_get_alias(struct sipe_core_public *sipe_public,
+				 const sipe_backend_buddy who);
+
+/**
+ * Gets the server alias for a contact.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param who The opaque handle to the contact as found by find_buddy
+ * @return The alias. Must be freed.
+ */
+gchar* sipe_backend_buddy_get_server_alias(struct sipe_core_public *sipe_public,
+					 const sipe_backend_buddy who);
+
+/**
+ * Gets the name of the group a contact belongs to.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param who The opaque handle to the contact as found by find_buddy
+ * @return The name. Must be freed.
+ */
+gchar* sipe_backend_buddy_get_group_name(struct sipe_core_public *sipe_public,
+					 const sipe_backend_buddy who);
+
+/**
+ * Called to retrieve a buddy-specific setting.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param buddy The handle representing the buddy
+ * @param key The name of the setting
+ * @return The value of the setting. Must be freed.
+ */
+gchar* sipe_backend_buddy_get_string(struct sipe_core_public *sipe_public,
+				 sipe_backend_buddy buddy,
+				 const sipe_buddy_info_fields key);
+
+/**
+ * Called to retrieve a buddy-specific setting.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param buddy The handle representing the buddy
+ * @param key The name of the setting
+ * @param val The value to set
+ */
+void sipe_backend_buddy_set_string(struct sipe_core_public *sipe_public,
+				 sipe_backend_buddy buddy,
+				 const sipe_buddy_info_fields key,
+				 const gchar *val);
+
+/**
+ * Sets the alias for a contact.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param who The opaque handle to the contact as found by find_buddy
+ * @param alias The location where the alias will be put
+ * case. FALSE if the buddy was not found. The value of alias will not be changed.
+ */
+void sipe_backend_buddy_set_alias(struct sipe_core_public *sipe_public,
+				 const sipe_backend_buddy who,
+				 const gchar *alias);
+
+/*
+ * Sets the server alias for a contact.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param who The opaque handle to the contact as found by find_buddy
+ * @param alias The server alias of the contact
+ */
+void sipe_backend_buddy_set_server_alias(struct sipe_core_public *sipe_public,
+					 const sipe_backend_buddy who,
+					 const gchar *alias);
+
+/*
+ * Add a contact to the buddy list
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param name The name of the contact
+ * @param alias The alias of the contact
+ * @param groupname The name of the group to add this contact to
+ * @return A handle to the newly created buddy
+ */
+sipe_backend_buddy sipe_backend_buddy_add(struct sipe_core_public *sipe_public,
+					 const gchar *name,
+					 const gchar *alias,
+					 const gchar *groupname);
+
+/*
+ * Remove a contact from the buddy list
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param who The opaque handle to the contact as found by find_buddy
+ */
+void sipe_backend_buddy_remove(struct sipe_core_public *sipe_public,
+			 const sipe_backend_buddy who);
+
+/*
+ * Notifies the user that a remote user has wants to add the local user to his
+ * or her buddy list and requires authorization to do so. 
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param who The name of the user that added this account
+ * @param alias The optional alias of the remote user
+ * @param on_list True if the user is already in our list
+ * @param auth_cb The callback called when the local user accepts 
+ * @param deny_cb The callback called when the local user rejects 
+ * @param data Data to be passed back to the above callbacks
+ */
+typedef void (*sipe_backend_buddy_request_authorization_cb)(void *);
+
+void sipe_backend_buddy_request_add(struct sipe_core_public *sipe_public,
+				 const gchar *who,
+				 const gchar *alias);
+
+void sipe_backend_buddy_request_authorization(struct sipe_core_public *sipe_public,
+					 const gchar *who,
+					 const gchar *alias,
+					 gboolean on_list,
+					 sipe_backend_buddy_request_authorization_cb auth_cb,
+					 sipe_backend_buddy_request_authorization_cb deny_cb,
+					 gpointer data);
+
+gboolean sipe_backend_buddy_is_blocked(struct sipe_core_public *sipe_public,
+				 const gchar *who);
+
+void sipe_backend_buddy_set_blocked_status(struct sipe_core_public *sipe_public,
+					 const gchar *who,
+					 gboolean blocked);
 
+void sipe_backend_buddy_set_status(struct sipe_core_public *sipe_public,
+				 const gchar *who,
+				 const gchar *status_id);
+
+/*
+ * Called when a new internal group is about to be added. If this returns FALSE,
+ * the group will not be added.
+ *
+ * @param sipe_public The handle representing the protocol instance making the call
+ * @param group The group being added
+ * @return TRUE if everything is ok, FALSE if the group should not be added
+ */
+gboolean sipe_backend_buddy_group_add(struct sipe_core_public *sipe_public,
+				 const gchar *group_name);
 
 #ifdef __cplusplus
 }
--- pidgin-sipe-1.11.2/src/api/sipe-common.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/api/sipe-common.h	2011-06-14 14:40:36.000000000 +0200
@@ -41,3 +41,8 @@
 #		define G_GNUC_NULL_TERMINATED
 #	endif
 #endif
+
+#ifdef _MSC_VER
+typedef long ssize_t;
+#endif
+
--- pidgin-sipe-1.11.2/src/api/sipe-core.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/api/sipe-core.h	2011-06-14 14:40:36.000000000 +0200
@@ -93,6 +93,11 @@
 };
 
 /**
+ * Opaque data type for chat session
+ */
+struct sipe_chat_session;
+
+/**
 * File transport (public part)
 */
 struct sipe_file_transfer {
@@ -163,6 +168,8 @@
 void
 sipe_utils_nameval_free(GSList *list);
 
+gboolean sipe_utils_is_avconf_uri(const gchar *uri);
+
 /*****************************************************************************/
 
 /**
@@ -195,6 +202,10 @@
 			 const sipe_activity activity,
 			 const gchar *status_text);
 
+void sipe_core_buddy_got_status(struct sipe_core_public *sipe_public,
+				const gchar* uri,
+				const gchar *status_id);
+
 /**
 * Return a list with buddy information label/text pairs
 *
@@ -241,55 +252,132 @@
 void sipe_core_transport_sip_keepalive(struct sipe_core_public *sipe_public);
 
 /**
- * DNS SRV resolved hook
- *
- * @param sipe_public
- * @param hostname SIP server hostname
- * @param port SIP server port
+ * Invite to chat
 */
-void sipe_core_dns_resolved(struct sipe_core_public *sipe_public,
-			 const gchar *hostname,
-			 guint port);
-void sipe_core_dns_resolve_failure(struct sipe_core_public *sipe_public);
+void sipe_core_chat_invite(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session,
+			 const char *name);
 
 /**
- * Create a new chat
+ * Rejoin a chat after connection re-establishment
 */
-void sipe_core_chat_create(struct sipe_core_public *sipe_public, int id,
-			 const char *name);
+void sipe_core_chat_rejoin(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session);
+
+/**
+ * Leave a chat
+ */
+void sipe_core_chat_leave(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session);
+
+/**
+ * Send message to chat
+ */
+void sipe_core_chat_send(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session,
+			 const char *what);
+
+/**
+ * Check chat lock status
+ */
+typedef enum {
+	SIPE_CHAT_LOCK_STATUS_NOT_ALLOWED = 0,
+	SIPE_CHAT_LOCK_STATUS_UNLOCKED,
+	SIPE_CHAT_LOCK_STATUS_LOCKED
+} sipe_chat_lock_status;
+sipe_chat_lock_status sipe_core_chat_lock_status(struct sipe_core_public *sipe_public,
+						 struct sipe_chat_session *chat_session);
+
+/**
+ * Lock chat
+ */
+void sipe_core_chat_modify_lock(struct sipe_core_public *sipe_public,
+				struct sipe_chat_session *chat_session,
+				const gboolean locked);
+
+/**
+ * Create new session with Focus URI
+ *
+ * @param sipe_public (in) SIPE core data.
+ * @param focus_uri (in) focus URI string
+ *
+ * @return new SIP session
+ */
+struct sip_session *
+sipe_core_conf_create(struct sipe_core_public *sipe_public,
+		 const gchar *focus_uri);
 
 /* media */
 void sipe_core_media_initiate_call(struct sipe_core_public *sipe_public,
 				 const char *participant,
 				 gboolean with_video);
+/**
+ * Connects to a conference call specified by given chat session
+ *
+ * @param sipe_public (in) SIPE core data.
+ * @param chat_session (in) chat session structure
+ */
+void sipe_core_media_connect_conference(struct sipe_core_public *sipe_public,
+					struct sipe_chat_session *chat_session);
+
+/**
+ * Checks whether there is a media call in progress
+ *
+ * @param sipe_public (in) SIPE core data.
+ *
+ * @return @c TRUE if media call is in progress
+ */
+gboolean sipe_core_media_in_call(struct sipe_core_public *sipe_public);
 
 /* file transfer */
 struct sipe_file_transfer *sipe_core_ft_allocate(struct sipe_core_public *sipe_public);
 void sipe_core_ft_deallocate(struct sipe_file_transfer *ft);
 void sipe_core_ft_cancel(struct sipe_file_transfer *ft);
 void sipe_core_ft_incoming_init(struct sipe_file_transfer *ft);
-void sipe_core_ft_incoming_accept(struct sipe_file_transfer *ft,
-				 const gchar *who,
-				 int fd,
-				 unsigned short port);
-void sipe_core_ft_incoming_start(struct sipe_file_transfer *ft,
-				 gsize total_size);
-gboolean sipe_core_ft_incoming_stop(struct sipe_file_transfer *ft);
 void sipe_core_ft_outgoing_init(struct sipe_file_transfer *ft,
 				const gchar *filename, gsize size,
 				const gchar *who);
-void sipe_core_ft_outgoing_start(struct sipe_file_transfer *ft,
+
+void sipe_core_tftp_incoming_start(struct sipe_file_transfer *ft,
 				 gsize total_size);
-gboolean sipe_core_ft_outgoing_stop(struct sipe_file_transfer *ft);
-gssize sipe_core_ft_read(struct sipe_file_transfer *ft, guchar **buffer,
+gboolean sipe_core_tftp_incoming_stop(struct sipe_file_transfer *ft);
+void sipe_core_tftp_outgoing_start(struct sipe_file_transfer *ft,
+				 gsize total_size);
+gboolean sipe_core_tftp_outgoing_stop(struct sipe_file_transfer *ft);
+gssize sipe_core_tftp_read(struct sipe_file_transfer *ft, guchar **buffer,
 			 gsize bytes_remaining, gsize bytes_available);
-gssize sipe_core_ft_write(struct sipe_file_transfer *ft,
-			 const guchar *buffer, gsize size);
+gssize sipe_core_tftp_write(struct sipe_file_transfer *ft, const guchar *buffer,
+			 gsize size);
+/* group chat */
+gboolean sipe_core_groupchat_query_rooms(struct sipe_core_public *sipe_public);
+void sipe_core_groupchat_join(struct sipe_core_public *sipe_public,
+			 const gchar *uri);
+
+/* IM */
+void sipe_core_im_send(struct sipe_core_public *sipe_public,
+		 const gchar *who,
+		 const gchar *what);
 
 /* user */
 void sipe_core_user_feedback_typing(struct sipe_core_public *sipe_public,
 				 const gchar *to);
 
+void sipe_core_user_ask_cb(gpointer key, gboolean accepted);
+
+/* groups */
+void sipe_core_group_rename(struct sipe_core_public *sipe_public,
+			 const gchar *old_name,
+			 const gchar *new_name);
+
+void sipe_core_group_remove(struct sipe_core_public *sipe_public,
+			 const gchar *name);
+
+/* buddies */
+void sipe_core_buddy_group(struct sipe_core_public *sipe_public,
+			 const gchar *who,
+			 const gchar *old_group_name,
+			 const gchar *new_group_name);
+
 #ifdef __cplusplus
 }
 #endif
--- pidgin-sipe-1.11.2/src/core/http-conn.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/http-conn.c	2011-06-14 14:40:36.000000000 +0200
@@ -481,17 +481,17 @@
 			if (http_conn->callback) {
 				(*http_conn->callback)(HTTP_CONN_ERROR_FATAL, NULL, NULL, http_conn, http_conn->data);
 			}
-			SIPE_DEBUG_INFO("http_conn_process_input_message: Only %s supported in the moment, exiting",
 #ifdef _WIN32
 #ifdef HAVE_LIBKRB5
-				"NTLM and Negotiate authentications are"
+#define AUTHSTRING				"NTLM and Negotiate authentications are"
 #else /* !HAVE_LIBKRB5 */
-				"NTLM authentication is"
+#define AUTHSTRING				"NTLM authentication is"
 #endif /* HAVE_LIBKRB5 */
 #else /* !_WIN32 */
-				"NTLM authentication is"
+#define AUTHSTRING				"NTLM authentication is"
 #endif /* _WIN32 */
-
+			SIPE_DEBUG_INFO("http_conn_process_input_message: Only %s supported in the moment, exiting",
+					AUTHSTRING
 			);
 			http_conn_set_close(http_conn);
 			return;
@@ -596,6 +596,91 @@
 		cur[0] = '\0';
 		msg = sipmsg_parse_header(conn->buffer);
 
+		/* HTTP/1.1 Transfer-Encoding: chunked */
+		if (msg && (msg->bodylen == SIPMSG_BODYLEN_CHUNKED)) {
+			gchar *start = cur + 2;
+			GSList *chunks = NULL;
+			gboolean incomplete = TRUE;
+
+			msg->bodylen = 0;
+			while (strlen(start) > 0) {
+				gchar *tmp;
+				guint length = strtol(start, &tmp, 16);
+				struct _chunk {
+					guint length;
+					const gchar *start;
+				} *chunk;
+
+				/* Illegal number */
+				if ((length == 0) && (start == tmp))
+					break;
+				msg->bodylen += length;
+
+				/* Chunk header not finished yet */
+				tmp = strstr(tmp, "\r\n");
+				if (tmp == NULL)
+					break;
+
+				/* Chunk not finished yet */
+				tmp += 2;
+				remainder = conn->buffer_used - (tmp - conn->buffer);
+				if (remainder < length + 2)
+					break;
+
+				/* Next chunk */
+				start = tmp + length + 2;
+
+				/* Body completed */
+				if (length == 0) {
+					gchar *dummy = g_malloc(msg->bodylen + 1);
+					gchar *p = dummy;
+					GSList *entry = chunks;
+
+					while (entry) {
+						chunk = entry->data;
+						memcpy(p, chunk->start, chunk->length);
+						p += chunk->length;
+						entry = entry->next;
+					}
+					p[0] = '\0';
+
+					msg->body = dummy;
+					sipe_utils_message_debug("HTTP",
+								 conn->buffer,
+								 msg->body,
+								 FALSE);
+
+					cur = start;
+					sipe_utils_shrink_buffer(conn, cur);
+
+					incomplete = FALSE;
+					break;
+				}
+
+				/* Append completed chunk */
+				chunk = g_new0(struct _chunk, 1);
+				chunk->length = length;
+				chunk->start = tmp;
+				chunks = g_slist_append(chunks, chunk);
+			}
+
+			if (chunks) {
+				GSList *entry = chunks;
+				while (entry) {
+					g_free(entry->data);
+					entry = entry->next;
+				}
+				g_slist_free(chunks);
+			}
+
+			if (incomplete) {
+				/* restore header for next try */
+				sipmsg_free(msg);
+				cur[0] = '\r';
+				return;
+			}
+
+		} else {
 		cur += 2;
 		remainder = conn->buffer_used - (cur - conn->buffer);
 		if (msg && remainder >= (guint) msg->bodylen) {
@@ -619,6 +704,7 @@
 			cur[-2] = '\r';
 			return;
 		}
+		}
 
 		/* important to set before callback call */
 		if (sipe_strcase_equal(sipmsg_find_header(msg, "Connection"), "close")) {
--- pidgin-sipe-1.11.2/src/core/Makefile.am	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/Makefile.am	2011-06-14 14:40:36.000000000 +0200
@@ -44,6 +44,13 @@
 	sipe-ews.c \
 	sipe-ft.h \
 	sipe-ft.c \
+	sipe-ft-tftp.c \
+	sipe-group.h \
+	sipe-group.c \
+	sipe-groupchat.h \
+	sipe-groupchat.c \
+	sipe-im.h \
+	sipe-im.c \
 	sipe-incoming.h \
 	sipe-incoming.c \
 	sipe-schedule.h \
@@ -55,6 +62,7 @@
 	sipe-subscriptions.h \
 	sipe-subscriptions.c \
 	sipe-user.c \
+	sipe-user.h \
 	sipe-xml.h \
 	sipe-xml.c \
 	uuid.h \
--- pidgin-sipe-1.11.2/src/core/sdpmsg.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sdpmsg.c	2011-06-14 14:40:36.000000000 +0200
@@@ -22,6 +22,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <glib.h>
 
@@ -62,9 +63,7 @@
 
 			smsg->media = g_slist_append(smsg->media, media);
 
-			media->name = parts[0];
-			parts[0] = NULL;
-
+			media->name = g_strdup(parts[0]);
 			media->port = atoi(parts[1]);
 
 			g_strfreev(parts);
@@ -91,38 +90,78 @@
 
 static void sdpcandidate_free(struct sdpcandidate *candidate);
 
-static GSList *
-parse_candidates(GSList *attrs)
+static SipeComponentType
+parse_component(const gchar *str)
 {
-	GSList *candidates = NULL;
-	const gchar *attr;
-	int i = 0;
+	switch (atoi(str)) {
+		case 1: return SIPE_COMPONENT_RTP;
+		case 2: return SIPE_COMPONENT_RTCP;
+		default: return SIPE_COMPONENT_NONE;
+	}
+}
 
-	while ((attr = sipe_utils_nameval_find_instance(attrs, "candidate", i++))) {
+static gchar *
+base64_pad(const gchar* str)
+{
+	size_t str_len = strlen(str);
+	int mod = str_len % 4;
+
+	if (mod > 0) {
+		gchar *result = NULL;
+		int pad = 4 - mod;
+		gchar *ptr = result = g_malloc(str_len + pad + 1);
+
+		memcpy(ptr, str, str_len);
+		ptr += str_len;
+		memset(ptr, '=', pad);
+		ptr += pad;
+		*ptr = '\0';
+
+		return result;
+	} else
+		return g_strdup(str);
+}
+
+static struct sdpcandidate *
+parse_candidate_draft_6(gchar **tokens)
+{
 		struct sdpcandidate *candidate = g_new0(struct sdpcandidate, 1);
-		gchar **tokens = g_strsplit_set(attr, " ", 0);
 
-		candidate->foundation = g_strdup(tokens[0]);
+	candidate->username = base64_pad(tokens[0]);
+	candidate->component = parse_component(tokens[1]);
+	candidate->password = base64_pad(tokens[2]);
 
-		switch (atoi(tokens[1])) {
-			case 1:
-				candidate->component = SIPE_COMPONENT_RTP;
-				break;
-			case 2:
-				candidate->component = SIPE_COMPONENT_RTCP;
-				break;
-			default:
-				candidate->component = SIPE_COMPONENT_NONE;
+	if (sipe_strequal(tokens[3], "UDP"))
+		candidate->protocol = SIPE_NETWORK_PROTOCOL_UDP;
+	else {
+		// Ignore TCP candidates, at least for now...
+		// Also, if this is ICEv6 candidate list, candidates are dropped here
+		sdpcandidate_free(candidate);
+		return NULL;
+	}
+
+	candidate->priority = atoi(tokens[4] + 2);
+	candidate->ip = g_strdup(tokens[5]);
+	candidate->port = atoi(tokens[6]);
+
+	return candidate;
 		}
 
+static struct sdpcandidate *
+parse_candidate_rfc_5245(gchar **tokens)
+{
+	struct sdpcandidate *candidate = g_new0(struct sdpcandidate, 1);
+
+	candidate->foundation = g_strdup(tokens[0]);
+	candidate->component = parse_component(tokens[1]);
+
 		if (sipe_strequal(tokens[2], "UDP"))
 			candidate->protocol = SIPE_NETWORK_PROTOCOL_UDP;
 		else {
 			// Ignore TCP candidates, at least for now...
 			// Also, if this is ICEv6 candidate list, candidates are dropped here
-			g_strfreev(tokens);
 			sdpcandidate_free(candidate);
-			continue;
+		return NULL;
 		}
 
 		candidate->priority = atoi(tokens[3]);
@@ -138,16 +177,58 @@
 		else if (sipe_strequal(tokens[7], "prflx"))
 			candidate->type = SIPE_CANDIDATE_TYPE_PRFLX;
 		else {
-			g_strfreev(tokens);
 			sdpcandidate_free(candidate);
-			continue;
+		return NULL;
 		}
 
-		candidates = g_slist_append(candidates, candidate);
+	return candidate;
+}
+
+static GSList *
+parse_candidates(GSList *attrs, SipeIceVersion *ice_version)
+{
+	GSList *candidates = NULL;
+	const gchar *attr;
+	int i = 0;
+
+	while ((attr = sipe_utils_nameval_find_instance(attrs, "candidate", i++))) {
+		gchar **tokens = g_strsplit_set(attr, " ", 0);
+
+		if (sipe_strequal(tokens[6], "typ")) {
+			struct sdpcandidate *c = parse_candidate_rfc_5245(tokens);
+
+			if (c) {
+				*ice_version = SIPE_ICE_RFC_5245;
+				candidates = g_slist_append(candidates, c);
+			}
+		} else {
+			struct sdpcandidate *c = parse_candidate_draft_6(tokens);
+			if (c) {
+				*ice_version = SIPE_ICE_DRAFT_6;
+				candidates = g_slist_append(candidates, c);
+			}
+		}
 
 		g_strfreev(tokens);
 	}
 
+	if (!candidates)
+		*ice_version = SIPE_ICE_NO_ICE;
+
+	if (*ice_version == SIPE_ICE_RFC_5245) {
+		const gchar *username = sipe_utils_nameval_find(attrs, "ice-ufrag");
+		const gchar *password = sipe_utils_nameval_find(attrs, "ice-pwd");
+
+		if (username && password) {
+			GSList *i;
+			for (i = candidates; i; i = i->next) {
+				struct sdpcandidate *c = i->data;
+				c->username = g_strdup(username);
+				c->password = g_strdup(password);
+			}
+		}
+	}
+
 	return candidates;
 }
 
@@ -232,8 +313,6 @@
 	struct sdpmsg *smsg = g_new0(struct sdpmsg, 1);
 	GSList *i;
 
-	smsg->legacy = FALSE;
-
 	if (!parse_attributes(smsg, msg)) {
 		sdpmsg_free(smsg);
 		return NULL;
@@ -243,11 +322,12 @@
 		struct sdpmedia *media = i->data;
 		SipeMediaType type;
 
-		media->candidates = parse_candidates(media->attributes);
+		media->candidates = parse_candidates(media->attributes,
+						 &smsg->ice_version);
+
 		if (!media->candidates && media->port != 0) {
-			// No a=candidate in SDP message, this seems to be pre-OC2007 R2 UAC
+			// No a=candidate in SDP message, this seems to be MSOC 2005
 			media->candidates = create_legacy_candidates(smsg->ip, media->port);
-			smsg->legacy = TRUE;
 		}
 
 		if (sipe_strequal(media->name, "audio"))
@@ -255,7 +335,9 @@
 		else if (sipe_strequal(media->name, "video"))
 			type = SIPE_MEDIA_VIDEO;
 		else {
-			// TODO unknown media type
+			// Unknown media type
+			sdpmsg_free(smsg);
+			return NULL;
 		}
 
 		media->codecs = parse_codecs(media->attributes, type);
@@ -309,12 +391,45 @@
 }
 
 static gchar *
-candidates_to_string(GSList *candidates)
+base64_unpad(const gchar *str)
+{
+	gchar *result = g_strdup(str);
+	gchar *ptr;
+
+	for (ptr = result + strlen(result); ptr != result; --ptr) {
+		if (*(ptr - 1) != '=') {
+			*ptr = '\0';
+			break;
+		}
+	}
+
+	return result;
+}
+
+static gint
+candidate_sort_cb(struct sdpcandidate *c1, struct sdpcandidate *c2)
+{
+	int cmp = sipe_strcompare(c1->foundation, c2->foundation);
+	if (cmp == 0) {
+		cmp = sipe_strcompare(c1->username, c2->username);
+		if (cmp == 0)
+			cmp = c1->component - c2->component;
+	}
+
+	return cmp;
+}
+
+static gchar *
+candidates_to_string(GSList *candidates, SipeIceVersion ice_version)
 {
 	GString *result = g_string_new("");
+	GSList *i;
 
-	for (; candidates; candidates = candidates->next) {
-		struct sdpcandidate *c = candidates->data;
+	candidates = g_slist_copy(candidates);
+	candidates = g_slist_sort(candidates, (GCompareFunc)candidate_sort_cb);
+
+	for (i = candidates; i; i = i->next) {
+		struct sdpcandidate *c = i->data;
 		const gchar *protocol;
 		const gchar *type;
 		gchar *related = NULL;
@@ -326,14 +441,23 @@
 			case SIPE_NETWORK_PROTOCOL_UDP:
 				protocol = "UDP";
 				break;
+			default:
+				/* error unknown/unsupported type */
+				protocol = "UNKOWN";
+				break;
 		}
 
+		if (ice_version == SIPE_ICE_RFC_5245) {
+
 		switch (c->type) {
 			case SIPE_CANDIDATE_TYPE_HOST:
 				type = "host";
 				break;
 			case SIPE_CANDIDATE_TYPE_RELAY:
 				type = "relay";
+					related = g_strdup_printf("raddr %s rport %d ",
+								 c->ip,
+								 c->port);
 				break;
 			case SIPE_CANDIDATE_TYPE_SRFLX:
 				type = "srflx";
@@ -345,7 +469,8 @@
 				type = "prflx";
 				break;
 			default:
-				// TODO: error unknown/unsupported type
+					/* error unknown/unsupported type */
+					type = "unknown";
 				break;
 		}
 
@@ -359,30 +484,42 @@
 				 c->port,
 				 type,
 				 related ? related : "");
-
 		g_free(related);
-	}
 
-	return g_string_free(result, FALSE);
+		} else if (ice_version == SIPE_ICE_DRAFT_6) {
+			gchar *username = base64_unpad(c->username);
+			gchar *password = base64_unpad(c->password);
+
+			g_string_append_printf(result,
+					 "a=candidate:%s %u %s %s 0.%u %s %d\r\n",
+					 username,
+					 c->component,
+					 password,
+					 protocol,
+					 c->priority,
+					 c->ip,
+					 c->port);
+
+			g_free(username);
+			g_free(password);
+		}
 }
 
-static gint
-candidate_compare_by_component_id(struct sdpcandidate *c1,
-				 struct sdpcandidate *c2)
-{
-	return c1->component - c2->component;
+	g_slist_free(candidates);
+
+	return g_string_free(result, FALSE);
 }
 
 static gchar *
-remote_candidates_to_string(GSList *candidates)
+remote_candidates_to_string(GSList *candidates, SipeIceVersion ice_version)
 {
 	GString *result = g_string_new("");
 
 	candidates = g_slist_copy(candidates);
-	candidates = g_slist_sort(candidates,
-				 (GCompareFunc)candidate_compare_by_component_id);
+	candidates = g_slist_sort(candidates, (GCompareFunc)candidate_sort_cb);
 
 	if (candidates) {
+		if (ice_version == SIPE_ICE_RFC_5245) {
 		GSList *i;
 		g_string_append(result, "a=remote-candidates:");
 
@@ -393,6 +530,11 @@
 		}
 
 		g_string_append(result, "\r\n");
+		} else if (ice_version == SIPE_ICE_DRAFT_6) {
+			struct sdpcandidate *c = candidates->data;
+			g_string_append_printf(result, "a=remote-candidate:%s\r\n",
+					 c->username);
+		}
 	}
 
 	g_slist_free(candidates);
@@ -416,36 +558,59 @@
 	return g_string_free(result, FALSE);
 }
 
-gchar *
-media_to_string(const struct sdpmedia *media, gboolean legacy)
+static gchar *
+media_to_string(const struct sdpmedia *media, SipeIceVersion ice_version)
 {
 	gchar *media_str;
 
-	gchar *codecs_str = codecs_to_string(media->codecs);
+	gchar *codecs_str = NULL;
 	gchar *codec_ids_str = codec_ids_to_string(media->codecs);
 
-	gchar *candidates_str = legacy ? g_strdup("")
-				 : candidates_to_string(media->candidates);
-	gchar *remote_candidates_str = remote_candidates_to_string(media->remote_candidates);
+	gchar *candidates_str = NULL;
+	gchar *remote_candidates_str = NULL;
+
+	gchar *attributes_str = NULL;
+	gchar *credentials = NULL;
+
+	if (media->port != 0) {
+		codecs_str = codecs_to_string(media->codecs);
+		candidates_str = candidates_to_string(media->candidates, ice_version);
+		remote_candidates_str = remote_candidates_to_string(media->remote_candidates,
+								 ice_version);
 
-	gchar *attributes_str = attributes_to_string(media->attributes);
+		attributes_str = attributes_to_string(media->attributes);
+		credentials = NULL;
+
+
+		if (ice_version == SIPE_ICE_RFC_5245 && media->candidates) {
+			struct sdpcandidate *c = media->candidates->data;
+
+			credentials = g_strdup_printf("a=ice-ufrag:%s\r\n"
+						 "a=ice-pwd:%s\r\n",
+						 c->username,
+						 c->password);
+		}
+	}
 
 	media_str = g_strdup_printf("m=%s %d RTP/AVP%s\r\n"
 				 "%s"
 				 "%s"
 				 "%s"
+				 "%s"
 				 "%s",
 				 media->name, media->port, codec_ids_str,
-				 candidates_str,
-				 remote_candidates_str,
-				 codecs_str,
-				 attributes_str);
+				 candidates_str ? candidates_str : "",
+				 remote_candidates_str ? remote_candidates_str : "",
+				 codecs_str ? codecs_str : "",
+				 attributes_str ? attributes_str : "",
+				 credentials ? credentials : "");
 
 	g_free(codecs_str);
 	g_free(codec_ids_str);
 	g_free(candidates_str);
 	g_free(remote_candidates_str);
 	g_free(attributes_str);
+	g_free(credentials);
 
 	return media_str;
 }
@@ -468,7 +633,7 @@
 
 
 	for (i = msg->media; i; i = i->next) {
-		gchar *media_str = media_to_string(i->data, msg->legacy);
+		gchar *media_str = media_to_string(i->data, msg->ice_version);
 		g_string_append(body, media_str);
 		g_free(media_str);
 	}
@@ -483,6 +648,8 @@
 		g_free(candidate->foundation);
 		g_free(candidate->ip);
 		g_free(candidate->base_ip);
+		g_free(candidate->username);
+		g_free(candidate->password);
 		g_free(candidate);
 	}
 }
@@ -497,13 +664,14 @@
 	}
 }
 
-static void
+void
 sdpmedia_free(struct sdpmedia *media)
 {
 	if (media) {
 		GSList *item;
 
 		g_free(media->name);
+		g_free(media->ip);
 
 		sipe_utils_nameval_free(media->attributes);
 
--- pidgin-sipe-1.11.2/src/core/sdpmsg.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sdpmsg.h	2011-06-14 14:40:36.000000000 +0200
@@ -23,19 +23,18 @@
 struct sdpmsg {
 	gchar		*ip;
 	GSList		*media;
-	gboolean	 legacy;
+	SipeIceVersion	 ice_version;
 };
 
 struct sdpmedia {
 	gchar		*name;
+	gchar		*ip;
 	guint		 port;
 
 	GSList		*attributes;
 	GSList		*candidates;
 	GSList		*codecs;
 	GSList		*remote_candidates;
-
-	gboolean	 legacy;
 };
 
 struct sdpcandidate {
@@ -48,6 +47,8 @@
 	guint			 port;
 	gchar			*base_ip;
 	guint			 base_port;
+	gchar			*username;
+	gchar			*password;
 };
 
 struct sdpcodec {
@@ -80,3 +81,8 @@
 * Deallocates @c sdpmsg.
 */
 void sdpmsg_free(struct sdpmsg *msg);
+
+/**
+ * Deallocates @c sdpmedia.
+ */
+void sdpmedia_free(struct sdpmedia *media);
--- pidgin-sipe-1.11.2/src/core/sipe-buddy.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-buddy.c	2011-06-14 14:40:36.000000000 +0200
@@ -20,11 +20,16 @@
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+#include <time.h>
+
 #include <glib.h>
 
+#include "sipe-backend.h"
 #include "sipe-buddy.h"
 #include "sipe-core.h"
 #include "sipe-core-private.h"
+#include "sipe-group.h"
+#include "sipe-utils.h"
 
 gchar *sipe_core_buddy_status(struct sipe_core_public *sipe_public,
 			 const gchar *name,
@@ -54,6 +59,51 @@
 	}
 }
 
+gchar *sipe_buddy_get_alias(struct sipe_core_private *sipe_private,
+			 const gchar *with)
+{
+	sipe_backend_buddy pbuddy;
+	gchar *alias = NULL;
+	if ((pbuddy = sipe_backend_buddy_find(SIPE_CORE_PUBLIC, with, NULL))) {
+		alias = sipe_backend_buddy_get_alias(SIPE_CORE_PUBLIC, pbuddy);
+	}
+	return alias;
+}
+
+void sipe_core_buddy_group(struct sipe_core_public *sipe_public,
+			 const gchar *who,
+			 const gchar *old_group_name,
+			 const gchar *new_group_name)
+{
+	struct sipe_buddy * buddy = g_hash_table_lookup(SIPE_CORE_PRIVATE->buddies, who);
+	struct sipe_group * old_group = NULL;
+	struct sipe_group * new_group;
+
+	SIPE_DEBUG_INFO("sipe_group_buddy[CB]: who:%s old_group_name:%s new_group_name:%s",
+			who ? who : "", old_group_name ? old_group_name : "", new_group_name ? new_group_name : "");
+
+	if(!buddy) { // buddy not in roaming list
+		return;
+	}
+
+	if (old_group_name) {
+		old_group = sipe_group_find_by_name(SIPE_CORE_PRIVATE, old_group_name);
+	}
+	new_group = sipe_group_find_by_name(SIPE_CORE_PRIVATE, new_group_name);
+
+	if (old_group) {
+		buddy->groups = g_slist_remove(buddy->groups, old_group);
+		SIPE_DEBUG_INFO("buddy %s removed from old group %s", who, old_group_name);
+	}
+
+	if (!new_group) {
+		sipe_group_create(SIPE_CORE_PRIVATE, new_group_name, who);
+	} else {
+		buddy->groups = slist_insert_unique_sorted(buddy->groups, new_group, (GCompareFunc)sipe_group_compare);
+		sipe_core_group_set_user(sipe_public, who);
+	}
+}
+
 /*
 Local Variables:
 mode: c
--- pidgin-sipe-1.11.2/src/core/sipe-buddy.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-buddy.h	2011-06-14 14:40:36.000000000 +0200
@@ -21,6 +21,7 @@
 */
 
 /* Forward declarations */
+struct sipe_core_private;
 struct sipe_cal_working_hours;
 
 struct sipe_buddy {
@@ -56,3 +57,16 @@
 	 /** flag to control sending 'context' element in 2007 subscriptions */
 	gboolean just_added;
 };
+
+/**
+ * Tries to retrieve a real user's name associated with given SIP URI.
+ *
+ * Result must be g_free'd after use.
+ *
+ * @param sipe_private SIPE core data
+ * @param with a SIP URI
+ *
+ * @return Name of the user if the URI is found in buddy list, otherwise @c NULL
+ */
+gchar *sipe_buddy_get_alias(struct sipe_core_private *sipe_private,
+			 const gchar *with);
--- pidgin-sipe-1.11.2/src/core/sipe.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe.c	2011-06-14 14:40:36.000000000 +0200
@@ -46,6 +46,8 @@
 
 #include <glib.h>
 
+#include <libintl.h>
+
 #include "sipe-common.h"
 
 #include "account.h"
@@ -72,10 +74,12 @@
 #include "sipe-conf.h"
 #include "sipe-core.h"
 #include "sipe-core-private.h"
+#include "sipe-group.h"
 #include "sipe-dialog.h"
 #include "sipe-ews.h"
 #include "sipe-domino.h"
-#include "sipe-ft.h"
+#include "sipe-groupchat.h"
+#include "sipe-im.h"
 #include "sipe-mime.h"
 #include "sipe-nls.h"
 #include "sipe-schedule.h"
@@ -178,7 +182,7 @@
 /**
 * @param from0	from URI (with 'sip:' prefix). Will be filled with self-URI if NULL passed.
 */
-static void
+void
 send_soap_request_with_cb(struct sipe_core_private *sipe_private,
 			 gchar *from0,
 			 gchar *body,
@@ -202,7 +206,8 @@
 	g_free(hdr);
 }
 
-static void send_soap_request(struct sipe_core_private *sipe_private,
+void
+send_soap_request(struct sipe_core_private *sipe_private,
 			 gchar *body)
 {
 	send_soap_request_with_cb(sipe_private, NULL, body, NULL, NULL);
@@ -291,7 +296,6 @@
 sipe_process_presence_wpending (struct sipe_core_private *sipe_private,
 				struct sipmsg * msg)
 {
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
 	sipe_xml *watchers;
 	const sipe_xml *watcher;
 	// Ensure it's either not a response (eg it's a BENOTIFY) or that it's a 200 OK response
@@ -312,16 +316,13 @@
 			struct sipe_auth_job * job = g_new0(struct sipe_auth_job, 1);
 			job->who = remote_user;
 			job->sipe_private = sipe_private;
-			purple_account_request_authorization(
-				sip->account,
+			sipe_backend_buddy_request_authorization(SIPE_CORE_PUBLIC,
 				remote_user,
-				_("you"), /* id */
 				alias,
-				NULL, /* message */
 				on_list,
 				sipe_auth_user_cb,
 				sipe_deny_user_cb,
-				(void *) job);
+								 (gpointer)job);
 		}
 	}
 
@@ -330,100 +331,6 @@
 	return;
 }
 
-static void
-sipe_group_add(struct sipe_core_private *sipe_private,
-	 struct sipe_group * group)
-{
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	PurpleGroup * purple_group = purple_find_group(group->name);
-	if (!purple_group) {
-		purple_group = purple_group_new(group->name);
-		purple_blist_add_group(purple_group, NULL);
-	}
-
-	if (purple_group) {
-		group->purple_group = purple_group;
-		sip->groups = g_slist_append(sip->groups, group);
-		SIPE_DEBUG_INFO("added group %s (id %d)", group->name, group->id);
-	} else {
-		SIPE_DEBUG_INFO("did not add group %s", group->name ? group->name : "");
-	}
-}
-
-static struct sipe_group *sipe_group_find_by_id(struct sipe_core_private *sipe_private,
-						int id)
-{
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	struct sipe_group *group;
-	GSList *entry;
-	if (sip == NULL) {
-		return NULL;
-	}
-
-	entry = sip->groups;
-	while (entry) {
-		group = entry->data;
-		if (group->id == id) {
-			return group;
-		}
-		entry = entry->next;
-	}
-	return NULL;
-}
-
-static struct sipe_group *sipe_group_find_by_name(struct sipe_core_private *sipe_private,
-						 const gchar * name)
-{
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	struct sipe_group *group;
-	GSList *entry;
-	if (!sip || !name) {
-		return NULL;
-	}
-
-	entry = sip->groups;
-	while (entry) {
-		group = entry->data;
-		if (sipe_strequal(group->name, name)) {
-			return group;
-		}
-		entry = entry->next;
-	}
-	return NULL;
-}
-
-static void
-sipe_group_rename(struct sipe_core_private *sipe_private,
-		 struct sipe_group *group,
-		 gchar *name)
-{
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	gchar *body;
-	SIPE_DEBUG_INFO("Renaming group %s to %s", group->name, name);
-	body = g_markup_printf_escaped(SIPE_SOAP_MOD_GROUP, group->id, name, sip->contacts_delta++);
-	send_soap_request(sipe_private, body);
-	g_free(body);
-	g_free(group->name);
-	group->name = g_strdup(name);
-}
-
-/**
- * Only appends if no such value already stored.
- * Like Set in Java.
- */
-GSList * slist_insert_unique_sorted(GSList *list, gpointer data, GCompareFunc func) {
-	GSList * res = list;
-	if (!g_slist_find_custom(list, data, func)) {
-		res = g_slist_insert_sorted(list, data, func);
-	}
-	return res;
-}
-
-static int
-sipe_group_compare(struct sipe_group *group1, struct sipe_group *group2) {
-	return group1->id - group2->id;
-}
-
 /**
 * Returns string like "2 4 7 8" - group ids buddy belong to.
 */
@@ -457,10 +364,10 @@
 {
 	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA;
 	struct sipe_buddy *buddy = g_hash_table_lookup(SIPE_CORE_PRIVATE->buddies, who);
-	PurpleBuddy *purple_buddy = purple_find_buddy (sip->account, who);
+	sipe_backend_buddy backend_buddy = sipe_backend_buddy_find(sipe_public, who, NULL);
 
-	if (buddy && purple_buddy) {
-		const char *alias = purple_buddy_get_alias(purple_buddy);
+	if (buddy && backend_buddy) {
+		gchar *alias = sipe_backend_buddy_get_alias(sipe_public, backend_buddy);
 		gchar *groups = sipe_get_buddy_groups_string(buddy);
 		if (groups) {
 			gchar *body;
@@ -473,86 +380,10 @@
 			g_free(groups);
 			g_free(body);
 		}
+		g_free(alias);
 	}
 }
 
-static gboolean process_add_group_response(struct sipe_core_private *sipe_private,
-					 struct sipmsg *msg,
-					 struct transaction *trans)
-{
-	if (msg->response == 200) {
-		struct sipe_group *group;
-		struct group_user_context *ctx = trans->payload->data;
-		sipe_xml *xml;
-		const sipe_xml *node;
-		char *group_id;
-		struct sipe_buddy *buddy;
-
-		xml = sipe_xml_parse(msg->body, msg->bodylen);
-		if (!xml) {
-			return FALSE;
-		}
-
-		node = sipe_xml_child(xml, "Body/addGroup/groupID");
-		if (!node) {
-			sipe_xml_free(xml);
-			return FALSE;
-		}
-
-		group_id = sipe_xml_data(node);
-		if (!group_id) {
-			sipe_xml_free(xml);
-			return FALSE;
-		}
-
-		group = g_new0(struct sipe_group, 1);
-		group->id = (int)g_ascii_strtod(group_id, NULL);
-		g_free(group_id);
-		group->name = g_strdup(ctx->group_name);
-
-		sipe_group_add(sipe_private, group);
-
-		if (ctx->user_name) {
-			buddy = g_hash_table_lookup(sipe_private->buddies, ctx->user_name);
-			if (buddy) {
-				buddy->groups = slist_insert_unique_sorted(buddy->groups, group, (GCompareFunc)sipe_group_compare);
-			}
-
-			sipe_core_group_set_user(SIPE_CORE_PUBLIC, ctx->user_name);
-		}
-
-		sipe_xml_free(xml);
-		return TRUE;
-	}
-	return FALSE;
-}
-
-static void sipe_group_context_destroy(gpointer data)
-{
-	struct group_user_context *ctx = data;
-	g_free(ctx->group_name);
-	g_free(ctx->user_name);
-	g_free(ctx);
-}
-
-static void sipe_group_create (struct sipe_core_private *sipe_private,
-			 const gchar *name, const gchar * who)
-{
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;	
-	struct transaction_payload *payload = g_new0(struct transaction_payload, 1);
-	struct group_user_context *ctx = g_new0(struct group_user_context, 1);
-	const gchar *soap_name = sipe_strequal(name, _("Other Contacts")) ? "~" : name;
-	gchar *body;
-	ctx->group_name = g_strdup(name);
-	ctx->user_name = g_strdup(who);
-	payload->destroy = sipe_group_context_destroy;
-	payload->data = ctx;
-
-	body = g_markup_printf_escaped(SIPE_SOAP_ADD_GROUP, soap_name, sip->contacts_delta++);
-	send_soap_request_with_cb(sipe_private, NULL, body, process_add_group_response, payload);
-	g_free(body);
-}
-
 static void
 sipe_sched_calendar_status_update(struct sipe_core_private *sipe_private,
 				 time_t calculate_from);
@@ -628,7 +459,7 @@
 
 	/* then set status_id actually */
 	SIPE_DEBUG_INFO("sipe_apply_calendar_status: to %s for %s", status_id, sbuddy->name ? sbuddy->name : "" );
-	purple_prpl_got_user_status(sip->account, sbuddy->name, status_id, NULL);
+	sipe_backend_buddy_set_status(SIPE_CORE_PUBLIC, sbuddy->name, status_id);
 
 	/* set our account state to the one in roaming (including calendar info) */
 	self_uri = sip_uri_self(sipe_private);
@@ -643,12 +474,12 @@
 	g_free(self_uri);
 }
 
-static void
-sipe_got_user_status(struct sipe_core_private *sipe_private,
-		 const char* uri,
-		 const char *status_id)
+void
+sipe_core_buddy_got_status(struct sipe_core_public *sipe_public,
+			 const gchar* uri,
+			 const gchar *status_id)
 {
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 	struct sipe_buddy *sbuddy = g_hash_table_lookup(sipe_private->buddies, uri);
 
 	if (!sbuddy) return;
@@ -659,7 +490,7 @@
 	if (!SIPE_CORE_PRIVATE_FLAG_IS(OCS2007)) {
 		sipe_apply_calendar_status(sipe_private, sbuddy, status_id);
 	} else {
-		purple_prpl_got_user_status(sip->account, uri, status_id, NULL);
+		sipe_backend_buddy_set_status(sipe_public, uri, status_id);
 	}
 }
 
@@ -1028,42 +859,6 @@
 	}
 }
 
-void
-sipe_group_buddy(PurpleConnection *gc,
-		 const char *who,
-		 const char *old_group_name,
-		 const char *new_group_name)
-{
-	struct sipe_core_private *sipe_private = PURPLE_GC_TO_SIPE_CORE_PRIVATE;
-	struct sipe_buddy * buddy = g_hash_table_lookup(sipe_private->buddies, who);
-	struct sipe_group * old_group = NULL;
-	struct sipe_group * new_group;
-
-	SIPE_DEBUG_INFO("sipe_group_buddy[CB]: who:%s old_group_name:%s new_group_name:%s",
-			who ? who : "", old_group_name ? old_group_name : "", new_group_name ? new_group_name : "");
-
-	if(!buddy) { // buddy not in roaming list
-		return;
-	}
-
-	if (old_group_name) {
-		old_group = sipe_group_find_by_name(sipe_private, old_group_name);
-	}
-	new_group = sipe_group_find_by_name(sipe_private, new_group_name);
-
-	if (old_group) {
-		buddy->groups = g_slist_remove(buddy->groups, old_group);
-		SIPE_DEBUG_INFO("buddy %s removed from old group %s", who, old_group_name);
-	}
-
-	if (!new_group) {
- 		sipe_group_create(sipe_private, new_group_name, who);
- 	} else {
-		buddy->groups = slist_insert_unique_sorted(buddy->groups, new_group, (GCompareFunc)sipe_group_compare);
-		sipe_core_group_set_user(SIPE_CORE_PUBLIC, who);
- 	}
-}
-
 void sipe_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
 {
 	SIPE_DEBUG_INFO("sipe_add_buddy[CB]: buddy:%s group:%s", buddy ? buddy->name : "", group ? group->name : "");
@@ -1090,13 +885,14 @@
 			b->name = g_strdup(buddy->name);
 			b->just_added = TRUE;
 			g_hash_table_insert(sipe_private->buddies, b->name, b);
-			sipe_group_buddy(gc, b->name, NULL, group->name);
 			/* @TODO should go to callback */
 			sipe_subscribe_presence_single(sipe_private,
 						 b->name);
 		} else {
 			SIPE_DEBUG_INFO("sipe_add_buddy: buddy %s already in internal list", buddy->name);
 		}
+
+		sipe_core_buddy_group(PURPLE_GC_TO_SIPE_CORE_PUBLIC, buddy->name, NULL, group->name);
 	}
 }
 
@@ -1183,42 +979,6 @@
 
 }
 
-void
-sipe_rename_group(PurpleConnection *gc,
-		 const char *old_name,
-		 PurpleGroup *group,
-		 SIPE_UNUSED_PARAMETER GList *moved_buddies)
-{
-	struct sipe_core_private *sipe_private = PURPLE_GC_TO_SIPE_CORE_PRIVATE;
-	struct sipe_group * s_group = sipe_group_find_by_name(sipe_private, old_name);
-	if (s_group) {
-		sipe_group_rename(sipe_private, s_group, group->name);
-	} else {
-		SIPE_DEBUG_INFO("Cannot find group %s to rename", old_name);
-	}
-}
-
-void
-sipe_remove_group(PurpleConnection *gc, PurpleGroup *group)
-{
-	struct sipe_core_private *sipe_private = PURPLE_GC_TO_SIPE_CORE_PRIVATE;
-	struct sipe_group * s_group = sipe_group_find_by_name(sipe_private, group->name);
-	if (s_group) {
-		struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-		gchar *body;
-		SIPE_DEBUG_INFO("Deleting group %s", group->name);
-		body = g_strdup_printf(SIPE_SOAP_DEL_GROUP, s_group->id, sip->contacts_delta++);
-		send_soap_request(sipe_private, body);
-		g_free(body);
-
-		sip->groups = g_slist_remove(sip->groups, s_group);
-		g_free(s_group->name);
-		g_free(s_group);
-	} else {
-		SIPE_DEBUG_INFO("Cannot find group %s to delete", group->name);
-	}
-}
-
 /**
 * A callback for g_hash_table_foreach
 */
@@ -1242,42 +1002,45 @@
 }
 
 /**
- * Removes entries from purple buddy list
+ * Removes entries from local buddy list
 * that does not correspond ones in the roaming contact list.
 */
 static void sipe_cleanup_local_blist(struct sipe_core_private *sipe_private) {
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	GSList *buddies = purple_find_buddies(sip->account, NULL);
+	GSList *buddies = sipe_backend_buddy_find_all(SIPE_CORE_PUBLIC, NULL, NULL);
 	GSList *entry = buddies;
 	struct sipe_buddy *buddy;
-	PurpleBuddy *b;
-	PurpleGroup *g;
+	sipe_backend_buddy b;
+	gchar *bname;
+	gchar *gname;
 
-	SIPE_DEBUG_INFO("sipe_cleanup_local_blist: overall %d Purple buddies (including clones)", g_slist_length(buddies));
+	SIPE_DEBUG_INFO("sipe_cleanup_local_blist: overall %d backend buddies (including clones)", g_slist_length(buddies));
 	SIPE_DEBUG_INFO("sipe_cleanup_local_blist: %d sipe buddies (unique)", g_hash_table_size(sipe_private->buddies));
 	while (entry) {
 		b = entry->data;
-		g = purple_buddy_get_group(b);
-		buddy = g_hash_table_lookup(sipe_private->buddies, b->name);
+		gname = sipe_backend_buddy_get_group_name(SIPE_CORE_PUBLIC, b);
+		bname = sipe_backend_buddy_get_name(SIPE_CORE_PUBLIC, b);
+		buddy = g_hash_table_lookup(sipe_private->buddies, bname);
+		g_free(bname);
 		if(buddy) {
 			gboolean in_sipe_groups = FALSE;
 			GSList *entry2 = buddy->groups;
 			while (entry2) {
 				struct sipe_group *group = entry2->data;
-				if (sipe_strequal(group->name, g->name)) {
+				if (sipe_strequal(group->name, gname)) {
 					in_sipe_groups = TRUE;
 					break;
 				}
 				entry2 = entry2->next;
 			}
 			if(!in_sipe_groups) {
-				SIPE_DEBUG_INFO("*** REMOVING %s from Purple group: %s as not having this group in roaming list", b->name, g->name);
-				purple_blist_remove_buddy(b);
+				SIPE_DEBUG_INFO("*** REMOVING %s from blist group: %s as not having this group in roaming list", bname, gname);
+				sipe_backend_buddy_remove(SIPE_CORE_PUBLIC, b);
 			}
 		} else {
-				SIPE_DEBUG_INFO("*** REMOVING %s from Purple group: %s as this buddy not in roaming list", b->name, g->name);
-				purple_blist_remove_buddy(b);
+				SIPE_DEBUG_INFO("*** REMOVING %s from blist group: %s as this buddy not in roaming list", bname, gname);
+				sipe_backend_buddy_remove(SIPE_CORE_PUBLIC, b);
 		}
+		g_free(gname);
 		entry = entry->next;
 	}
 	g_slist_free(buddies);
@@ -1294,31 +1057,15 @@
 			 SIPE_UNUSED_PARAMETER struct sipe_buddy *buddy,
 			 struct sipe_core_private *sipe_private)
 {
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
 	int container_id = sipe_find_access_level(sipe_private, "user", buddy_name, NULL);
 	gboolean blocked = (container_id == 32000);
-	gboolean blocked_in_blist = !purple_privacy_check(sip->account, buddy_name);
+	gboolean blocked_in_blist = sipe_backend_buddy_is_blocked(SIPE_CORE_PUBLIC, buddy_name);
 
 	/* SIPE_DEBUG_INFO("sipe_refresh_blocked_status_cb: buddy_name=%s, blocked=%s, blocked_in_blist=%s",
 		buddy_name, blocked ? "T" : "F", blocked_in_blist ? "T" : "F"); */
 
 	if (blocked != blocked_in_blist) {
-		if (blocked) {
-			purple_privacy_deny_add(sip->account, buddy_name, TRUE);
-		} else {
-			purple_privacy_deny_remove(sip->account, buddy_name, TRUE);
-		}
-
-		/* stupid workaround to make pidgin re-render screen to reflect our changes */
-		{
-			PurpleBuddy *pbuddy = purple_find_buddy(sip->account, buddy_name);
-			const PurplePresence *presence = purple_buddy_get_presence(pbuddy);
-			const PurpleStatus *pstatus = purple_presence_get_active_status(presence);
-
-			SIPE_DEBUG_INFO_NOFORMAT("sipe_refresh_blocked_status_cb: forcefully refreshing screen.");
-			sipe_got_user_status(sipe_private, buddy_name, purple_status_get_id(pstatus));
-		}
-
+		sipe_backend_buddy_set_blocked_status(SIPE_CORE_PUBLIC, buddy_name, blocked);
 	}
 }
 
@@ -1345,7 +1092,7 @@
 		return FALSE;
 	}
 
-	/* Convert the contact from XML to Purple Buddies */
+	/* Convert the contact from XML to backend Buddies */
 	isc = sipe_xml_parse(msg->body, len);
 	if (!isc) {
 		return FALSE;
@@ -1411,25 +1158,26 @@
 				}
 
 				if (group != NULL) {
-					PurpleBuddy *b = purple_find_buddy_in_group(sip->account, buddy_name, group->purple_group);
+					gchar *b_alias;
+					sipe_backend_buddy b = sipe_backend_buddy_find(SIPE_CORE_PUBLIC, buddy_name, group->name);
 					if (!b){
-						b = purple_buddy_new(sip->account, buddy_name, uri);
-						purple_blist_add_buddy(b, NULL, group->purple_group, NULL);
-
+						b = sipe_backend_buddy_add(SIPE_CORE_PUBLIC, buddy_name, uri, group->name);
 						SIPE_DEBUG_INFO("Created new buddy %s with alias %s", buddy_name, uri);
 					}
 
-					if (sipe_strcase_equal(uri, purple_buddy_get_alias(b))) {
+					b_alias = sipe_backend_buddy_get_alias(SIPE_CORE_PUBLIC, b);
+					if (sipe_strcase_equal(uri, b_alias)) {
 						if (name != NULL && strlen(name) != 0) {
-							purple_blist_alias_buddy(b, name);
+							sipe_backend_buddy_set_alias(SIPE_CORE_PUBLIC, b, name);
 
 							SIPE_DEBUG_INFO("Replaced buddy %s alias with %s", buddy_name, name);
 						}
 					}
+					g_free(b_alias);
 
 					if (!buddy) {
 						buddy = g_new0(struct sipe_buddy, 1);
-						buddy->name = g_strdup(b->name);
+						buddy->name = sipe_backend_buddy_get_name(SIPE_CORE_PUBLIC, b);
 						g_hash_table_insert(sipe_private->buddies, buddy->name, buddy);
 
 						SIPE_DEBUG_INFO("Added SIPE buddy %s", buddy->name);
@@ -1437,7 +1185,7 @@
 
 					buddy->groups = slist_insert_unique_sorted(buddy->groups, group, (GCompareFunc)sipe_group_compare);
 
-					SIPE_DEBUG_INFO("Added buddy %s to group %s", b->name, group->name);
+					SIPE_DEBUG_INFO("Added buddy %s to group %s", buddy->name, group->name);
 				} else {
 					SIPE_DEBUG_INFO("No group found for contact %s! Unable to add to buddy list",
 							name);
@@ -1508,10 +1256,8 @@
 	const gchar *contenttype = sipmsg_find_header(msg, "Content-Type");
 	gchar *event = NULL;
 	gchar *reason = NULL;
-	const gchar *diagnostics = sipmsg_find_header(msg, "ms-diagnostics");
 	gchar *warning;
 
-	diagnostics = diagnostics ? diagnostics : sipmsg_find_header(msg, "ms-diagnostics-public");
 	SIPE_DEBUG_INFO_NOFORMAT("sipe_process_registration_notify: deregistration received.");
 
 	if (!g_ascii_strncasecmp(contenttype, "text/registration-event", 23)) {
@@ -1523,19 +1269,15 @@
 		return;
 	}
 
-	if (diagnostics != NULL) {
-		reason = sipmsg_find_part_of_header(diagnostics, "reason=\"", "\"", NULL);
-	} else { // for LCS2005
-		int error_id = 0;
+	reason = sipmsg_get_ms_diagnostics_reason(msg);
+	reason = reason ? reason : sipmsg_get_ms_diagnostics_public_reason(msg);
+	if (!reason) { // for LCS2005
 		if (event && sipe_strcase_equal(event, "unregistered")) {
-			error_id = 4140; // [MS-SIPREGE]
 			//reason = g_strdup(_("User logged out")); // [MS-OCER]
 			reason = g_strdup(_("you are already signed in at another location"));
 		} else if (event && sipe_strcase_equal(event, "rejected")) {
-			error_id = 4141;
 			reason = g_strdup(_("user disabled")); // [MS-OCER]
 		} else if (event && sipe_strcase_equal(event, "deactivated")) {
-			error_id = 4142;
 			reason = g_strdup(_("user moved")); // [MS-OCER]
 		}
 	}
@@ -1565,6 +1307,16 @@
 			sipe_private->focus_factory_uri = sipe_xml_data(sipe_xml_child(node, "focusFactoryUri"));
 			SIPE_DEBUG_INFO("sipe_process_provisioning_v2: sipe_private->focus_factory_uri=%s",
 					sipe_private->focus_factory_uri ? sipe_private->focus_factory_uri : "");
+
+#ifdef HAVE_VV
+			g_free(sipe_private->mras_uri);
+			sipe_private->mras_uri = g_strstrip(sipe_xml_data(sipe_xml_child(node, "mrasUri")));
+			SIPE_DEBUG_INFO("sipe_process_provisioning_v2: sipe_private->mras_uri=%s",
+					sipe_private->mras_uri ? sipe_private->mras_uri : "");
+
+			if (sipe_private->mras_uri)
+					sipe_media_get_av_edge_credentials(sipe_private);
+#endif
 			break;
 		}
 	}
@@ -2200,9 +1952,9 @@
 			 char **last_name)
 {
 	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	PurpleBuddy *p_buddy;
+	sipe_backend_buddy p_buddy;
 	char *display_name;
-	const char *email;
+	gchar *email;
 	const char *first, *last;
 	char *tmp;
 	char **parts;
@@ -2210,12 +1962,12 @@
 
 	if (!sip || !uri) return;
 
-	p_buddy = purple_find_buddy(sip->account, uri);
+	p_buddy = sipe_backend_buddy_find(SIPE_CORE_PUBLIC, uri, NULL);
 
 	if (!p_buddy) return;
 
-	display_name = g_strdup(purple_buddy_get_alias(p_buddy));
-	email = purple_blist_node_get_string(&p_buddy->node, EMAIL_PROP);
+	display_name = sipe_backend_buddy_get_alias(SIPE_CORE_PUBLIC, p_buddy);
+	email = sipe_backend_buddy_get_string(SIPE_CORE_PUBLIC, p_buddy, SIPE_BUDDY_INFO_EMAIL);
 
 	if (!display_name && !email) return;
 
@@ -2237,6 +1989,7 @@
 	parts = g_strsplit(display_name, " ", 0);
 
 	if (!parts[0] || !parts[1]) {
+		g_free(email);
 		g_free(display_name);
 		g_strfreev(parts);
 		return;
@@ -2258,6 +2011,7 @@
 		*last_name = g_strstrip(g_strdup(last));
 	}
 
+	g_free(email);
 	g_free(display_name);
 	g_strfreev(parts);
 }
@@ -2272,44 +2026,47 @@
 static void
 sipe_update_user_info(struct sipe_core_private *sipe_private,
 		 const char *uri,
-		 const char *property_name,
+		 sipe_buddy_info_fields propkey,
 		 char *property_value)
 {
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
 	GSList *buddies, *entry;
 
-	if (!property_name || strlen(property_name) == 0) return;
-
 	if (property_value)
 		property_value = g_strstrip(property_value);
 
-	entry = buddies = purple_find_buddies(sip->account, uri); /* all buddies in different groups */
+	entry = buddies = sipe_backend_buddy_find_all(SIPE_CORE_PUBLIC, uri, NULL); /* all buddies in different groups */
 	while (entry) {
-		const char *prop_str;
-		const char *server_alias;
-		PurpleBuddy *p_buddy = entry->data;
+		gchar *prop_str;
+		gchar *server_alias;
+		gchar *alias;
+		sipe_backend_buddy p_buddy = entry->data;
 
 		/* for Display Name */
-		if (sipe_strequal(property_name, ALIAS_PROP)) {
-			if (property_value && sipe_is_bad_alias(uri, purple_buddy_get_alias(p_buddy))) {
+		if (propkey == SIPE_BUDDY_INFO_DISPLAY_NAME) {
+			alias = sipe_backend_buddy_get_alias(SIPE_CORE_PUBLIC, p_buddy);
+			if (property_value && sipe_is_bad_alias(uri, alias)) {
 				SIPE_DEBUG_INFO("Replacing alias for %s with %s", uri, property_value);
-				purple_blist_alias_buddy(p_buddy, property_value);
+				sipe_backend_buddy_set_alias(SIPE_CORE_PUBLIC, p_buddy, property_value);
 			}
+			g_free(alias);
 
-			server_alias = purple_buddy_get_server_alias(p_buddy);
+			server_alias = sipe_backend_buddy_get_server_alias(SIPE_CORE_PUBLIC, p_buddy);
 			if (!is_empty(property_value) &&
 			 (!sipe_strequal(property_value, server_alias) || is_empty(server_alias)) )
 			{
-				purple_blist_server_alias_buddy(p_buddy, property_value);
+				SIPE_DEBUG_INFO("Replacing service alias for %s with %s", uri, property_value);
+				sipe_backend_buddy_set_server_alias(SIPE_CORE_PUBLIC, p_buddy, property_value);
 			}
+			g_free(server_alias);
 		}
 		/* for other properties */
 		else {
 			if (!is_empty(property_value)) {
-				prop_str = purple_blist_node_get_string(&p_buddy->node, property_name);
+				prop_str = sipe_backend_buddy_get_string(SIPE_CORE_PUBLIC, p_buddy, propkey);
 				if (!prop_str || !sipe_strcase_equal(prop_str, property_value)) {
-					purple_blist_node_set_string(&p_buddy->node, property_name, property_value);
+					sipe_backend_buddy_set_string(SIPE_CORE_PUBLIC, p_buddy, propkey, property_value);
 				}
+				g_free(prop_str);
 			}
 		}
 
@@ -2329,28 +2086,28 @@
 */
 static void
 sipe_update_user_phone(struct sipe_core_private *sipe_private,
-		 const char *uri,
+		 const gchar *uri,
 		 const gchar *phone_type,
 		 gchar *phone,
 		 gchar *phone_display_string)
 {
-	const char *phone_node = PHONE_PROP; /* work phone by default */
-	const char *phone_display_node = PHONE_DISPLAY_PROP; /* work phone by default */
+	sipe_buddy_info_fields phone_node = SIPE_BUDDY_INFO_WORK_PHONE; /* work phone by default */
+	sipe_buddy_info_fields phone_display_node = SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY; /* work phone by default */
 
 	if(!phone || strlen(phone) == 0) return;
 
 	if ((sipe_strequal(phone_type, "mobile") || sipe_strequal(phone_type, "cell"))) {
-		phone_node = PHONE_MOBILE_PROP;
-		phone_display_node = PHONE_MOBILE_DISPLAY_PROP;
+		phone_node = SIPE_BUDDY_INFO_MOBILE_PHONE;
+		phone_display_node = SIPE_BUDDY_INFO_MOBILE_PHONE_DISPLAY;
 	} else if (sipe_strequal(phone_type, "home")) {
-		phone_node = PHONE_HOME_PROP;
-		phone_display_node = PHONE_HOME_DISPLAY_PROP;
+		phone_node = SIPE_BUDDY_INFO_HOME_PHONE;
+		phone_display_node = SIPE_BUDDY_INFO_HOME_PHONE_DISPLAY;
 	} else if (sipe_strequal(phone_type, "other")) {
-		phone_node = PHONE_OTHER_PROP;
-		phone_display_node = PHONE_OTHER_DISPLAY_PROP;
+		phone_node = SIPE_BUDDY_INFO_OTHER_PHONE;
+		phone_display_node = SIPE_BUDDY_INFO_OTHER_PHONE_DISPLAY;
 	} else if (sipe_strequal(phone_type, "custom1")) {
-		phone_node = PHONE_CUSTOM1_PROP;
-		phone_display_node = PHONE_CUSTOM1_DISPLAY_PROP;
+		phone_node = SIPE_BUDDY_INFO_CUSTOM1_PHONE;
+		phone_display_node = SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY;
 	}
 
 	sipe_update_user_info(sipe_private, uri, phone_node, phone);
@@ -2499,6 +2256,7 @@
 	int aggreg_avail = 0;
 	gboolean do_update_status = FALSE;
 	gboolean has_note_cleaned = FALSE;
+	GHashTable *devices;
 
 	SIPE_DEBUG_INFO_NOFORMAT("sipe_process_roaming_self");
 
@@ -2533,7 +2290,10 @@
 		}
 	}
 	g_slist_free(category_names);
+
 	/* filling our categories reflected in roaming data */
+	devices = g_hash_table_new_full(g_str_hash, g_str_equal,
+					g_free, NULL);
 	for (node = sipe_xml_child(xml, "categories/category"); node; node = sipe_xml_twin(node)) {
 		const char *tmp;
 		const gchar *name = sipe_xml_attribute(node, "name");
@@ -2592,6 +2352,10 @@
 			}
 		}
 
+		/* count each client instance only once */
+		if (sipe_strequal(name, "device"))
+			g_hash_table_replace(devices, g_strdup_printf("%u", instance), NULL);
+
 		if (sipe_is_our_publication(sipe_private, key)) {
 			struct sipe_publication *publication = g_new0(struct sipe_publication, 1);
 
@@ -2735,6 +2499,17 @@
 	SIPE_DEBUG_INFO("sipe_process_roaming_self: sip->our_publications size=%d",
 			sip->our_publications ? (int) g_hash_table_size(sip->our_publications) : -1);
 
+	/* active clients for user account */
+	if (g_hash_table_size(devices) > 1) {
+		SIPE_CORE_PRIVATE_FLAG_SET(MPOP);
+		SIPE_DEBUG_INFO("sipe_process_roaming_self: multiple clients detected (%d)",
+				g_hash_table_size(devices));
+	} else {
+		SIPE_CORE_PRIVATE_FLAG_UNSET(MPOP);
+		SIPE_DEBUG_INFO_NOFORMAT("sipe_process_roaming_self: single client detected");
+	}
+	g_hash_table_destroy(devices);
+
 	/* containers */
 	for (node = sipe_xml_child(xml, "containers/container"); node; node = sipe_xml_twin(node)) {
 		guint id = sipe_xml_int_attribute(node, "id", 0);
@@ -2804,13 +2579,13 @@
 		display_name = g_strdup(sipe_xml_attribute(node, "displayName"));
 		uri = sip_uri_from_name(user);
 
-		sipe_update_user_info(sipe_private, uri, ALIAS_PROP, display_name);
+		sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_DISPLAY_NAME, display_name);
 
 	 acknowledged= sipe_xml_attribute(node, "acknowledged");
 		if(sipe_strcase_equal(acknowledged,"false")){
 SIPE_DEBUG_INFO("sipe_process_roaming_self: user added you %s", user);
-			if (!purple_find_buddy(sip->account, uri)) {
-				purple_account_request_add(sip->account, uri, _("you"), display_name, NULL);
+			if (!sipe_backend_buddy_find(SIPE_CORE_PUBLIC, uri, NULL)) {
+				sipe_backend_buddy_request_add(SIPE_CORE_PUBLIC, uri, display_name);
 			}
 
 		 hdr = g_strdup_printf(
@@ -2844,6 +2619,7 @@
 	 */
 	if (!sip->initial_state_published) {
 		send_publish_category_initial(sipe_private);
+		sipe_groupchat_init(sipe_private);
 		sip->initial_state_published = TRUE;
 		/* dalayed run */
 		sipe_schedule_seconds(sipe_private,
@@ -2873,34 +2649,6 @@
 
 /* IM Session (INVITE and MESSAGE methods) */
 
-/* EndPoints: "alice alisson" <sip:alice@atlanta.local>, <sip:bob@atlanta.local>;epid=ebca82d94d, <sip:carol@atlanta.local> */
-static gchar *
-get_end_points (struct sipe_core_private *sipe_private,
-		struct sip_session *session)
-{
-	gchar *res;
-
-	if (session == NULL) {
-		return NULL;
-	}
-
-	res = g_strdup_printf("<sip:%s>", sipe_private->username);
-
-	SIPE_DIALOG_FOREACH {
-		gchar *tmp = res;
-		res = g_strdup_printf("%s, <%s>", res, dialog->with);
-		g_free(tmp);
-
-		if (dialog->theirepid) {
-			tmp = res;
-			res = g_strdup_printf("%s;epid=%s", res, dialog->theirepid);
-			g_free(tmp);
-		}
-	} SIPE_DIALOG_FOREACH_END;
-
-	return res;
-}
-
 static gboolean
 process_options_response(SIPE_UNUSED_PARAMETER struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg,
@@ -2944,566 +2692,6 @@
 	g_free(request);
 }
 
-static void
-sipe_notify_user(struct sipe_core_private *sipe_private,
-		 struct sip_session *session,
-		 PurpleMessageFlags flags,
-		 const gchar *message)
-{
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	PurpleConversation *conv;
-
-	if (!session->backend_session) {
-		conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY, session->with, sip->account);
-	} else {
-		/* TEMPORARY HACK!! */
-		conv = (PurpleConversation *) session->backend_session;
-	}
-	purple_conversation_write(conv, NULL, message, flags, time(NULL));
-}
-
-void
-sipe_present_info(struct sipe_core_private *sipe_private,
-		 struct sip_session *session,
-		 const gchar *message)
-{
-	sipe_notify_user(sipe_private, session, PURPLE_MESSAGE_SYSTEM, message);
-}
-
-void
-sipe_present_err(struct sipe_core_private *sipe_private,
-		 struct sip_session *session,
-		 const gchar *message)
-{
-	sipe_notify_user(sipe_private, session, PURPLE_MESSAGE_ERROR, message);
-}
-
-void
-sipe_present_message_undelivered_err(struct sipe_core_private *sipe_private,
-				 struct sip_session *session,
-				 int sip_error,
-				 int sip_warning,
-				 const gchar *who,
-				 const gchar *message)
-{
-	char *msg, *msg_tmp, *msg_tmp2;
-	const char *label;
-
-	msg_tmp = message ? sipe_backend_markup_strip_html(message) : NULL;
-	msg = msg_tmp ? g_strdup_printf("%s", msg_tmp) : NULL;
-	g_free(msg_tmp);
-	/* Service unavailable; Server Internal Error; Server Time-out */
-	if (sip_error == 606 && sip_warning == 309) { /* Not acceptable all. */ /* Message contents not allowed by policy */
-		label = _("Your message or invitation was not delivered, possibly because it contains a hyperlink or other content that the system administrator has blocked.");
-		g_free(msg);
-		msg = NULL;
-	} else if (sip_error == 503 || sip_error == 500 || sip_error == 504) {
-		label = _("This message was not delivered to %s because the service is not available");
-	} else if (sip_error == 486) { /* Busy Here */
-		label = _("This message was not delivered to %s because one or more recipients do not want to be disturbed");
-	} else if (sip_error == 415) { /* Unsupported media type */
-		label = _("This message was not delivered to %s because one or more recipients don't support this type of message");
-	} else {
-		label = _("This message was not delivered to %s because one or more recipients are offline");
-	}
-
-	msg_tmp = g_strdup_printf( "%s%s\n%s" ,
-			msg_tmp2 = g_strdup_printf(label, who ? who : ""),
-			msg ? ":" : "",
-			msg ? msg : "");
-	sipe_present_err(sipe_private, session, msg_tmp);
-	g_free(msg_tmp2);
-	g_free(msg_tmp);
-	g_free(msg);
-}
-
-
-static gboolean
-process_message_response(struct sipe_core_private *sipe_private,
-			 struct sipmsg *msg,
-			 SIPE_UNUSED_PARAMETER struct transaction *trans)
-{
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	gboolean ret = TRUE;
-	gchar *with = parse_from(sipmsg_find_header(msg, "To"));
-	struct sip_session *session = sipe_session_find_im(sipe_private, with);
-	struct sip_dialog *dialog;
-	gchar *cseq;
-	char *key;
-	struct queued_message *message;
-
-	if (!session) {
-		SIPE_DEBUG_INFO_NOFORMAT("process_message_response: unable to find IM session");
-		g_free(with);
-		return FALSE;
-	}
-
-	dialog = sipe_dialog_find(session, with);
-	if (!dialog) {
-		SIPE_DEBUG_INFO_NOFORMAT("process_message_response: session outgoing dialog is NULL");
-		g_free(with);
-		return FALSE;
-	}
-
-	cseq = sipmsg_find_part_of_header(sipmsg_find_header(msg, "CSeq"), NULL, " ", NULL);
-	key = g_strdup_printf("<%s><%d><MESSAGE><%s>", sipmsg_find_header(msg, "Call-ID"), atoi(cseq), with);
-	g_free(cseq);
-	message = g_hash_table_lookup(session->unconfirmed_messages, key);
-
-	if (msg->response >= 400) {
-		PurpleBuddy *pbuddy;
-		const char *alias = with;
-		const char *warn_hdr = sipmsg_find_header(msg, "Warning");
-		int warning = -1;
-
-		SIPE_DEBUG_INFO_NOFORMAT("process_message_response: MESSAGE response >= 400");
-
-		if (warn_hdr) {
-			gchar **parts = g_strsplit(warn_hdr, " ", 2);
-			if (parts[0]) {
-				warning = atoi(parts[0]);
-			}
-			g_strfreev(parts);
-		}
-
-		/* cancel file transfer as rejected by server */
-		if (msg->response == 606 &&	/* Not acceptable all. */
-		 warning == 309 &&		/* Message contents not allowed by policy */
-		 message && g_str_has_prefix(message->content_type, "text/x-msmsgsinvite"))
-		{
-			GSList *parsed_body = sipe_ft_parse_msg_body(msg->body);
-			sipe_ft_incoming_cancel(dialog, parsed_body);
-			sipe_utils_nameval_free(parsed_body);
-		}
-
-		if ((pbuddy = purple_find_buddy(sip->account, with))) {
-			alias = purple_buddy_get_alias(pbuddy);
-		}
-
-		sipe_present_message_undelivered_err(sipe_private, session, msg->response, warning, alias, (message ? message->body : NULL));
-
-		/* drop dangling IM sessions: assume that BYE from remote never reached us */
-		if (msg->response == 408 || /* Request timeout */
-		 msg->response == 480 || /* Temporarily Unavailable */
-		 msg->response == 481) { /* Call/Transaction Does Not Exist */
-			SIPE_DEBUG_INFO_NOFORMAT("process_message_response: assuming dangling IM session, dropping it.");
-			sip_transport_bye(sipe_private, dialog);
-
-			/* We might not get a valid reply to our BYE,
-			 so make sure the dialog is removed for sure. */
-			sipe_dialog_remove(session, with);
-			dialog = NULL;
-		}
-
-		ret = FALSE;
-	} else {
-		const gchar *message_id = sipmsg_find_header(msg, "Message-Id");
-		if (message_id) {
-			g_hash_table_insert(session->conf_unconfirmed_messages, g_strdup(message_id), g_strdup(message->body));
-			SIPE_DEBUG_INFO("process_message_response: added message with id %s to conf_unconfirmed_messages(count=%d)",
-					message_id, g_hash_table_size(session->conf_unconfirmed_messages));
-		}
-
-		g_hash_table_remove(session->unconfirmed_messages, key);
-		SIPE_DEBUG_INFO("process_message_response: removed message %s from unconfirmed_messages(count=%d)",
-				key, g_hash_table_size(session->unconfirmed_messages));
-	}
-
-	g_free(key);
-	g_free(with);
-
-	if (ret) sipe_im_process_queue(sipe_private, session);
-	return ret;
-}
-
-static void sipe_send_message(struct sipe_core_private *sipe_private,
-			 struct sip_dialog *dialog,
-			 const char *msg, const char *content_type)
-{
-	gchar *hdr;
-	gchar *tmp;
-	char *msgtext = NULL;
-	const gchar *msgr = "";
-	gchar *tmp2 = NULL;
-
-	if (!g_str_has_prefix(content_type, "text/x-msmsgsinvite")) {
-		char *msgformat;
-		gchar *msgr_value;
-
-		sipe_parse_html(msg, &msgformat, &msgtext);
-		SIPE_DEBUG_INFO("sipe_send_message: msgformat=%s", msgformat);
-
-		msgr_value = sipmsg_get_msgr_string(msgformat);
-		g_free(msgformat);
-		if (msgr_value) {
-			msgr = tmp2 = g_strdup_printf(";msgr=%s", msgr_value);
-			g_free(msgr_value);
-		}
-	} else {
-		msgtext = g_strdup(msg);
-	}
-
-	tmp = get_contact(sipe_private);
-	//hdr = g_strdup("Content-Type: text/plain; charset=UTF-8\r\n");
-	//hdr = g_strdup("Content-Type: text/rtf\r\n");
-	//hdr = g_strdup("Content-Type: text/plain; charset=UTF-8;msgr=WAAtAE0ATQBTAC....AoADQA\r\nSupported: timer\r\n");
-	if (content_type == NULL)
-		content_type = "text/plain";
-
-	hdr = g_strdup_printf("Contact: %s\r\nContent-Type: %s; charset=UTF-8%s\r\n", tmp, content_type, msgr);
-	g_free(tmp);
-	g_free(tmp2);
-
-	sip_transport_request(sipe_private,
-			 "MESSAGE",
-			 dialog->with,
-			 dialog->with,
-			 hdr,
-			 msgtext,
-			 dialog,
-			 process_message_response);
-	g_free(msgtext);
-	g_free(hdr);
-}
-
-
-void
-sipe_im_process_queue (struct sipe_core_private *sipe_private,
-		 struct sip_session * session)
-{
-	GSList *entry2 = session->outgoing_message_queue;
-	while (entry2) {
-		struct queued_message *msg = entry2->data;
-
-		/* for multiparty chat or conference */
-		if (session->is_multiparty || session->focus_uri) {
-			gchar *who = sip_uri_self(sipe_private);
-			sipe_backend_chat_message(SIPE_CORE_PUBLIC,
-						 session->chat_id,
-						 who,
-						 msg->body);
-			g_free(who);
-		}
-
-		SIPE_DIALOG_FOREACH {
-			char *key;
-			struct queued_message *message;
-
-			if (dialog->outgoing_invite) continue; /* do not send messages as INVITE is not responded. */
-
-			message = g_new0(struct queued_message,1);
-			message->body = g_strdup(msg->body);
-			if (msg->content_type != NULL)
-				message->content_type = g_strdup(msg->content_type);
-
-			key = g_strdup_printf("<%s><%d><MESSAGE><%s>", dialog->callid, (dialog->cseq) + 1, dialog->with);
-			g_hash_table_insert(session->unconfirmed_messages, g_strdup(key), message);
-			SIPE_DEBUG_INFO("sipe_im_process_queue: added message %s to unconfirmed_messages(count=%d)",
-					key, g_hash_table_size(session->unconfirmed_messages));
-			g_free(key);
-
-			sipe_send_message(sipe_private, dialog, msg->body, msg->content_type);
-		} SIPE_DIALOG_FOREACH_END;
-
-		entry2 = sipe_session_dequeue_message(session);
-	}
-}
-
-static void
-sipe_refer_notify(struct sipe_core_private *sipe_private,
-		 struct sip_session *session,
-		 const gchar *who,
-		 int status,
-		 const gchar *desc)
-{
-	gchar *hdr;
-	gchar *body;
-	struct sip_dialog *dialog = sipe_dialog_find(session, who);
-
-	hdr = g_strdup_printf(
-		"Event: refer\r\n"
-		"Subscription-State: %s\r\n"
-		"Content-Type: message/sipfrag\r\n",
-		status >= 200 ? "terminated" : "active");
-
-	body = g_strdup_printf(
-		"SIP/2.0 %d %s\r\n",
-		status, desc);
-
-	sip_transport_request(sipe_private,
-			 "NOTIFY",
-			 who,
-			 who,
-			 hdr,
-			 body,
-			 dialog,
-			 NULL);
-
-	g_free(hdr);
-	g_free(body);
-}
-
-static gboolean
-process_invite_response(struct sipe_core_private *sipe_private,
-			struct sipmsg *msg, struct transaction *trans)
-{
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	gchar *with = parse_from(sipmsg_find_header(msg, "To"));
-	struct sip_session *session;
-	struct sip_dialog *dialog;
-	char *cseq;
-	char *key;
-	struct queued_message *message;
-	struct sipmsg *request_msg = trans->msg;
-
-	const gchar *callid = sipmsg_find_header(msg, "Call-ID");
-	gchar *referred_by;
-
-	session = sipe_session_find_chat_or_im(sipe_private, callid, with);
-	if (!session) {
-		SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: unable to find IM session");
-		g_free(with);
-		return FALSE;
-	}
-
-	dialog = sipe_dialog_find(session, with);
-	if (!dialog) {
-		SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: session outgoing dialog is NULL");
-		g_free(with);
-		return FALSE;
-	}
-
-	sipe_dialog_parse(dialog, msg, TRUE);
-
-	cseq = sipmsg_find_part_of_header(sipmsg_find_header(msg, "CSeq"), NULL, " ", NULL);
-	key = g_strdup_printf("<%s><%d><INVITE>", dialog->callid, atoi(cseq));
-	g_free(cseq);
-	message = g_hash_table_lookup(session->unconfirmed_messages, key);
-
-	if (msg->response != 200) {
-		PurpleBuddy *pbuddy;
-		const char *alias = with;
-		const char *warn_hdr = sipmsg_find_header(msg, "Warning");
-		int warning = -1;
-
-		SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: INVITE response not 200");
-
-		if (warn_hdr) {
-			gchar **parts = g_strsplit(warn_hdr, " ", 2);
-			if (parts[0]) {
-				warning = atoi(parts[0]);
-			}
-			g_strfreev(parts);
-		}
-
-		/* cancel file transfer as rejected by server */
-		if (msg->response == 606 &&	/* Not acceptable all. */
-		 warning == 309 &&		/* Message contents not allowed by policy */
-		 message && g_str_has_prefix(message->content_type, "text/x-msmsgsinvite"))
-		{
-			GSList *parsed_body = sipe_ft_parse_msg_body(message->body);
-			sipe_ft_incoming_cancel(dialog, parsed_body);
-			sipe_utils_nameval_free(parsed_body);
-		}
-
-		if ((pbuddy = purple_find_buddy(sip->account, with))) {
-			alias = purple_buddy_get_alias(pbuddy);
-		}
-
-		if (message) {
-			sipe_present_message_undelivered_err(sipe_private, session, msg->response, warning, alias, message->body);
-		} else {
-			gchar *tmp_msg = g_strdup_printf(_("Failed to invite %s"), alias);
-			sipe_present_err(sipe_private, session, tmp_msg);
-			g_free(tmp_msg);
-		}
-
-		sipe_dialog_remove(session, with);
-
-		g_free(key);
-		g_free(with);
-		return FALSE;
-	}
-
-	dialog->cseq = 0;
-	sip_transport_ack(sipe_private, dialog);
-	dialog->outgoing_invite = NULL;
-	dialog->is_established = TRUE;
-
-	referred_by = parse_from(sipmsg_find_header(request_msg, "Referred-By"));
-	if (referred_by) {
-		sipe_refer_notify(sipe_private, session, referred_by, 200, "OK");
-		g_free(referred_by);
-	}
-
-	/* add user to chat if it is a multiparty session */
-	if (session->is_multiparty) {
-		sipe_backend_chat_add(session->backend_session,
-				 with,
-				 TRUE);
-	}
-
-	if(g_slist_find_custom(dialog->supported, "ms-text-format", (GCompareFunc)g_ascii_strcasecmp)) {
-		SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: remote system accepted message in INVITE");
-		sipe_session_dequeue_message(session);
-	}
-
-	sipe_im_process_queue(sipe_private, session);
-
-	g_hash_table_remove(session->unconfirmed_messages, key);
-	SIPE_DEBUG_INFO("process_invite_response: removed message %s from unconfirmed_messages(count=%d)",
-			key, g_hash_table_size(session->unconfirmed_messages));
-
-	g_free(key);
-	g_free(with);
-	return TRUE;
-}
-
-
-void
-sipe_invite(struct sipe_core_private *sipe_private,
-	 struct sip_session *session,
-	 const gchar *who,
-	 const gchar *msg_body,
-	 const gchar *msg_content_type,
-	 const gchar *referred_by,
-	 const gboolean is_triggered)
-{
-	gchar *hdr;
-	gchar *to;
-	gchar *contact;
-	gchar *body;
-	gchar *self;
-	char *ms_text_format = NULL;
-	gchar *roster_manager;
-	gchar *end_points;
-	gchar *referred_by_str;
-	struct sip_dialog *dialog = sipe_dialog_find(session, who);
-
-	if (dialog && dialog->is_established) {
-		SIPE_DEBUG_INFO("session with %s already has a dialog open", who);
-		return;
-	}
-
-	if (!dialog) {
-		dialog = sipe_dialog_add(session);
-		dialog->callid = session->callid ? g_strdup(session->callid) : gencallid();
-		dialog->with = g_strdup(who);
-	}
-
-	if (!(dialog->ourtag)) {
-		dialog->ourtag = gentag();
-	}
-
-	to = sip_uri(who);
-
-	if (msg_body) {
-		char *msgtext = NULL;
-		char *base64_msg;
-		const gchar *msgr = "";
-		char *key;
-		struct queued_message *message;
-		gchar *tmp = NULL;
-
-		if (!g_str_has_prefix(msg_content_type, "text/x-msmsgsinvite")) {
-			char *msgformat;
-			gchar *msgr_value;
-
-			sipe_parse_html(msg_body, &msgformat, &msgtext);
-			SIPE_DEBUG_INFO("sipe_invite: msgformat=%s", msgformat);
-
-			msgr_value = sipmsg_get_msgr_string(msgformat);
-			g_free(msgformat);
-			if (msgr_value) {
-				msgr = tmp = g_strdup_printf(";msgr=%s", msgr_value);
-				g_free(msgr_value);
-			}
-		} else {
-			msgtext = g_strdup(msg_body);
-		}
-
-		base64_msg = g_base64_encode((guchar*) msgtext, strlen(msgtext));
-		ms_text_format = g_strdup_printf(SIPE_INVITE_TEXT,
-						 msg_content_type ? msg_content_type : "text/plain",
-						 msgr,
-						 base64_msg);
-		g_free(msgtext);
-		g_free(tmp);
-		g_free(base64_msg);
-
-		message = g_new0(struct queued_message,1);
-		message->body = g_strdup(msg_body);
-		if (msg_content_type != NULL)
-			message->content_type = g_strdup(msg_content_type);
-
-		key = g_strdup_printf("<%s><%d><INVITE>", dialog->callid, (dialog->cseq) + 1);
-		g_hash_table_insert(session->unconfirmed_messages, g_strdup(key), message);
-		SIPE_DEBUG_INFO("sipe_invite: added message %s to unconfirmed_messages(count=%d)",
-				key, g_hash_table_size(session->unconfirmed_messages));
-		g_free(key);
-	}
-
-	contact = get_contact(sipe_private);
-	end_points = get_end_points(sipe_private, session);
-	self = sip_uri_self(sipe_private);
-	roster_manager = g_strdup_printf(
-		"Roster-Manager: %s\r\n"
-		"EndPoints: %s\r\n",
-		self,
-		end_points);
-	referred_by_str = referred_by ?
-		g_strdup_printf(
-			"Referred-By: %s\r\n",
-			referred_by)
-		: g_strdup("");
-	hdr = g_strdup_printf(
-		"Supported: ms-sender\r\n"
-		"%s"
-		"%s"
-		"%s"
-		"%s"
-		"Contact: %s\r\n%s"
-		"Content-Type: application/sdp\r\n",
-		sipe_strcase_equal(session->roster_manager, self) ? roster_manager : "",
-		referred_by_str,
-		is_triggered ? "TriggeredInvite: TRUE\r\n" : "",
-		is_triggered || session->is_multiparty ? "Require: com.microsoft.rtc-multiparty\r\n" : "",
-		contact,
-		ms_text_format ? ms_text_format : "");
-	g_free(ms_text_format);
-	g_free(self);
-
-	body = g_strdup_printf(
-		"v=0\r\n"
-		"o=- 0 0 IN IP4 %s\r\n"
-		"s=session\r\n"
-		"c=IN IP4 %s\r\n"
-		"t=0 0\r\n"
-		"m=%s %d sip null\r\n"
-		"a=accept-types:" SDP_ACCEPT_TYPES "\r\n",
-		sipe_backend_network_ip_address(),
-		sipe_backend_network_ip_address(),
-		SIPE_CORE_PRIVATE_FLAG_IS(OCS2007) ? "message" : "x-ms-message",
-		sip_transport_port(sipe_private));
-
-	dialog->outgoing_invite = sip_transport_request(sipe_private,
-							"INVITE",
-							to,
-							to,
-							hdr,
-							body,
-							dialog,
-							process_invite_response);
-
-	g_free(to);
-	g_free(roster_manager);
-	g_free(end_points);
-	g_free(referred_by_str);
-	g_free(body);
-	g_free(hdr);
-	g_free(contact);
-}
-
 void
 sipe_convo_closed(PurpleConnection * gc, const char *who)
 {
@@ -3514,78 +2702,6 @@
 			 sipe_session_find_im(sipe_private, who));
 }
 
-void
-sipe_chat_leave (PurpleConnection *gc, int id)
-{
-	struct sipe_core_private *sipe_private = PURPLE_GC_TO_SIPE_CORE_PRIVATE;
-	struct sip_session *session = sipe_session_find_chat_by_id(sipe_private,
-								 id);
-
-	sipe_session_close(sipe_private, session);
-}
-
-int sipe_im_send(PurpleConnection *gc, const char *who, const char *what,
-		 SIPE_UNUSED_PARAMETER PurpleMessageFlags flags)
-{
-	struct sipe_core_private *sipe_private = PURPLE_GC_TO_SIPE_CORE_PRIVATE;
-	struct sip_session *session;
-	struct sip_dialog *dialog;
-	gchar *uri = sip_uri(who);
-
-	SIPE_DEBUG_INFO("sipe_im_send what='%s'", what);
-
-	session = sipe_session_find_or_add_im(sipe_private, uri);
-	dialog = sipe_dialog_find(session, uri);
-
-	// Queue the message
-	sipe_session_enqueue_message(session, what, NULL);
-
-	if (dialog && !dialog->outgoing_invite) {
-		sipe_im_process_queue(sipe_private, session);
-	} else if (!dialog || !dialog->outgoing_invite) {
-		// Need to send the INVITE to get the outgoing dialog setup
-		sipe_invite(sipe_private, session, uri, what, NULL, NULL, FALSE);
-	}
-
-	g_free(uri);
-	return 1;
-}
-
-int sipe_chat_send(PurpleConnection *gc, int id, const char *what,
-		 SIPE_UNUSED_PARAMETER PurpleMessageFlags flags)
-{
-	struct sipe_core_private *sipe_private = PURPLE_GC_TO_SIPE_CORE_PRIVATE;
-	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
-	struct sip_session *session;
-
-	SIPE_DEBUG_INFO("sipe_chat_send what='%s'", what);
-
-	session = sipe_session_find_chat_by_id(sipe_private, id);
-
-	// Queue the message
-	if (session && session->dialogs) {
-		sipe_session_enqueue_message(session,what,NULL);
-		sipe_im_process_queue(sipe_private, session);
-	} else if (sip) {
-		gchar *chat_name = purple_find_chat(sip->gc, id)->name;
-		const gchar *proto_chat_id = sipe_chat_find_name(chat_name);
-
-		SIPE_DEBUG_INFO("sipe_chat_send: chat_name='%s'", chat_name ? chat_name : "NULL");
-		SIPE_DEBUG_INFO("sipe_chat_send: proto_chat_id='%s'", proto_chat_id ? proto_chat_id : "NULL");
-
-		if (SIPE_CORE_PRIVATE_FLAG_IS(OCS2007)) {
-			struct sip_session *session = sipe_session_add_chat(sipe_private);
-
-			session->is_multiparty = FALSE;
-			session->focus_uri = g_strdup(proto_chat_id);
-			sipe_session_enqueue_message(session, what, NULL);
-			sipe_invite_conf_focus(sipe_private, session);
-		}
-	}
-
-	return 1;
-}
-
 /**
 * Returns 2005-style activity and Availability.
 *
@@ -3802,8 +2918,8 @@
 					char* email = sipe_xml_data(
 						sipe_xml_child(node, "email"));
 
-					sipe_update_user_info(sipe_private, uri, ALIAS_PROP, display_name);
-					sipe_update_user_info(sipe_private, uri, EMAIL_PROP, email);
+					sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_DISPLAY_NAME, display_name);
+					sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_EMAIL, email);
 
 					g_free(display_name);
 					g_free(email);
@@ -3812,35 +2928,35 @@
 				node = sipe_xml_child(card, "company");
 				if (node) {
 					char* company = sipe_xml_data(node);
-					sipe_update_user_info(sipe_private, uri, COMPANY_PROP, company);
+					sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_COMPANY, company);
 					g_free(company);
 				}
 				/* department */
 				node = sipe_xml_child(card, "department");
 				if (node) {
 					char* department = sipe_xml_data(node);
-					sipe_update_user_info(sipe_private, uri, DEPARTMENT_PROP, department);
+					sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_DEPARTMENT, department);
 					g_free(department);
 				}
 				/* title */
 				node = sipe_xml_child(card, "title");
 				if (node) {
 					char* title = sipe_xml_data(node);
-					sipe_update_user_info(sipe_private, uri, TITLE_PROP, title);
+					sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_JOB_TITLE, title);
 					g_free(title);
 				}
 				/* office */
 				node = sipe_xml_child(card, "office");
 				if (node) {
 					char* office = sipe_xml_data(node);
-					sipe_update_user_info(sipe_private, uri, OFFICE_PROP, office);
+					sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_OFFICE, office);
 					g_free(office);
 				}
 				/* site (url) */
 				node = sipe_xml_child(card, "url");
 				if (node) {
 					char* site = sipe_xml_data(node);
-					sipe_update_user_info(sipe_private, uri, SITE_PROP, site);
+					sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_SITE, site);
 					g_free(site);
 				}
 				/* phone */
@@ -3869,11 +2985,11 @@
 						char* zipcode = sipe_xml_data(sipe_xml_child(node, "zipcode"));
 						char* country_code = sipe_xml_data(sipe_xml_child(node, "countryCode"));
 
-						sipe_update_user_info(sipe_private, uri, ADDRESS_STREET_PROP, street);
-						sipe_update_user_info(sipe_private, uri, ADDRESS_CITY_PROP, city);
-						sipe_update_user_info(sipe_private, uri, ADDRESS_STATE_PROP, state);
-						sipe_update_user_info(sipe_private, uri, ADDRESS_ZIPCODE_PROP, zipcode);
-						sipe_update_user_info(sipe_private, uri, ADDRESS_COUNTRYCODE_PROP, country_code);
+						sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_STREET, street);
+						sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_CITY, city);
+						sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_STATE, state);
+						sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_ZIPCODE, zipcode);
+						sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_COUNTRY, country_code);
 
 						g_free(street);
 						g_free(city);
@@ -4072,7 +3188,7 @@
 		}
 
 		SIPE_DEBUG_INFO("process_incoming_notify_rlmi: %s", status);
-		sipe_got_user_status(sipe_private, uri, status);
+		sipe_core_buddy_got_status(SIPE_CORE_PUBLIC, uri, status);
 	}
 
 	sipe_xml_free(xn_categories);
@@ -4189,7 +3305,7 @@
 	if (display_name_node) {
 		char * display_name = sipe_xml_data(display_name_node);
 
-		sipe_update_user_info(sipe_private, uri, ALIAS_PROP, display_name);
+		sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_DISPLAY_NAME, display_name);
 		g_free(display_name);
 	}
 
@@ -4219,9 +3335,9 @@
 		}
 
 		SIPE_DEBUG_INFO("process_incoming_notify_pidf: status_id(%s)", status_id);
-		sipe_got_user_status(sipe_private, uri, status_id);
+		sipe_core_buddy_got_status(SIPE_CORE_PUBLIC, uri, status_id);
 	} else {
-		sipe_got_user_status(sipe_private, uri, SIPE_STATUS_ID_OFFLINE);
+		sipe_core_buddy_got_status(SIPE_CORE_PUBLIC, uri, SIPE_STATUS_ID_OFFLINE);
 	}
 
 	g_free(activity);
@@ -4304,7 +3420,6 @@
 	const sipe_xml *xn_state;
 	const sipe_xml *xn_contact;
 	char *note;
-	char *free_activity;
 	int user_avail;
 	const char *user_avail_nil;
 	int res_avail;
@@ -4341,8 +3456,6 @@
 		user_avail_since = 0;
 	}
 
-	free_activity = NULL;
-
 	name = sipe_xml_attribute(xn_presentity, "uri"); /* without 'sip:' prefix */
 	uri = sip_uri_from_name(name);
 	avl = sipe_xml_int_attribute(xn_availability, "aggregate", 0);
@@ -4363,10 +3476,10 @@
 		char *phone_number = xn_phone_number ? g_strdup(sipe_xml_attribute(xn_phone_number, "number")) : NULL;
 		char *tel_uri = sip_to_tel_uri(phone_number);
 
-		sipe_update_user_info(sipe_private, uri, ALIAS_PROP, display_name);
-		sipe_update_user_info(sipe_private, uri, EMAIL_PROP, email);
-		sipe_update_user_info(sipe_private, uri, PHONE_PROP, tel_uri);
-		sipe_update_user_info(sipe_private, uri, PHONE_DISPLAY_PROP, !is_empty(phone_label) ? phone_label : phone_number);
+		sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_DISPLAY_NAME, display_name);
+		sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_EMAIL, email);
+		sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_WORK_PHONE, tel_uri);
+		sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY, !is_empty(phone_label) ? phone_label : phone_number);
 
 		g_free(tel_uri);
 		g_free(phone_label);
@@ -4526,7 +3639,7 @@
 	g_free(activity);
 
 	SIPE_DEBUG_INFO("process_incoming_notify_msrtc: status(%s)", status_id);
-	sipe_got_user_status(sipe_private, uri, status_id);
+	sipe_core_buddy_got_status(SIPE_CORE_PUBLIC, uri, status_id);
 
 	if (!SIPE_CORE_PRIVATE_FLAG_IS(OCS2007) && sipe_strcase_equal(self_uri, uri)) {
 		sipe_user_info_has_updated(sipe_private, xn_userinfo);
@@ -5010,8 +4123,8 @@
 		}
 		sipe_xml_free(xml);
 
-		/* here we are parsing own request to figure out what publication
-		 * referensed here only by index went wrong
+		/* here we are parsing our own request to figure out what publication
+		 * referenced here only by index went wrong
 		 */
 		xml = sipe_xml_parse(trans->msg->body, trans->msg->bodylen);
 
@@ -5212,6 +4325,8 @@
 	{
 		gchar *availability_xml_str = NULL;
 		gchar *activity_xml_str = NULL;
+		gchar *escaped_subject = event->subject ? g_markup_escape_text(event->subject, -1) : NULL;
+		gchar *escaped_location = event->location ? g_markup_escape_text(event->location, -1) : NULL;
 
 		if (event->cal_status == SIPE_CAL_BUSY) {
 			availability_xml_str = g_strdup_printf(SIPE_PUB_XML_STATE_CALENDAR_AVAIL, 6500);
@@ -5237,8 +4352,8 @@
 					start_time_str,
 					availability_xml_str ? availability_xml_str : "",
 					activity_xml_str ? activity_xml_str : "",
-					event->subject ? event->subject : "",
-					event->location ? event->location : "",
+					escaped_subject ? escaped_subject : "",
+					escaped_location ? escaped_location : "",
 
 					instance,
 					publication_3 ? publication_3->version : 0,
@@ -5246,9 +4361,11 @@
 					start_time_str,
 					availability_xml_str ? availability_xml_str : "",
 					activity_xml_str ? activity_xml_str : "",
-					event->subject ? event->subject : "",
-					event->location ? event->location : ""
+					escaped_subject ? escaped_subject : "",
+					escaped_location ? escaped_location : ""
 					);
+		g_free(escaped_location);
+		g_free(escaped_subject);
 		g_free(start_time_str);
 		g_free(availability_xml_str);
 		g_free(activity_xml_str);
@@ -5492,8 +4609,8 @@
 	guint cal_data_instance = sipe_get_pub_instance(sipe_private, SIPE_PUB_CALENDAR_DATA);
 	char *fb_start_str;
 	char *free_busy_base64;
-	const char *st;
-	const char *fb;
+	/* const char *st; */
+	/* const char *fb; */
 	char *res;
 
 	/* key is <category><instance><container> */
@@ -5532,12 +4649,12 @@
 	fb_start_str = sipe_utils_time_to_str(cal->fb_start);
 	free_busy_base64 = sipe_cal_get_freebusy_base64(cal->free_busy);
 
-	st = publication_cal_300 ? publication_cal_300->fb_start_str : NULL;
-	fb = publication_cal_300 ? publication_cal_300->free_busy_base64 : NULL;
-
 	/* we will rebuplish the same data to refresh publication time,
 	 * so if data from multiple sources, most recent will be choosen
 	 */
+	// st = publication_cal_300 ? publication_cal_300->fb_start_str : NULL;
+	// fb = publication_cal_300 ? publication_cal_300->free_busy_base64 : NULL;
+	//
 	//if (sipe_strequal(st, fb_start_str) && sipe_strequal(fb, free_busy_base64))
 	//{
 	//	SIPE_DEBUG_INFO_NOFORMAT("sipe_publish_get_category_cal_free_busy: FreeBusy has NOT changed. Exiting.");
@@ -5948,6 +5065,8 @@
 		sipe_cal_calendar_free(sip->cal);
 	}
 	sip->cal = NULL;
+
+	sipe_groupchat_free(sipe_private);
 }
 
 /**
@@ -6168,20 +5287,22 @@
 	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 	gchar *note = NULL;
 	gboolean is_oof_note = FALSE;
-	gchar *activity = NULL;
+	const gchar *activity = NULL;
 	gchar *calendar = NULL;
-	gchar *meeting_subject = NULL;
-	gchar *meeting_location = NULL;
+	const gchar *meeting_subject = NULL;
+	const gchar *meeting_location = NULL;
 	gchar *access_text = NULL;
 	GSList *info = NULL;
 
-#define SIPE_ADD_BUDDY_INFO(l, t) \
+#define SIPE_ADD_BUDDY_INFO_COMMON(l, t) \
 	{ \
 		struct sipe_buddy_info *sbi = g_malloc(sizeof(struct sipe_buddy_info)); \
 		sbi->label = (l); \
 		sbi->text = (t); \
 		info = g_slist_append(info, sbi); \
 	}
+#define SIPE_ADD_BUDDY_INFO(l, t) SIPE_ADD_BUDDY_INFO_COMMON((l), g_markup_escape_text((t), -1))
+#define SIPE_ADD_BUDDY_INFO_NOESCAPE(l, t) SIPE_ADD_BUDDY_INFO_COMMON((l), (t))
 
 	if (sipe_public) { //happens on pidgin exit
 		struct sipe_buddy *sbuddy = g_hash_table_lookup(sipe_private->buddies, name);
@@ -6206,32 +5327,34 @@
 	//Layout
 	if (is_online)
 	{
-		gchar *status_str = g_strdup(activity ? activity : status_name);
+		const gchar *status_str = activity ? activity : status_name;
 
 		SIPE_ADD_BUDDY_INFO(_("Status"), status_str);
 	}
 	if (is_online && !is_empty(calendar))
 	{
 		SIPE_ADD_BUDDY_INFO(_("Calendar"), calendar);
-		calendar = NULL;
 	}
 	g_free(calendar);
 	if (!is_empty(meeting_location))
 	{
-		SIPE_ADD_BUDDY_INFO(_("Meeting in"), g_strdup(meeting_location));
+		SIPE_DEBUG_INFO("sipe_tooltip_text: %s meeting location: '%s'", name, meeting_location);
+		SIPE_ADD_BUDDY_INFO(_("Meeting in"), meeting_location);
 	}
 	if (!is_empty(meeting_subject))
 	{
-		SIPE_ADD_BUDDY_INFO(_("Meeting about"), g_strdup(meeting_subject));
+		SIPE_DEBUG_INFO("sipe_tooltip_text: %s meeting subject: '%s'", name, meeting_subject);
+		SIPE_ADD_BUDDY_INFO(_("Meeting about"), meeting_subject);
 	}
 	if (note)
 	{
 		SIPE_DEBUG_INFO("sipe_tooltip_text: %s note: '%s'", name, note);
-		SIPE_ADD_BUDDY_INFO(is_oof_note ? _("Out of office note") : _("Note"),
+		SIPE_ADD_BUDDY_INFO_NOESCAPE(is_oof_note ? _("Out of office note") : _("Note"),
 				 g_strdup_printf("%s", note));
 	}
 	if (access_text) {
 		SIPE_ADD_BUDDY_INFO(_("Access level"), access_text);
+		g_free(access_text);
 	}
 
 	return(info);
@@ -6280,10 +5403,10 @@
 
 	b = purple_find_buddy_in_group(buddy->account, buddy->name, group);
 	if (!b){
-		purple_blist_add_buddy_clone(group, buddy);
+		b = purple_blist_add_buddy_clone(group, buddy);
 	}
 
-	sipe_group_buddy(gc, buddy->name, NULL, group_name);
+	sipe_add_buddy(gc, b, group);
 }
 
 static void
@@ -6303,21 +5426,17 @@
 		gchar *self = sip_uri_self(sipe_private);
 		struct sip_session *session;
 
-		session = sipe_session_add_chat(sipe_private);
-		session->chat_title = sipe_chat_get_name(session->callid);
-		session->roster_manager = g_strdup(self);
-
-		session->backend_session = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
-								 session->chat_id,
-								 session->chat_title,
-								 self,
-								 FALSE);
-		sipe_backend_chat_add(session->backend_session,
-				 self,
-				 FALSE);
-		sipe_invite(sipe_private, session, buddy->name, NULL, NULL, NULL, FALSE);
-
+		session = sipe_session_add_chat(sipe_private,
+						NULL,
+						TRUE,
+						self);
+		session->chat_session->backend = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
+									 session->chat_session,
+									 session->chat_session->title,
+									 self);
 		g_free(self);
+
+		sipe_im_invite(sipe_private, session, buddy->name, NULL, NULL, NULL, FALSE);
 	}
 }
 
@@ -6325,15 +5444,16 @@
 * For 2007+ conference only.
 */
 static void
-sipe_buddy_menu_chat_make_leader_cb(PurpleBuddy *buddy, const char *chat_title)
+sipe_buddy_menu_chat_make_leader_cb(PurpleBuddy *buddy,
+				 struct sipe_chat_session *chat_session)
 {
 	struct sipe_core_private *sipe_private = PURPLE_BUDDY_TO_SIPE_CORE_PRIVATE;
 	struct sip_session *session;
 
 	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_make_leader_cb: buddy->name=%s", buddy->name);
-	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_make_leader_cb: chat_title=%s", chat_title);
+	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_make_leader_cb: chat_title=%s", chat_session->title);
 
-	session = sipe_session_find_chat_by_title(sipe_private, chat_title);
+	session = sipe_session_find_chat(sipe_private, chat_session);
 
 	sipe_conf_modify_user_role(sipe_private, session, buddy->name);
 }
@@ -6342,31 +5462,30 @@
 * For 2007+ conference only.
 */
 static void
-sipe_buddy_menu_chat_remove_cb(PurpleBuddy *buddy, const char *chat_title)
+sipe_buddy_menu_chat_remove_cb(PurpleBuddy *buddy,
+			 struct sipe_chat_session *chat_session)
 {
 	struct sipe_core_private *sipe_private = PURPLE_BUDDY_TO_SIPE_CORE_PRIVATE;
 	struct sip_session *session;
 
 	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_remove_cb: buddy->name=%s", buddy->name);
-	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_remove_cb: chat_title=%s", chat_title);
+	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_remove_cb: chat_title=%s", chat_session->title);
 
-	session = sipe_session_find_chat_by_title(sipe_private, chat_title);
+	session = sipe_session_find_chat(sipe_private, chat_session);
 
 	sipe_conf_delete_user(sipe_private, session, buddy->name);
 }
 
 static void
-sipe_buddy_menu_chat_invite_cb(PurpleBuddy *buddy, char *chat_title)
+sipe_buddy_menu_chat_invite_cb(PurpleBuddy *buddy,
+			 struct sipe_chat_session *chat_session)
 {
 	struct sipe_core_private *sipe_private = PURPLE_BUDDY_TO_SIPE_CORE_PRIVATE;
-	struct sip_session *session;
 
 	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_invite_cb: buddy->name=%s", buddy->name);
-	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_invite_cb: chat_title=%s", chat_title);
+	SIPE_DEBUG_INFO("sipe_buddy_menu_chat_invite_cb: chat_title=%s", chat_session->title);
 
-	session = sipe_session_find_chat_by_title(sipe_private, chat_title);
-
-	sipe_invite_to_chat(sipe_private, session, buddy->name);
+	sipe_core_chat_invite(SIPE_CORE_PUBLIC, chat_session, buddy->name);
 }
 
 static void
@@ -6460,44 +5579,50 @@
 	gchar *self = sip_uri_self(sipe_private);
 
 	SIPE_SESSION_FOREACH {
-		if (!sipe_strcase_equal(self, buddy->name) && session->chat_title && session->backend_session)
+		if (!sipe_strcase_equal(self, buddy->name) && session->chat_session)
 		{
-			if (sipe_backend_chat_find(session->backend_session, buddy->name))
+			struct sipe_chat_session *chat_session = session->chat_session;
+			gboolean is_conf = (chat_session->type == SIPE_CHAT_TYPE_CONFERENCE);
+
+			if (sipe_backend_chat_find(chat_session->backend, buddy->name))
 			{
-				gboolean conf_op = sipe_backend_chat_is_operator(session->backend_session, self);
+				gboolean conf_op = sipe_backend_chat_is_operator(chat_session->backend, self);
 
-				if (session->focus_uri
-				 && !sipe_backend_chat_is_operator(session->backend_session, buddy->name) /* Not conf OP */
+				if (is_conf
+				 && !sipe_backend_chat_is_operator(chat_session->backend, buddy->name) /* Not conf OP */
 				 && conf_op) /* We are a conf OP */
 				{
-					gchar *label = g_strdup_printf(_("Make leader of '%s'"), session->chat_title);
+					gchar *label = g_strdup_printf(_("Make leader of '%s'"),
+								 chat_session->title);
 					act = purple_menu_action_new(label,
 								 PURPLE_CALLBACK(sipe_buddy_menu_chat_make_leader_cb),
-								 session->chat_title, NULL);
+								 chat_session, NULL);
 					g_free(label);
 					menu = g_list_prepend(menu, act);
 				}
 
-				if (session->focus_uri
+				if (is_conf
 				 && conf_op) /* We are a conf OP */
 				{
-					gchar *label = g_strdup_printf(_("Remove from '%s'"), session->chat_title);
+					gchar *label = g_strdup_printf(_("Remove from '%s'"),
+								 chat_session->title);
 					act = purple_menu_action_new(label,
 								 PURPLE_CALLBACK(sipe_buddy_menu_chat_remove_cb),
-								 session->chat_title, NULL);
+								 chat_session, NULL);
 					g_free(label);
 					menu = g_list_prepend(menu, act);
 				}
 			}
 			else
 			{
-				if (!session->focus_uri
-				 || (session->focus_uri && !session->locked))
+				if (!is_conf
+				 || (is_conf && !session->locked))
 				{
-					gchar *label = g_strdup_printf(_("Invite to '%s'"), session->chat_title);
+					gchar *label = g_strdup_printf(_("Invite to '%s'"),
+								 chat_session->title);
 					act = purple_menu_action_new(label,
 								 PURPLE_CALLBACK(sipe_buddy_menu_chat_invite_cb),
-								 session->chat_title, NULL);
+								 chat_session, NULL);
 					g_free(label);
 					menu = g_list_prepend(menu, act);
 				}
@@ -6889,68 +6014,6 @@
 	return menu_access_levels;
 }
 
-static void
-sipe_conf_modify_lock(PurpleChat *chat, gboolean locked)
-{
-	struct sipe_core_private *sipe_private = PURPLE_CHAT_TO_SIPE_CORE_PRIVATE;
-	struct sip_session *session;
-
-	session = sipe_session_find_chat_by_title(sipe_private,
-						 (gchar *)g_hash_table_lookup(chat->components, "channel"));
-	sipe_conf_modify_conference_lock(sipe_private, session, locked);
-}
-
-static void
-sipe_chat_menu_unlock_cb(PurpleChat *chat)
-{
-	SIPE_DEBUG_INFO_NOFORMAT("sipe_chat_menu_unlock_cb() called");
-	sipe_conf_modify_lock(chat, FALSE);
-}
-
-static void
-sipe_chat_menu_lock_cb(PurpleChat *chat)
-{
-	SIPE_DEBUG_INFO_NOFORMAT("sipe_chat_menu_lock_cb() called");
-	sipe_conf_modify_lock(chat, TRUE);
-}
-
-GList *
-sipe_chat_menu(PurpleChat *chat)
-{
-	PurpleMenuAction *act;
-	GList *menu = NULL;
-	struct sipe_core_private *sipe_private = PURPLE_CHAT_TO_SIPE_CORE_PRIVATE;
-	struct sip_session *session;
-	gchar *self;
-
-	session = sipe_session_find_chat_by_title(sipe_private,
-						 (gchar *)g_hash_table_lookup(chat->components, "channel"));
-	if (!session) return NULL;
-
-	self = sip_uri_self(sipe_private);
-
-	if (session->focus_uri &&
-	 sipe_backend_chat_is_operator(session->backend_session, self))
-	{
-		if (session->locked) {
-			act = purple_menu_action_new(_("Unlock"),
-						 PURPLE_CALLBACK(sipe_chat_menu_unlock_cb),
-						 NULL, NULL);
-			menu = g_list_prepend(menu, act);
-		} else {
-			act = purple_menu_action_new(_("Lock"),
-						 PURPLE_CALLBACK(sipe_chat_menu_lock_cb),
-						 NULL, NULL);
-			menu = g_list_prepend(menu, act);
-		}
-	}
-
-	menu = g_list_reverse(menu);
-
-	g_free(self);
-	return menu;
-}
-
 static gboolean
 process_get_info_response(struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg, struct transaction *trans)
@@ -7009,10 +6072,10 @@
 			if (!SIPE_CORE_PRIVATE_FLAG_IS(OCS2007)) {
 				char *tel_uri = sip_to_tel_uri(phone_number);
 				/* trims its parameters, so call first */
-				sipe_update_user_info(sipe_private, uri, ALIAS_PROP, server_alias);
-				sipe_update_user_info(sipe_private, uri, EMAIL_PROP, email);
-				sipe_update_user_info(sipe_private, uri, PHONE_PROP, tel_uri);
-				sipe_update_user_info(sipe_private, uri, PHONE_DISPLAY_PROP, phone_number);
+				sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_DISPLAY_NAME, server_alias);
+				sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_EMAIL, email);
+				sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_WORK_PHONE, tel_uri);
+				sipe_update_user_info(sipe_private, uri, SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY, phone_number);
 				g_free(tel_uri);
 			}
 
--- pidgin-sipe-1.11.2/src/core/sipe-chat.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-chat.c	2011-06-14 14:40:36.000000000 +0200
@@ -39,6 +39,8 @@
 #include "sipe-core.h"
 #include "sipe-core-private.h"
 #include "sipe-dialog.h"
+#include "sipe-groupchat.h"
+#include "sipe-im.h"
 #include "sipe-nls.h"
 #include "sipe-schedule.h"
 #include "sipe-session.h"
@@ -46,70 +48,191 @@
 #include "sipe-xml.h"
 #include "sipe.h"
 
-void sipe_core_chat_create(struct sipe_core_public *sipe_public, int id,
+/**
+ * Invite @who to chat
+ *
+ * @param sipe_private SIPE core private data
+ * @param session SIPE session for chat
+ * @param who URI whom to invite to chat.
+ */
+static void
+sipe_invite_to_chat(struct sipe_core_private *sipe_private,
+		 struct sip_session *session,
+		 const gchar *who);
+
+static GList *chat_sessions = NULL;
+
+struct sipe_chat_session *sipe_chat_create_session(enum sipe_chat_type type,
+						 const gchar *id,
+						 const gchar *title)
+{
+	struct sipe_chat_session *session = g_new0(struct sipe_chat_session, 1);
+	if (id)
+		session->id = g_strdup(id);
+	session->title = g_strdup(title);
+	session->type = type;
+	chat_sessions = g_list_prepend(chat_sessions, session);
+	return(session);
+}
+
+void sipe_chat_remove_session(struct sipe_chat_session *session)
+{
+	chat_sessions = g_list_remove(chat_sessions, session);
+	sipe_backend_chat_session_destroy(session->backend);
+	g_free(session->title);
+	g_free(session->id);
+	g_free(session);
+}
+
+void sipe_chat_destroy(void)
+{
+	while (chat_sessions) {
+		struct sipe_chat_session *chat_session = chat_sessions->data;
+		SIPE_DEBUG_INFO("sipe_chat_destroy: '%s' (%s)",
+				chat_session->title, chat_session->id);
+		sipe_chat_remove_session(chat_session);
+	}
+}
+
+void sipe_core_chat_invite(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session,
 			 const char *name)
 {
-	struct sip_session *session = sipe_session_find_chat_by_id(SIPE_CORE_PRIVATE,
-								 id);
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+
+	SIPE_DEBUG_INFO("sipe_core_chat_create: who '%s'", name);
+
+	switch (chat_session->type) {
+	case SIPE_CHAT_TYPE_MULTIPARTY:
+	case SIPE_CHAT_TYPE_CONFERENCE:
+		{
+			struct sip_session *session = sipe_session_find_chat(sipe_private,
+									 chat_session);
 
 	if (session) {
 		gchar *uri = sip_uri(name);
-		sipe_invite_to_chat(SIPE_CORE_PRIVATE, session, uri);
+				sipe_invite_to_chat(sipe_private, session, uri);
 		g_free(uri);
 	}
 }
+		break;
+	case SIPE_CHAT_TYPE_GROUPCHAT:
+		/* @TODO */
+		SIPE_DEBUG_INFO_NOFORMAT("GROUP CHAT: INVITE NOT IMPLEMENTED!");
+		break;
+	default:
+		break;
+	}
+}
 
-/** See below. Same as chat_names but swapped key with values */
-static GHashTable *chat_names_inverse = NULL;
-
-gchar *
-sipe_chat_get_name(const gchar *proto_chat_id)
+void sipe_core_chat_rejoin(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session)
 {
-	/**
-	 * A non-volatile mapping of protocol's chat identification
-	 * to purple's chat-name. The latter is very important to
-	 * find/rejoin chat.
-	 *
-	 * @key for 2007 conference this is (gchar *) Focus URI
-	 * for 2005 multiparty chat this is (gchar *) Call-Id of the conversation.
-	 * @value a purple chat name.
-	 */
-	static GHashTable *chat_names = NULL;
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 
-	/**
-	 * A non-volatile chat counter.
-	 * Should survive protocol reload.
-	 */
-	static int chat_seq = 0;
+	SIPE_DEBUG_INFO("sipe_core_chat_rejoin: '%s'", chat_session->title);
 
-	char *chat_name = NULL;
+	switch (chat_session->type) {
+	case SIPE_CHAT_TYPE_MULTIPARTY:
+		{
+			struct sip_session *session = sipe_session_add_chat(sipe_private,
+									 chat_session,
+									 TRUE,
+									 NULL);
+			gchar *self = sip_uri_self(sipe_private);
 
-	if (!chat_names) {
-		chat_names = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+			sipe_invite_to_chat(sipe_private, session, self);
+			sipe_backend_chat_rejoin(SIPE_CORE_PUBLIC,
+						 chat_session->backend,
+						 self,
+						 chat_session->title);
+			g_free(self);
+		}
+		break;
+	case SIPE_CHAT_TYPE_CONFERENCE:
+		sipe_conf_create(sipe_private, chat_session, NULL);
+		break;
+	case SIPE_CHAT_TYPE_GROUPCHAT:
+		sipe_groupchat_rejoin(sipe_private, chat_session);
+		break;
+	default:
+		break;
 	}
-	if (!chat_names_inverse) {
-		chat_names_inverse = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 	}
 
-	if (proto_chat_id) {
-		chat_name = g_hash_table_lookup(chat_names, proto_chat_id);
-		SIPE_DEBUG_INFO("sipe_chat_get_name: lookup results: %s", chat_name ? chat_name : "NULL");
+void sipe_core_chat_leave(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+
+	SIPE_DEBUG_INFO("sipe_core_chat_leave: '%s'", chat_session->title);
+
+	switch (chat_session->type) {
+	case SIPE_CHAT_TYPE_MULTIPARTY:
+	case SIPE_CHAT_TYPE_CONFERENCE:
+		{
+			struct sip_session *session = sipe_session_find_chat(sipe_private,
+									 chat_session);
+
+			if (session) {
+				sipe_session_close(sipe_private, session);
+			}
+		}
+		break;
+	case SIPE_CHAT_TYPE_GROUPCHAT:
+		sipe_groupchat_leave(sipe_private, chat_session);
+		break;
+	default:
+		break;
 	}
-	if (!chat_name) {
-		chat_name = g_strdup_printf(_("Chat #%d"), ++chat_seq);
-		g_hash_table_insert(chat_names, g_strdup(proto_chat_id), chat_name);
-		g_hash_table_insert(chat_names_inverse, chat_name, g_strdup(proto_chat_id));
-		SIPE_DEBUG_INFO("sipe_chat_get_name: added new: %s", chat_name);
 	}
 
-	return g_strdup(chat_name);
+void sipe_core_chat_send(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session,
+			 const char *what)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+
+	SIPE_DEBUG_INFO("sipe_core_chat_send: '%s' to '%s'",
+			what, chat_session->title);
+
+	switch (chat_session->type) {
+	case SIPE_CHAT_TYPE_MULTIPARTY:
+	case SIPE_CHAT_TYPE_CONFERENCE:
+		{
+			struct sip_session *session = sipe_session_find_chat(sipe_private,
+									 chat_session);
+
+			if (session) {
+				sipe_session_enqueue_message(session,
+							 what,
+							 NULL);
+				sipe_im_process_queue(sipe_private, session);
+			}
+		}
+		break;
+	case SIPE_CHAT_TYPE_GROUPCHAT:
+		sipe_groupchat_send(sipe_private, chat_session, what);
+		break;
+	default:
+		break;
+	}
 }
 
-const gchar *
-sipe_chat_find_name(const gchar *chat_name)
+gchar *
+sipe_chat_get_name(void)
 {
-	if (!chat_names_inverse) return NULL;
-	return(g_hash_table_lookup(chat_names_inverse, chat_name));
+	/**
+	 * A non-volatile ID counter.
+	 * Should survive connection drop & reconnect.
+	 */
+	static guint chat_seq = 0;
+
+	/* Generate next ID */
+	gchar *chat_name = g_strdup_printf(_("Chat #%d"), ++chat_seq);
+	SIPE_DEBUG_INFO("sipe_chat_get_name: added new: %s", chat_name);
+
+	return chat_name;
 }
 
 static void
@@ -121,7 +244,7 @@
 	gchar *contact;
 	gchar *epid = get_epid(sipe_private);
 	struct sip_dialog *dialog = sipe_dialog_find(session,
-						 session->roster_manager);
+						 session->chat_session->id);
 	const char *ourtag = dialog && dialog->ourtag ? dialog->ourtag : NULL;
 
 	contact = get_contact(sipe_private);
@@ -140,8 +263,8 @@
 
 	sip_transport_request(sipe_private,
 			 "REFER",
-			 session->roster_manager,
-			 session->roster_manager,
+			 session->chat_session->id,
+			 session->chat_session->id,
 			 hdr,
 			 NULL,
 			 dialog,
@@ -210,18 +333,28 @@
 	}
 }
 
+void sipe_chat_set_roster_manager(struct sip_session *session,
+				 const gchar *roster_manager)
+{
+	struct sipe_chat_session *chat_session = session->chat_session;
+
+	g_free(chat_session->id);
+	chat_session->id = NULL;
+	if (roster_manager)
+		chat_session->id = g_strdup(roster_manager);
+}
+
 static void
 sipe_election_result(struct sipe_core_private *sipe_private,
 		 void *sess)
 {
 	struct sip_session *session = (struct sip_session *)sess;
-	gchar *rival;
-	gboolean has_won = TRUE;
+	const gchar *rival = NULL;
 
-	if (session->roster_manager) {
+	if (session->chat_session->id) {
 		SIPE_DEBUG_INFO(
 			"sipe_election_result: RM has already been elected in the meantime. It is %s",
-			session->roster_manager);
+			session->chat_session->id);
 		return;
 	}
 
@@ -229,23 +362,25 @@
 
 	SIPE_DIALOG_FOREACH {
 		if (dialog->election_vote < 0) {
-			has_won = FALSE;
 			rival = dialog->with;
 			break;
 		}
 	} SIPE_DIALOG_FOREACH_END;
 
-	if (has_won) {
+	if (rival) {
+		SIPE_DEBUG_INFO("sipe_election_result: we loose RM election to %s", rival);
+	} else {
+		gchar *self = sip_uri_self(sipe_private);
+
 		SIPE_DEBUG_INFO_NOFORMAT("sipe_election_result: we have won RM election!");
 
-		session->roster_manager = sip_uri_self(sipe_private);
+		sipe_chat_set_roster_manager(session, self);
+		g_free(self);
 
 		SIPE_DIALOG_FOREACH {
 			/* send SetRM to each chat participant*/
 			sipe_send_election_set_rm(sipe_private, dialog);
 		} SIPE_DIALOG_FOREACH_END;
-	} else {
-		SIPE_DEBUG_INFO("sipe_election_result: we loose RM election to %s", rival);
 	}
 	session->bid = 0;
 
@@ -359,27 +494,27 @@
 			 NULL);
 }
 
-void
+static void
 sipe_invite_to_chat(struct sipe_core_private *sipe_private,
 		 struct sip_session *session,
 		 const gchar *who)
 {
 	/* a conference */
-	if (session->focus_uri)
+	if (session->chat_session->type == SIPE_CHAT_TYPE_CONFERENCE)
 	{
 		sipe_invite_conf(sipe_private, session, who);
 	}
 	else /* a multi-party chat */
 	{
 		gchar *self = sip_uri_self(sipe_private);
-		if (session->roster_manager) {
-			if (sipe_strcase_equal(session->roster_manager, self)) {
-				sipe_invite(sipe_private, session, who, NULL, NULL, NULL, FALSE);
+		if (session->chat_session->id) {
+			if (sipe_strcase_equal(session->chat_session->id, self)) {
+				sipe_im_invite(sipe_private, session, who, NULL, NULL, NULL, FALSE);
 			} else {
 				sipe_refer(sipe_private, session, who);
 			}
 		} else {
-			SIPE_DEBUG_INFO_NOFORMAT("sipe_buddy_menu_chat_invite: no RM available");
+			SIPE_DEBUG_INFO_NOFORMAT("sipe_invite_to_chat: no RM available");
 
 			session->pending_invite_queue = slist_insert_unique_sorted(
 				session->pending_invite_queue, g_strdup(who), (GCompareFunc)strcmp);
--- pidgin-sipe-1.11.2/src/core/sipe-chat.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-chat.h	2011-06-14 14:40:36.000000000 +0200
@@ -23,28 +23,63 @@
 /* Forward declarations */
 struct sipe_core_private;
 struct sip_session;
+struct sipe_backend_chat_session;
 
-/**
- * Returns purple's chat name for provided chat identification in protocol.
- * Stores newly created chat title if not yet exist.
+enum sipe_chat_type {
+	SIPE_CHAT_TYPE_UNKNOWN = 0,
+	SIPE_CHAT_TYPE_MULTIPARTY,
+	SIPE_CHAT_TYPE_CONFERENCE,
+	SIPE_CHAT_TYPE_GROUPCHAT
+};
+
+struct sipe_chat_session {
+	struct sipe_backend_chat_session *backend;
+
+	/*
+	 * Chat identifier (must be unique per account)
 *
- * @param proto_chat_id for 2007 conference this is (gchar *) Focus URI,
- * for 2005 multiparty chat this is (gchar *) Call-Id of the conversation.
+	 * 2007 Group chat: channel URI
+	 * 2007 Conference: focus URI
+	 * 2005 multiparty chat: roster manager SIP URI
+	 */
+	gchar *id;
+
+	/* Human readable chat identifier (can have duplicates) */
+	gchar *title;
+
+	enum sipe_chat_type type;
+};
+
+/**
+ * Create a new chat session
 *
- * @return chat name. Must be g_free()'d after use
+ * @param session
 */
-gchar *
-sipe_chat_get_name(const gchar *proto_chat_id);
+struct sipe_chat_session *
+sipe_chat_create_session(enum sipe_chat_type type,
+			 const gchar *id, const gchar *title);
 
 /**
- * Returns protocol id for provided purple's chat name
+ * Remove a chat session
 *
- * @param chat_name chat name
+ * @param session
+ */
+void
+sipe_chat_remove_session(struct sipe_chat_session *session);
+
+/**
+ * Release resources on unload
+ */
+void
+sipe_chat_destroy(void);
+
+/**
+ * Generate a name for a new private chat.
 *
- * @return protocol id
+ * @return chat name. Must be g_free()'d after use
 */
-const gchar *
-sipe_chat_find_name(const gchar *chat_name);
+gchar *
+sipe_chat_get_name(void);
 
 /**
 * 
@@ -57,13 +92,10 @@
 				 struct sip_session *session);
 
 /**
- * Invite @who to chat
+ * Set roster manager URI for a multiparty chat
 *
- * @param sipe_private SIPE core private data
 * @param session SIPE session for chat
- * @param who URI whom to invite to chat.
+ * @param roster_manager New roster manager URI or NULL
 */
-void
-sipe_invite_to_chat(struct sipe_core_private *sipe_private,
-		 struct sip_session *session,
-		 const gchar *who);
+void sipe_chat_set_roster_manager(struct sip_session *session,
+				 const gchar *roster_manager);
--- pidgin-sipe-1.11.2/src/core/sipe-conf.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-conf.c	2011-06-14 14:40:36.000000000 +0200
@@ -36,18 +36,30 @@
 #include "sipmsg.h"
 #include "sip-transport.h"
 #include "sipe-backend.h"
+#include "sipe-buddy.h"
 #include "sipe-chat.h"
 #include "sipe-conf.h"
 #include "sipe-core.h"
 #include "sipe-core-private.h"
 #include "sipe-dialog.h"
+#include "sipe-im.h"
+#ifdef HAVE_VV
+#include "sipe-media.h"
+#endif
 #include "sipe-nls.h"
 #include "sipe-session.h"
 #include "sipe-subscriptions.h"
+#include "sipe-user.h"
 #include "sipe-utils.h"
 #include "sipe-xml.h"
 #include "sipe.h"
 
+#ifdef HAVE_VV
+#define ENTITY_VIEW_AUDIO_VIDEO "<msci:entity-view entity=\"audio-video\"/>"
+#else
+#define ENTITY_VIEW_AUDIO_VIDEO
+#endif
+
 /**
 * Add Conference request to FocusFactory.
 * @param focus_factory_uri (%s) Ex.: sip:bob7@boston.local;gruu;opaque=app:conf:focusfactory
@@ -74,6 +86,7 @@
 			"</ci:conference-description>"\
 			"<msci:conference-view>"\
 				"<msci:entity-view entity=\"chat\"/>"\
+				ENTITY_VIEW_AUDIO_VIDEO \
 			"</msci:conference-view>"\
 		"</ci:conference-info>"\
 	"</addConference>"\
@@ -207,7 +220,7 @@
 			 gboolean expires)
 {
 	sipe_subscribe(sipe_private,
-		 session->focus_uri,
+		 session->chat_session->id,
 		 "conference",
 		 "application/conference-info+xml",
 		 expires ? "Expires: 0\r\n" : NULL,
@@ -249,8 +262,13 @@
 	}
 
 	if (msg->response >= 400) {
+		gchar *reason = sipmsg_get_ms_diagnostics_reason(msg);
+
 		SIPE_DEBUG_INFO_NOFORMAT("process_invite_conf_focus_response: INVITE response is not 200. Failed to join focus.");
-		/* @TODO notify user of failure to join focus */
+		sipe_backend_notify_error(_("Failed to join the conference"),
+					 reason ? reason : _("no reason given"));
+		g_free(reason);
+
 		sipe_session_remove(sipe_private, session);
 		g_free(focus_uri);
 		return FALSE;
@@ -260,6 +278,11 @@
 		if (sipe_strequal(code, "success")) {
 			/* subscribe to focus */
 			sipe_subscribe_conference(sipe_private, session, FALSE);
+#ifdef HAVE_VV
+			if (session->is_call)
+				sipe_core_media_connect_conference(SIPE_CORE_PUBLIC,
+								 session->chat_session);
+#endif
 		}
 		sipe_xml_free(xn_response);
 	}
@@ -268,30 +291,63 @@
 	return TRUE;
 }
 
-/** Invite us to the focus */
-void
-sipe_invite_conf_focus(struct sipe_core_private *sipe_private,
-		 struct sip_session *session)
+struct sip_session *
+sipe_core_conf_create(struct sipe_core_public *sipe_public,
+		 const gchar *focus_uri)
+{
+	gchar *buf;
+	const gchar *focus_uri_ue;
+	struct sip_session *session = NULL;
+
+	focus_uri_ue = buf = sipe_utils_uri_unescape(focus_uri);
+
+	// URI can have this prefix if it was typed in by the user
+	if (g_str_has_prefix(focus_uri_ue, "meet:"))
+		focus_uri_ue += 5;
+
+	if (!focus_uri_ue || !g_str_has_prefix(focus_uri_ue, "sip:") ||
+	 strlen(focus_uri_ue) == 4 || g_strstr_len(focus_uri_ue, -1, "%")) {
+		gchar *error = g_strdup_printf(_("\"%s\" is not a valid focus URI"),
+					 focus_uri ? focus_uri : "");
+		sipe_backend_notify_error(_("Failed to join the conference"),
+					 error);
+		g_free(error);
+	} else {
+		gchar *querystr = g_strstr_len(focus_uri_ue, -1, "?");
+		if (querystr) {
+			/* TODO: Investigate how conf-key field should be used,
+			 * ignoring for now */
+			*querystr = '\0';
+		}
+
+		session = sipe_conf_create(SIPE_CORE_PRIVATE, NULL, focus_uri_ue);
+	}
+
+	g_free(buf);
+
+	return session;
+}
+
+/** Create new session with Focus URI */
+struct sip_session *
+sipe_conf_create(struct sipe_core_private *sipe_private,
+		 struct sipe_chat_session *chat_session,
+		 const gchar *focus_uri)
 {
 	gchar *hdr;
 	gchar *contact;
 	gchar *body;
 	gchar *self;
+	struct sip_session *session = sipe_session_add_chat(sipe_private,
+							 chat_session,
+							 FALSE,
+							 focus_uri);
 
-	if (session->focus_dialog && session->focus_dialog->is_established) {
-		SIPE_DEBUG_INFO("session with %s already has a dialog open", session->focus_uri);
-		return;
-	}
-
-	if(!session->focus_dialog) {
 		session->focus_dialog = g_new0(struct sip_dialog, 1);
 		session->focus_dialog->callid = gencallid();
-		session->focus_dialog->with = g_strdup(session->focus_uri);
+	session->focus_dialog->with = g_strdup(session->chat_session->id);
 		session->focus_dialog->endpoint_GUID = rand_guid();
-	}
-	if (!(session->focus_dialog->ourtag)) {
 		session->focus_dialog->ourtag = gentag();
-	}
 
 	contact = get_contact(sipe_private);
 	hdr = g_strdup_printf(
@@ -312,7 +368,6 @@
 		session->focus_dialog->with,
 		self,
 		session->focus_dialog->endpoint_GUID);
-	g_free(self);
 
 	session->focus_dialog->outgoing_invite =
 		sip_transport_invite(sipe_private,
@@ -322,6 +377,20 @@
 				 process_invite_conf_focus_response);
 	g_free(body);
 	g_free(hdr);
+
+	/* Rejoin existing session? */
+	if (chat_session) {
+		SIPE_DEBUG_INFO("sipe_conf_create: rejoin '%s' (%s)",
+				chat_session->title,
+				chat_session->id);
+		sipe_backend_chat_rejoin(SIPE_CORE_PUBLIC,
+					 chat_session->backend,
+					 self,
+					 chat_session->title);
+	}
+	g_free(self);
+
+	return(session);
 }
 
 /** Modify User Role */
@@ -362,16 +431,55 @@
 	g_free(hdr);
 }
 
-/** Modify Conference Lock */
+/**
+ * Check conference lock status
+ */
+sipe_chat_lock_status sipe_core_chat_lock_status(struct sipe_core_public *sipe_public,
+						 struct sipe_chat_session *chat_session)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+	sipe_chat_lock_status status = SIPE_CHAT_LOCK_STATUS_NOT_ALLOWED;
+
+	if (chat_session &&
+	 (chat_session->type == SIPE_CHAT_TYPE_CONFERENCE)) {
+		struct sip_session *session = sipe_session_find_chat(sipe_private,
+								 chat_session);
+		if (session) {
+			gchar *self = sip_uri_self(sipe_private);
+
+			/* Only operators are allowed to change the lock status */
+			if (sipe_backend_chat_is_operator(chat_session->backend, self)) {
+				status = session->locked ?
+					SIPE_CHAT_LOCK_STATUS_LOCKED :
+					SIPE_CHAT_LOCK_STATUS_UNLOCKED;
+			}
+
+			g_free(self);
+		}
+	}
+
+	return(status);
+}
+
+/**
+ * Modify Conference Lock
+ * Sends request to Focus.
+ * INFO method is a carrier of application/cccp+xml
+ */
 void
-sipe_conf_modify_conference_lock(struct sipe_core_private *sipe_private,
-				 struct sip_session *session,
+sipe_core_chat_modify_lock(struct sipe_core_public *sipe_public,
+			 struct sipe_chat_session *chat_session,
 				 const gboolean locked)
 {
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 	gchar *hdr;
 	gchar *body;
 	gchar *self;
 
+	struct sip_session *session = sipe_session_find_chat(sipe_private,
+							 chat_session);
+
+	if (!session) return;
 	if (!session->focus_dialog || !session->focus_dialog->is_established) {
 		SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_modify_conference_lock: no dialog with focus, exiting.");
 		return;
@@ -447,7 +555,7 @@
 	struct sip_dialog *dialog = g_new0(struct sip_dialog, 1);
 
 	dialog->callid = g_strdup(sipmsg_find_header(msg, "Call-ID"));
-	dialog->cseq = parse_cseq(sipmsg_find_header(msg, "CSeq"));
+	dialog->cseq = sipmsg_parse_cseq(msg);
 	dialog->with = parse_from(sipmsg_find_header(msg, "To"));
 	sipe_dialog_parse(dialog, msg, TRUE);
 
@@ -512,7 +620,7 @@
 
 	body = g_strdup_printf(
 		SIPE_SEND_CONF_INVITE,
-		session->focus_uri,
+		session->chat_session->id,
 		session->subject ? session->subject : ""
 		);
 
@@ -543,20 +651,17 @@
 		if (sipe_strequal("success", sipe_xml_attribute(xn_response, "code")))
 		{
 			gchar *who = trans->payload->data;
-			struct sip_session *session;
 			const sipe_xml *xn_conference_info = sipe_xml_child(xn_response, "addConference/conference-info");
+			struct sip_session *session = sipe_conf_create(sipe_private,
+								 NULL,
+								 sipe_xml_attribute(xn_conference_info,
+											 "entity"));
 
-			session = sipe_session_add_chat(sipe_private);
-			session->is_multiparty = FALSE;
-			session->focus_uri = g_strdup(sipe_xml_attribute(xn_conference_info, "entity"));
 			SIPE_DEBUG_INFO("process_conf_add_response: session->focus_uri=%s",
-					session->focus_uri ? session->focus_uri : "");
+					session->chat_session->id);
 
 			session->pending_invite_queue = slist_insert_unique_sorted(
 				session->pending_invite_queue, g_strdup(who), (GCompareFunc)strcmp);
-
-			/* add self to conf */
-			sipe_invite_conf_focus(sipe_private, session);
 		}
 		sipe_xml_free(xn_response);
 	}
@@ -620,52 +725,209 @@
 	g_free(hdr);
 }
 
-void
-process_incoming_invite_conf(struct sipe_core_private *sipe_private,
+static void
+accept_incoming_invite_conf(struct sipe_core_private *sipe_private,
+			 gchar *focus_uri,
+			 gboolean audio,
 			 struct sipmsg *msg)
 {
-	struct sip_session *session = NULL;
-	struct sip_dialog *dialog = NULL;
-	sipe_xml *xn_conferencing = sipe_xml_parse(msg->body, msg->bodylen);
-	const sipe_xml *xn_focus_uri = sipe_xml_child(xn_conferencing, "focus-uri");
-	char *focus_uri = sipe_xml_data(xn_focus_uri);
+	struct sip_session *session;
 	gchar *newTag = gentag();
 	const gchar *oldHeader = sipmsg_find_header(msg, "To");
 	gchar *newHeader;
 
-	sipe_xml_free(xn_conferencing);
-
-	/* send OK */
-	SIPE_DEBUG_INFO("We have received invitation to Conference. Focus URI=%s", focus_uri);
-
 	newHeader = g_strdup_printf("%s;tag=%s", oldHeader, newTag);
+	g_free(newTag);
 	sipmsg_remove_header_now(msg, "To");
 	sipmsg_add_header_now(msg, "To", newHeader);
 	g_free(newHeader);
 
-	/* temporary dialog with invitor */
-	/* take data before 'msg' will be modified by send_sip_response */
-	dialog = g_new0(struct sip_dialog, 1);
-	dialog->callid = g_strdup(sipmsg_find_header(msg, "Call-ID"));
-	dialog->cseq = parse_cseq(sipmsg_find_header(msg, "CSeq"));
-	dialog->with = parse_from(sipmsg_find_header(msg, "From"));
-	sipe_dialog_parse(dialog, msg, FALSE);
+	/* acknowledge invite */
+	sip_transport_response(sipe_private, msg, 200, "OK", NULL);
+
+	/* add self to conf */
+	session = sipe_conf_create(sipe_private, NULL, focus_uri);
+	session->is_call = audio;
+}
+
+struct conf_accept_ctx {
+	gchar *focus_uri;
+	struct sipmsg *msg;
+	struct sipe_user_ask_ctx *ask_ctx;
+};
+
+static void
+conf_accept_ctx_free(struct conf_accept_ctx *ctx)
+{
+	g_return_if_fail(ctx != NULL);
+
+	sipmsg_free(ctx->msg);
+	g_free(ctx->focus_uri);
+	g_free(ctx);
+}
 
+static void
+conf_accept_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
+{
+	sipe_private->sessions_to_accept =
+			g_slist_remove(sipe_private->sessions_to_accept, ctx);
+
+	accept_incoming_invite_conf(sipe_private, ctx->focus_uri, TRUE, ctx->msg);
+	conf_accept_ctx_free(ctx);
+}
+
+static void
+conf_decline_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
+{
+	sipe_private->sessions_to_accept =
+			g_slist_remove(sipe_private->sessions_to_accept, ctx);
+
+	sip_transport_response(sipe_private,
+			 ctx->msg,
+			 603, "Decline", NULL);
+
+	conf_accept_ctx_free(ctx);
+}
+
+void
+sipe_conf_cancel_unaccepted(struct sipe_core_private *sipe_private,
+			 struct sipmsg *msg)
+{
+	const gchar *callid1 = msg ? sipmsg_find_header(msg, "Call-ID") : NULL;
+	GSList *it = sipe_private->sessions_to_accept;
+	while (it) {
+		struct conf_accept_ctx *ctx = it->data;
+		const gchar *callid2 = msg ? sipmsg_find_header(ctx->msg, "Call-ID") : NULL;
+
+		if (sipe_strequal(callid1, callid2)) {
+			GSList *tmp;
+
+			sip_transport_response(sipe_private, ctx->msg,
+					 487, "Request Terminated", NULL);
+
+			if (msg)
 	sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 
-	session = sipe_session_add_chat(sipe_private);
-	session->focus_uri = focus_uri;
-	session->is_multiparty = FALSE;
+			sipe_user_close_ask(ctx->ask_ctx);
+			conf_accept_ctx_free(ctx);
 
-	/* send BYE to invitor */
-	sip_transport_bye(sipe_private, dialog);
-	sipe_dialog_free(dialog);
+			tmp = it;
+			it = it->next;
 
-	/* add self to conf */
-	sipe_invite_conf_focus(sipe_private, session);
+			sipe_private->sessions_to_accept =
+				g_slist_delete_link(sipe_private->sessions_to_accept, tmp);
+
+			if (callid1)
+				break;
+		} else
+			it = it->next;
+	}
+}
+
+static void
+ask_accept_voice_conference(struct sipe_core_private *sipe_private,
+			 const gchar *focus_uri,
+			 struct sipmsg *msg,
+			 SipeUserAskCb accept_cb,
+			 SipeUserAskCb decline_cb)
+{
+	gchar **parts;
+	gchar *alias;
+	gchar *ask_msg;
+	gchar *novv_note;
+	struct conf_accept_ctx *ctx;
+
+#ifdef HAVE_VV
+	novv_note = "";
+#else
+	novv_note = _("\n\nAs this client was not compiled with voice call "
+		 "support, if you accept, you will be able to contact "
+		 "the other participants only via IM session.");
+#endif
+
+	parts = g_strsplit(focus_uri, ";", 2);
+	alias = sipe_buddy_get_alias(sipe_private, parts[0]);
+
+	ask_msg = g_strdup_printf(_("%s wants to invite you "
+				 "to the conference call%s"),
+				 alias ? alias : parts[0], novv_note);
+
+	g_free(alias);
+	g_strfreev(parts);
+
+	ctx = g_new0(struct conf_accept_ctx, 1);
+	sipe_private->sessions_to_accept =
+			g_slist_append(sipe_private->sessions_to_accept, ctx);
+
+	ctx->focus_uri = g_strdup(focus_uri);
+	ctx->msg = msg ? sipmsg_copy(msg) : NULL;
+	ctx->ask_ctx = sipe_user_ask(sipe_private, ask_msg,
+				 _("Accept"), accept_cb,
+				 _("Decline"), decline_cb,
+				 ctx);
+
+	g_free(ask_msg);
 }
 
 void
+process_incoming_invite_conf(struct sipe_core_private *sipe_private,
+			 struct sipmsg *msg)
+{
+	sipe_xml *xn_conferencing = sipe_xml_parse(msg->body, msg->bodylen);
+	const sipe_xml *xn_focus_uri = sipe_xml_child(xn_conferencing, "focus-uri");
+	const sipe_xml *xn_audio = sipe_xml_child(xn_conferencing, "audio");
+	gchar *focus_uri = sipe_xml_data(xn_focus_uri);
+	gboolean audio = sipe_strequal(sipe_xml_attribute(xn_audio, "available"), "true");
+
+	sipe_xml_free(xn_conferencing);
+
+	SIPE_DEBUG_INFO("We have received invitation to Conference. Focus URI=%s", focus_uri);
+
+	if (audio) {
+		sip_transport_response(sipe_private, msg, 180, "Ringing", NULL);
+		ask_accept_voice_conference(sipe_private, focus_uri, msg,
+					 (SipeUserAskCb) conf_accept_cb,
+					 (SipeUserAskCb) conf_decline_cb);
+
+	} else {
+		accept_incoming_invite_conf(sipe_private, focus_uri, FALSE, msg);
+	}
+
+	g_free(focus_uri);
+}
+
+#ifdef HAVE_VV
+
+static void
+call_accept_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
+{
+	struct sip_session *session;
+	session = sipe_session_find_conference(sipe_private, ctx->focus_uri);
+
+	sipe_private->sessions_to_accept =
+			g_slist_remove(sipe_private->sessions_to_accept, ctx);
+
+	if (session) {
+		session->is_call = TRUE;
+		sipe_core_media_connect_conference(SIPE_CORE_PUBLIC,
+						 session->chat_session);
+	}
+
+	conf_accept_ctx_free(ctx);
+}
+
+static void
+call_decline_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
+{
+	sipe_private->sessions_to_accept =
+			g_slist_remove(sipe_private->sessions_to_accept, ctx);
+
+	conf_accept_ctx_free(ctx);
+}
+
+#endif // HAVE_VV
+
+void
 sipe_process_conference(struct sipe_core_private *sipe_private,
 			struct sipmsg *msg)
 {
@@ -675,6 +937,9 @@
 	const gchar *focus_uri;
 	struct sip_session *session;
 	gboolean just_joined = FALSE;
+#ifdef HAVE_VV
+	gboolean audio_was_added = FALSE;
+#endif
 
 	if (msg->response != 0 && msg->response != 200) return;
 
@@ -691,17 +956,14 @@
 		return;
 	}
 
-	if (session->focus_uri && !session->backend_session) {
-		gchar *chat_title = sipe_chat_get_name(session->focus_uri);
+	if (!session->chat_session->backend) {
 		gchar *self = sip_uri_self(sipe_private);
 
-		/* create or join existing chat */
-		session->backend_session = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
-								 session->chat_id,
-								 chat_title,
-								 self,
-								 TRUE);
-		session->chat_title = chat_title;
+		/* create chat */
+		session->chat_session->backend = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
+									 session->chat_session,
+									 session->chat_session->title,
+									 self);
 		just_joined = TRUE;
 		/* @TODO ask for full state (re-subscribe) if it was a partial one -
 		 * this is to obtain full list of conference participants.
@@ -713,7 +975,7 @@
 	if ((xn_subject = sipe_xml_child(xn_conference_info, "conference-description/subject"))) {
 		g_free(session->subject);
 		session->subject = sipe_xml_data(xn_subject);
-		sipe_backend_chat_topic(session->backend_session, session->subject);
+		sipe_backend_chat_topic(session->chat_session->backend, session->subject);
 		SIPE_DEBUG_INFO("sipe_process_conference: subject=%s", session->subject ? session->subject : "");
 	}
 
@@ -745,35 +1007,45 @@
 		gchar *self = sip_uri_self(sipe_private);
 
 		if (sipe_strequal("deleted", state)) {
-			if (sipe_backend_chat_find(session->backend_session, user_uri)) {
-				sipe_backend_chat_remove(session->backend_session,
+			if (sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
+				sipe_backend_chat_remove(session->chat_session->backend,
 							 user_uri);
 			}
 		} else {
 			/* endpoints */
 			const sipe_xml *endpoint;
 			for (endpoint = sipe_xml_child(node, "endpoint"); endpoint; endpoint = sipe_xml_twin(endpoint)) {
-				if (sipe_strequal("chat", sipe_xml_attribute(endpoint, "session-type"))) {
+				const gchar *session_type;
 					gchar *status = sipe_xml_data(sipe_xml_child(endpoint, "status"));
-					if (sipe_strequal("connected", status)) {
+				gboolean connected = sipe_strequal("connected", status);
+				g_free(status);
+
+				if (!connected)
+					continue;
+
+				session_type = sipe_xml_attribute(endpoint, "session-type");
+
+				if (sipe_strequal("chat", session_type)) {
 						is_in_im_mcu = TRUE;
-						if (!sipe_backend_chat_find(session->backend_session, user_uri)) {
-							sipe_backend_chat_add(session->backend_session,
+					if (!sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
+						sipe_backend_chat_add(session->chat_session->backend,
 									 user_uri,
 									 !just_joined && g_strcasecmp(user_uri, self));
 						}
 						if (is_operator) {
-							sipe_backend_chat_operator(session->backend_session,
+						sipe_backend_chat_operator(session->chat_session->backend,
 										 user_uri);
 						}
-					}
-					g_free(status);
-					break;
+				} else if (sipe_strequal("audio-video", session_type)) {
+#ifdef HAVE_VV
+					if (!session->is_call)
+						audio_was_added = TRUE;
+#endif
 				}
 			}
 			if (!is_in_im_mcu) {
-				if (sipe_backend_chat_find(session->backend_session, user_uri)) {
-					sipe_backend_chat_remove(session->backend_session,
+				if (sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
+					sipe_backend_chat_remove(session->chat_session->backend,
 								 user_uri);
 				}
 			}
@@ -782,6 +1054,15 @@
 		g_free(self);
 	}
 
+#ifdef HAVE_VV
+	if (audio_was_added) {
+		session->is_call = TRUE;
+		ask_accept_voice_conference(sipe_private, focus_uri, NULL,
+					 (SipeUserAskCb) call_accept_cb,
+					 (SipeUserAskCb) call_decline_cb);
+	}
+#endif
+
 	/* entity-view, locked */
 	for (node = sipe_xml_child(xn_conference_info, "conference-view/entity-view");
 	 node;
@@ -796,11 +1077,11 @@
 				gboolean prev_locked = session->locked;
 				session->locked = sipe_strequal(locked, "true");
 				if (prev_locked && !session->locked) {
-					sipe_present_info(sipe_private, session,
+					sipe_user_present_info(sipe_private, session,
 						_("This conference is no longer locked. Additional participants can now join."));
 				}
 				if (!prev_locked && session->locked) {
-					sipe_present_info(sipe_private, session,
+					sipe_user_present_info(sipe_private, session,
 						_("This conference is locked. Nobody else can join the conference while it is locked."));
 				}
 
@@ -822,7 +1103,7 @@
 			dialog->with = g_strdup(session->im_mcu_uri);
 
 			/* send INVITE to IM MCU */
-			sipe_invite(sipe_private, session, dialog->with, NULL, NULL, NULL, FALSE);
+			sipe_im_invite(sipe_private, session, dialog->with, NULL, NULL, NULL, FALSE);
 		}
 	}
 
@@ -833,9 +1114,9 @@
 sipe_conf_immcu_closed(struct sipe_core_private *sipe_private,
 		 struct sip_session *session)
 {
-	sipe_present_info(sipe_private, session,
+	sipe_user_present_info(sipe_private, session,
 			 _("You have been disconnected from this conference."));
-	sipe_backend_chat_close(session->backend_session);
+	sipe_backend_chat_close(session->chat_session->backend);
 }
 
 void
@@ -881,7 +1162,7 @@
 	for (node = sipe_xml_child(xn_imdn, "recipient"); node; node = sipe_xml_twin(node)) {
 		gchar *tmp = parse_from(sipe_xml_attribute(node, "uri"));
 		gchar *uri = parse_from(tmp);
-		sipe_present_message_undelivered_err(sipe_private, session, -1, -1, uri, message);
+		sipe_user_present_message_undelivered(sipe_private, session, -1, -1, uri, message);
 		g_free(tmp);
 		g_free(uri);
 	}
--- pidgin-sipe-1.11.2/src/core/sipe-conf.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-conf.h	2011-06-14 14:40:36.000000000 +0200
@@ -44,10 +43,18 @@
 process_incoming_invite_conf(struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg);
 			 
-/** Invite us to the focus */
-void
-sipe_invite_conf_focus(struct sipe_core_private *sipe_private,
-		 struct sip_session *session);
+/**
+ * Create new session with Focus URI
+ *
+ * @param chat_session non-NULL if we rejoin a conference
+ * @param focus_uri non-NULL if we create a new conference
+ *
+ * @return new SIP session
+ */
+struct sip_session *
+sipe_conf_create(struct sipe_core_private *sipe_private,
+		 struct sipe_chat_session *chat_session,
+		 const gchar *focus_uri);
 			 
 /** 
 * Process of conference state
@@ -76,16 +83,6 @@
 			 const gchar* who);
 
 /** 
- * Modify Conference Lock.
- * Sends request to Focus.
- * INFO method is a carrier of application/cccp+xml
- */				 
-void
-sipe_conf_modify_conference_lock(struct sipe_core_private *sipe_private,
-				 struct sip_session *session,
-				 const gboolean locked);
-				 
-/** 
 * Ejects user from conference.
 * Sends request to Focus.
 * INFO method is a carrier of application/cccp+xml
@@ -104,6 +101,17 @@
 		 struct sip_session *session); 
 	
 /** 
+ * Removes a session waiting to be accepted or declined by the user.
+ *
+ * @param sipe_private SIPE core data
+ * @param msg SIP CANCEL message. If NULL is passed, all sessions not accepted
+ * will be canceled
+ */
+void
+sipe_conf_cancel_unaccepted(struct sipe_core_private *sipe_private,
+			 struct sipmsg *msg);
+
+/**
 * Invokes when we leave conversation.
 * Usually by closing chat wingow.
 */
--- pidgin-sipe-1.11.2/src/core/sipe-core.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-core.c	2011-06-14 14:40:36.000000000 +0200
@@ -27,26 +27,32 @@
 #include <stdlib.h>
 
 #include <glib.h>
-#ifdef HAVE_NSS
-#include "nss.h"
-#endif
-#ifdef HAVE_GMIME
-#include <gmime/gmime.h>
-#endif
 
+#include "sipe-common.h"
 #include "sip-csta.h"
 #include "sip-sec.h"
 #include "sip-transport.h"
 #include "sipe-backend.h"
+#include "sipe-chat.h"
+#include "sipe-conf.h"
 #include "sipe-core.h"
 #include "sipe-core-private.h"
+#include "sipe-group.h"
 #include "sipe-nls.h"
 #include "sipe-session.h"
 #include "sipe-subscriptions.h"
 #include "sipe-media.h"
 #include "sipe.h"
 
-void sipe_core_init(const char *locale_dir)
+#ifdef HAVE_NSS
+#include "nss.h"
+#endif
+#ifdef HAVE_GMIME
+#include <gmime/gmime.h>
+#endif
+
+/* locale_dir is unused if ENABLE_NLS is not defined */
+void sipe_core_init(SIPE_UNUSED_PARAMETER const char *locale_dir)
 {
 	srand(time(NULL));
 	sip_sec_init();
@@ -71,6 +77,7 @@
 
 void sipe_core_destroy(void)
 {
+	sipe_chat_destroy();
 #ifdef HAVE_NSS
 	/* do nothing.
 	 * We don't want accedently switch off NSS possibly used by other plugin -
@@ -188,6 +195,8 @@
 		}
 	}
 
+	sipe_conf_cancel_unaccepted(sipe_private, NULL);
+
 	if (sip->csta) {
 		sip_csta_close(sipe_private);
 	}
@@ -235,6 +244,13 @@
 	}
 	g_slist_free(sip->our_publication_keys);
 
+#ifdef HAVE_VV
+	g_free(sipe_private->mras_uri);
+	g_free(sipe_private->media_relay_username);
+	g_free(sipe_private->media_relay_password);
+	sipe_media_relay_list_free(sipe_private->media_relays);
+#endif
+
 	g_free(sip);
 	g_free(sipe_private);
 }
--- pidgin-sipe-1.11.2/src/core/sipe-core-private.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-core-private.h	2011-06-14 14:40:36.000000000 +0200
@@ -24,6 +24,7 @@
 struct sip_service_data;
 struct sip_transport;
 struct sipe_media_call_private;
+struct sipe_groupchat;
 
 /**
 * Private part of the Sipe data structure
@@ -49,6 +50,7 @@
 	gchar *epid;
 	gchar *focus_factory_uri;
 	GSList *sessions;
+	GSList *sessions_to_accept;
 
 	/* Buddies */
 	GHashTable *buddies;
@@ -61,10 +63,24 @@
 
 	/* Voice call */
 	struct sipe_media_call_private *media_call;
+	/**
+	 * Provides the necessary information on where we can obtain
+	 * credentials for the A/V Edge server service.
+	 */
+	gchar *mras_uri;
+	gchar *media_relay_username;
+	gchar *media_relay_password;
+	GSList *media_relays;
+
+
+	/* Group chat */
+	struct sipe_groupchat *groupchat;
 
 	/* @TODO: move to purple backend when menu code moves */
 	GSList *blist_menu_containers;
 
+	struct sipe_dns_query *dns_query;
+
 	/* the original data structure*/
 	struct sipe_account_data *temporary;
 };
@@ -72,7 +88,13 @@
 /**
 * Flags - stored in sipe_core_public.flags but names not exported
 */
-#define SIPE_CORE_PRIVATE_FLAG_OCS2007 0x80000000 /* server is OCS2007+ */
+/* server is OCS2007+ */
+#define SIPE_CORE_PRIVATE_FLAG_OCS2007 0x80000000
+/* we are connected from outside the enterprise network boundary
+ * via Edge Server */
+#define SIPE_CORE_PRIVATE_FLAG_REMOTE_USER 0x40000000
+/* multiple points of presence detected */
+#define SIPE_CORE_PRIVATE_FLAG_MPOP 0x20000000
 
 #define SIPE_CORE_PUBLIC_FLAG_IS(flag) \
 	((sipe_private->public.flags & SIPE_CORE_FLAG_ ## flag) == SIPE_CORE_FLAG_ ## flag)
--- pidgin-sipe-1.11.2/src/core/sipe-dialog.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-dialog.c	2011-06-14 14:40:36.000000000 +0200
@@ -26,13 +26,13 @@
 
 #include <glib.h>
 
+#include "sipe-core.h"
 #include "sipe-common.h"
 #include "sipmsg.h"
 #include "sipe-backend.h"
 #include "sipe-dialog.h"
 #include "sipe-session.h"
 #include "sipe-utils.h"
-#include "sipe-ft.h"
 
 void sipe_dialog_free(struct sip_dialog *dialog)
 {
@@ -151,7 +151,7 @@
 	}
 }
 
-void sipe_dialog_parse_routes(struct sip_dialog *dialog,
+static void sipe_dialog_parse_routes(struct sip_dialog *dialog,
 			 const struct sipmsg *msg,
 			 gboolean outgoing)
 {
@@ -174,12 +174,11 @@
 			gchar **part = parts;
 
 			while (*part) {
-				gchar *route = sipmsg_find_part_of_header(*part, "<", ">", NULL);
-				SIPE_DEBUG_INFO("sipe_dialog_parse_routes: route %s", route);
-				dialog->routes = g_slist_append(dialog->routes, route);
+				SIPE_DEBUG_INFO("sipe_dialog_parse_routes: route %s", *part);
+				dialog->routes = g_slist_append(dialog->routes,
+								g_strdup(*part));
 				part++;
 			}
-
 			g_strfreev(parts);
 }
 hdr = g_slist_next(hdr);
@@ -195,10 +194,15 @@
 	/* logic for strict router only - RFC3261 - 12.2.1.1 */
 	/* @TODO: proper check for presence of 'lr' PARAMETER in URI */
 	if (dialog->routes && !strstr(dialog->routes->data, ";lr")) {
-		dialog->request = dialog->routes->data;
-		dialog->routes = g_slist_remove(dialog->routes, dialog->routes->data);
+		gchar *route = dialog->routes->data;
+		dialog->request = sipmsg_find_part_of_header(route, "<", ">", NULL);
+		SIPE_DEBUG_INFO("sipe_dialog_parse_routes: strict route, contact %s", dialog->request);
+		dialog->routes = g_slist_remove(dialog->routes, route);
+		g_free(route);
 		if (contact) {
-			dialog->routes = g_slist_append(dialog->routes, contact);
+			dialog->routes = g_slist_append(dialog->routes,
+							g_strdup_printf("<%s>", contact));
+			g_free(contact);
 		}
 	}
 }
--- pidgin-sipe-1.11.2/src/core/sipe-dialog.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-dialog.h	2011-06-14 14:40:36.000000000 +0200
@@ -27,6 +27,7 @@
 */
 
 /* Forward declarations */
+struct sipe_delayed_invite;
 struct sipmsg;
 
 /* Helper macros to iterate over dialog list in a SIP session */
@@ -60,6 +61,7 @@
 	int expires;
 	gboolean is_established;
 	struct transaction *outgoing_invite;
+ struct sipe_delayed_invite *delayed_invite;
 };
 
 /* Forward declaration */
@@ -133,17 +135,6 @@
 #define sipe_dialog_first(session) ((struct sip_dialog *)session->dialogs->data)
 
 /**
- * Update routes in a dialog from a message
- *
- * @param dialog (in,out) dialog to fill
- * @param msg (in) mesage
- * @param outgoing (in) outgoing or incoming message
- */
-void sipe_dialog_parse_routes(struct sip_dialog *dialog,
-			 const struct sipmsg *msg,
-			 gboolean outgoing);
-
-/**
 * Fill dialog structure from SIP message
 *
 * @param dialog (in,out) dialog to fill
--- pidgin-sipe-1.11.2/src/core/sipe-digest.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-digest.c	2011-06-14 14:40:36.000000000 +0200
@@ -41,13 +41,12 @@
 			guchar *digest, gsize digest_length)
 {
 	PK11Context *context = 0;
-	SECStatus s;
 	unsigned int len;
 	
 	context = PK11_CreateDigestContext(algorithm);
-	s = PK11_DigestBegin(context);
-	s = PK11_DigestOp(context, data, data_length);
-	s = PK11_DigestFinal(context, digest, &len, digest_length);
+	PK11_DigestBegin(context);
+	PK11_DigestOp(context, data, data_length);
+	PK11_DigestFinal(context, digest, &len, digest_length);
 	PK11_DestroyContext(context, PR_TRUE);
 }
 
@@ -59,7 +58,6 @@
 	SECItem noParams;
 	PK11SymKey* SymKey;
 	PK11Context* DigestContext;
-	SECStatus s;
 
 	/* For key */
 	slot = PK11_GetBestSlot(hmacMech, NULL);
@@ -77,7 +75,7 @@
 
 	DigestContext = PK11_CreateContextBySymKey(hmacMech, CKA_SIGN, SymKey, &noParams);
 	
-	s = PK11_DigestBegin(DigestContext);
+	PK11_DigestBegin(DigestContext);
 	
 	PK11_FreeSymKey(SymKey);
 	PK11_FreeSlot(slot);
--- pidgin-sipe-1.11.2/src/core/sipe-domino.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-domino.c	2011-06-14 14:40:36.000000000 +0200
@@ -57,6 +57,7 @@
 #include <ctype.h>
 #include <stdio.h>
 #include <errno.h>
+#include <time.h>
 
 #include <glib.h>
 
--- pidgin-sipe-1.11.2/src/core/sipe-ft.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-ft.c	2011-06-14 14:40:36.000000000 +0200
@@ -30,7 +30,6 @@
 #include <string.h>
 
 #include <glib.h>
-#include <glib/gprintf.h>
 
 #include "sipmsg.h"
 #include "sip-transport.h"
@@ -41,13 +40,10 @@
 #include "sipe-dialog.h"
 #include "sipe-digest.h"
 #include "sipe-ft.h"
+#include "sipe-im.h"
 #include "sipe-nls.h"
 #include "sipe-session.h"
 #include "sipe-utils.h"
-#include "sipe.h"
-
-#define SIPE_FT_KEY_LENGTH 24
-#define SIPE_FT_CHUNK_HEADER_LENGTH 3
 
 /*
 * DO NOT CHANGE THE FOLLOWING CONSTANTS!!!
@@ -62,170 +58,19 @@
 #define SIPE_FT_TCP_PORT_MIN 6891
 #define SIPE_FT_TCP_PORT_MAX 6901
 
-/**
- * File transport (private part)
- */
-struct sipe_file_transfer_private {
-	struct sipe_file_transfer public;
-
-	struct sipe_core_private *sipe_private;
-
-	guchar encryption_key[SIPE_FT_KEY_LENGTH];
-	guchar hash_key[SIPE_FT_KEY_LENGTH];
-	unsigned auth_cookie;
-	gchar *invitation_cookie;
-
-	struct sip_dialog *dialog;
-
-	gpointer cipher_context;
-	gpointer hmac_context;
-
-	gsize bytes_remaining_chunk;
-
-	guchar *encrypted_outbuf;
-	guchar *outbuf_ptr;
-	gsize outbuf_size;
-};
-#define SIPE_FILE_TRANSFER_PUBLIC ((struct sipe_file_transfer *) ft_private)
-#define SIPE_FILE_TRANSFER_PRIVATE ((struct sipe_file_transfer_private *) ft)
-
-static void raise_ft_error(struct sipe_file_transfer_private *ft_private,
-			 const gchar *errmsg)
-{
-	gchar *tmp = g_strdup_printf("%s: %s", errmsg,
-				 sipe_backend_ft_get_error(SIPE_FILE_TRANSFER_PUBLIC));
-	sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC, tmp);
-	g_free(tmp);
-}
-
-static void raise_ft_error_and_cancel(struct sipe_file_transfer_private *ft_private,
+void sipe_ft_raise_error_and_cancel(struct sipe_file_transfer_private *ft_private,
 				 const gchar *errmsg)
 {
 	sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC, errmsg);
 	sipe_backend_ft_cancel_local(SIPE_FILE_TRANSFER_PUBLIC);
 }
 
-static void raise_ft_socket_read_error_and_cancel(struct sipe_file_transfer_private *ft_private)
-{
-	raise_ft_error_and_cancel(ft_private, _("Socket read failed"));
-}
-
-static void raise_ft_socket_write_error_and_cancel(struct sipe_file_transfer_private *ft_private)
-{
-	raise_ft_error_and_cancel(ft_private, _("Socket write failed"));
-}
-
-static gboolean read_exact(struct sipe_file_transfer_private *ft_private,
-			 guchar *data,
-			 gsize size)
-{
-	const gulong READ_TIMEOUT = 10000000;
-	gulong time_spent = 0;
-
-	while (size) {
-		gssize bytes_read = sipe_backend_ft_read(SIPE_FILE_TRANSFER_PUBLIC,
-							 data, size);
-		if (bytes_read == 0) {
-			g_usleep(100000);
-			time_spent += 100000;
-		} else if (bytes_read < 0 || time_spent > READ_TIMEOUT) {
-			return FALSE;
-		} else {
-			size -= bytes_read;
-			data += bytes_read;
-			time_spent = 0;
-		}
-	}
-	return TRUE;	
-}
-
-static gboolean read_line(struct sipe_file_transfer_private *ft_private,
-			 guchar *data,
-			 gsize size)
-{
-	gsize pos = 0;
-
-	if (size < 2) return FALSE;
-
-	memset(data, 0, size--);
-	do {
-		if (!read_exact(ft_private, data + pos, 1))
-			return FALSE;
-	} while ((data[pos] != '\n') && (++pos < size));
-
-	/* Buffer too short? */
-	if ((pos == size) && (data[pos - 1] != '\n')) {
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-static gboolean write_exact(struct sipe_file_transfer_private *ft_private,
-			 const guchar *data,
-			 gsize size)
-{
-	gssize bytes_written = sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC,
-						 data, size);
-	if ((bytes_written < 0) || ((gsize) bytes_written != size))
-		return FALSE;
-	return TRUE;
-}
-
 static void generate_key(guchar *buffer, gsize size)
 {
 	gsize i = 0;
 	while (i < size) buffer[i++] = rand();
 }
 
-static gpointer sipe_cipher_context_init(const guchar *enc_key)
-{
-	/*
-	 * Decryption of file from SIPE file transfer
-	 *
-	 * Decryption:
-	 * 1.) SHA1-Key = SHA1sum (Encryption-Key); Do SHA1 digest from Encryption-Key, return 20 bytes SHA1-Key.
-	 * 2.) Decrypt-Data = RC4 (Encrypt-Data, substr(SHA1-Key, 0, 15)); Decryption of encrypted data, used 16 bytes SHA1-Key;
-	 */
-
-	guchar k2[SIPE_DIGEST_SHA1_LENGTH];
-
-	/* 1.) SHA1 sum	*/
- sipe_digest_sha1(enc_key, SIPE_FT_KEY_LENGTH, k2);
-
-	/* 2.) RC4 decryption */
-	return sipe_crypt_ft_start(k2);
-}
-
-static gpointer sipe_hmac_context_init(const guchar *hash_key)
-{
-	/*
-	 * 	Count MAC digest
-	 *
-	 * 	HMAC digest:
-	 * 1.) SHA1-Key = SHA1sum (Hash-Key); Do SHA1 digest from Hash-Key, return 20 bytes SHA1-Key.
-	 * 2.) MAC = HMAC_SHA1 (Decrypt-Data, substr(HMAC-Key,0,15)); Digest of decrypted file and SHA1-Key (used again only 16 bytes)
-	 */
-
-	guchar k2[SIPE_DIGEST_SHA1_LENGTH];
-
-	/* 1.) SHA1 sum	*/
-	sipe_digest_sha1(hash_key, SIPE_FT_KEY_LENGTH, k2);
-
-	/* 2.) HMAC (initialization only) */
-	return sipe_digest_ft_start(k2);
-}
-
-static gchar *sipe_hmac_finalize(gpointer hmac_context)
-{
-	guchar hmac_digest[SIPE_DIGEST_FILETRANSFER_LENGTH];
-
-	/* MAC = Digest of decrypted file and SHA1-Key (used again only 16 bytes) */
-	sipe_digest_ft_end(hmac_context, hmac_digest);
-
-	return g_base64_encode(hmac_digest, sizeof (hmac_digest));
-}
-
 struct sipe_file_transfer *sipe_core_ft_allocate(struct sipe_core_public *sipe_public)
 {
 	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
@@ -245,6 +90,9 @@
 	if (ft->backend_private)
 		sipe_backend_ft_deallocate(ft);
 
+	if (ft_private->listendata)
+		sipe_backend_network_listen_cancel(ft_private->listendata);
+
 	if (ft_private->cipher_context)
 		sipe_crypt_ft_destroy(ft_private->cipher_context);
 
@@ -293,167 +141,105 @@
 	g_free(body);
 }
 
-void sipe_core_ft_incoming_init(struct sipe_file_transfer *ft)
+static void
+send_ft_accept(struct sipe_file_transfer_private *ft_private,
+	 gboolean send_enc_key,
+	 gboolean send_connect_data,
+	 gboolean sender_connect)
 {
-	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
-	gchar *b64_encryption_key = g_base64_encode(ft_private->encryption_key,
+	GString *body = g_string_new("");
+
+	g_string_append_printf(body,
+			 "Invitation-Command: ACCEPT\r\n"
+			 "Request-Data: IP-Address:\r\n"
+			 "Invitation-Cookie: %s\r\n",
+			 ft_private->invitation_cookie);
+
+	if (send_enc_key) {
+		gchar *b64_encryption_key;
+		gchar *b64_hash_key;
+
+		b64_encryption_key = g_base64_encode(ft_private->encryption_key,
 						 SIPE_FT_KEY_LENGTH);
-	gchar *b64_hash_key = g_base64_encode(ft_private->hash_key,
+		b64_hash_key = g_base64_encode(ft_private->hash_key,
 					 SIPE_FT_KEY_LENGTH);
 
-	gchar *body = g_strdup_printf("Invitation-Command: ACCEPT\r\n"
-				 "Request-Data: IP-Address:\r\n"
-				 "Invitation-Cookie: %s\r\n"
+		g_string_append_printf(body,
 				 "Encryption-Key: %s\r\n"
-				 "Hash-Key: %s\r\n"
-				 /*"IP-Address: %s\r\n"
-					"Port: 6900\r\n"
-					"PortX: 11178\r\n"
-					"Auth-Cookie: 11111111\r\n"
-					"Sender-Connect: TRUE\r\n"*/,
-				 ft_private->invitation_cookie,
+				 "Hash-Key: %s\r\n",
 				 b64_encryption_key,
-				 b64_hash_key
- /*,sipe_backend_network_ip_address()*/
-		);
-	sipe_ft_request(ft_private, body);
+				 b64_hash_key);
 
-	g_free(body);
 	g_free(b64_hash_key);
 	g_free(b64_encryption_key);
 }
 
-void sipe_core_ft_incoming_accept(struct sipe_file_transfer *ft,
-				 const gchar *who,
-				 int fd,
-				 unsigned short port)
-{
-	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
-	gchar *body;
-
-	ft_private->auth_cookie = rand() % 1000000000;
-
-	body = g_strdup_printf("Invitation-Command: ACCEPT\r\n"
-			 "Invitation-Cookie: %s\r\n"
+	if (send_connect_data) {
+		g_string_append_printf(body,
 			 "IP-Address: %s\r\n"
-			 "Port: %u\r\n"
+				 "Port: %d\r\n"
 			 "PortX: 11178\r\n"
-			 "AuthCookie: %u\r\n"
-			 "Request-Data: IP-Address:\r\n",
-			 ft_private->invitation_cookie,
-			 sipe_utils_get_suitable_local_ip(fd),
-			 port,
+				 "AuthCookie: %u\r\n",
+				 sipe_backend_network_ip_address(),
+				 ft_private->port,
 			 ft_private->auth_cookie);
-
-	if (!ft_private->dialog) {
-		struct sip_session *session = sipe_session_find_or_add_im(ft_private->sipe_private,
-									 who);
-		ft_private->dialog = sipe_dialog_find(session, who);
 	}
 
-	if (ft_private->dialog) {
-		sipe_ft_request(ft_private, body);
+	if (sender_connect) {
+		g_string_append(body,
+				"Sender-Connect: TRUE\r\n");
 	}
-	g_free(body);
+
+	sipe_ft_request(ft_private, body->str);
+
+	g_string_free(body, TRUE);
 }
 
-void sipe_core_ft_incoming_start(struct sipe_file_transfer *ft,
-				 gsize total_size)
+static void
+listen_socket_created_cb(unsigned short port, gpointer data)
 {
-	static const guchar VER[] = "VER MSN_SECURE_FTP\r\n";
-	static const guchar TFR[] = "TFR\r\n";
-	const gsize BUFFER_SIZE = 50;
-	const gsize FILE_SIZE_OFFSET = 4;
+	struct sipe_file_transfer *ft = data;
 
-	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
-	guchar buf[BUFFER_SIZE];
-	gchar *request;
-	gsize file_size;
+	SIPE_FILE_TRANSFER_PRIVATE->port = port;
+	SIPE_FILE_TRANSFER_PRIVATE->auth_cookie = rand() % 1000000000;
 
-	if (!write_exact(ft_private, VER, sizeof(VER) - 1)) {
-		raise_ft_socket_read_error_and_cancel(ft_private);
-		return;
-	}
-	if (!read_line(ft_private, buf, BUFFER_SIZE)) {
-		raise_ft_socket_read_error_and_cancel(ft_private);
-		return;
+	if (sipe_backend_ft_is_incoming(ft))
+		send_ft_accept(SIPE_FILE_TRANSFER_PRIVATE, TRUE, TRUE, TRUE);
+	else
+		send_ft_accept(SIPE_FILE_TRANSFER_PRIVATE, FALSE, TRUE, FALSE);
 	}
 
-	request = g_strdup_printf("USR %s %u\r\n",
-				 ft_private->sipe_private->username,
-				 ft_private->auth_cookie);
-	if (!write_exact(ft_private, (guchar *)request, strlen(request))) {
-		raise_ft_socket_write_error_and_cancel(ft_private);
-		g_free(request);
-		return;
-	}
-	g_free(request);
+static void
+client_connected_cb(struct sipe_backend_fd *fd, gpointer data)
+{
+	struct sipe_file_transfer *ft = data;
 
-	if (!read_line(ft_private, buf, BUFFER_SIZE)) {
-		raise_ft_socket_read_error_and_cancel(ft_private);
-		return;
-	}
+	SIPE_FILE_TRANSFER_PRIVATE->listendata = NULL;
 
-	file_size = g_ascii_strtoull((gchar *) buf + FILE_SIZE_OFFSET, NULL, 10);
-	if (file_size != total_size) {
-		raise_ft_error_and_cancel(ft_private,
-					 _("File size is different from the advertised value."));
-		return;
-	}
-
-	if (!sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC, TFR, sizeof(TFR) - 1)) {
-		raise_ft_socket_write_error_and_cancel(ft_private);
-		return;
+	if (!sipe_backend_fd_is_valid(fd)) {
+		sipe_backend_ft_error(ft, _("Socket read failed"));
+		sipe_backend_ft_cancel_local(ft);
+	} else {
+		sipe_backend_ft_start(ft, fd, NULL, 0);
 	}
 
-	ft_private->bytes_remaining_chunk = 0;
-	ft_private->cipher_context = sipe_cipher_context_init(ft_private->encryption_key);
-	ft_private->hmac_context = sipe_hmac_context_init(ft_private->hash_key);
+	sipe_backend_fd_free(fd);
 }
 
-gboolean sipe_core_ft_incoming_stop(struct sipe_file_transfer *ft)
+void sipe_core_ft_incoming_init(struct sipe_file_transfer *ft)
 {
-	static const guchar BYE[] = "BYE 16777989\r\n";
-	const gsize BUFFER_SIZE = 50;
-	const gsize MAC_OFFSET = 4;
-
 	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
-	gchar buffer[BUFFER_SIZE];
-	gsize mac_len;
-	gchar *mac;
-	gchar *mac1;
-
-	if (!sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC, BYE, sizeof(BYE) - 1)) {
-		raise_ft_socket_write_error_and_cancel(ft_private);
-		return FALSE;
-	}
-
-	if (!read_line(ft_private, (guchar *) buffer, BUFFER_SIZE)) {
-		raise_ft_socket_read_error_and_cancel(ft_private);
-		return FALSE;
-	}
-
-	mac_len = strlen(buffer);
-	if (mac_len < (MAC_OFFSET)) {
-		raise_ft_error_and_cancel(ft_private,
-					 _("Received MAC is corrupted"));
-		return FALSE;
-	}
-
-	/* Check MAC */
-	mac = g_strndup(buffer + MAC_OFFSET, mac_len - MAC_OFFSET);
-	mac1 = sipe_hmac_finalize(ft_private->hmac_context);
-	if (!sipe_strequal(mac, mac1)) {
-		g_free(mac1);
-		g_free(mac);
-		raise_ft_error_and_cancel(ft_private,
-					 _("Received file is corrupted"));
-		return(FALSE);
-	}
-	g_free(mac1);
-	g_free(mac);
 
-	return(TRUE);
+	if (ft_private->peer_using_nat) {
+		ft_private->listendata =
+			sipe_backend_network_listen_range(SIPE_FT_TCP_PORT_MIN,
+							 SIPE_FT_TCP_PORT_MAX,
+							 listen_socket_created_cb,
+							 client_connected_cb,
+							 ft);
+	} else {
+		send_ft_accept(ft_private, TRUE, FALSE, FALSE);
+	}
 }
 
 void sipe_core_ft_outgoing_init(struct sipe_file_transfer *ft,
@@ -464,17 +250,19 @@
 	struct sipe_core_private *sipe_private = ft_private->sipe_private;
 	struct sip_dialog *dialog;
 
+	const gchar *ip = sipe_backend_network_ip_address();
 	gchar *body = g_strdup_printf("Application-Name: File Transfer\r\n"
 				 "Application-GUID: {5D3E02AB-6190-11d3-BBBB-00C04F795683}\r\n"
 				 "Invitation-Command: INVITE\r\n"
 				 "Invitation-Cookie: %s\r\n"
 				 "Application-File: %s\r\n"
 				 "Application-FileSize: %" G_GSIZE_FORMAT "\r\n"
-				 //"Connectivity: N\r\n" TODO
+				 "%s"
 				 "Encryption: R\r\n", // TODO: non encrypted file transfer support
 				 ft_private->invitation_cookie,
 				 filename,
-				 size);
+				 size,
+				 sipe_utils_ip_is_private(ip) ? "Connectivity: N\r\n" : "");
 
 	struct sip_session *session = sipe_session_find_or_add_im(sipe_private, who);
 
@@ -486,7 +274,7 @@
 		sipe_im_process_queue(sipe_private, session);
 	} else if (!dialog || !dialog->outgoing_invite) {
 		// Need to send the INVITE to get the outgoing dialog setup
-		sipe_invite(sipe_private, session, who, body, "text/x-msmsgsinvite", NULL, FALSE);
+		sipe_im_invite(sipe_private, session, who, body, "text/x-msmsgsinvite", NULL, FALSE);
 		dialog = sipe_dialog_find(session, who);
 	}
 
@@ -496,269 +284,6 @@
 	g_free(body);
 }
 
-void sipe_core_ft_outgoing_start(struct sipe_file_transfer *ft,
-				 gsize total_size)
-{
-	static const guchar VER[] = "VER MSN_SECURE_FTP\r\n";
-	const gsize BUFFER_SIZE = 50;
-
-	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
-	guchar buf[BUFFER_SIZE];
-	gchar **parts;
-	unsigned auth_cookie_received;
-	gboolean users_match;
-
-	if (!read_line(ft_private, buf, BUFFER_SIZE)) {
-		raise_ft_socket_read_error_and_cancel(ft_private);
-		return;
-	}
-
-	if (!sipe_strequal((gchar *)buf, (gchar *)VER)) {
-		raise_ft_error_and_cancel(ft_private,
-					 _("File transfer initialization failed."));
-		SIPE_DEBUG_INFO("File transfer VER string incorrect, received: %s expected: %s",
-				buf, VER);
-		return;
-	}
-
-	if (!write_exact(ft_private, VER, sizeof(VER) - 1)) {
-		raise_ft_socket_write_error_and_cancel(ft_private);
-		return;
-	}
-
-	if (!read_line(ft_private, buf, BUFFER_SIZE)) {
-		raise_ft_socket_read_error_and_cancel(ft_private);
-		return;
-	}
-
-	parts = g_strsplit((gchar *)buf, " ", 3);
-	auth_cookie_received = g_ascii_strtoull(parts[2], NULL, 10);
-	/* dialog->with has 'sip:' prefix, skip these four characters */
-	users_match = sipe_strcase_equal(parts[1],
-					 (ft_private->dialog->with + 4));
-	g_strfreev(parts);
-
-	SIPE_DEBUG_INFO("File transfer authentication: %s Expected: USR %s %u",
-			buf,
-			ft_private->dialog->with + 4,
-			ft_private->auth_cookie);
-
-	if (!users_match ||
-	 (ft_private->auth_cookie != auth_cookie_received)) {
-		raise_ft_error_and_cancel(ft_private,
-					 _("File transfer authentication failed."));
-		return;
-	}
-
-	g_sprintf((gchar *)buf, "FIL %" G_GSIZE_FORMAT "\r\n", total_size);
-	if (!write_exact(ft_private, buf, strlen((gchar *)buf))) {
-		raise_ft_socket_write_error_and_cancel(ft_private);
-		return;
-	}
-
-	/* TFR */
-	if (!read_line(ft_private ,buf, BUFFER_SIZE)) {
-		raise_ft_socket_read_error_and_cancel(ft_private);
-		return;
-	}
-
-	ft_private->bytes_remaining_chunk = 0;
-	ft_private->cipher_context = sipe_cipher_context_init(ft_private->encryption_key);
-	ft_private->hmac_context = sipe_hmac_context_init(ft_private->hash_key);
-}
-
-gboolean sipe_core_ft_outgoing_stop(struct sipe_file_transfer *ft)
-{
-	gsize BUFFER_SIZE = 50;
-
-	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
-	guchar buffer[BUFFER_SIZE];
-	gchar *mac;
-	gsize mac_len;
-
-	/* BYE */
-	if (!read_line(ft_private, buffer, BUFFER_SIZE)) {
-		raise_ft_socket_read_error_and_cancel(ft_private);
-		return FALSE;
-	}
-
-	mac = sipe_hmac_finalize(ft_private->hmac_context);
-	g_sprintf((gchar *)buffer, "MAC %s \r\n", mac);
-	g_free(mac);
-
-	mac_len = strlen((gchar *)buffer);
-	/* There must be this zero byte between mac and \r\n */
-	buffer[mac_len - 3] = 0;
-
-	if (!write_exact(ft_private, buffer, mac_len)) {
-		raise_ft_socket_write_error_and_cancel(ft_private);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-gssize sipe_core_ft_read(struct sipe_file_transfer *ft, guchar **buffer,
-			 gsize bytes_remaining, gsize bytes_available)
-{
-	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
-	gsize bytes_to_read;
-	gssize bytes_read;
-
-	if (ft_private->bytes_remaining_chunk == 0) {
-		guchar hdr_buf[SIPE_FT_CHUNK_HEADER_LENGTH];
-
-		/* read chunk header */
-		if (!read_exact(ft_private, hdr_buf, sizeof(hdr_buf))) {
-			raise_ft_error(ft_private, _("Socket read failed"));
-			return -1;
-		}
-
-		/* chunk header format:
-		 *
-		 * 0: 00 unknown (always zero?)
-		 * 1: LL chunk size in bytes (low byte)
-		 * 2: HH chunk size in bytes (high byte)
-		 *
-		 * Convert size from little endian to host order
-		 */
-		ft_private->bytes_remaining_chunk =
-			hdr_buf[1] + (hdr_buf[2] << 8);
-	}
-
-	bytes_to_read = MIN(bytes_remaining, bytes_available);
-	bytes_to_read = MIN(bytes_to_read, ft_private->bytes_remaining_chunk);
-
-	*buffer = g_malloc(bytes_to_read);
-	if (!*buffer) {
-		sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC, _("Out of memory"));
-		SIPE_DEBUG_ERROR("sipe_core_ft_read: can't allocate %" G_GSIZE_FORMAT " bytes for receive buffer",
-				 bytes_to_read);
-		return -1;
-	}
-
-	bytes_read = sipe_backend_ft_read(SIPE_FILE_TRANSFER_PUBLIC, *buffer, bytes_to_read);
-	if (bytes_read < 0) {
-		raise_ft_error(ft_private, _("Socket read failed"));
-		g_free(*buffer);
-		*buffer = NULL;
-		return -1;
-	}
-
-	if (bytes_read > 0) {
-		guchar *decrypted = g_malloc(bytes_read);
-
-		if (!decrypted) {
-			sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC, _("Out of memory"));
-			SIPE_DEBUG_ERROR("sipe_core_ft_read: can't allocate %" G_GSIZE_FORMAT " bytes for decryption buffer",
-					 (gsize)bytes_read);
-			g_free(*buffer);
-			*buffer = NULL;
-			return -1;
-		}
-		sipe_crypt_ft_stream(ft_private->cipher_context,
-				 *buffer, bytes_read, decrypted);
-		g_free(*buffer);
-		*buffer = decrypted;
-
-		sipe_digest_ft_update(ft_private->hmac_context,
-				 decrypted, bytes_read);
-
-		ft_private->bytes_remaining_chunk -= bytes_read;
-	}
-
-	return(bytes_read);
-}
-
-gssize sipe_core_ft_write(struct sipe_file_transfer *ft,
-			 const guchar *buffer, gsize size)
-{
-	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
-	gssize bytes_written;
-
-	/* When sending data via server with ForeFront installed, block bigger than
-	 * this default causes ending of transmission. Hard limit block to this value
-	 * when libpurple sends us more data. */
-	const gsize DEFAULT_BLOCK_SIZE = 2045;
-	if (size > DEFAULT_BLOCK_SIZE)
-		size = DEFAULT_BLOCK_SIZE;
-
-	if (ft_private->bytes_remaining_chunk == 0) {
-		gssize bytes_read;
-		guchar local_buf[16];
-		guchar hdr_buf[SIPE_FT_CHUNK_HEADER_LENGTH];
-
-		memset(local_buf, 0, sizeof local_buf);
-
-		/* Check if receiver did not cancel the transfer
-		 before it is finished */
-		bytes_read = sipe_backend_ft_read(SIPE_FILE_TRANSFER_PUBLIC,
-						 local_buf,
-						 sizeof(local_buf));
-		if (bytes_read < 0) {
-			sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC,
-					 _("Socket read failed"));
-			return -1;
-		} else if ((bytes_read > 0) &&
-			 (g_str_has_prefix((gchar *)local_buf, "CCL\r\n") ||
-			 g_str_has_prefix((gchar *)local_buf, "BYE 2164261682\r\n"))) {
-			return -1;
-		}
-
-		if (ft_private->outbuf_size < size) {
-			g_free(ft_private->encrypted_outbuf);
-			ft_private->outbuf_size = size;
-			ft_private->encrypted_outbuf = g_malloc(ft_private->outbuf_size);
-			if (!ft_private->encrypted_outbuf) {
-				sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC,
-						 _("Out of memory"));
-				SIPE_DEBUG_ERROR("sipe_core_ft_write: can't allocate %" G_GSIZE_FORMAT " bytes for send buffer",
-						 ft_private->outbuf_size);
-				return -1;
-			}
-		}
-
-		ft_private->bytes_remaining_chunk = size;
-		ft_private->outbuf_ptr = ft_private->encrypted_outbuf;
-		sipe_crypt_ft_stream(ft_private->cipher_context,
-				 buffer, size,
-				 ft_private->encrypted_outbuf);
-		sipe_digest_ft_update(ft_private->hmac_context,
-				 buffer, size);
-
-		/* chunk header format:
-		 *
-		 * 0: 00 unknown (always zero?)
-		 * 1: LL chunk size in bytes (low byte)
-		 * 2: HH chunk size in bytes (high byte)
-		 *
-		 * Convert size from host order to little endian
-		 */
-		hdr_buf[0] = 0;
-		hdr_buf[1] = (ft_private->bytes_remaining_chunk & 0x00FF);
-		hdr_buf[2] = (ft_private->bytes_remaining_chunk & 0xFF00) >> 8;
-
-		/* write chunk header */
-		if (!sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC, hdr_buf, sizeof(hdr_buf))) {
-			sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC,
-					 _("Socket write failed"));
-			return -1;
-		}
-	}
-
-	bytes_written = sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC,
-					 ft_private->outbuf_ptr,
-					 ft_private->bytes_remaining_chunk);
-	if (bytes_written < 0) {
-		raise_ft_error(ft_private, _("Socket write failed"));
-	} else if (bytes_written > 0) {
-		ft_private->bytes_remaining_chunk -= bytes_written;
-		ft_private->outbuf_ptr += bytes_written;
-	}
-
-	return bytes_written;
-}
-
 void sipe_ft_incoming_transfer(struct sipe_core_private *sipe_private,
 			 struct sip_dialog *dialog,
 			 const GSList *body)
@@ -773,6 +298,7 @@
 	generate_key(ft_private->hash_key, SIPE_FT_KEY_LENGTH);
 
 	ft_private->invitation_cookie = g_strdup(sipe_utils_nameval_find(body, "Invitation-Cookie"));
+	ft_private->peer_using_nat = sipe_strequal(sipe_utils_nameval_find(body, "Connectivity"), "N");
 
 	ft_private->dialog = dialog;
 
@@ -827,7 +353,7 @@
 				memcpy(ft_private->encryption_key,
 				 enc_key, SIPE_FT_KEY_LENGTH);
 			} else {
-				raise_ft_error_and_cancel(ft_private,
+				sipe_ft_raise_error_and_cancel(ft_private,
 							 _("Received encryption key has wrong size."));
 				g_free(enc_key);
 				return;
@@ -842,7 +368,7 @@
 				memcpy(ft_private->hash_key,
 				 hash_key, SIPE_FT_KEY_LENGTH);
 			} else {
-				raise_ft_error_and_cancel(ft_private,
+				sipe_ft_raise_error_and_cancel(ft_private,
 							 _("Received hash key has wrong size."));
 				g_free(hash_key);
 				return;
@@ -852,22 +378,18 @@
 
 
 		if (ip && port_str) {
-			unsigned short port = g_ascii_strtoull(port_str,
-							 NULL, 10);
-
-			sipe_backend_ft_incoming_accept(SIPE_FILE_TRANSFER_PUBLIC,
-							ip,
-							port,
-							port);
+			sipe_backend_ft_start(SIPE_FILE_TRANSFER_PUBLIC, NULL, ip,
+					 g_ascii_strtoull(port_str, NULL, 10));
 		} else {
-			if (!sipe_backend_ft_incoming_accept(SIPE_FILE_TRANSFER_PUBLIC,
-							 NULL,
-							 SIPE_FT_TCP_PORT_MIN,
-							 SIPE_FT_TCP_PORT_MAX)) {
-				raise_ft_error_and_cancel(ft_private,
+			ft_private->listendata =
+				sipe_backend_network_listen_range(SIPE_FT_TCP_PORT_MIN,
+								 SIPE_FT_TCP_PORT_MAX,
+								 listen_socket_created_cb,
+								 client_connected_cb,
+								 ft_private);
+			if (!ft_private->listendata)
+				sipe_ft_raise_error_and_cancel(ft_private,
 							 _("Could not create listen socket"));
-				return;
-			}
 		}
 	}
 }
--- pidgin-sipe-1.11.2/src/core/sipe-ft.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-ft.h	2011-06-14 14:40:36.000000000 +0200
@@ -24,13 +24,40 @@
 
 /* Forward declarations */
 struct sipe_core_private;
-struct sipe_file_transfer;
 
+#define SIPE_FT_KEY_LENGTH 24
 
 /**
- * Deallocate file transfer data structure
+ * File transport (private part)
 */
-void sipe_core_ft_deallocate(struct sipe_file_transfer *ft);
+struct sipe_file_transfer_private {
+	struct sipe_file_transfer public;
+
+	struct sipe_core_private *sipe_private;
+
+	gboolean peer_using_nat;
+	unsigned short port;
+
+	guchar encryption_key[SIPE_FT_KEY_LENGTH];
+	guchar hash_key[SIPE_FT_KEY_LENGTH];
+	unsigned auth_cookie;
+	gchar *invitation_cookie;
+
+	struct sip_dialog *dialog;
+
+	gpointer cipher_context;
+	gpointer hmac_context;
+
+	gsize bytes_remaining_chunk;
+
+	guchar *encrypted_outbuf;
+	guchar *outbuf_ptr;
+	gsize outbuf_size;
+
+	struct sipe_backend_listendata *listendata;
+};
+#define SIPE_FILE_TRANSFER_PUBLIC ((struct sipe_file_transfer *) ft_private)
+#define SIPE_FILE_TRANSFER_PRIVATE ((struct sipe_file_transfer_private *) ft)
 
 /**
 * Called when remote peer wants to send a file.
@@ -76,3 +103,6 @@
 * incorrect format
 */
 GSList *sipe_ft_parse_msg_body(const gchar *body);
+
+void sipe_ft_raise_error_and_cancel(struct sipe_file_transfer_private *ft_private,
+				 const gchar *errmsg);
--- pidgin-sipe-1.11.2/src/core/sipe-ft-tftp.c	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-ft-tftp.c	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,545 @@
+/**
+ * @file sipe-ft-tftp.c
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2010-11 SIPE Project <http://sipe.sourceforge.net/>
+ * Copyright (C) 2010 Jakub Adam <jakub.adam@ktknet.cz>
+ * Copyright (C) 2010 Tomáš Hrabčík <tomas.hrabcik@tieto.com>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+
+#include <glib.h>
+#include <glib/gprintf.h>
+
+#include "sipe-backend.h"
+#include "sipe-core.h"
+#include "sipe-core-private.h"
+#include "sipe-crypt.h"
+#include "sipe-dialog.h"
+#include "sipe-digest.h"
+#include "sipe-ft.h"
+#include "sipe-nls.h"
+#include "sipe-utils.h"
+
+#define BUFFER_SIZE 50
+#define SIPE_FT_CHUNK_HEADER_LENGTH 3
+
+static gboolean
+write_exact(struct sipe_file_transfer_private *ft_private, const guchar *data,
+	 gsize size)
+{
+	gssize bytes_written = sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC,
+						 data, size);
+	if ((bytes_written < 0) || ((gsize) bytes_written != size))
+		return FALSE;
+	return TRUE;
+}
+
+static gboolean
+read_exact(struct sipe_file_transfer_private *ft_private, guchar *data,
+	 gsize size)
+{
+	const gulong READ_TIMEOUT = 10000000;
+	gulong time_spent = 0;
+
+	while (size) {
+		gssize bytes_read = sipe_backend_ft_read(SIPE_FILE_TRANSFER_PUBLIC,
+							 data, size);
+		if (bytes_read == 0) {
+			g_usleep(100000);
+			time_spent += 100000;
+		} else if (bytes_read < 0 || time_spent > READ_TIMEOUT) {
+			return FALSE;
+		} else {
+			size -= bytes_read;
+			data += bytes_read;
+			time_spent = 0;
+		}
+	}
+	return TRUE;
+}
+
+static gboolean
+read_line(struct sipe_file_transfer_private *ft_private, guchar *data,
+	 gsize size)
+{
+	gsize pos = 0;
+
+	if (size < 2) return FALSE;
+
+	memset(data, 0, size--);
+	do {
+		if (!read_exact(ft_private, data + pos, 1))
+			return FALSE;
+	} while ((data[pos] != '\n') && (++pos < size));
+
+	/* Buffer too short? */
+	if ((pos == size) && (data[pos - 1] != '\n')) {
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+
+static void
+raise_ft_socket_read_error_and_cancel(struct sipe_file_transfer_private *ft_private)
+{
+	sipe_ft_raise_error_and_cancel(ft_private, _("Socket read failed"));
+}
+
+static void
+raise_ft_socket_write_error_and_cancel(struct sipe_file_transfer_private *ft_private)
+{
+	sipe_ft_raise_error_and_cancel(ft_private, _("Socket write failed"));
+}
+
+static gpointer
+sipe_cipher_context_init(const guchar *enc_key)
+{
+	/*
+	 * Decryption of file from SIPE file transfer
+	 *
+	 * Decryption:
+	 * 1.) SHA1-Key = SHA1sum (Encryption-Key); Do SHA1 digest from Encryption-Key, return 20 bytes SHA1-Key.
+	 * 2.) Decrypt-Data = RC4 (Encrypt-Data, substr(SHA1-Key, 0, 15)); Decryption of encrypted data, used 16 bytes SHA1-Key;
+	 */
+
+	guchar k2[SIPE_DIGEST_SHA1_LENGTH];
+
+	/* 1.) SHA1 sum	*/
+ sipe_digest_sha1(enc_key, SIPE_FT_KEY_LENGTH, k2);
+
+	/* 2.) RC4 decryption */
+	return sipe_crypt_ft_start(k2);
+}
+
+static gpointer
+sipe_hmac_context_init(const guchar *hash_key)
+{
+	/*
+	 * 	Count MAC digest
+	 *
+	 * 	HMAC digest:
+	 * 1.) SHA1-Key = SHA1sum (Hash-Key); Do SHA1 digest from Hash-Key, return 20 bytes SHA1-Key.
+	 * 2.) MAC = HMAC_SHA1 (Decrypt-Data, substr(HMAC-Key,0,15)); Digest of decrypted file and SHA1-Key (used again only 16 bytes)
+	 */
+
+	guchar k2[SIPE_DIGEST_SHA1_LENGTH];
+
+	/* 1.) SHA1 sum	*/
+	sipe_digest_sha1(hash_key, SIPE_FT_KEY_LENGTH, k2);
+
+	/* 2.) HMAC (initialization only) */
+	return sipe_digest_ft_start(k2);
+}
+
+static gchar *
+sipe_hmac_finalize(gpointer hmac_context)
+{
+	guchar hmac_digest[SIPE_DIGEST_FILETRANSFER_LENGTH];
+
+	/* MAC = Digest of decrypted file and SHA1-Key (used again only 16 bytes) */
+	sipe_digest_ft_end(hmac_context, hmac_digest);
+
+	return g_base64_encode(hmac_digest, sizeof (hmac_digest));
+}
+
+void
+sipe_core_tftp_incoming_start(struct sipe_file_transfer *ft, gsize total_size)
+{
+	static const guchar VER[] = "VER MSN_SECURE_FTP\r\n";
+	static const guchar TFR[] = "TFR\r\n";
+	const gsize FILE_SIZE_OFFSET = 4;
+
+	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
+	guchar buf[BUFFER_SIZE];
+	gchar *request;
+	gsize file_size;
+
+	if (!write_exact(ft_private, VER, sizeof(VER) - 1)) {
+		raise_ft_socket_read_error_and_cancel(ft_private);
+		return;
+	}
+	if (!read_line(ft_private, buf, BUFFER_SIZE)) {
+		raise_ft_socket_read_error_and_cancel(ft_private);
+		return;
+	}
+
+	request = g_strdup_printf("USR %s %u\r\n",
+				 ft_private->sipe_private->username,
+				 ft_private->auth_cookie);
+	if (!write_exact(ft_private, (guchar *)request, strlen(request))) {
+		raise_ft_socket_write_error_and_cancel(ft_private);
+		g_free(request);
+		return;
+	}
+	g_free(request);
+
+	if (!read_line(ft_private, buf, BUFFER_SIZE)) {
+		raise_ft_socket_read_error_and_cancel(ft_private);
+		return;
+	}
+
+	file_size = g_ascii_strtoull((gchar *) buf + FILE_SIZE_OFFSET, NULL, 10);
+	if (file_size != total_size) {
+		sipe_ft_raise_error_and_cancel(ft_private,
+					 _("File size is different from the advertised value."));
+		return;
+	}
+
+	if (!sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC, TFR, sizeof(TFR) - 1)) {
+		raise_ft_socket_write_error_and_cancel(ft_private);
+		return;
+	}
+
+	ft_private->bytes_remaining_chunk = 0;
+	ft_private->cipher_context = sipe_cipher_context_init(ft_private->encryption_key);
+	ft_private->hmac_context = sipe_hmac_context_init(ft_private->hash_key);
+}
+
+gboolean
+sipe_core_tftp_incoming_stop(struct sipe_file_transfer *ft)
+{
+	static const guchar BYE[] = "BYE 16777989\r\n";
+	const gsize MAC_OFFSET = 4;
+
+	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
+	gchar buffer[BUFFER_SIZE];
+	gsize mac_len;
+	gchar *mac;
+	gchar *mac1;
+
+	if (!sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC, BYE, sizeof(BYE) - 1)) {
+		raise_ft_socket_write_error_and_cancel(ft_private);
+		return FALSE;
+	}
+
+	if (!read_line(ft_private, (guchar *) buffer, BUFFER_SIZE)) {
+		raise_ft_socket_read_error_and_cancel(ft_private);
+		return FALSE;
+	}
+
+	mac_len = strlen(buffer);
+	if (mac_len < (MAC_OFFSET)) {
+		sipe_ft_raise_error_and_cancel(ft_private,
+					 _("Received MAC is corrupted"));
+		return FALSE;
+	}
+
+	/* Check MAC */
+	mac = g_strndup(buffer + MAC_OFFSET, mac_len - MAC_OFFSET);
+	mac1 = sipe_hmac_finalize(ft_private->hmac_context);
+	if (!sipe_strequal(mac, mac1)) {
+		g_free(mac1);
+		g_free(mac);
+		sipe_ft_raise_error_and_cancel(ft_private,
+					 _("Received file is corrupted"));
+		return(FALSE);
+	}
+	g_free(mac1);
+	g_free(mac);
+
+	return(TRUE);
+}
+
+void
+sipe_core_tftp_outgoing_start(struct sipe_file_transfer *ft, gsize total_size)
+{
+	static const guchar VER[] = "VER MSN_SECURE_FTP\r\n";
+
+	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
+	guchar buf[BUFFER_SIZE];
+	gchar **parts;
+	unsigned auth_cookie_received;
+	gboolean users_match;
+
+	if (!read_line(ft_private, buf, BUFFER_SIZE)) {
+		raise_ft_socket_read_error_and_cancel(ft_private);
+		return;
+	}
+
+	if (!sipe_strequal((gchar *)buf, (gchar *)VER)) {
+		sipe_ft_raise_error_and_cancel(ft_private,
+					 _("File transfer initialization failed."));
+		SIPE_DEBUG_INFO("File transfer VER string incorrect, received: %s expected: %s",
+				buf, VER);
+		return;
+	}
+
+	if (!write_exact(ft_private, VER, sizeof(VER) - 1)) {
+		raise_ft_socket_write_error_and_cancel(ft_private);
+		return;
+	}
+
+	if (!read_line(ft_private, buf, BUFFER_SIZE)) {
+		raise_ft_socket_read_error_and_cancel(ft_private);
+		return;
+	}
+
+	parts = g_strsplit((gchar *)buf, " ", 3);
+	auth_cookie_received = g_ascii_strtoull(parts[2], NULL, 10);
+	/* dialog->with has 'sip:' prefix, skip these four characters */
+	users_match = sipe_strcase_equal(parts[1],
+					 (ft_private->dialog->with + 4));
+	g_strfreev(parts);
+
+	SIPE_DEBUG_INFO("File transfer authentication: %s Expected: USR %s %u",
+			buf,
+			ft_private->dialog->with + 4,
+			ft_private->auth_cookie);
+
+	if (!users_match ||
+	 (ft_private->auth_cookie != auth_cookie_received)) {
+		sipe_ft_raise_error_and_cancel(ft_private,
+					 _("File transfer authentication failed."));
+		return;
+	}
+
+	g_sprintf((gchar *)buf, "FIL %" G_GSIZE_FORMAT "\r\n", total_size);
+	if (!write_exact(ft_private, buf, strlen((gchar *)buf))) {
+		raise_ft_socket_write_error_and_cancel(ft_private);
+		return;
+	}
+
+	/* TFR */
+	if (!read_line(ft_private ,buf, BUFFER_SIZE)) {
+		raise_ft_socket_read_error_and_cancel(ft_private);
+		return;
+	}
+
+	ft_private->bytes_remaining_chunk = 0;
+	ft_private->cipher_context = sipe_cipher_context_init(ft_private->encryption_key);
+	ft_private->hmac_context = sipe_hmac_context_init(ft_private->hash_key);
+}
+
+gboolean
+sipe_core_tftp_outgoing_stop(struct sipe_file_transfer *ft)
+{
+	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
+	guchar buffer[BUFFER_SIZE];
+	gchar *mac;
+	gsize mac_len;
+
+	/* BYE */
+	if (!read_line(ft_private, buffer, BUFFER_SIZE)) {
+		raise_ft_socket_read_error_and_cancel(ft_private);
+		return FALSE;
+	}
+
+	mac = sipe_hmac_finalize(ft_private->hmac_context);
+	g_sprintf((gchar *)buffer, "MAC %s \r\n", mac);
+	g_free(mac);
+
+	mac_len = strlen((gchar *)buffer);
+	/* There must be this zero byte between mac and \r\n */
+	buffer[mac_len - 3] = 0;
+
+	if (!write_exact(ft_private, buffer, mac_len)) {
+		raise_ft_socket_write_error_and_cancel(ft_private);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void raise_ft_error(struct sipe_file_transfer_private *ft_private,
+			 const gchar *errmsg)
+{
+	gchar *tmp = g_strdup_printf("%s: %s", errmsg,
+				 sipe_backend_ft_get_error(SIPE_FILE_TRANSFER_PUBLIC));
+	sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC, tmp);
+	g_free(tmp);
+}
+
+gssize
+sipe_core_tftp_read(struct sipe_file_transfer *ft, guchar **buffer,
+		 gsize bytes_remaining, gsize bytes_available)
+{
+	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
+	gsize bytes_to_read;
+	gssize bytes_read;
+
+	if (ft_private->bytes_remaining_chunk == 0) {
+		guchar hdr_buf[SIPE_FT_CHUNK_HEADER_LENGTH];
+
+		/* read chunk header */
+		if (!read_exact(ft_private, hdr_buf, sizeof(hdr_buf))) {
+			raise_ft_error(ft_private, _("Socket read failed"));
+			return -1;
+		}
+
+		/* chunk header format:
+		 *
+		 * 0: 00 unknown (always zero?)
+		 * 1: LL chunk size in bytes (low byte)
+		 * 2: HH chunk size in bytes (high byte)
+		 *
+		 * Convert size from little endian to host order
+		 */
+		ft_private->bytes_remaining_chunk =
+			hdr_buf[1] + (hdr_buf[2] << 8);
+	}
+
+	bytes_to_read = MIN(bytes_remaining, bytes_available);
+	bytes_to_read = MIN(bytes_to_read, ft_private->bytes_remaining_chunk);
+
+	*buffer = g_malloc(bytes_to_read);
+	if (!*buffer) {
+		sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC, _("Out of memory"));
+		SIPE_DEBUG_ERROR("sipe_core_ft_read: can't allocate %" G_GSIZE_FORMAT " bytes for receive buffer",
+				 bytes_to_read);
+		return -1;
+	}
+
+	bytes_read = sipe_backend_ft_read(SIPE_FILE_TRANSFER_PUBLIC, *buffer, bytes_to_read);
+	if (bytes_read < 0) {
+		raise_ft_error(ft_private, _("Socket read failed"));
+		g_free(*buffer);
+		*buffer = NULL;
+		return -1;
+	}
+
+	if (bytes_read > 0) {
+		guchar *decrypted = g_malloc(bytes_read);
+
+		if (!decrypted) {
+			sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC, _("Out of memory"));
+			SIPE_DEBUG_ERROR("sipe_core_ft_read: can't allocate %" G_GSIZE_FORMAT " bytes for decryption buffer",
+					 (gsize)bytes_read);
+			g_free(*buffer);
+			*buffer = NULL;
+			return -1;
+		}
+		sipe_crypt_ft_stream(ft_private->cipher_context,
+				 *buffer, bytes_read, decrypted);
+		g_free(*buffer);
+		*buffer = decrypted;
+
+		sipe_digest_ft_update(ft_private->hmac_context,
+				 decrypted, bytes_read);
+
+		ft_private->bytes_remaining_chunk -= bytes_read;
+	}
+
+	return(bytes_read);
+}
+
+gssize
+sipe_core_tftp_write(struct sipe_file_transfer *ft, const guchar *buffer,
+		 gsize size)
+{
+	struct sipe_file_transfer_private *ft_private = SIPE_FILE_TRANSFER_PRIVATE;
+	gssize bytes_written;
+
+	/* When sending data via server with ForeFront installed, block bigger than
+	 * this default causes ending of transmission. Hard limit block to this value
+	 * when libpurple sends us more data. */
+	const gsize DEFAULT_BLOCK_SIZE = 2045;
+	if (size > DEFAULT_BLOCK_SIZE)
+		size = DEFAULT_BLOCK_SIZE;
+
+	if (ft_private->bytes_remaining_chunk == 0) {
+		gssize bytes_read;
+		guchar local_buf[16];
+		guchar hdr_buf[SIPE_FT_CHUNK_HEADER_LENGTH];
+
+		memset(local_buf, 0, sizeof local_buf);
+
+		/* Check if receiver did not cancel the transfer
+		 before it is finished */
+		bytes_read = sipe_backend_ft_read(SIPE_FILE_TRANSFER_PUBLIC,
+						 local_buf,
+						 sizeof(local_buf));
+		if (bytes_read < 0) {
+			sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC,
+					 _("Socket read failed"));
+			return -1;
+		} else if ((bytes_read > 0) &&
+			 (g_str_has_prefix((gchar *)local_buf, "CCL\r\n") ||
+			 g_str_has_prefix((gchar *)local_buf, "BYE 2164261682\r\n"))) {
+			return -1;
+		}
+
+		if (ft_private->outbuf_size < size) {
+			g_free(ft_private->encrypted_outbuf);
+			ft_private->outbuf_size = size;
+			ft_private->encrypted_outbuf = g_malloc(ft_private->outbuf_size);
+			if (!ft_private->encrypted_outbuf) {
+				sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC,
+						 _("Out of memory"));
+				SIPE_DEBUG_ERROR("sipe_core_ft_write: can't allocate %" G_GSIZE_FORMAT " bytes for send buffer",
+						 ft_private->outbuf_size);
+				return -1;
+			}
+		}
+
+		ft_private->bytes_remaining_chunk = size;
+		ft_private->outbuf_ptr = ft_private->encrypted_outbuf;
+		sipe_crypt_ft_stream(ft_private->cipher_context,
+				 buffer, size,
+				 ft_private->encrypted_outbuf);
+		sipe_digest_ft_update(ft_private->hmac_context,
+				 buffer, size);
+
+		/* chunk header format:
+		 *
+		 * 0: 00 unknown (always zero?)
+		 * 1: LL chunk size in bytes (low byte)
+		 * 2: HH chunk size in bytes (high byte)
+		 *
+		 * Convert size from host order to little endian
+		 */
+		hdr_buf[0] = 0;
+		hdr_buf[1] = (ft_private->bytes_remaining_chunk & 0x00FF);
+		hdr_buf[2] = (ft_private->bytes_remaining_chunk & 0xFF00) >> 8;
+
+		/* write chunk header */
+		if (!sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC, hdr_buf, sizeof(hdr_buf))) {
+			sipe_backend_ft_error(SIPE_FILE_TRANSFER_PUBLIC,
+					 _("Socket write failed"));
+			return -1;
+		}
+	}
+
+	bytes_written = sipe_backend_ft_write(SIPE_FILE_TRANSFER_PUBLIC,
+					 ft_private->outbuf_ptr,
+					 ft_private->bytes_remaining_chunk);
+	if (bytes_written < 0) {
+		raise_ft_error(ft_private, _("Socket write failed"));
+	} else if (bytes_written > 0) {
+		ft_private->bytes_remaining_chunk -= bytes_written;
+		ft_private->outbuf_ptr += bytes_written;
+	}
+
+	return bytes_written;
+}
+
+/*
+ Local Variables:
+ mode: c
+ c-file-style: "bsd"
+ indent-tabs-mode: t
+ tab-width: 8
+ End:
+*/
--- pidgin-sipe-1.11.2/src/core/sipe-group.c	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-group.c	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,232 @@
+/**
+ * @file sipe-group.c
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2011 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <glib.h>
+
+#include "sipe-core.h"
+#include "sipe-core-private.h"
+#include "sipe-backend.h"
+#include "sip-transport.h"
+#include "sipe-xml.h"
+#include "sipe-buddy.h"
+#include "sipmsg.h"
+#include "sipe-group.h"
+#include "sipe-nls.h"
+#include "sipe.h"
+
+static void
+sipe_group_context_destroy(gpointer data)
+{
+	struct group_user_context *ctx = data;
+	g_free(ctx->group_name);
+	g_free(ctx->user_name);
+	g_free(ctx);
+}
+
+static gboolean
+process_add_group_response(struct sipe_core_private *sipe_private,
+			 struct sipmsg *msg,
+			 struct transaction *trans)
+{
+	if (msg->response == 200) {
+		struct sipe_group *group;
+		struct group_user_context *ctx = trans->payload->data;
+		sipe_xml *xml;
+		const sipe_xml *node;
+		char *group_id;
+		struct sipe_buddy *buddy;
+
+		xml = sipe_xml_parse(msg->body, msg->bodylen);
+		if (!xml) {
+			return FALSE;
+		}
+
+		node = sipe_xml_child(xml, "Body/addGroup/groupID");
+		if (!node) {
+			sipe_xml_free(xml);
+			return FALSE;
+		}
+
+		group_id = sipe_xml_data(node);
+		if (!group_id) {
+			sipe_xml_free(xml);
+			return FALSE;
+		}
+
+		group = g_new0(struct sipe_group, 1);
+		group->id = (int)g_ascii_strtod(group_id, NULL);
+		g_free(group_id);
+		group->name = g_strdup(ctx->group_name);
+
+		sipe_group_add(sipe_private, group);
+
+		if (ctx->user_name) {
+			buddy = g_hash_table_lookup(sipe_private->buddies, ctx->user_name);
+			if (buddy) {
+				buddy->groups = slist_insert_unique_sorted(buddy->groups, group, (GCompareFunc)sipe_group_compare);
+			}
+
+			sipe_core_group_set_user(SIPE_CORE_PUBLIC, ctx->user_name);
+		}
+
+		sipe_xml_free(xml);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+int
+sipe_group_compare(struct sipe_group *group1, struct sipe_group *group2) {
+	return group1->id - group2->id;
+}
+
+struct sipe_group*
+sipe_group_find_by_id(struct sipe_core_private *sipe_private,
+		 int id)
+{
+	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
+	struct sipe_group *group;
+	GSList *entry;
+	if (sip == NULL) {
+		return NULL;
+	}
+
+	entry = sip->groups;
+	while (entry) {
+		group = entry->data;
+		if (group->id == id) {
+			return group;
+		}
+		entry = entry->next;
+	}
+	return NULL;
+}
+
+struct sipe_group*
+sipe_group_find_by_name(struct sipe_core_private *sipe_private,
+			const gchar * name)
+{
+	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
+	struct sipe_group *group;
+	GSList *entry;
+	if (!sip || !name) {
+		return NULL;
+	}
+
+	entry = sip->groups;
+	while (entry) {
+		group = entry->data;
+		if (sipe_strequal(group->name, name)) {
+			return group;
+		}
+		entry = entry->next;
+	}
+	return NULL;
+}
+
+void
+sipe_group_create(struct sipe_core_private *sipe_private,
+		 const gchar *name,
+		 const gchar * who)
+{
+	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
+	struct transaction_payload *payload = g_new0(struct transaction_payload, 1);
+	struct group_user_context *ctx = g_new0(struct group_user_context, 1);
+	const gchar *soap_name = sipe_strequal(name, _("Other Contacts")) ? "~" : name;
+	gchar *body;
+	ctx->group_name = g_strdup(name);
+	ctx->user_name = g_strdup(who);
+	payload->destroy = sipe_group_context_destroy;
+	payload->data = ctx;
+
+	body = g_markup_printf_escaped(SIPE_SOAP_ADD_GROUP, soap_name, sip->contacts_delta++);
+	send_soap_request_with_cb(sipe_private, NULL, body, process_add_group_response, payload);
+	g_free(body);
+}
+
+void
+sipe_group_add(struct sipe_core_private *sipe_private,
+	 struct sipe_group * group)
+{
+	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
+	if (sipe_backend_buddy_group_add(SIPE_CORE_PUBLIC,group->name))
+	{
+		SIPE_DEBUG_INFO("added group %s (id %d)", group->name, group->id);
+		sip->groups = g_slist_append(sip->groups, group);
+	}
+	else
+	{
+		SIPE_DEBUG_INFO("did not add group %s", group->name ? group->name : "");
+	}
+}
+
+void
+sipe_core_group_rename(struct sipe_core_public *sipe_public,
+		 const gchar *old_name,
+		 const gchar *new_name)
+{
+	struct sipe_group *s_group = sipe_group_find_by_name(SIPE_CORE_PRIVATE, old_name);
+
+	if (s_group) {
+		struct sipe_account_data *sip = SIPE_ACCOUNT_DATA;
+		gchar *body;
+		SIPE_DEBUG_INFO("Renaming group %s to %s", old_name, new_name);
+		body = g_markup_printf_escaped(SIPE_SOAP_MOD_GROUP, s_group->id, new_name, sip->contacts_delta++);
+		send_soap_request(SIPE_CORE_PRIVATE, body);
+		g_free(body);
+		g_free(s_group->name);
+		s_group->name = g_strdup(new_name);
+	} else {
+		SIPE_DEBUG_INFO("Cannot find group %s to rename", old_name);
+	}
+}
+
+void
+sipe_core_group_remove(struct sipe_core_public *sipe_public,
+		 const gchar *name)
+{
+	struct sipe_group * s_group = sipe_group_find_by_name(SIPE_CORE_PRIVATE, name);
+
+	if (s_group) {
+		struct sipe_account_data *sip = SIPE_ACCOUNT_DATA;
+		gchar *body;
+		SIPE_DEBUG_INFO("Deleting group %s", name);
+		body = g_strdup_printf(SIPE_SOAP_DEL_GROUP, s_group->id, sip->contacts_delta++);
+		send_soap_request(SIPE_CORE_PRIVATE, body);
+		g_free(body);
+
+		sip->groups = g_slist_remove(sip->groups, s_group);
+		g_free(s_group->name);
+		g_free(s_group);
+	} else {
+		SIPE_DEBUG_INFO("Cannot find group %s to delete", name);
+	}
+}
+
+/*
+ Local Variables:
+ mode: c
+ c-file-style: "bsd"
+ indent-tabs-mode: t
+ tab-width: 8
+ End:
+*/
--- pidgin-sipe-1.11.2/src/core/sipe-groupchat.c	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-groupchat.c	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,1105 @@
+/**
+ * @file sipe-groupchat.c
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2010-11 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/**
+ * This module implements the OCS2007R2 Group Chat functionality
+ *
+ * Documentation references:
+ *
+ * Microsoft TechNet: Key Protocols and Windows Services Used by Group Chat
+ * <http://technet.microsoft.com/en-us/library/ee323484%28office.13%29.aspx>
+ * Microsoft TechNet: Group Chat Call Flows
+ * <http://technet.microsoft.com/en-us/library/ee323524%28office.13%29.aspx>
+ * Microsoft Office Communications Server 2007 R2 Technical Reference Guide
+ * <http://go.microsoft.com/fwlink/?LinkID=159649>
+ * XML XCCOS message specification
+ * <???> (searches on the internet currently reveal nothing)
+ *
+ *
+ * @TODO:
+ *
+ * -.cmd:getserverinfo
+ * <sib domain="<DOMAIN>" infoType="123" />
+ * rpl:getservinfo
+ * <sib infoType="123"
+ * serverTime="2010-09-14T14:26:17.6206356Z"
+ * searchLimit="999"
+ * messageSizeLimit="512"
+ * storySizeLimit="4096"
+ * rootUri="ma-cat://<DOMAIN>/<GUID>"
+ * dbVersion="3ea3a5a8-ef36-46cf-898f-7a5133931d63"
+ * />
+ *
+ * is there any information in there we would need/use?
+ *
+ * - cmd:getpref/rpl:getpref/cmd:setpref/rpl:setpref
+ * probably useless, as libpurple stores configuration locally
+ *
+ * can store base64 encoded "free text" in key/value fashion
+ * <cmd id="cmd:getpref" seqid="x">
+ * <data>
+ * <pref label="kedzie.GroupChannels"
+ * seqid="71"
+ * createdefault="true" />
+ * </data>
+ * </cmd>
+ * <cmd id="cmd:setpref" seqid="x">
+ * <data>
+ * <pref label="kedzie.GroupChannels"
+ * seqid="71"
+ * createdefault="false"
+ * content="<BASE64 text>" />
+ * </data>
+ * </cmd>
+ *
+ * use this to sync chats in buddy list on multiple clients?
+ *
+ * - cmd:bccontext
+ * send after cmd:join to trigger rpl:bccontext
+ *
+ * - rpl:bccontext
+ * according to available documentation delivers channel history, etc.
+ * [no log file examples]
+ * can we add the history to the window when we open the window, or would
+ * that confuse users that use history based on client log?
+ *
+ * - cmd:getinv
+ * <inv inviteId="1" domain="<DOMAIN>" />
+ * rpl:getinv
+ * ???
+ *
+ * according to documentation should provide list of outstanding invites.
+ * [no log file examples]
+ * should we automatically join those channels or ask user to join/add?
+ *
+ * - chatserver_command_message()
+ * needs to support multiple <chatgrp> nodes?
+ * [no log file examples]
+ *
+ * - create/delete chat rooms
+ * [no log file examples]
+ * are these related to this functionality?
+ *
+ * <cmd id="cmd:nodespermcreatechild" seqid="1">
+ * <data />
+ * </cmd>
+ * <rpl id="rpl:nodespermcreatechild" seqid="1">
+ * <commandid seqid="1" envid="xxx" />
+ * <resp code="200">SUCCESS_OK</resp>
+ * <data />
+ * </rpl>
+ *
+ * - file transfer (uses HTTPS PUT/GET via a filestore server)
+ * [no log file examples]
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include "sipe-common.h"
+#include "sipmsg.h"
+#include "sip-transport.h"
+#include "sipe-backend.h"
+#include "sipe-chat.h"
+#include "sipe-core.h"
+#include "sipe-core-private.h"
+#include "sipe-dialog.h"
+#include "sipe-groupchat.h"
+#include "sipe-im.h"
+#include "sipe-nls.h"
+#include "sipe-schedule.h"
+#include "sipe-session.h"
+#include "sipe-utils.h"
+#include "sipe-xml.h"
+
+#define GROUPCHAT_RETRY_TIMEOUT 5*60 /* seconds */
+
+/**
+ * aib node - magic numbers?
+ *
+ * Example:
+ * <aib key="3984" value="0,1,2,3,4,5,7,9,10,12,13,14,15,16,17" />
+ * <aib key="12276" value="6,8,11" />
+ *
+ * "value" corresponds to the "id" attribute in uib nodes.
+ *
+ * @TODO: Confirm "guessed" meaning of the magic numbers:
+ * 3984 = normal users
+ * 12276 = channel operators
+ */
+#define GROUPCHAT_AIB_KEY_USER "3984"
+#define GROUPCHAT_AIB_KEY_CHANOP "12276"
+
+struct sipe_groupchat {
+	struct sip_session *session;
+	gchar *domain;
+	GSList *join_queue;
+	GHashTable *uri_to_chat_session;
+	GHashTable *msgs;
+	guint envid;
+	gboolean connected;
+};
+
+struct sipe_groupchat_msg {
+	GHashTable *container;
+	struct sipe_chat_session *session;
+	gchar *content;
+	gchar *xccos;
+	guint envid;
+};
+
+/* GDestroyNotify */
+static void sipe_groupchat_msg_free(gpointer data) {
+	struct sipe_groupchat_msg *msg = data;
+	g_free(msg->content);
+	g_free(msg->xccos);
+	g_free(msg);
+}
+
+/* GDestroyNotify */
+static void sipe_groupchat_msg_remove(gpointer data) {
+	struct sipe_groupchat_msg *msg = data;
+	g_hash_table_remove(msg->container, &msg->envid);
+}
+
+static void sipe_groupchat_allocate(struct sipe_core_private *sipe_private)
+{
+	struct sipe_groupchat *groupchat = g_new0(struct sipe_groupchat, 1);
+
+	groupchat->uri_to_chat_session = g_hash_table_new(g_str_hash, g_str_equal);
+	groupchat->msgs = g_hash_table_new_full(g_int_hash, g_int_equal,
+						NULL,
+						sipe_groupchat_msg_free);
+	groupchat->envid = rand();
+	groupchat->connected = FALSE;
+	sipe_private->groupchat = groupchat;
+}
+
+static void sipe_groupchat_free_join_queue(struct sipe_groupchat *groupchat)
+{
+	GSList *entry = groupchat->join_queue;
+	while (entry) {
+		g_free(entry->data);
+		entry = entry->next;
+	}
+	g_slist_free(groupchat->join_queue);
+	groupchat->join_queue = NULL;
+}
+
+void sipe_groupchat_free(struct sipe_core_private *sipe_private)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+	if (groupchat) {
+		sipe_groupchat_free_join_queue(groupchat);
+		g_hash_table_destroy(groupchat->msgs);
+		g_hash_table_destroy(groupchat->uri_to_chat_session);
+		g_free(groupchat->domain);
+		g_free(groupchat);
+		sipe_private->groupchat = NULL;
+	}
+}
+
+static struct sipe_groupchat_msg *generate_xccos_message(struct sipe_groupchat *groupchat,
+							 const gchar *content)
+{
+	struct sipe_groupchat_msg *msg = g_new0(struct sipe_groupchat_msg, 1);
+
+	msg->container = groupchat->msgs;
+	msg->envid = groupchat->envid++;
+	msg->xccos = g_strdup_printf("<xccos ver=\"1\" envid=\"%u\" xmlns=\"urn:parlano:xml:ns:xccos\">"
+					 "%s"
+					 "</xccos>",
+					 msg->envid,
+					 content);
+
+	g_hash_table_insert(groupchat->msgs, &msg->envid, msg);
+
+	return(msg);
+}
+
+/**
+ * Create short-lived dialog with ocschat@<domain> (or user specified value)
+ * This initiates the Group Chat feature
+ */
+void sipe_groupchat_init(struct sipe_core_private *sipe_private)
+{
+	const gchar *setting = sipe_backend_setting(SIPE_CORE_PUBLIC,
+						 SIPE_SETTING_GROUPCHAT_USER);
+	gboolean user_set = !is_empty(setting);
+	gchar **parts = g_strsplit(user_set ? setting : sipe_private->username,
+				 "@", 2);
+	gboolean domain_found = !is_empty(parts[1]);
+	const gchar *user = "ocschat";
+	const gchar *domain = parts[domain_found ? 1 : 0];
+	gchar *chat_uri;
+	struct sip_session *session;
+	struct sipe_groupchat *groupchat;
+
+	/* User specified valid 'user@company.com' */
+	if (user_set && domain_found && !is_empty(parts[0]))
+		user = parts[0];
+
+	SIPE_DEBUG_INFO("sipe_groupchat_init: username '%s' setting '%s' split '%s'/'%s' GC user %s@%s",
+			sipe_private->username, setting ? setting : "(null)", parts[0],
+			parts[1] ? parts[1] : "(null)", user, domain);
+
+	if (!sipe_private->groupchat)
+		sipe_groupchat_allocate(sipe_private);
+	groupchat = sipe_private->groupchat;
+
+	chat_uri = g_strdup_printf("sip:%s@%s", user, domain);
+	session = sipe_session_find_or_add_im(sipe_private,
+					 chat_uri);
+	session->is_groupchat = TRUE;
+	sipe_im_invite(sipe_private, session, chat_uri,
+		 NULL, NULL, NULL, FALSE);
+
+	g_free(groupchat->domain);
+	groupchat->domain = g_strdup(domain);
+
+	g_free(chat_uri);
+	g_strfreev(parts);
+}
+
+/* sipe_schedule_action */
+static void groupchat_init_retry_cb(struct sipe_core_private *sipe_private,
+				 SIPE_UNUSED_PARAMETER gpointer data)
+{
+	sipe_groupchat_init(sipe_private);
+}
+
+static void groupchat_init_retry(struct sipe_core_private *sipe_private)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+
+	SIPE_DEBUG_INFO_NOFORMAT("groupchat_init_retry: trying again later...");
+
+	groupchat->session = NULL;
+	groupchat->connected = FALSE;
+
+	sipe_schedule_seconds(sipe_private,
+			 "<+grouchat-retry>",
+			 NULL,
+			 GROUPCHAT_RETRY_TIMEOUT,
+			 groupchat_init_retry_cb,
+			 NULL);
+}
+
+void sipe_groupchat_invite_failed(struct sipe_core_private *sipe_private,
+				 struct sip_session *session)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+	const gchar *setting = sipe_backend_setting(SIPE_CORE_PUBLIC,
+						 SIPE_SETTING_GROUPCHAT_USER);
+
+	if (groupchat->session) {
+		/* response to group chat server invite */
+		SIPE_DEBUG_ERROR_NOFORMAT("can't connect to group chat server!");
+	} else {
+		/* response to initial invite */
+		SIPE_DEBUG_INFO_NOFORMAT("no group chat server found.");
+	}
+
+	sipe_session_close(sipe_private, session);
+	groupchat_init_retry(sipe_private);
+
+	if (!is_empty(setting)) {
+		gchar *msg = g_strdup_printf(_("Group Chat Proxy setting is incorrect:\n\n\t%s\n\nPlease update your Account."),
+					 setting);
+		sipe_backend_notify_error(_("Couldn't find Group Chat server!"), msg);
+		g_free(msg);
+	}
+}
+
+static gchar *generate_chanid_node(const gchar *uri, guint key)
+{
+	/* ma-chan://<domain>/<value> */
+	gchar **parts = g_strsplit(uri, "/", 4);
+	gchar *chanid = NULL;
+
+	if (parts[2] && parts[3]) {
+		chanid = g_strdup_printf("<chanid key=\"%d\" domain=\"%s\" value=\"%s\"/>",
+					 key, parts[2], parts[3]);
+	} else {
+		SIPE_DEBUG_ERROR("generate_chanid_node: mal-formed URI '%s'",
+				 uri);
+	}
+	g_strfreev(parts);
+
+	return chanid;
+}
+
+static struct sipe_groupchat_msg *chatserver_command(struct sipe_core_private *sipe_private,
+						 const gchar *cmd);
+
+void sipe_groupchat_invite_response(struct sipe_core_private *sipe_private,
+				 struct sip_dialog *dialog)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+
+	SIPE_DEBUG_INFO_NOFORMAT("sipe_groupchat_invite_response");
+
+	if (!groupchat->session) {
+		/* response to initial invite */
+		struct sipe_groupchat_msg *msg = generate_xccos_message(groupchat,
+									"<cmd id=\"cmd:requri\" seqid=\"1\"><data/></cmd>");
+		sip_transport_info(sipe_private,
+				 "Content-Type: text/plain\r\n",
+				 msg->xccos,
+				 dialog,
+				 NULL);
+		sipe_groupchat_msg_remove(msg);
+
+	} else {
+		/* response to group chat server invite */
+		gchar *invcmd;
+
+		SIPE_DEBUG_INFO_NOFORMAT("connection to group chat server established.");
+
+		groupchat->connected = TRUE;
+
+		/* Any queued joins? */
+		if (groupchat->join_queue) {
+			GString *cmd = g_string_new("<cmd id=\"cmd:bjoin\" seqid=\"1\">"
+						 "<data>");
+			GSList *entry;
+			guint i = 0;
+
+			/* We used g_slist_prepend() to create the list */
+			groupchat->join_queue = entry = g_slist_reverse(groupchat->join_queue);
+			while (entry) {
+				gchar *chanid = generate_chanid_node(entry->data, i++);
+				g_string_append(cmd, chanid);
+				g_free(chanid);
+				entry = entry->next;
+			}
+			sipe_groupchat_free_join_queue(groupchat);
+
+			g_string_append(cmd, "</data></cmd>");
+			chatserver_command(sipe_private, cmd->str);
+			g_string_free(cmd, TRUE);
+		}
+
+		/* Request outstanding invites from server */
+		invcmd = g_strdup_printf("<cmd id=\"cmd:getinv\" seqid=\"1\">"
+					 "<data>"
+					 "<inv inviteId=\"1\" domain=\"%s\"/>"
+					 "</data>"
+					 "</cmd>", groupchat->domain);
+		chatserver_command(sipe_private, invcmd);
+		g_free(invcmd);
+	}
+}
+
+/* TransCallback */
+static gboolean chatserver_command_response(struct sipe_core_private *sipe_private,
+					 struct sipmsg *msg,
+					 struct transaction *trans)
+{
+	if (msg->response != 200) {
+		struct sipe_groupchat_msg *gmsg = trans->payload->data;
+		struct sipe_chat_session *chat_session = gmsg->session;
+
+		SIPE_DEBUG_INFO("chatserver_command_response: failure %d", msg->response);
+
+		if (chat_session) {
+			gchar *label = g_strdup_printf(_("This message was not delivered to chat room '%s'"),
+							chat_session->title);
+			gchar *errmsg = g_strdup_printf("%s:\n%s",
+							label, gmsg->content);
+			g_free(label);
+			sipe_backend_notify_message_error(SIPE_CORE_PUBLIC,
+							 chat_session->backend,
+							 NULL,
+							 errmsg);
+			g_free(errmsg);
+		}
+	}
+	return TRUE;
+}
+
+static struct sipe_groupchat_msg *chatserver_command(struct sipe_core_private *sipe_private,
+						 const gchar *cmd)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+	struct sipe_groupchat_msg *msg = generate_xccos_message(groupchat, cmd);
+
+	struct sip_dialog *dialog = sipe_dialog_find(groupchat->session,
+						 groupchat->session->with);
+
+	struct transaction_payload *payload = g_new0(struct transaction_payload, 1);
+	struct transaction *trans = sip_transport_info(sipe_private,
+						 "Content-Type: text/plain\r\n",
+						 msg->xccos,
+						 dialog,
+						 chatserver_command_response);
+
+	payload->destroy = sipe_groupchat_msg_remove;
+	payload->data = msg;
+	trans->payload = payload;
+
+	return(msg);
+}
+
+static void chatserver_response_uri(struct sipe_core_private *sipe_private,
+				 struct sip_session *session,
+				 SIPE_UNUSED_PARAMETER guint result,
+				 SIPE_UNUSED_PARAMETER const gchar *message,
+				 const sipe_xml *xml)
+{
+		const sipe_xml *uib = sipe_xml_child(xml, "uib");
+		const gchar *uri = sipe_xml_attribute(uib, "uri");
+
+		/* drop connection to ocschat@<domain> again */
+		sipe_session_close(sipe_private, session);
+
+		if (uri) {
+			struct sipe_groupchat *groupchat = sipe_private->groupchat;
+
+			SIPE_DEBUG_INFO("chatserver_response_uri: '%s'", uri);
+
+			groupchat->session = session = sipe_session_find_or_add_im(sipe_private,
+										 uri);
+
+			session->is_groupchat = TRUE;
+			sipe_im_invite(sipe_private, session, uri, NULL, NULL, NULL, FALSE);
+		} else {
+			SIPE_DEBUG_WARNING_NOFORMAT("process_incoming_info_groupchat: no server URI found!");
+			groupchat_init_retry(sipe_private);
+		}
+}
+
+static void chatserver_response_channel_search(struct sipe_core_private *sipe_private,
+					 SIPE_UNUSED_PARAMETER struct sip_session *session,
+					 guint result,
+					 const gchar *message,
+					 const sipe_xml *xml)
+{
+	struct sipe_core_public *sipe_public = SIPE_CORE_PUBLIC;
+
+	if (result != 200) {
+		sipe_backend_notify_error(_("Error retrieving room list"),
+					 message);
+	} else {
+		const sipe_xml *chanib;
+
+		for (chanib = sipe_xml_child(xml, "chanib");
+		 chanib;
+		 chanib = sipe_xml_twin(chanib)) {
+			const gchar *name = sipe_xml_attribute(chanib, "name");
+			const gchar *desc = sipe_xml_attribute(chanib, "description");
+			const gchar *uri = sipe_xml_attribute(chanib, "uri");
+			const sipe_xml *node;
+			guint user_count = 0;
+			guint32 flags = 0;
+
+			/* information */
+			for (node = sipe_xml_child(chanib, "info");
+			 node;
+			 node = sipe_xml_twin(node)) {
+				const gchar *id = sipe_xml_attribute(node, "id");
+				gchar *data;
+
+				if (!id) continue;
+
+				data = sipe_xml_data(node);
+				if (data) {
+					if (sipe_strcase_equal(id, "urn:parlano:ma:info:ucnt")) {
+						user_count = g_ascii_strtoll(data, NULL, 10);
+					} else if (sipe_strcase_equal(id, "urn:parlano:ma:info:visibilty")) {
+						if (sipe_strcase_equal(data, "private")) {
+							flags |= SIPE_GROUPCHAT_ROOM_PRIVATE;
+						}
+					}
+					g_free(data);
+				}
+			}
+
+			/* properties */
+			for (node = sipe_xml_child(chanib, "prop");
+			 node;
+			 node = sipe_xml_twin(node)) {
+				const gchar *id = sipe_xml_attribute(node, "id");
+				gchar *data;
+
+				if (!id) continue;
+
+				data = sipe_xml_data(node);
+				if (data) {
+					gboolean value = sipe_strcase_equal(data, "true");
+					g_free(data);
+
+					if (value) {
+						guint32 add = 0;
+						if (sipe_strcase_equal(id, "urn:parlano:ma:prop:filepost")) {
+							add = SIPE_GROUPCHAT_ROOM_FILEPOST;
+						} else if (sipe_strcase_equal(id, "urn:parlano:ma:prop:invite")) {
+							add = SIPE_GROUPCHAT_ROOM_INVITE;
+						} else if (sipe_strcase_equal(id, "urn:parlano:ma:prop:logged")) {
+							add = SIPE_GROUPCHAT_ROOM_LOGGED;
+						}
+						flags |= add;
+					}
+				}
+			}
+
+			SIPE_DEBUG_INFO("group chat channel '%s': '%s' (%s) with %u users, flags 0x%x",
+					name, desc, uri, user_count, flags);
+			sipe_backend_groupchat_room_add(sipe_public,
+							uri, name, desc,
+							user_count, flags);
+		}
+	}
+
+	sipe_backend_groupchat_room_terminate(sipe_public);
+}
+
+static gboolean is_chanop(const sipe_xml *aib)
+{
+	return sipe_strequal(sipe_xml_attribute(aib, "key"),
+			 GROUPCHAT_AIB_KEY_CHANOP);
+}
+
+static void add_user(struct sipe_chat_session *chat_session,
+		 const gchar *uri,
+		 gboolean new, gboolean chanop)
+{
+	SIPE_DEBUG_INFO("add_user: %s%s%s to room %s (%s)",
+			new ? "new " : "",
+			chanop ? "chanop " : "",
+			uri,
+			chat_session->title, chat_session->id);
+	sipe_backend_chat_add(chat_session->backend, uri, new);
+	if (chanop)
+		sipe_backend_chat_operator(chat_session->backend, uri);
+}
+
+static void chatserver_response_join(struct sipe_core_private *sipe_private,
+				 SIPE_UNUSED_PARAMETER struct sip_session *session,
+				 guint result,
+				 const gchar *message,
+				 const sipe_xml *xml)
+{
+	if (result != 200) {
+		sipe_backend_notify_error(_("Error joining chat room"),
+					 message);
+	} else {
+		struct sipe_groupchat *groupchat = sipe_private->groupchat;
+		const sipe_xml *node;
+		GHashTable *user_ids = g_hash_table_new(g_str_hash, g_str_equal);
+
+		/* Extract user IDs & URIs and generate ID -> URI map */
+		for (node = sipe_xml_child(xml, "uib");
+		 node;
+		 node = sipe_xml_twin(node)) {
+			const gchar *id = sipe_xml_attribute(node, "id");
+			const gchar *uri = sipe_xml_attribute(node, "uri");
+			if (id && uri)
+				g_hash_table_insert(user_ids,
+						 (gpointer) id,
+						 (gpointer) uri);
+		}
+
+		/* Process channel data */
+		for (node = sipe_xml_child(xml, "chanib");
+		 node;
+		 node = sipe_xml_twin(node)) {
+			const gchar *uri = sipe_xml_attribute(node, "uri");
+
+			if (uri) {
+				struct sipe_chat_session *chat_session = g_hash_table_lookup(groupchat->uri_to_chat_session,
+											 uri);
+				gboolean new = (chat_session == NULL);
+				const gchar *attr = sipe_xml_attribute(node, "name");
+				char *self = sip_uri_self(sipe_private);
+				const sipe_xml *aib;
+
+				if (new) {
+					chat_session = sipe_chat_create_session(SIPE_CHAT_TYPE_GROUPCHAT,
+										sipe_xml_attribute(node,
+												 "uri"),
+										attr ? attr : "");
+					g_hash_table_insert(groupchat->uri_to_chat_session,
+							 chat_session->id,
+							 chat_session);
+
+					SIPE_DEBUG_INFO("joined room '%s' (%s)",
+							chat_session->title,
+							chat_session->id);
+					chat_session->backend = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
+											 chat_session,
+											 chat_session->title,
+											 self);
+				} else {
+					SIPE_DEBUG_INFO("rejoining room '%s' (%s)",
+							chat_session->title,
+							chat_session->id);
+					sipe_backend_chat_rejoin(SIPE_CORE_PUBLIC,
+								 chat_session->backend,
+								 self,
+								 chat_session->title);
+				}
+				g_free(self);
+
+				attr = sipe_xml_attribute(node, "topic");
+				if (attr) {
+					sipe_backend_chat_topic(chat_session->backend,
+								attr);
+				}
+
+				/* Process user map for channel */
+				for (aib = sipe_xml_child(node, "aib");
+				 aib;
+				 aib = sipe_xml_twin(aib)) {
+					const gchar *value = sipe_xml_attribute(aib, "value");
+					gboolean chanop = is_chanop(aib);
+					gchar **ids = g_strsplit(value, ",", 0);
+
+					if (ids) {
+						gchar **uid = ids;
+
+						while (*uid) {
+							const gchar *uri = g_hash_table_lookup(user_ids,
+											 *uid);
+							if (uri)
+								add_user(chat_session,
+									 uri,
+									 FALSE,
+									 chanop);
+							uid++;
+						}
+
+						g_strfreev(ids);
+					}
+				}
+			}
+		}
+
+		g_hash_table_destroy(user_ids);
+	}
+}
+
+static void chatserver_response_part(struct sipe_core_private *sipe_private,
+				 SIPE_UNUSED_PARAMETER struct sip_session *session,
+				 guint result,
+				 const gchar *message,
+				 const sipe_xml *xml)
+{
+	if (result != 200) {
+		SIPE_DEBUG_WARNING("chatserver_response_part: failed with %d: %s. Dropping room",
+				 result, message);
+	} else {
+		struct sipe_groupchat *groupchat = sipe_private->groupchat;
+		const gchar *uri = sipe_xml_attribute(sipe_xml_child(xml, "chanib"),
+						 "uri");
+		struct sipe_chat_session *chat_session;
+
+		if (uri &&
+		 (chat_session = g_hash_table_lookup(groupchat->uri_to_chat_session,
+							uri))) {
+
+			SIPE_DEBUG_INFO("leaving room '%s' (%s)",
+					chat_session->title, chat_session->id);
+
+			g_hash_table_remove(groupchat->uri_to_chat_session,
+					 uri);
+			sipe_chat_remove_session(chat_session);
+
+		} else {
+			SIPE_DEBUG_WARNING("chatserver_response_part: unknown chat room uri '%s'",
+					 uri ? uri : "");
+		}
+	}
+}
+
+static void chatserver_notice_join(struct sipe_core_private *sipe_private,
+				 SIPE_UNUSED_PARAMETER struct sip_session *session,
+				 SIPE_UNUSED_PARAMETER guint result,
+				 SIPE_UNUSED_PARAMETER const gchar *message,
+				 const sipe_xml *xml)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+	const sipe_xml *uib;
+
+	for (uib = sipe_xml_child(xml, "uib");
+	 uib;
+	 uib = sipe_xml_twin(uib)) {
+		const gchar *uri = sipe_xml_attribute(uib, "uri");
+
+		if (uri) {
+			const sipe_xml *aib;
+
+			for (aib = sipe_xml_child(uib, "aib");
+			 aib;
+			 aib = sipe_xml_twin(aib)) {
+				const gchar *domain = sipe_xml_attribute(aib, "domain");
+				const gchar *path = sipe_xml_attribute(aib, "value");
+
+				if (domain && path) {
+					gchar *room_uri = g_strdup_printf("ma-chan://%s/%s",
+									 domain, path);
+					struct sipe_chat_session *chat_session = g_hash_table_lookup(groupchat->uri_to_chat_session,
+												 room_uri);
+					if (chat_session)
+						add_user(chat_session,
+							 uri,
+							 TRUE,
+							 is_chanop(aib));
+
+					g_free(room_uri);
+				}
+			}
+		}
+	}
+}
+
+static void chatserver_notice_part(struct sipe_core_private *sipe_private,
+				 SIPE_UNUSED_PARAMETER struct sip_session *session,
+				 SIPE_UNUSED_PARAMETER guint result,
+				 SIPE_UNUSED_PARAMETER const gchar *message,
+				 const sipe_xml *xml)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+	const sipe_xml *chanib;
+
+	for (chanib = sipe_xml_child(xml, "chanib");
+	 chanib;
+	 chanib = sipe_xml_twin(chanib)) {
+		const gchar *room_uri = sipe_xml_attribute(chanib, "uri");
+
+		if (room_uri) {
+			struct sipe_chat_session *chat_session = g_hash_table_lookup(groupchat->uri_to_chat_session,
+										 room_uri);
+
+			if (chat_session) {
+				const sipe_xml *uib;
+
+				for (uib = sipe_xml_child(chanib, "uib");
+				 uib;
+				 uib = sipe_xml_twin(uib)) {
+					const gchar *uri = sipe_xml_attribute(uib, "uri");
+
+					if (uri) {
+						SIPE_DEBUG_INFO("remove_user: %s from room %s (%s)",
+								uri,
+								chat_session->title,
+								chat_session->id);
+						sipe_backend_chat_remove(chat_session->backend,
+									 uri);
+					}
+				}
+			}
+		}
+	}
+}
+
+static const struct response {
+	const gchar *key;
+	void (* const handler)(struct sipe_core_private *,
+			 struct sip_session *,
+			 guint result, const gchar *,
+			 const sipe_xml *xml);
+} response_table[] = {
+	{ "rpl:requri", chatserver_response_uri },
+	{ "rpl:chansrch", chatserver_response_channel_search },
+	{ "rpl:join", chatserver_response_join },
+	{ "rpl:bjoin", chatserver_response_join },
+	{ "rpl:part", chatserver_response_part },
+	{ "ntc:join", chatserver_notice_join },
+	{ "ntc:bjoin", chatserver_notice_join },
+	{ "ntc:part", chatserver_notice_part },
+	{ NULL, NULL }
+};
+
+/* Handles rpl:XXX & ntc:YYY */
+static void chatserver_response(struct sipe_core_private *sipe_private,
+				const sipe_xml *reply,
+				struct sip_session *session)
+{
+	do {
+		const sipe_xml *resp, *data;
+		const gchar *id;
+		gchar *message;
+		guint result = 500;
+		const struct response *r;
+
+		id = sipe_xml_attribute(reply, "id");
+		if (!id) {
+			SIPE_DEBUG_INFO_NOFORMAT("chatserver_response: no reply ID found!");
+			continue;
+		}
+
+		resp = sipe_xml_child(reply, "resp");
+		if (resp) {
+			result = sipe_xml_int_attribute(resp, "code", 500);
+			message = sipe_xml_data(resp);
+		} else {
+			message = g_strdup("");
+		}
+
+		data = sipe_xml_child(reply, "data");
+
+		SIPE_DEBUG_INFO("chatserver_response: '%s' result (%d) %s",
+				id, result, message ? message : "");
+
+		for (r = response_table; r->key; r++) {
+			if (sipe_strcase_equal(id, r->key)) {
+				(*r->handler)(sipe_private, session, result, message, data);
+				break;
+			}
+		}
+		if (!r->key) {
+			SIPE_DEBUG_INFO_NOFORMAT("chatserver_response: ignoring unknown response");
+		}
+
+		g_free(message);
+	} while ((reply = sipe_xml_twin(reply)) != NULL);
+}
+
+static void chatserver_grpchat_message(struct sipe_core_private *sipe_private,
+				 const sipe_xml *chatgrp)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+	const gchar *uri = sipe_xml_attribute(chatgrp, "chanUri");
+	const gchar *from = sipe_xml_attribute(chatgrp, "author");
+	gchar *text = sipe_xml_data(sipe_xml_child(chatgrp, "chat"));
+	struct sipe_chat_session *chat_session;
+	gchar *escaped;
+
+	if (!uri || !from) {
+		SIPE_DEBUG_INFO("chatserver_grpchat_message: message '%s' received without chat room URI or author!",
+				text ? text : "");
+		g_free(text);
+		return;
+	}
+
+	chat_session = g_hash_table_lookup(groupchat->uri_to_chat_session,
+					 uri);
+	if (!chat_session) {
+		SIPE_DEBUG_INFO("chatserver_grpchat_message: message '%s' from '%s' received from unknown chat room '%s'!",
+				text ? text : "", from, uri);
+		g_free(text);
+		return;
+	}
+
+	/* libxml2 decodes all entities, but the backend expects HTML */
+	escaped = g_markup_escape_text(text, -1);
+	g_free(text);
+	sipe_backend_chat_message(SIPE_CORE_PUBLIC, chat_session->backend,
+				 from, escaped);
+	g_free(escaped);
+}
+
+void process_incoming_info_groupchat(struct sipe_core_private *sipe_private,
+				 struct sipmsg *msg,
+				 struct sip_session *session)
+{
+	sipe_xml *xml = sipe_xml_parse(msg->body, msg->bodylen);
+	const sipe_xml *node;
+
+	/* @TODO: is this always correct?*/
+	sip_transport_response(sipe_private, msg, 200, "OK", NULL);
+
+	if (!xml) return;
+
+	if (((node = sipe_xml_child(xml, "rpl")) != NULL) ||
+		 ((node = sipe_xml_child(xml, "ntc")) != NULL)) {
+		chatserver_response(sipe_private, node, session);
+	} else if ((node = sipe_xml_child(xml, "grpchat")) != NULL) {
+		chatserver_grpchat_message(sipe_private, node);
+	} else {
+		SIPE_DEBUG_INFO_NOFORMAT("process_incoming_info_groupchat: ignoring unknown response");
+	}
+
+	sipe_xml_free(xml);
+}
+
+void sipe_groupchat_send(struct sipe_core_private *sipe_private,
+			 struct sipe_chat_session *chat_session,
+			 const gchar *what)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+	gchar *cmd, *self, *timestamp, *tmp;
+	struct sipe_groupchat_msg *msg;
+
+	if (!groupchat || !chat_session)
+		return;
+
+	SIPE_DEBUG_INFO("sipe_groupchat_send: '%s' to %s",
+			what, chat_session->id);
+
+	self = sip_uri_self(sipe_private);
+	timestamp = sipe_utils_time_to_str(time(NULL));
+
+	/**
+	 * 'what' is already XML-escaped, e.g.
+	 *
+	 * " -> &quot;
+	 * > -> &gt;
+	 * < -> &lt;
+	 * & -> &amp;
+	 *
+	 * No need to escape them here.
+	 *
+	 * Only exception are line breaks which are encoded as .
+	 * Replace them with the correct XML tag .
+	 */
+ tmp = replace(what, " ", " ");
+	cmd = g_strdup_printf("<grpchat id=\"grpchat\" seqid=\"1\" chanUri=\"%s\" author=\"%s\" ts=\"%s\">"
+			 "<chat>%s</chat>"
+			 "</grpchat>",
+			 chat_session->id, self, timestamp, tmp);
+	g_free(tmp);
+	g_free(timestamp);
+	g_free(self);
+	msg = chatserver_command(sipe_private, cmd);
+	g_free(cmd);
+
+	msg->session = chat_session;
+	msg->content = g_strdup(what);
+}
+
+void sipe_groupchat_leave(struct sipe_core_private *sipe_private,
+			 struct sipe_chat_session *chat_session)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+	gchar *cmd;
+
+	if (!groupchat || !chat_session)
+		return;
+
+	SIPE_DEBUG_INFO("sipe_groupchat_leave: %s", chat_session->id);
+
+	cmd = g_strdup_printf("<cmd id=\"cmd:part\" seqid=\"1\">"
+			 "<data>"
+			 "<chanib uri=\"%s\"/>"
+			 "</data>"
+			 "</cmd>", chat_session->id);
+	chatserver_command(sipe_private, cmd);
+	g_free(cmd);
+}
+
+gboolean sipe_core_groupchat_query_rooms(struct sipe_core_public *sipe_public)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+
+	if (!groupchat || !groupchat->connected)
+		return FALSE;
+
+	chatserver_command(sipe_private,
+			 "<cmd id=\"cmd:chansrch\" seqid=\"1\">"
+			 "<data>"
+			 "<qib qtype=\"BYNAME\" criteria=\"\" extended=\"false\"/>"
+			 "</data>"
+			 "</cmd>");
+
+	return TRUE;
+}
+
+void sipe_core_groupchat_join(struct sipe_core_public *sipe_public,
+			 const gchar *uri)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+
+	if (!g_str_has_prefix(uri, "ma-chan://"))
+		return;
+
+	if (!groupchat) {
+		/* This happens when a user has set auto-join on a channel */
+		sipe_groupchat_allocate(sipe_private);
+		groupchat = sipe_private->groupchat;
+	}
+
+	if (groupchat->connected) {
+		struct sipe_chat_session *chat_session = g_hash_table_lookup(groupchat->uri_to_chat_session,
+									 uri);
+
+		/* Already joined? */
+		if (chat_session) {
+
+			/* Yes, update backend session */
+			SIPE_DEBUG_INFO("sipe_core_groupchat_join: show '%s' (%s)",
+					chat_session->title,
+					chat_session->id);
+			sipe_backend_chat_show(chat_session->backend);
+
+		} else {
+			/* No, send command out directly */
+			gchar *chanid = generate_chanid_node(uri, 0);
+			if (chanid) {
+				gchar *cmd = g_strdup_printf("<cmd id=\"cmd:join\" seqid=\"1\">"
+							 "<data>%s</data>"
+							 "</cmd>",
+							 chanid);
+				SIPE_DEBUG_INFO("sipe_core_groupchat_join: join %s",
+						uri);
+				chatserver_command(sipe_private, cmd);
+				g_free(cmd);
+				g_free(chanid);
+			}
+		}
+	} else {
+		/* Add it to the queue but avoid duplicates */
+		if (!g_slist_find_custom(groupchat->join_queue, uri,
+					 sipe_strcompare)) {
+			SIPE_DEBUG_INFO_NOFORMAT("sipe_core_groupchat_join: URI queued");
+			groupchat->join_queue = g_slist_prepend(groupchat->join_queue,
+								g_strdup(uri));
+		}
+	}
+}
+
+void sipe_groupchat_rejoin(struct sipe_core_private *sipe_private,
+			 struct sipe_chat_session *chat_session)
+{
+	struct sipe_groupchat *groupchat = sipe_private->groupchat;
+
+	if (!groupchat) {
+		/* First rejoined channel after reconnect will trigger this */
+		sipe_groupchat_allocate(sipe_private);
+		groupchat = sipe_private->groupchat;
+	}
+
+	/* Remember "old" session, so that we don't recreate it at join */
+	g_hash_table_insert(groupchat->uri_to_chat_session,
+			 chat_session->id,
+			 chat_session);
+	sipe_core_groupchat_join(SIPE_CORE_PUBLIC, chat_session->id);
+}
+
+/*
+ Local Variables:
+ mode: c
+ c-file-style: "bsd"
+ indent-tabs-mode: t
+ tab-width: 8
+ End:
+*/
--- pidgin-sipe-1.11.2/src/core/sipe-groupchat.h	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-groupchat.h	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,44 @@
+ /**
+ * @file sipe-groupchat.h
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2010 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* Forward declarations */
+struct sip_dialog;
+struct sip_session;
+struct sipe_chat_session;
+struct sipe_core_private;
+
+void sipe_groupchat_free(struct sipe_core_private *sipe_private);
+void sipe_groupchat_init(struct sipe_core_private *sipe_private);
+void sipe_groupchat_invite_failed(struct sipe_core_private *sipe_private,
+				 struct sip_session *session);
+void sipe_groupchat_invite_response(struct sipe_core_private *sipe_private,
+				 struct sip_dialog *dialog);
+void process_incoming_info_groupchat(struct sipe_core_private *sipe_private,
+				 struct sipmsg *msg,
+				 struct sip_session *session);
+void sipe_groupchat_send(struct sipe_core_private *sipe_private,
+			 struct sipe_chat_session *chat_session,
+			 const gchar *what);
+void sipe_groupchat_leave(struct sipe_core_private *sipe_private,
+			 struct sipe_chat_session *chat_session);
+void sipe_groupchat_rejoin(struct sipe_core_private *sipe_private,
+			 struct sipe_chat_session *chat_session);
--- pidgin-sipe-1.11.2/src/core/sipe-group.h	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-group.h	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,41 @@
+/**
+ * @file sipe-group.h
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2011 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+struct sipe_group {
+	gchar *name;
+	int id;
+};
+
+int sipe_group_compare(struct sipe_group *group1, struct sipe_group *group2);
+
+struct sipe_group *sipe_group_find_by_id(struct sipe_core_private *sipe_private, int id);
+
+struct sipe_group *sipe_group_find_by_name(struct sipe_core_private *sipe_private,
+					 const gchar * name);
+
+void sipe_group_create(struct sipe_core_private *sipe_private,
+		 const gchar *name,
+		 const gchar * who);
+
+void sipe_group_add(struct sipe_core_private *sipe_private,
+		 struct sipe_group * group);
+
--- pidgin-sipe-1.11.2/src/core/sipe.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe.h	2011-06-14 14:40:36.000000000 +0200
@@ -36,6 +36,8 @@
 struct _PurpleConnection;
 struct _PurpleGroup;
 struct sipe_core_private;
+struct transaction;
+struct transaction_payload;
 
 /** MS-PRES publication */
 struct sipe_publication {
@@ -102,12 +104,6 @@
 	struct sipe_core_private *sipe_private;
 };
 
-struct sipe_group {
-	gchar *name;
-	int id;
-	struct _PurpleGroup *purple_group;
-};
-
 struct group_user_context {
 	gchar * group_name;
 	gchar * user_name;
@@ -152,39 +148,10 @@
 * This way our code will not be monolithic, but potentially _reusable_. May be
 * a top of other SIP core, and/or other front-end (Telepathy framework?).
 */
-/* Forward declarations */
-struct sip_session;
-struct sip_dialog;
-struct transaction;
 
-void
-sipe_invite(struct sipe_core_private *sipe_private, struct sip_session *session,
-	 const gchar *who, const gchar *msg_body, const gchar *msg_content_type,
-	 const gchar *referred_by, const gboolean is_triggered);
 /* ??? module */
 void sipe_connection_cleanup(struct sipe_core_private *sipe_private);
 void sipe_buddy_free_all(struct sipe_core_private *sipe_private);
-/* Session module? */
-void
-sipe_present_message_undelivered_err(struct sipe_core_private *sipe_private,
-				 struct sip_session *session,
-				 int sip_error,
-				 int sip_warning,
-				 const gchar *who,
-				 const gchar *message);
-
-void
-sipe_present_info(struct sipe_core_private *sipe_private,
-		 struct sip_session *session,
-		 const gchar *message);
-void
-sipe_present_err(struct sipe_core_private *sipe_private,
-		 struct sip_session *session,
-		 const gchar *message);
-
-void
-sipe_im_process_queue(struct sipe_core_private *sipe_private,
-		 struct sip_session *session);
 
 /* sipe-notify? */
 void process_incoming_notify(struct sipe_core_private *sipe_private,
@@ -192,18 +159,16 @@
 			 gboolean request,
 			 gboolean benotify);
 
-/*** THE BIG SPLIT END ***/
+/* sipe-soap? */
+void send_soap_request_with_cb(struct sipe_core_private *sipe_private,
+			 gchar *from0,
+			 gchar *body,
+ gboolean (*callbackb) (struct sipe_core_private *, struct sipmsg *,struct transaction *),
+			 struct transaction_payload *payload);
 
-#ifdef HAVE_GMIME
-/* pls. don't add multipart/related - it's not used in IM modality */
-#define SDP_ACCEPT_TYPES "text/plain text/html image/gif multipart/alternative application/im-iscomposing+xml application/ms-imdn+xml text/x-msmsgsinvite"
-#else
-/* this is a rediculous hack as Pidgin's MIME implementastion doesn't support (or have bug) in multipart/alternative */
-/* OCS/OC won't use multipart/related so we don't advertase it */
-#define SDP_ACCEPT_TYPES "text/plain text/html image/gif application/im-iscomposing+xml application/ms-imdn+xml text/x-msmsgsinvite"
-#endif
+void send_soap_request(struct sipe_core_private *sipe_private, gchar *body);
 
-#define SIPE_INVITE_TEXT "ms-text-format: %s; charset=UTF-8%s;ms-body=%s\r\n"
+/*** THE BIG SPLIT END ***/
 
 /**
 * Publishes categories.
--- pidgin-sipe-1.11.2/src/core/sipe-im.c	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-im.c	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,885 @@
+/**
+ * @file sipe-im.c
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2011 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include "sipe-common.h"
+#include "sipmsg.h"
+#include "sip-transport.h"
+#include "sipe-backend.h"
+#include "sipe-buddy.h"
+#include "sipe-chat.h"
+#include "sipe-core.h"
+#include "sipe-core-private.h"
+#include "sipe-dialog.h"
+#include "sipe-ft.h"
+#include "sipe-groupchat.h"
+#include "sipe-im.h"
+#include "sipe-incoming.h"
+#include "sipe-nls.h"
+#include "sipe-session.h"
+#include "sipe-user.h"
+#include "sipe-utils.h"
+#include "sipe-xml.h"
+
+/*
+ * Hash key template for unconfirmed messages
+ *
+ * Call-ID Recipient URI (or empty)
+ * | |
+ * | SIP method | CSeq
+ * | | | | */
+#define UNCONFIRMED_KEY_TEMPLATE(method, cseq) "<%s><" method "><%s><" cseq
+
+/* key must be g_free()'d */
+static gchar *get_unconfirmed_message_key(const gchar *callid,
+					 unsigned int cseq,
+					 const gchar *with)
+{
+	return(g_strdup_printf(UNCONFIRMED_KEY_TEMPLATE("%s", "%d>"),
+			 callid,
+			 with ? "MESSAGE" : "INVITE",
+			 with ? with : "",
+			 cseq));
+}
+
+static void insert_unconfirmed_message(struct sip_session *session,
+				 struct sip_dialog *dialog,
+				 const gchar *with,
+				 const gchar *body,
+				 const gchar *content_type)
+{
+	gchar *key = get_unconfirmed_message_key(dialog->callid, dialog->cseq + 1, with);
+	struct queued_message *message = g_new0(struct queued_message, 1);
+
+	message->body = g_strdup(body);
+	if (content_type != NULL)
+		message->content_type = g_strdup(content_type);
+	message->cseq = dialog->cseq + 1;
+
+	g_hash_table_insert(session->unconfirmed_messages, key, message);
+	SIPE_DEBUG_INFO("insert_unconfirmed_message: added %s to list (count=%d)",
+			key, g_hash_table_size(session->unconfirmed_messages));
+}
+
+static gboolean remove_unconfirmed_message(struct sip_session *session,
+					 const gchar *key)
+{
+	gboolean found = g_hash_table_remove(session->unconfirmed_messages, key);
+	if (found) {
+		SIPE_DEBUG_INFO("remove_unconfirmed_message: removed %s from list (count=%d)",
+				key, g_hash_table_size(session->unconfirmed_messages));
+	} else {
+		SIPE_DEBUG_INFO("remove_unconfirmed_message: key %s not found",
+				key);
+	}
+	return(found);
+}
+
+static void sipe_refer_notify(struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 const gchar *who,
+			 int status,
+			 const gchar *desc)
+{
+	gchar *hdr;
+	gchar *body;
+	struct sip_dialog *dialog = sipe_dialog_find(session, who);
+
+	hdr = g_strdup_printf(
+		"Event: refer\r\n"
+		"Subscription-State: %s\r\n"
+		"Content-Type: message/sipfrag\r\n",
+		status >= 200 ? "terminated" : "active");
+
+	body = g_strdup_printf(
+		"SIP/2.0 %d %s\r\n",
+		status, desc);
+
+	sip_transport_request(sipe_private,
+			 "NOTIFY",
+			 who,
+			 who,
+			 hdr,
+			 body,
+			 dialog,
+			 NULL);
+
+	g_free(hdr);
+	g_free(body);
+}
+
+static gboolean process_invite_response(struct sipe_core_private *sipe_private,
+					struct sipmsg *msg,
+					struct transaction *trans)
+{
+	gchar *with = parse_from(sipmsg_find_header(msg, "To"));
+	struct sip_session *session;
+	struct sip_dialog *dialog;
+	gchar *key;
+	struct queued_message *message;
+	struct sipmsg *request_msg = trans->msg;
+
+	const gchar *callid = sipmsg_find_header(msg, "Call-ID");
+	gchar *referred_by;
+
+	session = sipe_session_find_chat_or_im(sipe_private, callid, with);
+	if (!session) {
+		SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: unable to find IM session");
+		g_free(with);
+		return FALSE;
+	}
+
+	dialog = sipe_dialog_find(session, with);
+	if (!dialog) {
+		SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: session outgoing dialog is NULL");
+		g_free(with);
+		return FALSE;
+	}
+
+	sipe_dialog_parse(dialog, msg, TRUE);
+
+	key = get_unconfirmed_message_key(dialog->callid, sipmsg_parse_cseq(msg), NULL);
+	message = g_hash_table_lookup(session->unconfirmed_messages, key);
+
+	if (msg->response != 200) {
+		gchar *alias = sipe_buddy_get_alias(sipe_private, with);
+		int warning = sipmsg_parse_warning(msg, NULL);
+
+		SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: INVITE response not 200");
+
+		/* cancel file transfer as rejected by server */
+		if (msg->response == 606 &&	/* Not acceptable all. */
+		 warning == 309 &&		/* Message contents not allowed by policy */
+		 message && g_str_has_prefix(message->content_type, "text/x-msmsgsinvite"))
+		{
+			GSList *parsed_body = sipe_ft_parse_msg_body(message->body);
+			sipe_ft_incoming_cancel(dialog, parsed_body);
+			sipe_utils_nameval_free(parsed_body);
+		}
+
+		if (message) {
+			/* generate error for each unprocessed message */
+			GSList *entry = session->outgoing_message_queue;
+			while (entry) {
+				struct queued_message *queued = entry->data;
+				sipe_user_present_message_undelivered(sipe_private, session, msg->response, warning, alias ? alias : with, queued->body);
+				entry = sipe_session_dequeue_message(session);
+			}
+		} else {
+			/* generate one error and remove all unprocessed messages */
+			gchar *tmp_msg = g_strdup_printf(_("Failed to invite %s"), alias ? alias : with);
+			sipe_user_present_error(sipe_private, session, tmp_msg);
+			g_free(tmp_msg);
+			while (sipe_session_dequeue_message(session));
+		}
+		g_free(alias);
+
+		remove_unconfirmed_message(session, key);
+		/* message is no longer valid */
+		g_free(key);
+
+		sipe_dialog_remove(session, with);
+		g_free(with);
+
+		if (session->is_groupchat) {
+			sipe_groupchat_invite_failed(sipe_private, session);
+			/* session is no longer valid */
+		}
+
+		return FALSE;
+	}
+
+	dialog->cseq = 0;
+	sip_transport_ack(sipe_private, dialog);
+	dialog->outgoing_invite = NULL;
+	dialog->is_established = TRUE;
+
+	referred_by = parse_from(sipmsg_find_header(request_msg, "Referred-By"));
+	if (referred_by) {
+		sipe_refer_notify(sipe_private, session, referred_by, 200, "OK");
+		g_free(referred_by);
+	}
+
+	/* add user to chat if it is a multiparty session */
+	if (session->chat_session &&
+	 (session->chat_session->type == SIPE_CHAT_TYPE_MULTIPARTY)) {
+		sipe_backend_chat_add(session->chat_session->backend,
+				 with,
+				 TRUE);
+	}
+
+	if (session->is_groupchat) {
+		sipe_groupchat_invite_response(sipe_private, dialog);
+	}
+
+	if(g_slist_find_custom(dialog->supported, "ms-text-format", (GCompareFunc)g_ascii_strcasecmp)) {
+		SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: remote system accepted message in INVITE");
+		sipe_session_dequeue_message(session);
+	}
+
+	sipe_im_process_queue(sipe_private, session);
+
+	remove_unconfirmed_message(session, key);
+
+	g_free(key);
+	g_free(with);
+	return TRUE;
+}
+
+/* EndPoints: "alice alisson" <sip:alice@atlanta.local>, <sip:bob@atlanta.local>;epid=ebca82d94d, <sip:carol@atlanta.local> */
+static gchar *get_end_points(struct sipe_core_private *sipe_private,
+			 struct sip_session *session)
+{
+	gchar *res;
+
+	if (session == NULL) {
+		return NULL;
+	}
+
+	res = g_strdup_printf("<sip:%s>", sipe_private->username);
+
+	SIPE_DIALOG_FOREACH {
+		gchar *tmp = res;
+		res = g_strdup_printf("%s, <%s>", res, dialog->with);
+		g_free(tmp);
+
+		if (dialog->theirepid) {
+			tmp = res;
+			res = g_strdup_printf("%s;epid=%s", res, dialog->theirepid);
+			g_free(tmp);
+		}
+	} SIPE_DIALOG_FOREACH_END;
+
+	return res;
+}
+
+void
+sipe_im_invite(struct sipe_core_private *sipe_private,
+	 struct sip_session *session,
+	 const gchar *who,
+	 const gchar *msg_body,
+	 const gchar *content_type,
+	 const gchar *referred_by,
+	 const gboolean is_triggered)
+{
+	gchar *hdr;
+	gchar *to;
+	gchar *contact;
+	gchar *body;
+	gchar *self;
+	char *ms_text_format = NULL;
+	char *ms_conversation_id = NULL;
+	gchar *roster_manager;
+	gchar *end_points;
+	gchar *referred_by_str;
+	gboolean is_multiparty =
+		session->chat_session &&
+		(session->chat_session->type == SIPE_CHAT_TYPE_MULTIPARTY);
+	struct sip_dialog *dialog = sipe_dialog_find(session, who);
+
+	if (dialog && dialog->is_established) {
+		SIPE_DEBUG_INFO("session with %s already has a dialog open", who);
+		return;
+	}
+
+	if (!dialog) {
+		dialog = sipe_dialog_add(session);
+		dialog->callid = session->callid ? g_strdup(session->callid) : gencallid();
+		dialog->with = g_strdup(who);
+	}
+
+	if (!(dialog->ourtag)) {
+		dialog->ourtag = gentag();
+	}
+
+	to = sip_uri(who);
+
+	if (msg_body) {
+		char *msgtext = NULL;
+		char *base64_msg;
+		const gchar *msgr = "";
+		gchar *tmp = NULL;
+
+		if (!g_str_has_prefix(content_type, "text/x-msmsgsinvite")) {
+			char *msgformat;
+			gchar *msgr_value;
+
+			sipe_parse_html(msg_body, &msgformat, &msgtext);
+			SIPE_DEBUG_INFO("sipe_invite: msgformat=%s", msgformat);
+
+			msgr_value = sipmsg_get_msgr_string(msgformat);
+			g_free(msgformat);
+			if (msgr_value) {
+				msgr = tmp = g_strdup_printf(";msgr=%s", msgr_value);
+				g_free(msgr_value);
+			}
+
+			/* When Sipe reconnects after a crash, we are not able
+			 * to send messages to contacts with which we had open
+			 * conversations when the crash occured. Server sends
+			 * error response with reason="This client has an IM
+			 * session with the same conversation ID"
+			 *
+			 * Setting random Ms-Conversation-ID prevents this problem
+			 * so we can continue the conversation. */
+			ms_conversation_id = g_strdup_printf("Ms-Conversation-ID: %u\r\n",
+							 rand() % 1000000000);
+		} else {
+			msgtext = g_strdup(msg_body);
+		}
+
+		base64_msg = g_base64_encode((guchar*) msgtext, strlen(msgtext));
+		ms_text_format = g_strdup_printf("ms-text-format: %s; charset=UTF-8%s;ms-body=%s\r\n",
+						 content_type ? content_type : "text/plain",
+						 msgr,
+						 base64_msg);
+		g_free(msgtext);
+		g_free(tmp);
+		g_free(base64_msg);
+
+		insert_unconfirmed_message(session, dialog, NULL,
+					 msg_body, content_type);
+	}
+
+	contact = get_contact(sipe_private);
+	end_points = get_end_points(sipe_private, session);
+	self = sip_uri_self(sipe_private);
+	roster_manager = g_strdup_printf(
+		"Roster-Manager: %s\r\n"
+		"EndPoints: %s\r\n",
+		self,
+		end_points);
+	referred_by_str = referred_by ?
+		g_strdup_printf(
+			"Referred-By: %s\r\n",
+			referred_by)
+		: g_strdup("");
+	hdr = g_strdup_printf(
+		"Supported: ms-sender\r\n"
+		"%s"
+		"%s"
+		"%s"
+		"%s"
+		"Contact: %s\r\n%s"
+		"%s"
+		"Content-Type: application/sdp\r\n",
+		is_multiparty && sipe_strcase_equal(session->chat_session->id, self) ? roster_manager : "",
+		referred_by_str,
+		is_triggered ? "TriggeredInvite: TRUE\r\n" : "",
+		is_triggered || is_multiparty ? "Require: com.microsoft.rtc-multiparty\r\n" : "",
+		contact,
+		ms_text_format ? ms_text_format : "",
+		ms_conversation_id ? ms_conversation_id : "");
+	g_free(ms_text_format);
+	g_free(ms_conversation_id);
+	g_free(self);
+
+	body = g_strdup_printf(
+		"v=0\r\n"
+		"o=- 0 0 IN IP4 %s\r\n"
+		"s=session\r\n"
+		"c=IN IP4 %s\r\n"
+		"t=0 0\r\n"
+		"m=%s %d sip null\r\n"
+		"a=accept-types:" SDP_ACCEPT_TYPES "\r\n",
+		sipe_backend_network_ip_address(),
+		sipe_backend_network_ip_address(),
+		SIPE_CORE_PRIVATE_FLAG_IS(OCS2007) ? "message" : "x-ms-message",
+		sip_transport_port(sipe_private));
+
+	dialog->outgoing_invite = sip_transport_request(sipe_private,
+							"INVITE",
+							to,
+							to,
+							hdr,
+							body,
+							dialog,
+							process_invite_response);
+
+	g_free(to);
+	g_free(roster_manager);
+	g_free(end_points);
+	g_free(referred_by_str);
+	g_free(body);
+	g_free(hdr);
+	g_free(contact);
+}
+
+static gboolean
+process_message_response(struct sipe_core_private *sipe_private,
+			 struct sipmsg *msg,
+			 SIPE_UNUSED_PARAMETER struct transaction *trans)
+{
+	gboolean ret = TRUE;
+	gchar *with = parse_from(sipmsg_find_header(msg, "To"));
+	const gchar *callid = sipmsg_find_header(msg, "Call-ID");
+	struct sip_session *session = sipe_session_find_chat_or_im(sipe_private, callid, with);
+	struct sip_dialog *dialog;
+	gchar *key;
+	struct queued_message *message;
+
+	if (!session) {
+		SIPE_DEBUG_INFO_NOFORMAT("process_message_response: unable to find IM session");
+		g_free(with);
+		return FALSE;
+	}
+
+	dialog = sipe_dialog_find(session, with);
+	if (!dialog) {
+		SIPE_DEBUG_INFO_NOFORMAT("process_message_response: session outgoing dialog is NULL");
+		g_free(with);
+		return FALSE;
+	}
+
+	key = get_unconfirmed_message_key(sipmsg_find_header(msg, "Call-ID"), sipmsg_parse_cseq(msg), with);
+	message = g_hash_table_lookup(session->unconfirmed_messages, key);
+
+	if (msg->response >= 400) {
+		int warning = sipmsg_parse_warning(msg, NULL);
+
+		SIPE_DEBUG_INFO_NOFORMAT("process_message_response: MESSAGE response >= 400");
+
+		/* cancel file transfer as rejected by server */
+		if (msg->response == 606 &&	/* Not acceptable all. */
+		 warning == 309 &&		/* Message contents not allowed by policy */
+		 message && g_str_has_prefix(message->content_type, "text/x-msmsgsinvite"))
+		{
+			GSList *parsed_body = sipe_ft_parse_msg_body(msg->body);
+			sipe_ft_incoming_cancel(dialog, parsed_body);
+			sipe_utils_nameval_free(parsed_body);
+		}
+
+		/* drop dangling IM sessions: assume that BYE from remote never reached us */
+		if (msg->response == 408 || /* Request timeout */
+		 msg->response == 480 || /* Temporarily Unavailable */
+		 msg->response == 481) { /* Call/Transaction Does Not Exist */
+			sipe_im_cancel_dangling(sipe_private, session, dialog, with,
+						sipe_im_cancel_unconfirmed);
+			/* dialog is no longer valid */
+		} else {
+			gchar *alias = sipe_buddy_get_alias(sipe_private, with);
+			sipe_user_present_message_undelivered(sipe_private, session,
+							 msg->response, warning,
+							 alias ? alias : with,
+							 message ? message->body : NULL);
+			remove_unconfirmed_message(session, key);
+			/* message is no longer valid */
+			g_free(alias);
+		}
+
+		ret = FALSE;
+	} else {
+		const gchar *message_id = sipmsg_find_header(msg, "Message-Id");
+		if (message_id) {
+			g_hash_table_insert(session->conf_unconfirmed_messages, g_strdup(message_id), g_strdup(message->body));
+			SIPE_DEBUG_INFO("process_message_response: added message with id %s to conf_unconfirmed_messages(count=%d)",
+					message_id, g_hash_table_size(session->conf_unconfirmed_messages));
+		}
+		remove_unconfirmed_message(session, key);
+	}
+
+	g_free(key);
+	g_free(with);
+
+	if (ret) sipe_im_process_queue(sipe_private, session);
+	return ret;
+}
+
+#ifndef ENABLE_OCS2005_MESSAGE_HACK
+/*
+ * Hack to circumvent problems reported in the bug report
+ *
+ * #3267073 - False "could not be delivered" errors
+ *
+ * The logs provided by the reporters indicate that OCS2005 clients DO NOT
+ * acknowledge our SIP MESSAGEs. Therefore the message timeout is triggered
+ * and messages are reported to the user as not delivered.
+ *
+ * Either this is a bug in the OCS2005 client or we do something wrong in our
+ * SIP MESSAGEs. This hack removes the message timeout and is provided for
+ * users who need to communicate with a still existing OCS2005 user base.
+ *
+ * Do not enable it by default!
+ */
+static gboolean
+process_message_timeout(struct sipe_core_private *sipe_private,
+			struct sipmsg *msg,
+			SIPE_UNUSED_PARAMETER struct transaction *trans)
+{
+	gchar *with = parse_from(sipmsg_find_header(msg, "To"));
+	const gchar *callid = sipmsg_find_header(msg, "Call-ID");
+	struct sip_session *session = sipe_session_find_chat_or_im(sipe_private, callid, with);
+	gchar *key;
+	gboolean found;
+
+	if (!session) {
+		SIPE_DEBUG_INFO_NOFORMAT("process_message_timeout: unable to find IM session");
+		g_free(with);
+		return TRUE;
+	}
+
+	/* Remove timed-out message from unconfirmed list */
+	key = get_unconfirmed_message_key(sipmsg_find_header(msg, "Call-ID"), sipmsg_parse_cseq(msg), with);
+	found = remove_unconfirmed_message(session, key);
+	g_free(key);
+
+	if (found) {
+		gchar *alias = sipe_buddy_get_alias(sipe_private, with);
+		sipe_user_present_message_undelivered(sipe_private, session, -1, -1,
+						 alias ? alias : with,
+						 msg->body);
+		g_free(alias);
+	}
+
+	g_free(with);
+	return TRUE;
+}
+#endif
+
+static void sipe_im_send_message(struct sipe_core_private *sipe_private,
+				 struct sip_dialog *dialog,
+				 const gchar *msg_body,
+				 const gchar *content_type)
+{
+	gchar *hdr;
+	gchar *tmp;
+	char *msgtext = NULL;
+	const gchar *msgr = "";
+	gchar *tmp2 = NULL;
+
+	if (content_type == NULL)
+		content_type = "text/plain";
+
+	if (!g_str_has_prefix(content_type, "text/x-msmsgsinvite")) {
+		char *msgformat;
+		gchar *msgr_value;
+
+		sipe_parse_html(msg_body, &msgformat, &msgtext);
+		SIPE_DEBUG_INFO("sipe_send_message: msgformat=%s", msgformat);
+
+		msgr_value = sipmsg_get_msgr_string(msgformat);
+		g_free(msgformat);
+		if (msgr_value) {
+			msgr = tmp2 = g_strdup_printf(";msgr=%s", msgr_value);
+			g_free(msgr_value);
+		}
+	} else {
+		msgtext = g_strdup(msg_body);
+	}
+
+	tmp = get_contact(sipe_private);
+	//hdr = g_strdup("Content-Type: text/plain; charset=UTF-8\r\n");
+	//hdr = g_strdup("Content-Type: text/rtf\r\n");
+	//hdr = g_strdup("Content-Type: text/plain; charset=UTF-8;msgr=WAAtAE0ATQBTAC....AoADQA\r\nSupported: timer\r\n");
+
+	hdr = g_strdup_printf("Contact: %s\r\nContent-Type: %s; charset=UTF-8%s\r\n", tmp, content_type, msgr);
+	g_free(tmp);
+	g_free(tmp2);
+
+#ifdef ENABLE_OCS2005_MESSAGE_HACK
+	sip_transport_request(
+#else
+	sip_transport_request_timeout(
+#endif
+				 sipe_private,
+				 "MESSAGE",
+				 dialog->with,
+				 dialog->with,
+				 hdr,
+				 msgtext,
+				 dialog,
+				 process_message_response
+#ifndef ENABLE_OCS2005_MESSAGE_HACK
+				 ,
+				 60,
+				 process_message_timeout
+#endif
+				 );
+	g_free(msgtext);
+	g_free(hdr);
+}
+
+void sipe_im_process_queue(struct sipe_core_private *sipe_private,
+			 struct sip_session *session)
+{
+	GSList *entry2 = session->outgoing_message_queue;
+	while (entry2) {
+		struct queued_message *msg = entry2->data;
+
+		/* for multiparty chat or conference */
+		if (session->chat_session) {
+			gchar *who = sip_uri_self(sipe_private);
+			sipe_backend_chat_message(SIPE_CORE_PUBLIC,
+						 session->chat_session->backend,
+						 who,
+						 msg->body);
+			g_free(who);
+		}
+
+		SIPE_DIALOG_FOREACH {
+			if (dialog->outgoing_invite) continue; /* do not send messages as INVITE is not responded. */
+
+			insert_unconfirmed_message(session, dialog, dialog->with,
+						 msg->body, msg->content_type);
+
+			sipe_im_send_message(sipe_private, dialog, msg->body, msg->content_type);
+		} SIPE_DIALOG_FOREACH_END;
+
+		entry2 = sipe_session_dequeue_message(session);
+	}
+}
+
+struct unconfirmed_callback_data {
+	const gchar *prefix;
+	GSList *list;
+};
+
+struct unconfirmed_message {
+	const gchar *key;
+	const struct queued_message *msg;
+};
+
+static gint compare_cseq(gconstpointer a,
+			 gconstpointer b)
+{
+	return(((struct unconfirmed_message *) a)->msg->cseq -
+	 ((struct unconfirmed_message *) b)->msg->cseq);
+}
+
+static void unconfirmed_message_callback(gpointer key,
+					 gpointer value,
+					 gpointer user_data)
+{
+	const gchar *message_key = key;
+	struct unconfirmed_callback_data *data = user_data;
+
+	SIPE_DEBUG_INFO("unconfirmed_message_callback: key %s", message_key);
+
+	/* Put messages with the same prefix on a list sorted by CSeq */
+	if (g_str_has_prefix(message_key, data->prefix)) {
+		struct unconfirmed_message *msg = g_malloc(sizeof(struct unconfirmed_message));
+		msg->key = message_key;
+		msg->msg = value;
+		data->list = g_slist_insert_sorted(data->list, msg,
+						 compare_cseq);
+	}
+}
+
+static void foreach_unconfirmed_message(struct sipe_core_private *sipe_private,
+					struct sip_session *session,
+					const gchar *callid,
+					const gchar *with,
+					unconfirmed_callback callback,
+					const gchar *callback_data)
+{
+	gchar *prefix = g_strdup_printf(UNCONFIRMED_KEY_TEMPLATE("MESSAGE", ""),
+					callid, with);
+	struct unconfirmed_callback_data data = { prefix, NULL };
+
+	SIPE_DEBUG_INFO("foreach_unconfirmed_message: prefix %s", prefix);
+
+	/* Generate list of matching unconfirmed messages */
+	g_hash_table_foreach(session->unconfirmed_messages,
+			 unconfirmed_message_callback,
+			 &data);
+	g_free(prefix);
+
+	/* Process list unconfirmed messages */
+	if (data.list) {
+		GSList *entry;
+
+		while ((entry = data.list) != NULL) {
+			struct unconfirmed_message *unconfirmed = entry->data;
+			data.list = g_slist_remove(data.list, unconfirmed);
+
+			SIPE_DEBUG_INFO("foreach_unconfirmed_message: %s", unconfirmed->key);
+			(*callback)(sipe_private, session, unconfirmed->msg->body, callback_data);
+
+			g_hash_table_remove(session->unconfirmed_messages, unconfirmed->key);
+			g_free(unconfirmed);
+		}
+	}
+}
+
+static void cancel_callback(struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 const gchar *body,
+			 const gchar *with)
+{
+	sipe_user_present_message_undelivered(sipe_private, session,
+					 -1, -1, with, body);
+}
+
+void sipe_im_cancel_unconfirmed(struct sipe_core_private *sipe_private,
+				struct sip_session *session,
+				const gchar *callid,
+				const gchar *with)
+{
+	gchar *alias = sipe_buddy_get_alias(sipe_private, with);
+
+	SIPE_DEBUG_INFO("sipe_im_cancel_unconfirmed: with %s callid '%s'",
+			with, callid);
+
+	foreach_unconfirmed_message(sipe_private, session, callid, with,
+				 cancel_callback, alias ? alias : with);
+	g_free(alias);
+}
+
+static void reenqueue_callback(SIPE_UNUSED_PARAMETER struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 const gchar *body,
+			 SIPE_UNUSED_PARAMETER const gchar *with)
+{
+	sipe_session_enqueue_message(session, body, NULL);
+}
+
+void sipe_im_reenqueue_unconfirmed(struct sipe_core_private *sipe_private,
+				 struct sip_session *session,
+				 const gchar *callid,
+				 const gchar *with)
+{
+	/* Remember original list, start with an empty list */
+	GSList *first = session->outgoing_message_queue;
+	session->outgoing_message_queue = NULL;
+
+	SIPE_DEBUG_INFO("sipe_im_reenqueue_unconfirmed: with %s callid '%s'",
+			with, callid);
+
+	/* Enqueue unconfirmed messages */
+	foreach_unconfirmed_message(sipe_private, session, callid, with,
+				 reenqueue_callback, NULL);
+
+	/* Append or restore original list */
+	if (session->outgoing_message_queue) {
+		GSList *last = g_slist_last(session->outgoing_message_queue);
+		last->next = first;
+	} else {
+		session->outgoing_message_queue = first;
+	}
+}
+
+void sipe_core_im_send(struct sipe_core_public *sipe_public,
+		 const gchar *who,
+		 const gchar *what)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+	struct sip_session *session;
+	struct sip_dialog *dialog;
+	gchar *uri = sip_uri(who);
+
+	SIPE_DEBUG_INFO("sipe_core_im_send: '%s'", what);
+
+	session = sipe_session_find_or_add_im(sipe_private, uri);
+	dialog = sipe_dialog_find(session, uri);
+
+	/* Queue the message */
+	sipe_session_enqueue_message(session, what, NULL);
+
+	if (dialog && !dialog->outgoing_invite) {
+ if (dialog->delayed_invite)
+			sipe_incoming_cancel_delayed_invite(sipe_private,
+							 dialog);
+		sipe_im_process_queue(sipe_private, session);
+	} else if (!dialog || !dialog->outgoing_invite) {
+		/* Need to send the INVITE to get the outgoing dialog setup */
+		sipe_im_invite(sipe_private, session, uri, what, NULL, NULL, FALSE);
+	}
+
+	g_free(uri);
+}
+
+void sipe_im_cancel_dangling(struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 struct sip_dialog *dialog,
+			 const gchar *with,
+			 unconfirmed_callback callback)
+{
+	SIPE_DEBUG_INFO_NOFORMAT("sipe_im_cancel_dangling: assuming dangling IM session, dropping it.");
+	sip_transport_bye(sipe_private, dialog);
+
+	(*callback)(sipe_private, session, dialog->callid, with);
+
+	/* We might not get a valid reply to our BYE,
+	 so make sure the dialog is removed for sure. */
+	sipe_dialog_remove(session, with);
+	/* dialog is no longer valid */
+}
+
+void sipe_im_topic(struct sipe_core_private *sipe_private,
+		 struct sip_session *session,
+		 const gchar *topic)
+{
+	g_free(session->subject);
+	session->subject = g_strdup(topic);
+	sipe_backend_im_topic(SIPE_CORE_PUBLIC, session->with, topic);
+}
+
+void process_incoming_info_conversation(struct sipe_core_private *sipe_private,
+					struct sipmsg *msg)
+{
+	sipe_xml *xml = sipe_xml_parse(msg->body, msg->bodylen);
+	const gchar *from = NULL;
+	const gchar *subject = NULL;
+
+
+	if (!xml)
+		return;
+
+	if (sipe_strequal(sipe_xml_name(xml), "ConversationInfo")) {
+		const sipe_xml *node = sipe_xml_child(xml, "From");
+		if (node)
+			from = sipe_xml_attribute(node, "uri");
+
+		node = sipe_xml_child(xml, "Subject");
+		if (node)
+			subject = sipe_xml_data(node);
+	}
+
+	if (from && subject) {
+		struct sip_session *session;
+		session = sipe_session_find_im(sipe_private, from);
+
+		if (session)
+			sipe_im_topic(sipe_private, session, subject);
+	}
+
+	sipe_xml_free(xml);
+
+	sip_transport_response(sipe_private, msg, 200, "OK", NULL);
+}
+
+/*
+ Local Variables:
+ mode: c
+ c-file-style: "bsd"
+ indent-tabs-mode: t
+ tab-width: 8
+ End:
+*/
--- pidgin-sipe-1.11.2/src/core/sipe-im.h	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-im.h	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,129 @@
+/**
+ * @file sipe-im.h
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2011 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* Forward declarations */
+struct sip_dialog;
+struct sip_session;
+struct sipe_core_private;
+
+#ifdef HAVE_GMIME
+/* pls. don't add multipart/related - it's not used in IM modality */
+#define SDP_ACCEPT_TYPES "text/plain text/html image/gif multipart/alternative application/im-iscomposing+xml application/ms-imdn+xml text/x-msmsgsinvite"
+#else
+/* this is a rediculous hack as Pidgin's MIME implementastion doesn't support (or have bug) in multipart/alternative */
+/* OCS/OC won't use multipart/related so we don't advertase it */
+#define SDP_ACCEPT_TYPES "text/plain text/html image/gif application/im-iscomposing+xml application/ms-imdn+xml text/x-msmsgsinvite"
+#endif
+
+/**
+ * Send invitation and initial message to IM session
+ *
+ * @param sipe_private SIPE core private data
+ * @param session session for the IM conversation(s)
+ * @param who URI of the invitee
+ * @param msg_body message body or NULL
+ * @param content_type message body MIME type
+ * @param referred_by value for Referred-By or NULL
+ * @param is_triggered triggered invite or not
+ */
+void sipe_im_invite(struct sipe_core_private *sipe_private,
+		 struct sip_session *session,
+		 const gchar *who,
+		 const gchar *msg_body,
+		 const gchar *content_type,
+		 const gchar *referred_by,
+		 const gboolean is_triggered);
+
+/**
+ * Process queue IM messages
+ *
+ * @param sipe_private SIPE core private data
+ * @param session session for the IM conversation(s)
+ */
+void sipe_im_process_queue(struct sipe_core_private *sipe_private,
+			 struct sip_session *session);
+
+/**
+ * Cancel unconfirmed IM messages
+ *
+ * @param sipe_private SIPE core private data
+ * @param session session for the IM conversation(s)
+ * @param callid Call ID of the conversation
+ * @param with URI of the remote party
+ */
+void sipe_im_cancel_unconfirmed(struct sipe_core_private *sipe_private,
+				struct sip_session *session,
+				const gchar *callid,
+				const gchar *with);
+
+/**
+ * Re-enqueue unconfirmed IM messages
+ *
+ * @param sipe_private SIPE core private data
+ * @param session session for the IM conversation(s)
+ * @param callid Call ID of the conversation
+ * @param with URI of the remote party
+ */
+void sipe_im_reenqueue_unconfirmed(struct sipe_core_private *sipe_private,
+				 struct sip_session *session,
+				 const gchar *callid,
+				 const gchar *with);
+
+typedef void (*unconfirmed_callback)(struct sipe_core_private *sipe_private,
+				 struct sip_session *session,
+				 const gchar *callid,
+				 const gchar *with);
+
+/**
+ * Close dangling IM session
+ *
+ * @param sipe_private (in) SIPE core data.
+ * @param session (in) pointer to session
+ * @param dialog (in) pointer to dialog
+ * @param with (in) URI of dialog partner
+ * @param callback (in) callback for unconfirmed message
+ */
+void sipe_im_cancel_dangling(struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 struct sip_dialog *dialog,
+			 const gchar *with,
+			 unconfirmed_callback callback);
+
+/**
+ * Sets a topic for IM conversation
+ *
+ * @param sipe_private (in) SIPE core data
+ * @param session (in) pointer to session
+ * @param topic (in) string describing conversation topic
+ */
+void sipe_im_topic(struct sipe_core_private *sipe_private,
+		 struct sip_session *session,
+		 const gchar *topic);
+
+/**
+ * Processes INFO message with application/xml+conversationinfo content type
+ *
+ * @param sipe_private (in) SIPE core data
+ * @param msg (in) SIP INFO message
+ */
+void process_incoming_info_conversation(struct sipe_core_private *sipe_private,
+					struct sipmsg *msg);
--- pidgin-sipe-1.11.2/src/core/sipe-incoming.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-incoming.c	2011-06-14 14:40:36.000000000 +0200
@@ -40,14 +40,17 @@
 #include "sipe-core-private.h"
 #include "sipe-dialog.h"
 #include "sipe-ft.h"
+#include "sipe-groupchat.h"
+#include "sipe-im.h"
 #include "sipe-incoming.h"
 #include "sipe-media.h"
+#include "sipe-mime.h"
 #include "sipe-nls.h"
+#include "sipe-schedule.h"
 #include "sipe-session.h"
+#include "sipe-user.h"
 #include "sipe-utils.h"
 #include "sipe-xml.h"
-#include "sipe-mime.h"
-#include "sipe.h"
 
 void process_incoming_bye(struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg)
@@ -60,7 +63,7 @@
 #ifdef HAVE_VV
 	if (is_media_session_msg(sipe_private->media_call, msg)) {
 		// BYE ends a media call
-		sipe_media_hangup(sipe_private);
+		sipe_media_hangup(sipe_private->media_call);
 	}
 #endif
 
@@ -70,7 +73,7 @@
 	/* take data before 'msg' will be modified by sip_transport_response */
 	dialog = g_new0(struct sip_dialog, 1);
 	dialog->callid = g_strdup(callid);
-	dialog->cseq = parse_cseq(sipmsg_find_header(msg, "CSeq"));
+	dialog->cseq = sipmsg_parse_cseq(msg);
 	dialog->with = g_strdup(from);
 	sipe_dialog_parse(dialog, msg, FALSE);
 
@@ -78,37 +81,58 @@
 
 	session = sipe_session_find_chat_or_im(sipe_private, callid, from);
 	if (!session) {
+		SIPE_DEBUG_INFO_NOFORMAT("process_incoming_bye: couldn't find session. Ignoring");
 		sipe_dialog_free(dialog);
 		g_free(from);
 		return;
 	}
 
-	if (session->roster_manager && !g_strcasecmp(from, session->roster_manager)) {
-		g_free(session->roster_manager);
-		session->roster_manager = NULL;
-	}
+	SIPE_DEBUG_INFO("process_incoming_bye: session found (chat ID %s)",
+			(session->chat_session && session->chat_session->id) ?
+			session->chat_session->id : "<NO CHAT>");
+
+	if (session->chat_session &&
+	 (session->chat_session->type == SIPE_CHAT_TYPE_MULTIPARTY) &&
+	 session->chat_session->id &&
+	 !g_strcasecmp(from, session->chat_session->id))
+		sipe_chat_set_roster_manager(session, NULL);
+
+	sipe_im_cancel_unconfirmed(sipe_private, session, callid, from);
 
 	/* This what BYE is essentially for - terminating dialog */
 	sipe_dialog_remove_3(session, dialog);
 	sipe_dialog_free(dialog);
-	if (session->focus_uri && !g_strcasecmp(from, session->im_mcu_uri)) {
+	if (session->chat_session) {
+		if ((session->chat_session->type == SIPE_CHAT_TYPE_CONFERENCE) &&
+		 !g_strcasecmp(from, session->im_mcu_uri)) {
+			SIPE_DEBUG_INFO("process_incoming_bye: disconnected from conference %s",
+					session->im_mcu_uri);
 		sipe_conf_immcu_closed(sipe_private, session);
-	} else if (session->is_multiparty) {
-		sipe_backend_chat_remove(session->backend_session,
+		} else if (session->chat_session->type == SIPE_CHAT_TYPE_MULTIPARTY) {
+			SIPE_DEBUG_INFO_NOFORMAT("process_incoming_bye: disconnected from multiparty chat");
+			sipe_backend_chat_remove(session->chat_session->backend,
 					 from);
 	}
+	}
 
 	g_free(from);
 }
 
-void process_incoming_cancel(SIPE_UNUSED_PARAMETER struct sipe_core_private *sipe_private,
-			 SIPE_UNUSED_PARAMETER struct sipmsg *msg)
+void process_incoming_cancel(struct sipe_core_private *sipe_private,
+			 struct sipmsg *msg)
 {
+	const gchar *callid;
+
 #ifdef HAVE_VV
 	if (is_media_session_msg(sipe_private->media_call, msg)) {
 		process_incoming_cancel_call(sipe_private, msg);
+		return;
 	}
 #endif
+	callid = sipmsg_find_header(msg, "Call-ID");
+
+	if (!sipe_session_find_chat_by_callid(sipe_private, callid))
+		sipe_conf_cancel_unaccepted(sipe_private, msg);
 }
 
 void process_incoming_info(struct sipe_core_private *sipe_private,
@@ -119,7 +143,7 @@
 	gchar *from;
 	struct sip_session *session;
 
-	SIPE_DEBUG_INFO("process_incoming_info: \n%s", msg->body ? msg->body : "");
+	SIPE_DEBUG_INFO_NOFORMAT("process_incoming_info");
 
 	/* Call Control protocol */
 	if (g_str_has_prefix(contenttype, "application/csta+xml"))
@@ -127,6 +151,11 @@
 		process_incoming_info_csta(sipe_private, msg);
 		return;
 	}
+	else if (g_str_has_prefix(contenttype, "application/xml+conversationinfo"))
+	{
+		process_incoming_info_conversation(sipe_private, msg);
+		return;
+	}
 
 	from = parse_from(sipmsg_find_header(msg, "From"));
 	session = sipe_session_find_chat_or_im(sipe_private, callid, from);
@@ -135,6 +164,13 @@
 		return;
 	}
 
+	/* Group Chat uses text/plain */
+	if (session->is_groupchat) {
+		process_incoming_info_groupchat(sipe_private, msg, session);
+		g_free(from);
+		return;
+	}
+
 	if (g_str_has_prefix(contenttype, "application/x-ms-mim"))
 	{
 		sipe_xml *xn_action = sipe_xml_parse(msg->body, msg->bodylen);
@@ -156,9 +192,9 @@
 			g_free(body);
 		} else if (xn_set_rm) {
 			gchar *body;
-			const char *rm = sipe_xml_attribute(xn_set_rm, "uri");
-			g_free(session->roster_manager);
-			session->roster_manager = g_strdup(rm);
+
+			sipe_chat_set_roster_manager(session,
+						 sipe_xml_attribute(xn_set_rm, "uri"));
 
 			body = g_strdup_printf(
 				"<?xml version=\"1.0\"?>\r\n"
@@ -174,7 +210,7 @@
 	else
 	{
 		/* looks like purple lacks typing notification for chat */
-		if (!session->is_multiparty && !session->focus_uri) {
+		if (!session->chat_session) {
 			sipe_xml *xn_keyboard_activity = sipe_xml_parse(msg->body, msg->bodylen);
 			const char *status = sipe_xml_attribute(sipe_xml_child(xn_keyboard_activity, "status"),
 								"status");
@@ -218,7 +254,7 @@
 
 #ifdef HAVE_VV
 static void sipe_invite_mime_cb(gpointer user_data, const GSList *fields,
-				const gchar *body, SIPE_UNUSED_PARAMETER gsize length)
+				const gchar *body, gsize length)
 {
 	const gchar *type = sipe_utils_nameval_find(fields, "Content-Type");
 	const gchar *cd = sipe_utils_nameval_find(fields, "Content-Disposition");
@@ -243,19 +279,84 @@
 		 * process it as a normal single part message. */
 		g_free(msg->body);
 		msg->body = g_strndup(body, length);
+		msg->bodylen = length;
 	}
 }
 #endif
 
+static void send_invite_response(struct sipe_core_private *sipe_private,
+				 struct sipmsg *msg)
+{
+	gchar *body = g_strdup_printf(
+		"v=0\r\n"
+		"o=- 0 0 IN IP4 %s\r\n"
+		"s=session\r\n"
+		"c=IN IP4 %s\r\n"
+		"t=0 0\r\n"
+		"m=%s %d sip sip:%s\r\n"
+		"a=accept-types:" SDP_ACCEPT_TYPES "\r\n",
+		sipe_backend_network_ip_address(),
+		sipe_backend_network_ip_address(),
+		SIPE_CORE_PRIVATE_FLAG_IS(OCS2007) ? "message" : "x-ms-message",
+		sip_transport_port(sipe_private),
+		sipe_private->username);
+	sipmsg_add_header(msg, "Content-Type", "application/sdp");
+	sip_transport_response(sipe_private, msg, 200, "OK", body);
+	g_free(body);
+}
+
+struct sipe_delayed_invite {
+	gchar *action;
+	struct sipmsg *msg;
+};
+
+static void delayed_invite_destroy(gpointer data)
+{
+	struct sipe_delayed_invite *delayed_invite = data;
+	sipmsg_free(delayed_invite->msg);
+	g_free(delayed_invite->action);
+	g_free(delayed_invite);
+}
+
+static void delayed_invite_timeout(struct sipe_core_private *sipe_private,
+				 gpointer data)
+{
+	struct sipe_delayed_invite *delayed_invite = data;
+	send_invite_response(sipe_private, delayed_invite->msg);
+}
+
+static void delayed_invite_response(struct sipe_core_private *sipe_private,
+				 struct sipmsg *msg,
+				 const gchar *callid)
+{
+	struct sipe_delayed_invite *delayed_invite = g_new0(struct sipe_delayed_invite, 1);
+
+	delayed_invite->action = g_strdup_printf("<delayed-invite-%s>", callid);
+	delayed_invite->msg = sipmsg_copy(msg);
+	sipe_schedule_seconds(sipe_private,
+			 delayed_invite->action,
+			 delayed_invite,
+			 10,
+			 delayed_invite_timeout,
+			 delayed_invite_destroy);
+}
+
+void sipe_incoming_cancel_delayed_invite(struct sipe_core_private *sipe_private,
+					 struct sip_dialog *dialog)
+{
+	struct sipe_delayed_invite *delayed_invite = dialog->delayed_invite;
+	dialog->delayed_invite = NULL;
+	send_invite_response(sipe_private, delayed_invite->msg);
+	sipe_schedule_cancel(sipe_private, delayed_invite->action);
+}
+
 void process_incoming_invite(struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg)
 {
-	gchar *body;
 	gchar *newTag;
 	const gchar *oldHeader;
 	gchar *newHeader;
 	gboolean is_multiparty = FALSE;
-	gboolean is_triggered = FALSE;
 	gboolean was_multiparty = TRUE;
 	gboolean just_joined = FALSE;
 	gchar *from;
@@ -264,13 +365,18 @@
 	const gchar *end_points_hdr = sipmsg_find_header(msg, "EndPoints");
 	const gchar *trig_invite = sipmsg_find_header(msg, "TriggeredInvite");
 	const gchar *content_type = sipmsg_find_header(msg, "Content-Type");
+	const gchar *subject = sipmsg_find_header(msg, "Subject");
 	GSList *end_points = NULL;
 	struct sip_session *session;
+	struct sip_dialog *dialog;
 	const gchar *ms_text_format;
+	gboolean dont_delay = FALSE;
 
 #ifdef HAVE_VV
 	if (g_str_has_prefix(content_type, "multipart/alternative")) {
 		sipe_mime_parts_foreach(content_type, msg->body, sipe_invite_mime_cb, msg);
+		/* Reload Content-Type to get type of the selected message part */
+		content_type = sipmsg_find_header(msg, "Content-Type");
 	}
 #endif
 
@@ -299,6 +405,7 @@
 	oldHeader = sipmsg_find_header(msg, "To");
 	newTag = gentag();
 	newHeader = g_strdup_printf("%s;tag=%s", oldHeader, newTag);
+	g_free(newTag);
 	sipmsg_remove_header_now(msg, "To");
 	sipmsg_add_header_now(msg, "To", newHeader);
 	g_free(newHeader);
@@ -311,45 +418,64 @@
 		}
 	}
 	if (trig_invite && !g_strcasecmp(trig_invite, "TRUE")) {
-		is_triggered = TRUE;
 		is_multiparty = TRUE;
 	}
 
+	/* Multiparty session */
 	session = sipe_session_find_chat_by_callid(sipe_private, callid);
-	/* Convert to multiparty */
-	if (session && is_multiparty && !session->is_multiparty) {
+	if (is_multiparty) {
+
+		if (session) {
+			if (session->chat_session) {
+				/* Update roster manager for existing multiparty session */
+				if (roster_manager)
+					sipe_chat_set_roster_manager(session, roster_manager);
+
+			} else {
+				gchar *chat_title = sipe_chat_get_name();
+
+				/* Convert IM session to multiparty session */
 		g_free(session->with);
 		session->with = NULL;
 		was_multiparty = FALSE;
-		session->is_multiparty = TRUE;
-		session->chat_id = rand();
+				session->chat_session = sipe_chat_create_session(SIPE_CHAT_TYPE_MULTIPARTY,
+										 roster_manager,
+										 chat_title);
+
+				g_free(chat_title);
+			}
+		} else {
+			/* New multiparty session */
+			session = sipe_session_add_chat(sipe_private,
+							NULL,
+							TRUE,
+							roster_manager);
 	}
 
-	if (!session && is_multiparty) {
-		session = sipe_session_find_or_add_chat_by_callid(sipe_private,
-								 callid);
+		/* Create chat */
+		if (!session->chat_session->backend) {
+			gchar *self = sip_uri_self(sipe_private);
+			session->chat_session->backend = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
+										 session->chat_session,
+										 session->chat_session->title,
+										 self);
+			g_free(self);
+		}
 	}
+
 	/* IM session */
 	from = parse_from(sipmsg_find_header(msg, "From"));
-	if (!session) {
+	if (!session)
 		session = sipe_session_find_or_add_im(sipe_private, from);
-	}
 
-	if (session) {
+	/* session is now initialized */
 		g_free(session->callid);
 		session->callid = g_strdup(callid);
 
-		session->is_multiparty = is_multiparty;
-		if (roster_manager) {
-			session->roster_manager = g_strdup(roster_manager);
-		}
-	}
-
 	if (is_multiparty && end_points) {
 		gchar *to = parse_from(sipmsg_find_header(msg, "To"));
 		GSList *entry = end_points;
 		while (entry) {
-			struct sip_dialog *dialog;
 			struct sipendpoint *end_point = entry->data;
 			entry = entry->next;
 
@@ -374,7 +500,7 @@
 				just_joined = TRUE;
 
 				/* send triggered INVITE */
-				sipe_invite(sipe_private, session, dialog->with, NULL, NULL, NULL, TRUE);
+				sipe_im_invite(sipe_private, session, dialog->with, NULL, NULL, NULL, TRUE);
 			}
 		}
 		g_free(to);
@@ -392,62 +518,37 @@
 		g_slist_free(end_points);
 	}
 
-	if (session) {
-		struct sip_dialog *dialog = sipe_dialog_find(session, from);
+	dialog = sipe_dialog_find(session, from);
 		if (dialog) {
-			SIPE_DEBUG_INFO_NOFORMAT("process_incoming_invite, session already has dialog!");
-			sipe_dialog_parse_routes(dialog, msg, FALSE);
+		sipe_im_cancel_dangling(sipe_private, session, dialog, from,
+					sipe_im_reenqueue_unconfirmed);
+		/* dialog is no longer valid */
 		} else {
-			dialog = sipe_dialog_add(session);
-
-			dialog->callid = g_strdup(session->callid);
-			dialog->with = g_strdup(from);
-			sipe_dialog_parse(dialog, msg, FALSE);
-
-			if (!dialog->ourtag) {
-				dialog->ourtag = newTag;
-				newTag = NULL;
-			}
-
 			just_joined = TRUE;
 		}
-	} else {
-		SIPE_DEBUG_INFO_NOFORMAT("process_incoming_invite, failed to find or create IM session");
-	}
-	g_free(newTag);
 
-	if (is_multiparty && !session->backend_session) {
-		gchar *chat_title = sipe_chat_get_name(callid);
-		gchar *self = sip_uri_self(sipe_private);
-		/* create chat */
-		session->backend_session = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
-								 session->chat_id,
-								 chat_title, 
-								 self,
-								 FALSE);
-		session->chat_title = g_strdup(chat_title);
-		/* add self */
-		sipe_backend_chat_add(session->backend_session,
-				 self,
-				 FALSE);
-		g_free(chat_title);
-		g_free(self);
-	}
+	dialog = sipe_dialog_add(session);
+	dialog->with = g_strdup(from);
+	dialog->callid = g_strdup(session->callid);
+	sipe_dialog_parse(dialog, msg, FALSE);
 
 	if (is_multiparty && !was_multiparty) {
 		/* add current IM counterparty to chat */
-		sipe_backend_chat_add(session->backend_session,
+		sipe_backend_chat_add(session->chat_session->backend,
 				 sipe_dialog_first(session)->with,
 				 FALSE);
 	}
 
 	/* add inviting party to chat */
-	if (just_joined && session->backend_session) {
-		sipe_backend_chat_add(session->backend_session,
+	if (just_joined && session->chat_session) {
+		sipe_backend_chat_add(session->chat_session->backend,
 				 from,
 				 TRUE);
 	}
 
+	if (!is_multiparty && subject)
+		sipe_im_topic(sipe_private, session, subject);
+
 	/* ms-text-format: text/plain; charset=UTF-8;msgr=WAAtAE0...DIADQAKAA0ACgA;ms-body=SGk= */
 
 	/* This used only in 2005 official client, not 2007 or Reuters.
@@ -462,19 +563,7 @@
 		if (ms_text_format) {
 			if (g_str_has_prefix(ms_text_format, "text/x-msmsgsinvite"))
 			{
-				gchar *tmp = sipmsg_find_part_of_header(ms_text_format, "ms-body=", NULL, NULL);
-				if (tmp) {
-					gsize len;
-					struct sip_dialog *dialog = sipe_dialog_find(session, from);
-					gchar *body = (gchar *) g_base64_decode(tmp, &len);
-
-					GSList *parsed_body = sipe_ft_parse_msg_body(body);
-
-					sipe_process_incoming_x_msmsgsinvite(sipe_private, dialog, parsed_body);
-					sipe_utils_nameval_free(parsed_body);
-					sipmsg_add_header(msg, "Supported", "ms-text-format"); /* accepts received message */
-				}
-				g_free(tmp);
+				dont_delay = TRUE;
 			}
 			else if (g_str_has_prefix(ms_text_format, "text/plain") || g_str_has_prefix(ms_text_format, "text/html"))
 			{
@@ -483,7 +572,7 @@
 				if (html) {
 					if (is_multiparty) {
 						sipe_backend_chat_message(SIPE_CORE_PUBLIC,
-									 session->chat_id,
+									 session->chat_session->backend,
 									 from,
 									 html);
 					} else {
@@ -493,6 +582,7 @@
 					}
 					g_free(html);
 					sipmsg_add_header(msg, "Supported", "ms-text-format"); /* accepts received message */
+					dont_delay = TRUE;
 				}
 			}
 		}
@@ -501,24 +591,12 @@
 	g_free(from);
 
 	sipmsg_add_header(msg, "Supported", "com.microsoft.rtc-multiparty");
-	sipmsg_add_header(msg, "User-Agent", sip_transport_user_agent(sipe_private));
-	sipmsg_add_header(msg, "Content-Type", "application/sdp");
 
-	body = g_strdup_printf(
-		"v=0\r\n"
-		"o=- 0 0 IN IP4 %s\r\n"
-		"s=session\r\n"
-		"c=IN IP4 %s\r\n"
-		"t=0 0\r\n"
-		"m=%s %d sip sip:%s\r\n"
-		"a=accept-types:" SDP_ACCEPT_TYPES "\r\n",
-		sipe_backend_network_ip_address(),
-		sipe_backend_network_ip_address(),
-		SIPE_CORE_PRIVATE_FLAG_IS(OCS2007) ? "message" : "x-ms-message",
-		sip_transport_port(sipe_private),
-		sipe_private->username);
-	sip_transport_response(sipe_private, msg, 200, "OK", body);
-	g_free(body);
+	if (dont_delay || !SIPE_CORE_PRIVATE_FLAG_IS(MPOP)) {
+		send_invite_response(sipe_private, msg);
+	} else {
+		delayed_invite_response(sipe_private, msg, session->callid);
+	}
 }
 
 void process_incoming_message(struct sipe_core_private *sipe_private,
@@ -546,20 +624,22 @@
 		struct sip_session *session = sipe_session_find_chat_or_im(sipe_private,
 									 callid,
 									 from);
-		if (session && session->focus_uri) { /* a conference */
+		if (session && session->chat_session) {
+			if (session->chat_session->type == SIPE_CHAT_TYPE_CONFERENCE) { /* a conference */
 			gchar *tmp = parse_from(sipmsg_find_header(msg, "Ms-Sender"));
 			gchar *sender = parse_from(tmp);
 			g_free(tmp);
 			sipe_backend_chat_message(SIPE_CORE_PUBLIC,
-						 session->chat_id,
+							 session->chat_session->backend,
 						 sender,
 						 html);
 			g_free(sender);
-		} else if (session && session->is_multiparty) { /* a multiparty chat */
+			} else { /* a multiparty chat */
 			sipe_backend_chat_message(SIPE_CORE_PUBLIC,
-						 session->chat_id,
+							 session->chat_session->backend,
 						 from,
 						 html);
+			}
 		} else {
 			sipe_backend_im_message(SIPE_CORE_PUBLIC,
 						from,
@@ -624,7 +704,7 @@
 		if (session) {
 			gchar *errmsg = g_strdup_printf(_("Received a message with unrecognized contents from %s"),
 							from);
-			sipe_present_err(sipe_private, session, errmsg);
+			sipe_user_present_error(sipe_private, session, errmsg);
 			g_free(errmsg);
 		}
 
@@ -640,7 +720,6 @@
 	gchar *body;
 
 	sipmsg_add_header(msg, "Allow", "INVITE, MESSAGE, INFO, SUBSCRIBE, OPTIONS, BYE, CANCEL, NOTIFY, ACK, REFER, BENOTIFY");
-	sipmsg_add_header(msg, "User-Agent", sip_transport_user_agent(sipe_private));
 	sipmsg_add_header(msg, "Content-Type", "application/sdp");
 
 	body = g_strdup_printf(
@@ -672,12 +751,15 @@
 	session = sipe_session_find_chat_by_callid(sipe_private, callid);
 	dialog = sipe_dialog_find(session, from);
 
-	if (!session || !dialog || !session->roster_manager || !sipe_strcase_equal(session->roster_manager, self)) {
+	if (!session || !dialog || !session->chat_session ||
+	 (session->chat_session->type != SIPE_CHAT_TYPE_MULTIPARTY) ||
+	 !session->chat_session->id ||
+	 !sipe_strcase_equal(session->chat_session->id, self)) {
 		sip_transport_response(sipe_private, msg, 500, "Server Internal Error", NULL);
 	} else {
 		sip_transport_response(sipe_private, msg, 202, "Accepted", NULL);
 
-		sipe_invite(sipe_private, session, refer_to, NULL, NULL, referred_by, FALSE);
+		sipe_im_invite(sipe_private, session, refer_to, NULL, NULL, referred_by, FALSE);
 	}
 
 	g_free(self);
--- pidgin-sipe-1.11.2/src/core/sipe-incoming.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-incoming.h	2011-06-14 14:40:36.000000000 +0200
@@ -22,6 +22,7 @@
 
 /* Forward declarations */
 struct sipe_core_private;
+struct sip_dialog;
 struct sipmsg;
 
 void process_incoming_bye(struct sipe_core_private *sipe_private,
@@ -38,3 +39,6 @@
 			 struct sipmsg *msg);
 void process_incoming_refer(struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg);
+
+void sipe_incoming_cancel_delayed_invite(struct sipe_core_private *sipe_private,
+					 struct sip_dialog *dialog);
--- pidgin-sipe-1.11.2/src/core/sipe-media.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-media.c	2011-06-14 14:40:36.000000000 +0200
@@ -25,6 +25,7 @@
 #endif
 
 #include <stdio.h>
+#include <stdlib.h>
 
 #include <glib.h>
 
@@ -33,6 +34,7 @@
 #include "sip-transport.h"
 #include "sipe-backend.h"
 #include "sdpmsg.h"
+#include "sipe-chat.h"
 #include "sipe-core.h"
 #include "sipe-core-private.h"
 #include "sipe-dialog.h"
@@ -40,6 +42,8 @@
 #include "sipe-session.h"
 #include "sipe-utils.h"
 #include "sipe-nls.h"
+#include "sipe-schedule.h"
+#include "sipe-xml.h"
 
 struct sipe_media_call_private {
 	struct sipe_media_call public;
@@ -49,11 +53,11 @@
 	gchar				*with;
 
 	struct sipmsg			*invitation;
-	gboolean			 legacy_mode;
-	gboolean			 using_nice;
+	SipeIceVersion			 ice_version;
 	gboolean			 encryption_compatible;
 
 	struct sdpmsg			*smsg;
+	GSList				*failed_media;
 };
 #define SIPE_MEDIA_CALL ((struct sipe_media_call *) call_private)
 #define SIPE_MEDIA_CALL_PRIVATE ((struct sipe_media_call_private *) call)
@@ -86,6 +90,8 @@
 			sipmsg_free(call_private->invitation);
 
 		sdpmsg_free(call_private->smsg);
+		g_slist_free_full(call_private->failed_media,
+				 (GDestroyNotify)sdpmedia_free);
 		g_free(call_private->with);
 		g_free(call_private);
 	}
@@ -110,6 +116,8 @@
 		c->base_ip = sipe_backend_candidate_get_base_ip(candidate);
 		c->base_port = sipe_backend_candidate_get_base_port(candidate);
 		c->priority = sipe_backend_candidate_get_priority(candidate);
+		c->username = sipe_backend_candidate_get_username(candidate);
+		c->password = sipe_backend_candidate_get_password(candidate);
 
 		result = g_slist_append(result, c);
 	}
@@ -117,20 +125,42 @@
 	return result;
 }
 
+static void
+get_stream_ip_and_ports(GSList *candidates,
+			gchar **ip, guint *rtp_port, guint *rtcp_port,
+			SipeCandidateType type)
+{
+	*rtp_port = 0;
+	*rtcp_port = 0;
+
+	for (; candidates; candidates = candidates->next) {
+		struct sdpcandidate *candidate = candidates->data;
+
+		if (type == SIPE_CANDIDATE_TYPE_ANY || candidate->type == type) {
+			if (candidate->component == SIPE_COMPONENT_RTP) {
+				*rtp_port = candidate->port;
+				*ip = g_strdup(candidate->ip);
+			} else if (candidate->component == SIPE_COMPONENT_RTCP)
+				*rtcp_port = candidate->port;
+		}
+
+		if (*rtp_port != 0 && *rtcp_port != 0)
+			return;
+	}
+}
+
 static struct sdpmedia *
-backend_stream_to_sdpmedia(struct sipe_media_call_private *call_private,
+backend_stream_to_sdpmedia(struct sipe_backend_media *backend_media,
 			 struct sipe_backend_stream *backend_stream)
 {
-	struct sipe_backend_media *backend_media = call_private->public.backend_private;
 	struct sdpmedia *media = g_new0(struct sdpmedia, 1);
-	GList *codecs = sipe_backend_get_local_codecs(SIPE_MEDIA_CALL,
+	GList *codecs = sipe_backend_get_local_codecs(backend_media,
 						 backend_stream);
-	guint rtcp_port;
+	guint rtcp_port = 0;
 	SipeMediaType type;
 	GSList *attributes = NULL;
 	GList *candidates;
 	GList *i;
-	GSList *j;
 
 	media->name = g_strdup(sipe_backend_stream_get_id(backend_stream));
 
@@ -140,6 +170,10 @@
 		type = SIPE_MEDIA_VIDEO;
 	else {
 		// TODO: incompatible media, should not happen here
+		g_free(media->name);
+		g_free(media);
+		sipe_media_codec_list_free(codecs);
+		return(NULL);
 	}
 
 	// Process codecs
@@ -180,33 +214,14 @@
 
 	media->candidates = backend_candidates_to_sdpcandidate(candidates);
 
-	// Process stream attributes
-	if (!call_private->legacy_mode) {
-		struct sipe_backend_candidate *candidate = candidates->data;
-
-		gchar *username = sipe_backend_candidate_get_username(candidate);
-		gchar *password = sipe_backend_candidate_get_password(candidate);
-
-		attributes = sipe_utils_nameval_add(attributes,
-						 "ice-ufrag", username);
-		attributes = sipe_utils_nameval_add(attributes,
-						 "ice-pwd", password);
-
-		g_free(username);
-		g_free(password);
-	}
-
 	sipe_media_candidate_list_free(candidates);
 
-	for (j = media->candidates; j; j = j->next) {
-		struct sdpcandidate *candidate = j->data;
-
-		if (candidate->type == SIPE_CANDIDATE_TYPE_HOST) {
-			if (candidate->component == SIPE_COMPONENT_RTP)
-				media->port = candidate->port;
-			else if (candidate->component == SIPE_COMPONENT_RTCP)
-				rtcp_port = candidate->port;
-		}
+	get_stream_ip_and_ports(media->candidates, &media->ip, &media->port,
+				&rtcp_port, SIPE_CANDIDATE_TYPE_HOST);
+	// No usable HOST candidates, use any candidate
+	if (media->ip == NULL && media->candidates) {
+		get_stream_ip_and_ports(media->candidates, &media->ip, &media->port,
+					&rtcp_port, SIPE_CANDIDATE_TYPE_ANY);
 	}
 
 	if (sipe_backend_stream_is_held(backend_stream))
@@ -234,17 +249,24 @@
 static struct sdpmsg *
 sipe_media_to_sdpmsg(struct sipe_media_call_private *call_private)
 {
+	struct sipe_backend_media *backend_media = call_private->public.backend_private;
 	struct sdpmsg *msg = g_new0(struct sdpmsg, 1);
-	GSList *streams = sipe_backend_media_get_streams(call_private->public.backend_private);
+	GSList *streams = sipe_backend_media_get_streams(backend_media);
 
 	for (; streams; streams = streams->next) {
-		struct sdpmedia *media;
-		media = backend_stream_to_sdpmedia(call_private, streams->data);
+		struct sdpmedia *media = backend_stream_to_sdpmedia(backend_media, streams->data);
+		if (media) {
 		msg->media = g_slist_append(msg->media, media);
+
+			if (msg->ip == NULL)
+				msg->ip = g_strdup(media->ip);
+		}
 	}
 
-	msg->legacy = call_private->legacy_mode;
-	msg->ip = g_strdup(sipe_utils_get_suitable_local_ip(-1));
+	msg->media = g_slist_concat(msg->media, call_private->failed_media);
+	call_private->failed_media = NULL;
+
+	msg->ice_version = call_private->ice_version;
 
 	return msg;
 }
@@ -259,9 +281,11 @@
 	struct sip_session *session;
 	struct sip_dialog *dialog;
 	struct sdpmsg *msg;
+	gboolean add_2007_fallback = FALSE;
 
 	session = sipe_session_find_call(sipe_private, call_private->with);
 	dialog = session->dialogs->data;
+	add_2007_fallback = dialog->cseq == 0 && call_private->ice_version == SIPE_ICE_RFC_5245;
 
 	contact = get_contact(sipe_private);
 	hdr = g_strdup_printf(
@@ -269,12 +293,42 @@
 		"Supported: 100rel\r\n"
 		"ms-keep-alive: UAC;hop-hop=yes\r\n"
 		"Contact: %s\r\n"
-		"Content-Type: application/sdp\r\n",
-		contact);
+		"Content-Type: %s\r\n",
+		contact,
+		add_2007_fallback ?
+			 "multipart/alternative;boundary=\"----=_NextPart_000_001E_01CB4397.0B5EB570\""
+			: "application/sdp");
 	g_free(contact);
 
 	msg = sipe_media_to_sdpmsg(call_private);
 	body = sdpmsg_to_string(msg);
+
+	if (add_2007_fallback) {
+		gchar *tmp;
+		tmp = g_strdup_printf(
+			"------=_NextPart_000_001E_01CB4397.0B5EB570\r\n"
+			"Content-Type: application/sdp\r\n"
+			"Content-Transfer-Encoding: 7bit\r\n"
+			"Content-Disposition: session; handling=optional; ms-proxy-2007fallback\r\n"
+			"\r\n"
+			"o=- 0 0 IN IP4 %s\r\n"
+			"s=session\r\n"
+			"c=IN IP4 %s\r\n"
+			"m=audio 0 RTP/AVP\r\n"
+			"\r\n"
+			"------=_NextPart_000_001E_01CB4397.0B5EB570\r\n"
+			"Content-Type: application/sdp\r\n"
+			"Content-Transfer-Encoding: 7bit\r\n"
+			"Content-Disposition: session; handling=optional\r\n"
+			"\r\n"
+			"%s"
+			"\r\n"
+			"------=_NextPart_000_001E_01CB4397.0B5EB570--\r\n",
+			msg->ip, msg->ip, body);
+		g_free(body);
+		body = tmp;
+	}
+
 	sdpmsg_free(msg);
 
 	dialog->outgoing_invite = sip_transport_invite(sipe_private,
@@ -339,20 +393,6 @@
 	return TRUE;
 }
 
-static void
-handle_incompatible_encryption_level(struct sipe_media_call_private *call_private)
-{
-	sipmsg_add_header(call_private->invitation, "Warning",
-			 "308 lcs.microsoft.com \"Encryption Levels not compatible\"");
-	sip_transport_response(call_private->sipe_private,
-			 call_private->invitation,
-			 488, "Encryption Levels not compatible",
-			 NULL);
-	sipe_backend_media_reject(call_private->public.backend_private, FALSE);
-	sipe_backend_notify_error(_("Unable to establish a call"),
-		_("Encryption settings of peer are incompatible with ours."));
-}
-
 static gboolean
 process_invite_call_response(struct sipe_core_private *sipe_private,
 								 struct sipmsg *msg,
@@ -366,8 +406,6 @@
 	struct sipe_backend_stream *backend_stream;
 	GList *backend_candidates = NULL;
 	GList *backend_codecs = NULL;
-	const gchar *username = sipe_utils_nameval_find(media->attributes, "ice-ufrag");
-	const gchar *password = sipe_utils_nameval_find(media->attributes, "ice-pwd");
 	GSList *i;
 	gboolean result = TRUE;
 
@@ -382,31 +420,6 @@
 	if (!backend_stream)
 		return FALSE;
 
-
-	for (i = media->candidates; i; i = i->next) {
-		struct sdpcandidate *c = i->data;
-		struct sipe_backend_candidate *candidate;
-		candidate = sipe_backend_candidate_new(c->foundation,
-						 c->component,
-						 c->type,
-						 c->protocol,
-						 c->ip,
-						 c->port);
-		sipe_backend_candidate_set_priority(candidate, c->priority);
-
-		if (username)
-			sipe_backend_candidate_set_username_and_pwd(candidate,
-								 username,
-								 password);
-
-		backend_candidates = g_list_append(backend_candidates, candidate);
-	}
-
-	sipe_backend_media_add_remote_candidates(backend_media,
-						 backend_stream,
-						 backend_candidates);
-	sipe_media_candidate_list_free(backend_candidates);
-
 	for (i = media->codecs; i; i = i->next) {
 		struct sdpcodec *c = i->data;
 		struct sipe_backend_codec *codec;
@@ -433,102 +446,152 @@
 						backend_codecs);
 	sipe_media_codec_list_free(backend_codecs);
 
+	if (result == FALSE) {
+		sipe_backend_media_remove_stream(backend_media, backend_stream);
+		return FALSE;
+	}
+
+	for (i = media->candidates; i; i = i->next) {
+		struct sdpcandidate *c = i->data;
+		struct sipe_backend_candidate *candidate;
+		candidate = sipe_backend_candidate_new(c->foundation,
+						 c->component,
+						 c->type,
+						 c->protocol,
+						 c->ip,
+						 c->port,
+						 c->username,
+						 c->password);
+		sipe_backend_candidate_set_priority(candidate, c->priority);
+
+		backend_candidates = g_list_append(backend_candidates, candidate);
+	}
+
+	sipe_backend_media_add_remote_candidates(backend_media,
+						 backend_stream,
+						 backend_candidates);
+	sipe_media_candidate_list_free(backend_candidates);
+
 	if (sipe_utils_nameval_find(media->attributes, "inactive")) {
 		sipe_backend_stream_hold(backend_media, backend_stream, FALSE);
 	} else if (sipe_backend_stream_is_held(backend_stream)) {
 		sipe_backend_stream_unhold(backend_media, backend_stream, FALSE);
 	}
 
-	return result;
+	return TRUE;
 }
 
-static gboolean
+static void
 apply_remote_message(struct sipe_media_call_private* call_private,
 		 struct sdpmsg* msg)
 {
 	GSList *i;
+
+	g_slist_free_full(call_private->failed_media, (GDestroyNotify)sdpmedia_free);
+	call_private->failed_media = NULL;
+
 	for (i = msg->media; i; i = i->next) {
-		if (!update_remote_media(call_private, i->data))
-			return FALSE;
+		struct sdpmedia *media = i->data;
+		if (!update_remote_media(call_private, media)) {
+			media->port = 0;
+			call_private->failed_media =
+				g_slist_append(call_private->failed_media, media);
+		}
 	}
 
-	call_private->legacy_mode = msg->legacy;
-	call_private->encryption_compatible = encryption_levels_compatible(msg);
+	/* We need to keep failed medias until response is sent, remove them
+	 * from sdpmsg that is to be freed. */
+	for (i = call_private->failed_media; i; i = i->next) {
+		msg->media = g_slist_remove(msg->media, i->data);
+	}
 
-	return TRUE;
+	call_private->encryption_compatible = encryption_levels_compatible(msg);
 }
 
-void do_apply_remote_message(struct sipe_media_call_private *call_private,
-			 struct sdpmsg *smsg)
+// Sends an invite response when the call is accepted and local candidates were
+// prepared, otherwise does nothing. If error response is sent, call_private is
+// disposed before function returns. Returns true when response was sent.
+static gboolean
+send_invite_response_if_ready(struct sipe_media_call_private *call_private)
 {
-	if (!apply_remote_message(call_private, smsg)) {
-		sip_transport_response(call_private->sipe_private,
-				 call_private->invitation,
-				 487, "Request Terminated", NULL);
-		sipe_media_hangup(call_private->sipe_private);
-		return;
-	}
+	struct sipe_backend_media *backend_media;
 
-	sdpmsg_free(call_private->smsg);
-	call_private->smsg = NULL;
+	backend_media = call_private->public.backend_private;
 
-	if (sipe_backend_media_accepted(call_private->public.backend_private)) {
-		send_response_with_session_description(call_private,
-						 200, "OK");
-		return;
+	if (!sipe_backend_media_accepted(backend_media) ||
+	 !sipe_backend_candidates_prepared(backend_media))
+		return FALSE;
+
+	if (!call_private->encryption_compatible) {
+		sipmsg_add_header(call_private->invitation, "Warning",
+			"308 lcs.microsoft.com \"Encryption Levels not compatible\"");
+		sip_transport_response(call_private->sipe_private,
+			call_private->invitation,
+			488, "Encryption Levels not compatible",
+			NULL);
+		sipe_backend_media_reject(backend_media, FALSE);
+		sipe_backend_notify_error(_("Unable to establish a call"),
+			_("Encryption settings of peer are incompatible with ours."));
+	} else {
+		send_response_with_session_description(call_private, 200, "OK");
 	}
 
-	if (!call_private->legacy_mode && call_private->encryption_compatible)
-		send_response_with_session_description(call_private,
-						 183, "Session Progress");
+	return TRUE;
 }
 
-static void candidates_prepared_cb(struct sipe_media_call *call,
+static void
+candidates_prepared_cb(struct sipe_media_call *call,
 				 struct sipe_backend_stream *stream)
 {
 	struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
+	struct sipe_backend_media *backend_private = call->backend_private;
 
-	if (sipe_backend_media_is_initiator(call_private->public.backend_private,
-					 stream)) {
+	if (sipe_backend_media_is_initiator(backend_private, stream)) {
 		sipe_invite_call(call_private->sipe_private,
 				 process_invite_call_response);
-		return;
 	} else {
 		struct sdpmsg *smsg = call_private->smsg;
 		call_private->smsg = NULL;
 
-		do_apply_remote_message(call_private, smsg);
-		sdpmsg_free(call_private->smsg);
-	}
+		apply_remote_message(call_private, smsg);
+
+		if (!send_invite_response_if_ready(call_private) &&
+		 call_private->ice_version == SIPE_ICE_RFC_5245 &&
+		 call_private->encryption_compatible) {
+			send_response_with_session_description(call_private,
+						 183, "Session Progress");
 }
 
-static void media_connected_cb(SIPE_UNUSED_PARAMETER struct sipe_media_call_private *call_private)
-{
+		sdpmsg_free(smsg);
+	}
 }
 
-static void call_accept_cb(struct sipe_media_call *call, gboolean local)
+static void
+media_end_cb(struct sipe_media_call *call)
 {
-	if (local) {
-		struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
+	g_return_if_fail(call);
 
-		if (!call_private->encryption_compatible) {
-			handle_incompatible_encryption_level(call_private);
-			return;
+	SIPE_MEDIA_CALL_PRIVATE->sipe_private->media_call = NULL;
+	sipe_media_call_free(SIPE_MEDIA_CALL_PRIVATE);
 		}
 
-		send_response_with_session_description(call_private, 200, "OK");
+static void
+call_accept_cb(struct sipe_media_call *call, gboolean local)
+{
+	if (local) {
+		send_invite_response_if_ready(SIPE_MEDIA_CALL_PRIVATE);
 	}
 }
 
-static void call_reject_cb(struct sipe_media_call *call, gboolean local)
+static void
+call_reject_cb(struct sipe_media_call *call, gboolean local)
 {
-	struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
-
 	if (local) {
-		sip_transport_response(call_private->sipe_private, call_private->invitation, 603, "Decline", NULL);
+		struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
+		sip_transport_response(call_private->sipe_private,
+				 call_private->invitation,
+				 603, "Decline", NULL);
 	}
-	call_private->sipe_private->media_call = NULL;
-	sipe_media_call_free(call_private);
 }
 
 static gboolean
@@ -546,9 +609,8 @@
 
 static void call_hangup_cb(struct sipe_media_call *call, gboolean local)
 {
-	struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
-
 	if (local) {
+		struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
 		struct sip_session *session;
 		session = sipe_session_find_call(call_private->sipe_private,
 						 call_private->with);
@@ -557,59 +619,85 @@
 			sipe_session_close(call_private->sipe_private, session);
 		}
 	}
-	call_private->sipe_private->media_call = NULL;
-	sipe_media_call_free(call_private);
+}
+
+static void
+error_cb(struct sipe_media_call *call, gchar *message)
+{
+	struct sipe_media_call_private *call_private = SIPE_MEDIA_CALL_PRIVATE;
+	gboolean initiator = sipe_backend_media_is_initiator(call->backend_private, NULL);
+	gboolean accepted = sipe_backend_media_accepted(call->backend_private);
+
+	gchar *title = g_strdup_printf("Call with %s failed", call_private->with);
+	sipe_backend_notify_error(title, message);
+	g_free(title);
+
+	if (!initiator && !accepted) {
+		sip_transport_response(call_private->sipe_private,
+				 call_private->invitation,
+				 488, "Not Acceptable Here", NULL);
+	}
+
+	sipe_backend_media_hangup(call->backend_private, initiator || accepted);
 }
 
 static struct sipe_media_call_private *
 sipe_media_call_new(struct sipe_core_private *sipe_private,
-		 const gchar* with, gboolean initiator)
+		 const gchar* with, gboolean initiator, SipeIceVersion ice_version)
 {
 	struct sipe_media_call_private *call_private = g_new0(struct sipe_media_call_private, 1);
+	gchar *cname;
 
 	call_private->sipe_private = sipe_private;
+
+	cname = g_strdup(sipe_private->contact + 1);
+	cname[strlen(cname) - 1] = '\0';
+
 	call_private->public.backend_private = sipe_backend_media_new(SIPE_CORE_PUBLIC,
 								 SIPE_MEDIA_CALL,
 								 with,
 								 initiator);
+	sipe_backend_media_set_cname(call_private->public.backend_private, cname);
 
-	call_private->legacy_mode = FALSE;
-	call_private->using_nice = TRUE;
+	call_private->ice_version = ice_version;
 	call_private->encryption_compatible = TRUE;
 
 	call_private->public.candidates_prepared_cb = candidates_prepared_cb;
-	call_private->public.media_connected_cb = media_connected_cb;
+	call_private->public.media_end_cb = media_end_cb;
 	call_private->public.call_accept_cb = call_accept_cb;
 	call_private->public.call_reject_cb = call_reject_cb;
 	call_private->public.call_hold_cb = call_hold_cb;
 	call_private->public.call_hangup_cb = call_hangup_cb;
+	call_private->public.error_cb = error_cb;
+
+	g_free(cname);
 
 	return call_private;
 }
 
-void sipe_media_hangup(struct sipe_core_private *sipe_private)
+void sipe_media_hangup(struct sipe_media_call_private *call_private)
 {
-	struct sipe_media_call_private *call_private = sipe_private->media_call;
-	if (call_private)
+	if (call_private) {
 		sipe_backend_media_hangup(call_private->public.backend_private,
 					 FALSE);
 }
+}
 
-void
-sipe_core_media_initiate_call(struct sipe_core_public *sipe_public,
-			 const char *with,
+static void
+sipe_media_initiate_call(struct sipe_core_private *sipe_private,
+			 const char *with, SipeIceVersion ice_version,
 			 gboolean with_video)
 {
-	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 	struct sipe_media_call_private *call_private;
 	struct sipe_backend_media *backend_media;
+	struct sipe_backend_media_relays *backend_media_relays;
 	struct sip_session *session;
 	struct sip_dialog *dialog;
 
 	if (sipe_private->media_call)
 		return;
 
-	call_private = sipe_media_call_new(sipe_private, with, TRUE);
+	call_private = sipe_media_call_new(sipe_private, with, TRUE, ice_version);
 
 	session = sipe_session_add_call(sipe_private, with);
 	dialog = sipe_dialog_add(session);
@@ -621,36 +709,117 @@
 
 	backend_media = call_private->public.backend_private;
 
+	backend_media_relays =
+		sipe_backend_media_relays_convert(sipe_private->media_relays,
+						 sipe_private->media_relay_username,
+						 sipe_private->media_relay_password);
+
 	if (!sipe_backend_media_add_stream(backend_media,
 					 "audio", with, SIPE_MEDIA_AUDIO,
-					 call_private->using_nice, TRUE)) {
+					 call_private->ice_version, TRUE,
+					 backend_media_relays)) {
 		sipe_backend_notify_error(_("Error occured"),
 					 _("Error creating audio stream"));
 		sipe_media_call_free(call_private);
+		sipe_backend_media_relays_free(backend_media_relays);
 		return;
 	}
 
 	if ( with_video
 	 && !sipe_backend_media_add_stream(backend_media,
 			 	 	 "video", with, SIPE_MEDIA_VIDEO,
-			 	 	 call_private->using_nice, TRUE)) {
+			 	 	 call_private->ice_version, TRUE,
+			 	 	 backend_media_relays)) {
 		sipe_backend_notify_error(_("Error occured"),
 					 _("Error creating video stream"));
 		sipe_media_call_free(call_private);
+		sipe_backend_media_relays_free(backend_media_relays);
 		return;
 	}
 
 	sipe_private->media_call = call_private;
 
+	sipe_backend_media_relays_free(backend_media_relays);
+
+	// Processing continues in candidates_prepared_cb
+}
+
+void
+sipe_core_media_initiate_call(struct sipe_core_public *sipe_public,
+			 const char *with,
+			 gboolean with_video)
+{
+	sipe_media_initiate_call(SIPE_CORE_PRIVATE, with,
+				 SIPE_ICE_RFC_5245, with_video);
+}
+
+void sipe_core_media_connect_conference(struct sipe_core_public *sipe_public,
+					struct sipe_chat_session *chat_session)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+	struct sipe_backend_media_relays *backend_media_relays;
+	struct sip_session *session;
+	struct sip_dialog *dialog;
+	gchar **parts;
+	gchar *av_uri;
+
+	if (sipe_private->media_call)
+		return;
+
+	parts = g_strsplit(chat_session->id, "app:conf:focus:", 2);
+	av_uri = g_strjoinv("app:conf:audio-video:", parts);
+	g_strfreev(parts);
+
+	sipe_private->media_call = sipe_media_call_new(sipe_private, av_uri,
+						 TRUE, SIPE_ICE_DRAFT_6);
+
+	session = sipe_session_add_call(sipe_private, av_uri);
+	dialog = sipe_dialog_add(session);
+	dialog->callid = gencallid();
+	dialog->with = g_strdup(session->with);
+	dialog->ourtag = gentag();
+
+	g_free(av_uri);
+
+	sipe_private->media_call->with = g_strdup(session->with);
+	sipe_private->media_call->ice_version = SIPE_ICE_DRAFT_6;
+
+	backend_media_relays =
+		sipe_backend_media_relays_convert(sipe_private->media_relays,
+						 sipe_private->media_relay_username,
+						 sipe_private->media_relay_password);
+
+	if (!sipe_backend_media_add_stream(sipe_private->media_call->public.backend_private,
+					 "audio", dialog->with,
+					 SIPE_MEDIA_AUDIO,
+					 SIPE_ICE_DRAFT_6, TRUE,
+					 backend_media_relays)) {
+		sipe_backend_notify_error(_("Error occured"),
+					 _("Error creating audio stream"));
+		sipe_media_call_free(sipe_private->media_call);
+		sipe_private->media_call = NULL;
+	}
+
+	sipe_backend_media_relays_free(backend_media_relays);
+
 	// Processing continues in candidates_prepared_cb
 }
 
+gboolean sipe_core_media_in_call(struct sipe_core_public *sipe_public)
+{
+	if (sipe_public) {
+		return SIPE_CORE_PRIVATE->media_call != NULL;
+	}
+	return FALSE;
+}
+
 void
 process_incoming_invite_call(struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg)
 {
 	struct sipe_media_call_private *call_private = sipe_private->media_call;
 	struct sipe_backend_media *backend_media;
+	struct sipe_backend_media_relays *backend_media_relays = NULL;
 	struct sdpmsg *smsg;
 	gboolean has_new_media = FALSE;
 	GSList *i;
@@ -664,18 +833,17 @@
 	if (!smsg) {
 		sip_transport_response(sipe_private, msg,
 				 488, "Not Acceptable Here", NULL);
-		sipe_media_hangup(sipe_private);
+		sipe_media_hangup(call_private);
 		return;
 	}
 
 	if (!call_private) {
 		gchar *with = parse_from(sipmsg_find_header(msg, "From"));
 		struct sip_session *session;
-		struct sip_dialog *dialog;
 
-		call_private = sipe_media_call_new(sipe_private, with, FALSE);
+		call_private = sipe_media_call_new(sipe_private, with, FALSE, smsg->ice_version);
 		session = sipe_session_add_call(sipe_private, with);
-		dialog = sipe_media_dialog_init(session, msg);
+		sipe_media_dialog_init(session, msg);
 
 		call_private->with = g_strdup(session->with);
 		sipe_private->media_call = call_private;
@@ -688,6 +856,12 @@
 		sipmsg_free(call_private->invitation);
 	call_private->invitation = sipmsg_copy(msg);
 
+	if (smsg->media)
+		backend_media_relays = sipe_backend_media_relays_convert(
+						sipe_private->media_relays,
+						sipe_private->media_relay_username,
+						sipe_private->media_relay_password);
+
 	// Create any new media streams
 	for (i = smsg->media; i; i = i->next) {
 		struct sdpmedia *media = i->data;
@@ -708,20 +882,26 @@
 			with = parse_from(sipmsg_find_header(msg, "From"));
 			sipe_backend_media_add_stream(backend_media, id, with,
 						 type,
-						 !call_private->legacy_mode,
-						 FALSE);
+						 smsg->ice_version,
+						 FALSE,
+						 backend_media_relays);
 			has_new_media = TRUE;
 			g_free(with);
 		}
 	}
 
+	sipe_backend_media_relays_free(backend_media_relays);
+
 	if (has_new_media) {
+		sdpmsg_free(call_private->smsg);
 		call_private->smsg = smsg;
 		sip_transport_response(sipe_private, call_private->invitation,
 				 180, "Ringing", NULL);
 		// Processing continues in candidates_prepared_cb
 	} else {
-		do_apply_remote_message(call_private, smsg);
+		apply_remote_message(call_private, smsg);
+		send_response_with_session_description(call_private, 200, "OK");
+
 		sdpmsg_free(smsg);
 	}
 }
@@ -740,20 +920,22 @@
 				 487, "Request Terminated", NULL);
 	}
 
-	sipe_media_hangup(sipe_private);
+	sipe_media_hangup(call_private);
 }
 
 static gboolean
 sipe_media_send_ack(struct sipe_core_private *sipe_private,
-					SIPE_UNUSED_PARAMETER struct sipmsg *msg,
+		 struct sipmsg *msg,
 					struct transaction *trans)
 {
 	struct sipe_media_call_private *call_private = sipe_private->media_call;
 	struct sip_session *session;
 	struct sip_dialog *dialog;
-	int trans_cseq;
 	int tmp_cseq;
 
+	if (!is_media_session_msg(call_private, msg))
+		return FALSE;
+
 	session = sipe_session_find_call(sipe_private, call_private->with);
 	dialog = session->dialogs->data;
 	if (!dialog)
@@ -761,8 +943,7 @@
 
 	tmp_cseq = dialog->cseq;
 
-	sscanf(trans->key, "<%*[a-zA-Z0-9]><%d INVITE>", &trans_cseq);
-	dialog->cseq = trans_cseq - 1;
+	dialog->cseq = sip_transaction_cseq(trans) - 1;
 	sip_transport_ack(sipe_private, dialog);
 	dialog->cseq = tmp_cseq;
 
@@ -773,16 +954,54 @@
 
 static gboolean
 sipe_media_send_final_ack(struct sipe_core_private *sipe_private,
-			 SIPE_UNUSED_PARAMETER struct sipmsg *msg,
+			 struct sipmsg *msg,
 			 struct transaction *trans)
 {
-	sipe_media_send_ack(sipe_private, msg, trans);
+	if (!sipe_media_send_ack(sipe_private, msg, trans))
+		return FALSE;
+
 	sipe_backend_media_accept(sipe_private->media_call->public.backend_private,
 				 FALSE);
 
 	return TRUE;
 }
 
+static void
+reinvite_on_candidate_pair_cb(struct sipe_core_public *sipe_public)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+	struct sipe_media_call_private *media_call = sipe_private->media_call;
+	struct sipe_backend_media *backend_media;
+	GSList *streams;
+
+	if (!media_call)
+		return;
+
+	backend_media = media_call->public.backend_private;
+	streams = sipe_backend_media_get_streams(backend_media);
+
+	for (; streams; streams = streams->next) {
+		struct sipe_backend_stream *s = streams->data;
+		GList *remote_candidates = sipe_backend_media_get_active_remote_candidates(backend_media, s);
+		guint components = g_list_length(remote_candidates);
+
+		sipe_media_candidate_list_free(remote_candidates);
+
+		// We must have candidates for both (RTP + RTCP) components ready
+		if (components < 2) {
+			sipe_schedule_mseconds(sipe_private,
+					 "<+media-reinvite-on-candidate-pair>",
+					 NULL,
+					 500,
+					 (sipe_schedule_action) reinvite_on_candidate_pair_cb,
+					 NULL);
+			return;
+		}
+	}
+
+	sipe_invite_call(sipe_private, sipe_media_send_final_ack);
+}
+
 static gboolean
 process_invite_call_response(struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg,
@@ -814,10 +1033,9 @@
 
 		switch (msg->response) {
 			case 480: {
-				const gchar *warn = sipmsg_find_header(msg, "Warning");
 				title = _("User unavailable");
 
-				if (warn && g_str_has_prefix(warn, "391 lcs.microsoft.com")) {
+				if (sipmsg_parse_warning(msg, NULL) == 391) {
 					g_string_append_printf(desc, _("%s does not want to be disturbed"), with);
 				} else
 					g_string_append_printf(desc, _("User %s is not available"), with);
@@ -828,6 +1046,21 @@
 				title = _("Call rejected");
 				g_string_append_printf(desc, _("User %s rejected call"), with);
 				break;
+			case 488:
+				if (call_private->ice_version == SIPE_ICE_RFC_5245 &&
+				 sip_transaction_cseq(trans) == 1) {
+					gchar *with = g_strdup(call_private->with);
+					gboolean with_video = sipe_backend_media_get_stream_by_id(backend_private, "video") != NULL;
+
+					sipe_media_hangup(call_private);
+					// We might be calling to OC 2007 instance, retry with ICEv6
+					sipe_media_initiate_call(sipe_private, with,
+								 SIPE_ICE_DRAFT_6, with_video);
+
+					g_free(with);
+					return TRUE;
+				}
+				// Break intentionally omitted
 			default:
 				title = _("Error occured");
 				g_string_append(desc, _("Unable to establish a call"));
@@ -843,7 +1076,7 @@
 		g_string_free(desc, TRUE);
 
 		sipe_media_send_ack(sipe_private, msg, trans);
-		sipe_media_hangup(sipe_private);
+		sipe_media_hangup(call_private);
 
 		return TRUE;
 	}
@@ -853,15 +1086,13 @@
 	if (!smsg) {
 		sip_transport_response(sipe_private, msg,
 				 488, "Not Acceptable Here", NULL);
-		sipe_media_hangup(sipe_private);
+		sipe_media_hangup(call_private);
 		return FALSE;
 	}
 
-	if (!apply_remote_message(call_private, smsg)) {
-		sip_transport_response(sipe_private, msg,
-				 487, "Request Terminated", NULL);
-		sipe_media_hangup(sipe_private);
-	} else if (msg->response == 183) {
+	apply_remote_message(call_private, smsg);
+
+	if (msg->response == 183) {
 		// Session in progress
 		const gchar *rseq = sipmsg_find_header(msg, "RSeq");
 		const gchar *cseq = sipmsg_find_header(msg, "CSeq");
@@ -877,33 +1108,7 @@
 		g_free(rack);
 	} else {
 		sipe_media_send_ack(sipe_private, msg, trans);
-
-		if (call_private->legacy_mode && call_private->using_nice) {
-			// TODO: legacy
-/*			// We created non-legacy stream as we don't know which version of
-			// client is on the other side until first SDP response is received.
-			// This client requires legacy mode, so we must remove current session
-			// (using ICE) and create new using raw UDP transport.
-			struct sipe_backend_stream *new_stream;
-
-			call_private->using_nice = FALSE;
-
-			new_stream = sipe_backend_media_add_stream(backend_private,
-								 with,
-								 SIPE_MEDIA_AUDIO,
-								 FALSE,
-								 TRUE);
-
-			sipe_backend_media_remove_stream(backend_private,
-							 call_private->voice_stream);
-			call_private->voice_stream = new_stream;
-
-			apply_remote_message(call_private, smsg);
-
-			// New INVITE will be sent in candidates_prepared_cb */
-		} else {
-			sipe_invite_call(sipe_private, sipe_media_send_final_ack);
-		}
+		reinvite_on_candidate_pair_cb(SIPE_CORE_PUBLIC);
 	}
 
 	sdpmsg_free(smsg);
@@ -948,7 +1153,154 @@
 			sipe_session_close(call_private->sipe_private, session);
 	}
 
-	sipe_media_hangup(call_private->sipe_private);
+	sipe_media_hangup(call_private);
+}
+
+static void
+sipe_media_relay_free(struct sipe_media_relay *relay)
+{
+	g_free(relay->hostname);
+	if (relay->dns_query)
+		sipe_backend_dns_query_cancel(relay->dns_query);
+	g_free(relay);
+}
+
+void
+sipe_media_relay_list_free(GSList *list)
+{
+	for (; list; list = g_slist_delete_link(list, list))
+		sipe_media_relay_free(list->data);
+}
+
+static void
+relay_ip_resolved_cb(struct sipe_media_relay* relay,
+		 const gchar *ip, SIPE_UNUSED_PARAMETER guint port)
+{
+	gchar *hostname = relay->hostname;
+	relay->dns_query = NULL;
+
+	if (ip && port) {
+		relay->hostname = g_strdup(ip);
+		SIPE_DEBUG_INFO("Media relay %s resolved to %s.", hostname, ip);
+	} else {
+		relay->hostname = NULL;
+		SIPE_DEBUG_INFO("Unable to resolve media relay %s.", hostname);
+	}
+
+	g_free(hostname);
+}
+
+static gboolean
+process_get_av_edge_credentials_response(struct sipe_core_private *sipe_private,
+					 struct sipmsg *msg,
+					 SIPE_UNUSED_PARAMETER struct transaction *trans)
+{
+	g_free(sipe_private->media_relay_username);
+	g_free(sipe_private->media_relay_password);
+	sipe_media_relay_list_free(sipe_private->media_relays);
+	sipe_private->media_relay_username = NULL;
+	sipe_private->media_relay_password = NULL;
+	sipe_private->media_relays = NULL;
+
+	if (msg->response >= 400) {
+		SIPE_DEBUG_INFO_NOFORMAT("process_get_av_edge_credentials_response: SERVICE response is not 200. "
+					 "Failed to obtain A/V Edge credentials.");
+		return FALSE;
+	}
+
+	if (msg->response == 200) {
+		sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
+
+		if (sipe_strequal("OK", sipe_xml_attribute(xn_response, "reasonPhrase"))) {
+			const sipe_xml *xn_credentials = sipe_xml_child(xn_response, "credentialsResponse/credentials");
+			const sipe_xml *xn_relays = sipe_xml_child(xn_response, "credentialsResponse/mediaRelayList");
+			const sipe_xml *item;
+			GSList *relays = NULL;
+
+			item = sipe_xml_child(xn_credentials, "username");
+			sipe_private->media_relay_username = g_strdup(sipe_xml_data(item));
+			item = sipe_xml_child(xn_credentials, "password");
+			sipe_private->media_relay_password = g_strdup(sipe_xml_data(item));
+
+			for (item = sipe_xml_child(xn_relays, "mediaRelay"); item; item = sipe_xml_twin(item)) {
+				struct sipe_media_relay *relay = g_new0(struct sipe_media_relay, 1);
+				const sipe_xml *node;
+
+				node = sipe_xml_child(item, "hostName");
+				relay->hostname = g_strdup(sipe_xml_data(node));
+
+				node = sipe_xml_child(item, "udpPort");
+				relay->udp_port = atoi(sipe_xml_data(node));
+
+				node = sipe_xml_child(item, "tcpPort");
+				relay->tcp_port = atoi(sipe_xml_data(node));
+
+				relays = g_slist_append(relays, relay);
+
+				relay->dns_query = sipe_backend_dns_query_a(
+							relay->hostname,
+							relay->udp_port,
+							(sipe_dns_resolved_cb) relay_ip_resolved_cb,
+							relay);
+
+				SIPE_DEBUG_INFO("Media relay: %s TCP: %d UDP: %d",
+						relay->hostname,
+						relay->tcp_port, relay->udp_port);
+			}
+
+			sipe_private->media_relays = relays;
+		}
+
+		sipe_xml_free(xn_response);
+	}
+
+	return TRUE;
+}
+
+void
+sipe_media_get_av_edge_credentials(struct sipe_core_private *sipe_private)
+{
+	// TODO: re-request credentials after duration expires?
+	const char CRED_REQUEST_XML[] =
+		"<request requestID=\"%d\" "
+		 "from=\"%s\" "
+			 "version=\"1.0\" "
+			 "to=\"%s\" "
+			 "xmlns=\"http://schemas.microsoft.com/2006/09/sip/mrasp\" "
+			 "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
+			"<credentialsRequest credentialsRequestID=\"%d\">"
+				"<identity>%s</identity>"
+				"<location>%s</location>"
+				"<duration>480</duration>"
+			"</credentialsRequest>"
+		"</request>";
+
+	int request_id = rand();
+	gchar *self;
+	gchar *body;
+
+	if (!sipe_private->mras_uri)
+		return;
+
+	self = sip_uri_self(sipe_private);
+
+	body = g_strdup_printf(
+		CRED_REQUEST_XML,
+		request_id,
+		self,
+		sipe_private->mras_uri,
+		request_id,
+		self,
+		SIPE_CORE_PRIVATE_FLAG_IS(REMOTE_USER) ? "internet" : "intranet");
+	g_free(self);
+
+	sip_transport_service(sipe_private,
+			 sipe_private->mras_uri,
+			 "Content-Type: application/msrtc-media-relay-auth+xml\r\n",
+			 body,
+			 process_get_av_edge_credentials_response);
+
+	g_free(body);
 }
 
 /*
--- pidgin-sipe-1.11.2/src/core/sipe-media.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-media.h	2011-06-14 14:40:36.000000000 +0200
@@ -46,9 +46,9 @@
 /**
 * Hangs up a media session and closes all allocated resources.
 *
- * @param sipe_private (in) SIPE core data.
+ * @param sipe_private (in) media call data.
 */
-void sipe_media_hangup(struct sipe_core_private *sipe_private);
+void sipe_media_hangup(struct sipe_media_call_private *call_private);
 
 /**
 * Call before SIP account logs of the server. Function hangs up the call and
@@ -71,3 +71,20 @@
 */
 gboolean is_media_session_msg(struct sipe_media_call_private *call_private,
 			 struct sipmsg *msg);
+
+/**
+ * Sends a request to mras URI for the credentials to the A/V edge server.
+ * Given @c sipe_core_private must have non-NULL mras_uri. When the valid
+ * response is received, media_relay_username, media_relay_password and
+ * media_relays attributes of the sipe core are filled.
+ *
+ * @param sipe_private (in) SIPE core data.
+ */
+void sipe_media_get_av_edge_credentials(struct sipe_core_private *sipe_private);
+
+/**
+ * Deallocates the opaque list of media relay structures
+ *
+ * @param list (in) GSList to free
+ */
+void sipe_media_relay_list_free(GSList *list);
--- pidgin-sipe-1.11.2/src/core/sipe-mime.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-mime.c	2011-06-14 14:40:36.000000000 +0200
@@ -22,10 +22,11 @@
 
 #include <string.h>
 
+#include "sipe-common.h"
+
 #include <glib.h>
 #include <gmime/gmime.h>
 
-#include "sipe-common.h"
 #include "sipe-mime.h"
 
 #include "sipe-backend.h"
--- pidgin-sipe-1.11.2/src/core/sipe-schedule.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-schedule.c	2011-06-14 14:40:36.000000000 +0200
@@ -53,7 +53,7 @@
 	struct sipe_schedule *expired = data;
 	struct sipe_core_private *sipe_private = expired->sipe_private;
 
-	SIPE_DEBUG_INFO_NOFORMAT("sipe_core_schedule_execute: executing");
+	SIPE_DEBUG_INFO("sipe_core_schedule_execute: executing %s", expired->name);
 	sipe_private->timeouts = g_slist_remove(sipe_private->timeouts, expired);
 	SIPE_DEBUG_INFO("sipe_core_schedule_execute timeouts count %d after removal",
 			g_slist_length(sipe_private->timeouts));
--- pidgin-sipe-1.11.2/src/core/sipe-session.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-session.c	2011-06-14 14:40:36.000000000 +0200
@@ -33,6 +32,7 @@
 
 #include "sip-transport.h"
 #include "sipe-backend.h"
+#include "sipe-chat.h"
 #include "sipe-conf.h"
 #include "sipe-core.h"
 #include "sipe-core-private.h"
@@ -49,12 +49,24 @@
 }
 
 struct sip_session *
-sipe_session_add_chat(struct sipe_core_private *sipe_private)
+sipe_session_add_chat(struct sipe_core_private *sipe_private,
+		 struct sipe_chat_session *chat_session,
+		 gboolean multiparty,
+		 const gchar *id)
 {
 	struct sip_session *session = g_new0(struct sip_session, 1);
 	session->callid = gencallid();
-	session->is_multiparty = TRUE;
-	session->chat_id = rand();
+	if (chat_session) {
+		session->chat_session = chat_session;
+	} else {
+		gchar *chat_title = sipe_chat_get_name();
+		session->chat_session = sipe_chat_create_session(multiparty ?
+								 SIPE_CHAT_TYPE_MULTIPARTY :
+								 SIPE_CHAT_TYPE_CONFERENCE,
+								 id,
+								 chat_title);
+		g_free(chat_title);
+	}
 	session->unconfirmed_messages = g_hash_table_new_full(
 		g_str_hash, g_str_equal, g_free, (GDestroyNotify)sipe_free_queued_message);
 	session->conf_unconfirmed_messages = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
@@ -70,7 +82,6 @@
 {
 	struct sip_session *session = g_new0(struct sip_session, 1);
 	SIPE_DEBUG_INFO("sipe_session_add_call: new session for %s", who);
-	session->is_multiparty = FALSE;
 	session->with = g_strdup(who);
 	session->unconfirmed_messages = g_hash_table_new_full(
 		g_str_hash, g_str_equal, g_free, (GDestroyNotify)sipe_free_queued_message);
@@ -99,63 +110,33 @@
 #endif
 
 struct sip_session *
-sipe_session_find_or_add_chat_by_callid(struct sipe_core_private *sipe_private,
-					const gchar *callid)
-{
-	struct sip_session *session = sipe_session_find_chat_by_callid(sipe_private,
-								 callid);
-	if (!session) {
-		SIPE_DEBUG_INFO("sipe_session_find_or_add_chat_by_callid: new session for %s", callid);
-		session = sipe_session_add_chat(sipe_private);
-		session->callid = g_strdup(callid);
-	}
-	return session;
-}
-
-struct sip_session *
-sipe_session_find_chat_by_callid(struct sipe_core_private *sipe_private,
-				 const gchar *callid)
+sipe_session_find_chat(struct sipe_core_private *sipe_private,
+		 struct sipe_chat_session *chat_session)
 {
-	if (sipe_private == NULL || callid == NULL) {
+	if (sipe_private == NULL || chat_session == NULL) {
 		return NULL;
 	}
 
 	SIPE_SESSION_FOREACH {
-		if (session->callid &&
-		 sipe_strcase_equal(callid, session->callid)) {
+		if (session->chat_session == chat_session) {
 			return session;
 		}
 	} SIPE_SESSION_FOREACH_END;
 	return NULL;
-}
-
-struct sip_session *
-sipe_session_find_chat_by_id(struct sipe_core_private *sipe_private,
-			 int id)
-{
-	if (sipe_private == NULL) {
-		return NULL;
-	}
 
-	SIPE_SESSION_FOREACH {
-		if (id == session->chat_id) {
-			return session;
-		}
-	} SIPE_SESSION_FOREACH_END;
-	return NULL;
 }
 
 struct sip_session *
-sipe_session_find_chat_by_title(struct sipe_core_private *sipe_private,
-			 const gchar *name)
+sipe_session_find_chat_by_callid(struct sipe_core_private *sipe_private,
+				 const gchar *callid)
 {
-	if (sipe_private == NULL || name == NULL) {
+	if (sipe_private == NULL || callid == NULL) {
 		return NULL;
 	}
 
 	SIPE_SESSION_FOREACH {
-		if (session->chat_title &&
-		 !g_strcasecmp(name, session->chat_title)) {
+		if (session->callid &&
+		 sipe_strcase_equal(callid, session->callid)) {
 			return session;
 		}
 	} SIPE_SESSION_FOREACH_END;
@@ -171,8 +152,9 @@
 	}
 
 	SIPE_SESSION_FOREACH {
-		if (session->focus_uri &&
-		 sipe_strcase_equal(focus_uri, session->focus_uri)) {
+		if (session->chat_session &&
+		 (session->chat_session->type == SIPE_CHAT_TYPE_CONFERENCE) &&
+		 sipe_strcase_equal(focus_uri, session->chat_session->id)) {
 			return session;
 		}
 	} SIPE_SESSION_FOREACH_END;
@@ -188,7 +170,8 @@
 	}
 
 	SIPE_SESSION_FOREACH {
-		if (session->with && sipe_strcase_equal(who, session->with)) {
+		if (!session->is_call &&
+		 session->with && sipe_strcase_equal(who, session->with)) {
 			return session;
 		}
 	} SIPE_SESSION_FOREACH_END;
@@ -203,7 +186,6 @@
 	if (!session) {
 		SIPE_DEBUG_INFO("sipe_session_find_or_add_im: new session for %s", who);
 		session = g_new0(struct sip_session, 1);
-		session->is_multiparty = FALSE;
 		session->with = g_strdup(who);
 		session->unconfirmed_messages = g_hash_table_new_full(
 			g_str_hash, g_str_equal, g_free, (GDestroyNotify)sipe_free_queued_message);
@@ -246,13 +228,11 @@
 	g_slist_free(session->pending_invite_queue);
 
 	g_hash_table_destroy(session->unconfirmed_messages);
+	if (session->conf_unconfirmed_messages)
 	g_hash_table_destroy(session->conf_unconfirmed_messages);
 
 	g_free(session->with);
-	g_free(session->chat_title);
 	g_free(session->callid);
-	g_free(session->roster_manager);
-	g_free(session->focus_uri);
 	g_free(session->im_mcu_uri);
 	g_free(session->subject);
 	g_free(session);
@@ -263,7 +243,8 @@
 		 struct sip_session *session)
 {
 	if (session) {
-		if (session->focus_uri) {
+		if (session->chat_session &&
+		 (session->chat_session->type == SIPE_CHAT_TYPE_CONFERENCE)) {
 			sipe_conf_immcu_closed(sipe_private, session);
 			conf_session_close(sipe_private, session);
 		}
--- pidgin-sipe-1.11.2/src/core/sipe-session.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-session.h	2011-06-14 14:40:36.000000000 +0200
@@ -28,7 +28,7 @@
 
 /* Forward declarations */
 struct sipe_core_private;
-struct sipe_backend_session;
+struct sipe_chat_session;
 
 /* Helper macros to iterate over session list in a SIP account */
 #define SIPE_SESSION_FOREACH { \
@@ -40,10 +40,10 @@
 
 /** Correspond to multi-party conversation */
 struct sip_session {
-	/** backend private data structure for IM or chat */
-	struct sipe_backend_session *backend_session;
+	/** chat session */
+	struct sipe_chat_session *chat_session;
 
-	gchar *with; /* For IM sessions only (not multi-party) . A URI.*/
+	gchar *with; /* For IM or call sessions only (not multi-party) . A URI.*/
 	/** key is user (URI) */
 	GSList *dialogs;
 	/** Key is <Call-ID><CSeq><METHOD><To> */
@@ -53,17 +53,8 @@
 	/*
 	 * Multiparty conversation related fields
 	 */
-	gboolean is_multiparty;
-	/** purple chat id */
-	int chat_id;
-	/** purple indexes chats by names */
-	//gchar *chat_name;
-	/** Human readable chat name */
-	gchar *chat_title;
 	/** Call-Id identifying the conversation */
 	gchar *callid; /* For multiparty conversations */
-	/** Roster Manager URI */
-	gchar *roster_manager;
 	int bid;
 	gboolean is_voting_in_progress;
 	GSList *pending_invite_queue;
@@ -71,7 +62,6 @@
 	/*
 	 * Conference related fields
 	 */
-	gchar *focus_uri;
 	gchar *im_mcu_uri;
 	gchar *subject;
 	gboolean locked;
@@ -84,6 +74,11 @@
 	 * Media call related fields
 	 */
 	gboolean is_call;
+
+	/*
+	 * Group Chat related fields
+	 */
+	gboolean is_groupchat;
 };
 
 /**
@@ -101,17 +96,24 @@
 	 * means default value text/plain.
 	 */
 	gchar *content_type;
+	guint cseq;
 };
 
 /**
 * Add a new chat session
 *
 * @param sipe_private (in) SIPE core data. May be NULL
+ * @param chat_session (in) non-NULL to rejoin existing chat
+ * @param multiparty (in) multiparty or conference
+ * @param id (in) new chat session identifier (ignored for rejoin).
 *
 * @return pointer to new session
 */
 struct sip_session *
-sipe_session_add_chat(struct sipe_core_private *sipe_private);
+sipe_session_add_chat(struct sipe_core_private *sipe_private,
+		 struct sipe_chat_session *chat_session,
+		 gboolean multiparty,
+		 const gchar *id);
 
 #ifdef HAVE_VV
 
@@ -142,52 +144,28 @@
 #endif
 
 /**
- * Find chat session by Call ID
- *
- * @param sipe_private (in) SIPE core data. May be NULL
- * @param callid (in) Call ID. May be NULL
- *
- * @return pointer to session or NULL
- */
-struct sip_session *
-sipe_session_find_chat_by_callid(struct sipe_core_private *sipe_private,
-				 const gchar *callid);
-
-/**
- * Find or add new chat session by Call ID
- *
- * @param sipe_private (in) SIPE core data
- * @param callid (in) Call ID
- *
- * @return pointer to session
- */
-struct sip_session *
-sipe_session_find_or_add_chat_by_callid(struct sipe_core_private *sipe_private,
-					const gchar *callid);
-
-/**
- * Find chat session by ID
+ * Find chat session
 *
 * @param sipe_private (in) SIPE core data. May be NULL
- * @param id (in) Chat ID
+ * @param chat_session (in) chat session data. May be NULL
 *
 * @return pointer to session or NULL
 */
 struct sip_session * 
-sipe_session_find_chat_by_id(struct sipe_core_private *sipe_private,
-			 int id);
+sipe_session_find_chat(struct sipe_core_private *sipe_private,
+		 struct sipe_chat_session *chat_session);
 
 /**
- * Find chat session by name
+ * Find chat session by Call ID
 *
 * @param sipe_private (in) SIPE core data. May be NULL
- * @param name (in) Chat name. May be NULL
+ * @param callid (in) Call ID. May be NULL
 *
 * @return pointer to session or NULL
 */
 struct sip_session * 
-sipe_session_find_chat_by_title(struct sipe_core_private *sipe_private,
-			 const gchar *name);
+sipe_session_find_chat_by_callid(struct sipe_core_private *sipe_private,
+				 const gchar *callid);
 
 /**
 * Find Conference session
--- pidgin-sipe-1.11.2/src/core/sipe-subscriptions.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-subscriptions.c	2011-06-14 14:40:36.000000000 +0200
@@ -129,18 +129,14 @@
 	}
 
 	/* create/store subscription dialog if not yet */
-	if (msg->response == 200) {
-		const gchar *callid = sipmsg_find_header(msg, "Call-ID");
-		gchar *cseq = sipmsg_find_part_of_header(sipmsg_find_header(msg, "CSeq"), NULL, " ", NULL);
-
-		if (key) {
+	if (key && (msg->response == 200)) {
 			struct sip_subscription *subscription = g_new0(struct sip_subscription, 1);
 			g_hash_table_insert(sipe_private->subscriptions,
 					 g_strdup(key),
 					 subscription);
 
-			subscription->dialog.callid = g_strdup(callid);
-			subscription->dialog.cseq = atoi(cseq);
+		subscription->dialog.callid = g_strdup(sipmsg_find_header(msg, "Call-ID"));
+		subscription->dialog.cseq = sipmsg_parse_cseq(msg);
 			subscription->dialog.with = g_strdup(with);
 			subscription->event = g_strdup(event);
 			sipe_dialog_parse(&subscription->dialog, msg, TRUE);
@@ -148,9 +144,6 @@
 			SIPE_DEBUG_INFO("process_subscribe_response: subscription dialog added for: %s", key);
 		}
 
-		g_free(cseq);
-	}
-
 	g_free(key);
 	g_free(with);
 
--- pidgin-sipe-1.11.2/src/core/sipe-user.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-user.c	2011-06-14 14:40:36.000000000 +0200
@@ -22,11 +22,96 @@
 
 #include <glib.h>
 
+#include "sipe-common.h"
+#include "sipmsg.h"
 #include "sip-transport.h"
+#include "sipe-backend.h"
+#include "sipe-chat.h"
 #include "sipe-core.h"
 #include "sipe-core-private.h"
 #include "sipe-dialog.h"
+#include "sipe-im.h"
+#include "sipe-nls.h"
 #include "sipe-session.h"
+#include "sipe-user.h"
+#include "sipe-utils.h"
+
+void sipe_user_present_info(struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 const gchar *message)
+{
+	sipe_backend_notify_message_info(SIPE_CORE_PUBLIC,
+					 session->chat_session ? session->chat_session->backend : NULL,
+					 session->with,
+					 message);
+}
+
+void sipe_user_present_error(struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 const gchar *message)
+{
+	sipe_backend_notify_message_error(SIPE_CORE_PUBLIC,
+					 session->chat_session ? session->chat_session->backend : NULL,
+					 session->with,
+					 message);
+}
+
+void sipe_user_present_message_undelivered(struct sipe_core_private *sipe_private,
+					 struct sip_session *session,
+					 int sip_error,
+					 int sip_warning,
+					 const gchar *who,
+					 const gchar *message)
+{
+	char *msg, *msg_tmp, *msg_tmp2;
+	const char *label;
+
+	msg_tmp = message ? sipe_backend_markup_strip_html(message) : NULL;
+	msg = msg_tmp ? g_strdup_printf("%s", msg_tmp) : NULL;
+	g_free(msg_tmp);
+	/* Service unavailable; Server Internal Error; Server Time-out */
+	if (sip_error == 606 && sip_warning == 309) { /* Not acceptable all. */ /* Message contents not allowed by policy */
+		label = _("Your message or invitation was not delivered, possibly because it contains a hyperlink or other content that the system administrator has blocked.");
+		g_free(msg);
+		msg = NULL;
+	} else if (sip_error == 500 || sip_error == 503 || sip_error == 504 || sip_error == 603) {
+		label = _("This message was not delivered to %s because the service is not available");
+	} else if (sip_error == 486) { /* Busy Here */
+		label = _("This message was not delivered to %s because one or more recipients do not want to be disturbed");
+	} else if (sip_error == 415) { /* Unsupported media type */
+		label = _("This message was not delivered to %s because one or more recipients don't support this type of message");
+	} else {
+		label = _("This message was not delivered to %s because one or more recipients are offline");
+	}
+
+	msg_tmp = g_strdup_printf( "%s%s\n%s" ,
+			msg_tmp2 = g_strdup_printf(label, who ? who : ""),
+			msg ? ":" : "",
+			msg ? msg : "");
+	sipe_user_present_error(sipe_private, session, msg_tmp);
+	g_free(msg_tmp2);
+	g_free(msg_tmp);
+	g_free(msg);
+}
+
+static gboolean process_info_typing_response(struct sipe_core_private *sipe_private,
+					 struct sipmsg *msg,
+					 SIPE_UNUSED_PARAMETER struct transaction *trans)
+{
+	/* Indicates dangling IM session which needs to be dropped */
+	if (msg->response == 408 || /* Request timeout */
+	 msg->response == 480 || /* Temporarily Unavailable */
+	 msg->response == 481) { /* Call/Transaction Does Not Exist */
+		gchar *with = parse_from(sipmsg_find_header(msg, "To"));
+		struct sip_session *session = sipe_session_find_im(sipe_private, with);
+		struct sip_dialog *dialog = sipe_dialog_find(session, with);
+		if (dialog)
+			sipe_im_cancel_dangling(sipe_private, session, dialog, with,
+						sipe_im_cancel_unconfirmed);
+		g_free(with);
+	}	
+	return(TRUE);
+}
 
 void sipe_core_user_feedback_typing(struct sipe_core_public *sipe_public,
 				 const gchar *to)
@@ -43,10 +128,55 @@
 				 "<status status=\"type\" />"
 				 "</KeyboardActivity>",
 				 dialog,
-				 NULL);
+				 process_info_typing_response);
 	}
 }
 
+struct sipe_user_ask_ctx {
+	struct sipe_core_private *sipe_private;
+	SipeUserAskCb accept_cb;
+	SipeUserAskCb decline_cb;
+	gpointer data;
+};
+
+struct sipe_user_ask_ctx * sipe_user_ask(struct sipe_core_private *sipe_private,
+					 const gchar *message,
+					 const gchar *accept_label,
+					 SipeUserAskCb accept_cb,
+					 const gchar *decline_label,
+					 SipeUserAskCb decline_cb,
+					 gpointer data)
+{
+	struct sipe_user_ask_ctx *ctx = g_new0(struct sipe_user_ask_ctx, 1);
+	ctx->sipe_private = sipe_private;
+	ctx->accept_cb = accept_cb;
+	ctx->decline_cb = decline_cb;
+	ctx->data = data;
+
+	sipe_backend_user_ask(SIPE_CORE_PUBLIC, message,
+			 accept_label, decline_label,
+			 ctx);
+
+	return ctx;
+}
+
+void sipe_core_user_ask_cb(gpointer context, gboolean accepted)
+{
+	struct sipe_user_ask_ctx *ctx = context;
+
+	if (accepted && ctx->accept_cb)
+		ctx->accept_cb(ctx->sipe_private, ctx->data);
+	else if (ctx->decline_cb)
+		ctx->decline_cb(ctx->sipe_private, ctx->data);
+
+	g_free(ctx);
+}
+
+void sipe_user_close_ask(struct sipe_user_ask_ctx *context)
+{
+	sipe_backend_user_close_ask(context);
+	g_free(context);
+}
 
 /*
 Local Variables:
--- pidgin-sipe-1.11.2/src/core/sipe-user.h	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-user.h	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,98 @@
+/**
+ * @file sipe-user.h
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2011 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* Forward declarations */
+struct sip_session;
+struct sipe_core_private;
+
+/* Opaque ask context structure */
+struct sipe_user_ask_ctx;
+
+/**
+ * Present error message in users session
+ *
+ * @param sipe_private SIPE core private data
+ * @param session session for the conversation
+ * @param message message text
+ */
+void sipe_user_present_error(struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 const gchar *message);
+
+/**
+ * Present info message in users session
+ *
+ * @param sipe_private SIPE core private data
+ * @param session session for the conversation
+ * @param message message text
+ */
+void sipe_user_present_info(struct sipe_core_private *sipe_private,
+			 struct sip_session *session,
+			 const gchar *message);
+
+/**
+ * Present error that his message wasn't delivered in users session
+ *
+ * @param sipe_private SIPE core private data
+ * @param session session for the conversation
+ * @param sip_error SIP error code or -1
+ * @param sip_warning SIP warning code or -1
+ * @param who URI of recipient
+ * @param message message text
+ */
+void sipe_user_present_message_undelivered(struct sipe_core_private *sipe_private,
+					 struct sip_session *session,
+					 int sip_error,
+					 int sip_warning,
+					 const gchar *who,
+					 const gchar *message);
+
+typedef void (* SipeUserAskCb)(struct sipe_core_private *, gpointer data);
+
+/**
+ * Present a query that is to be accepted or declined by the user
+ *
+ * @param sipe_private SIPE core private data
+ * @param message Text of the query to be shown to user
+ * @param accept_label Label to be displayed on UI control that accepts query
+ * @param accept_cb callback function to be invoked when query is accepted
+ * @param decline_label Label to be displayed on UI control that declines query
+ * @param decline_cb callback function to be invoked when query is declined
+ * @param data custom user data
+ *
+ * @return opaque sipe_user_ask_ctx pointer that can be used to close the query
+ * before user answered it.
+ */
+struct sipe_user_ask_ctx * sipe_user_ask(struct sipe_core_private *sipe_private,
+					 const gchar *message,
+					 const gchar *accept_label,
+					 SipeUserAskCb accept_cb,
+					 const gchar *decline_label,
+					 SipeUserAskCb decline_cb,
+					 gpointer data);
+
+/**
+ * Closes the pending user query
+ *
+ * @param context sipe_user_ask_ctx pointer returned by sipe_user_ask()
+ */
+void sipe_user_close_ask(struct sipe_user_ask_ctx *context);
--- pidgin-sipe-1.11.2/src/core/sipe-utils.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-utils.c	2011-06-14 14:40:36.000000000 +0200
@@ -24,26 +24,9 @@
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
-#include <time.h>
 
 #include <glib.h>
 
-#ifdef _WIN32
-/* for network */
-#include "win32/libc_interface.h"
-#include <nspapi.h>
-#else
-#if defined(__APPLE__) || defined(__FreeBSD__)
-#include <sys/socket.h>
-#endif
-#include <unistd.h>
-#include <net/if.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#endif
-
 #include "sipe-backend.h"
 #include "sipe-core.h" /* to ensure same API for backends */
 #include "sipe-core-private.h"
@@ -111,18 +94,6 @@
 	return from;
 }
 
-int parse_cseq(const gchar *hdr)
-{
-	int res = -1;
-	gchar **items;
-	items = g_strsplit(hdr, " ", 1);
-	if (items[0]) {
-		res = atoi(items[0]);
-	}
-	g_strfreev(items);
-	return res;
-}
-
 gchar *sip_uri_from_name(const gchar *name)
 {
 	return(g_strdup_printf("sip:%s", name));
@@ -290,6 +261,19 @@
 	 (left != NULL && right != NULL && g_ascii_strcasecmp(left, right) == 0));
 }
 
+gint sipe_strcompare(gconstpointer a, gconstpointer b)
+{
+#if GLIB_CHECK_VERSION(2,16,0)
+	return (g_strcmp0(a, b));
+#else
+	if (!a)
+		return -(a != b);
+	if (!b)
+		return a != b;
+	return strcmp(a, b);
+#endif	
+}
+
 time_t
 sipe_utils_str_to_time(const gchar *timestamp)
 {
@@ -470,61 +454,11 @@
 	memmove(conn->buffer, unread, conn->buffer_used + 1);
 }
 
-/*
- * Calling sizeof(struct ifreq) isn't always correct on
- * Mac OS X (and maybe others).
- */
-#ifdef _SIZEOF_ADDR_IFREQ
-# define HX_SIZE_OF_IFREQ(a) _SIZEOF_ADDR_IFREQ(a)
-#else
-# define HX_SIZE_OF_IFREQ(a) sizeof(a)
-#endif
-
-const char * sipe_utils_get_suitable_local_ip(int fd)
-{
-	int source = (fd >= 0) ? fd : socket(PF_INET,SOCK_STREAM, 0);
-
-	if (source >= 0) {
-		char buffer[1024];
-		static char ip[16];
-		char *tmp;
-		struct ifconf ifc;
-		guint32 lhost = htonl(127 * 256 * 256 * 256 + 1);
-		guint32 llocal = htonl((169 << 24) + (254 << 16));
-
-		ifc.ifc_len = sizeof(buffer);
-		ifc.ifc_req = (struct ifreq *)buffer;
-		ioctl(source, SIOCGIFCONF, &ifc);
-
-		if (fd < 0)
-			close(source);
-
-		tmp = buffer;
-		while (tmp < buffer + ifc.ifc_len)
+gboolean sipe_utils_ip_is_private(const char *ip)
 		{
-			struct ifreq *ifr = (struct ifreq *)tmp;
-			tmp += HX_SIZE_OF_IFREQ(*ifr);
-
-			if (ifr->ifr_addr.sa_family == AF_INET)
-			{
-				struct sockaddr_in *sinptr = (struct sockaddr_in *)&ifr->ifr_addr;
-				if (sinptr->sin_addr.s_addr != lhost
-				 && (sinptr->sin_addr.s_addr & htonl(0xFFFF0000)) != llocal)
-				{
-					long unsigned int add = ntohl(sinptr->sin_addr.s_addr);
-					g_snprintf(ip, 16, "%lu.%lu.%lu.%lu",
-						 ((add >> 24) & 255),
-						 ((add >> 16) & 255),
-						 ((add >> 8) & 255),
-						 add & 255);
-
-					return ip;
-				}
-			}
-		}
-	}
-
-	return "0.0.0.0";
+	return g_str_has_prefix(ip, "10.") ||
+	 g_str_has_prefix(ip, "172.16.") ||
+	 g_str_has_prefix(ip, "192.168.");
 }
 
 gchar *sipe_utils_presence_key(const gchar *uri)
@@ -550,6 +484,68 @@
 	return key;
 }
 
+gchar *
+sipe_utils_uri_unescape(const gchar *string)
+{
+	gchar *unescaped;
+	gchar *tmp;
+
+	if (!string)
+		return NULL;
+
+#if GLIB_CHECK_VERSION(2,16,0)
+	unescaped = g_uri_unescape_string(string, NULL);
+#else
+	// based on libpurple/util.c:purple_url_decode()
+	{
+		GString *buf = g_string_new(NULL);
+		size_t len = strlen(string);
+		char hex[3];
+
+		hex[2] = '\0';
+
+		while (len--) {
+			gchar c = *string++;
+
+			if ((len >= 2) && (c == '%')) {
+				strncpy(hex, string, 2);
+				c = strtol(hex, NULL, 16);
+
+				string += 2;
+				len -= 2;
+			}
+
+			g_string_append_c(buf, c);
+		}
+
+		unescaped = g_string_free(buf, FALSE);
+	}
+#endif
+	if (unescaped && !g_utf8_validate(unescaped, -1, (const gchar **)&tmp))
+		*tmp = '\0';
+
+	return unescaped;
+}
+
+gboolean
+sipe_utils_is_avconf_uri(const gchar *uri)
+{
+	return g_strstr_len(uri, -1, "app:conf:audio-video:") != NULL;
+}
+
+/**
+ * Only appends if no such value already stored.
+ * Like Set in Java.
+ */
+GSList *
+slist_insert_unique_sorted(GSList *list, gpointer data, GCompareFunc func) {
+	GSList * res = list;
+	if (!g_slist_find_custom(list, data, func)) {
+		res = g_slist_insert_sorted(list, data, func);
+	}
+	return res;
+}
+
 /*
 Local Variables:
 mode: c
--- pidgin-sipe-1.11.2/src/core/sipe-utils.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipe-utils.h	2011-06-14 14:40:36.000000000 +0200
@@ -164,15 +164,6 @@
 gchar *parse_from(const gchar *hdr);
 
 /**
- * Parses CSeq from SIP header
- *
- * @param hdr (in) CSeqm header
- *
- * @return int type CSeq value (i.e. without method).
- */
-int parse_cseq(const gchar *hdr);
-
-/**
 * Create sip: URI from name
 *
 * @param name (in)
@@ -268,6 +259,24 @@
 gboolean sipe_strcase_equal(const gchar *left, const gchar *right);
 
 /**
+ * Compares two strings
+ *
+ * Unlike strcmp(), this function will not crash if one or both of the
+ * strings are @c NULL.
+ *
+ * Same as g_strcmp0 (defined only for >= 2.16) to maintain
+ * our backward compatibility. The declaration is compatible to
+ * @c GCompareFunc.
+ *
+ * @param a A string
+ * @param b A string to compare with a
+ *
+ * @return negative value if a < b; zero if a = b; positive value if a > b.
+ *
+ */
+gint sipe_strcompare(gconstpointer a, gconstpointer b);
+
+/**
 * Parses a timestamp in ISO8601 format and returns a time_t.
 * Assumes UTC if no timezone specified
 *
@@ -398,17 +407,12 @@
 void sipe_utils_shrink_buffer(struct sipe_transport_connection *conn,
 			 const gchar *unread);
 /**
- * Returns local IP address suitable for connection.
- *
- * purple_network_get_my_ip() will not do this, because it might return an
- * address within 169.254.x.x range that was assigned to interface disconnected
- * from the network (when multiple network adapters are available). This is a
- * copy-paste from libpurple's network.c, only change is that link local addresses
- * are ignored.
+ * Checks whether given IP address belongs to private block as defined in RFC1918
 *
- * Maybe this should be fixed in libpurple or some better solution found.
+ * @param ip IPv4 address in "X.X.X.X" format
+ * @return @c TRUE if address is private
 */
-const char * sipe_utils_get_suitable_local_ip(int fd);
+gboolean sipe_utils_ip_is_private(const char *ip);
 
 /**
 * Generate presence key
@@ -429,3 +433,34 @@
 */
 gchar *sipe_utils_subscription_key(const gchar *event,
 				 const gchar *uri);
+
+/**
+ * Decodes a URI into a plain string.
+ *
+ * @param string the string to translate.
+ *
+ * @return the resulting string. Must be g_free()'d after use.
+ */
+gchar *sipe_utils_uri_unescape(const gchar *string);
+
+/**
+ * Tests whether given string is a Uniform Resource Identifier of audio/video
+ * conference
+ *
+ * @param uri a string
+ * @return @c TRUE if the string represents AV conference URI
+ */
+gboolean sipe_utils_is_avconf_uri(const gchar *uri);
+
+/**
+ * Inserts in item in the list only if the value isn't already in that list
+ *
+ * @param list a singly linked list
+ * @param data the item to insert
+ * @param fund function to use to compare the values
+ *
+ * @return the new list head
+ */
+GSList *
+slist_insert_unique_sorted(GSList *list, gpointer data, GCompareFunc func);
+
--- pidgin-sipe-1.11.2/src/core/sipmsg.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipmsg.c	2011-06-14 14:40:36.000000000 +0200
@@ -86,8 +86,13 @@
 	if (contentlength) {
 		msg->bodylen = strtol(contentlength,NULL,10);
 	} else {
+		const gchar *tmp = sipmsg_find_header(msg, "Transfer-Encoding");
+		if (tmp && sipe_strcase_equal(tmp, "chunked")) {
+			msg->bodylen = SIPMSG_BODYLEN_CHUNKED;
+		} else {
 		SIPE_DEBUG_FATAL_NOFORMAT("sipmsg_parse_header(): Content-Length header not found");
 	}
+	}
 	if(msg->response) {
 		const gchar *tmp;
 		tmp = sipmsg_find_header(msg, "CSeq");
@@ -127,7 +132,7 @@
 	}
 
 	msg->bodylen	= other->bodylen;
-	msg->body	= g_memdup(other->body, other->bodylen);
+	msg->body	= g_strdup(other->body);
 	msg->signature	= g_strdup(other->signature);
 	msg->rand	= g_strdup(other->rand);
 	msg->num	= g_strdup(other->num);
@@ -264,6 +269,7 @@
 }
 
 void sipmsg_free(struct sipmsg *msg) {
+	if (msg) {
 	sipe_utils_nameval_free(msg->headers);
 	sipe_utils_nameval_free(msg->new_headers);
 	g_free(msg->signature);
@@ -275,6 +281,7 @@
 	g_free(msg->body);
 	g_free(msg);
 }
+}
 
 void sipmsg_remove_header_now(struct sipmsg *msg, const gchar *name) {
 	struct sipnameval *elem;
@@ -333,6 +340,18 @@
 	return res2;
 }
 
+int sipmsg_parse_cseq(struct sipmsg *msg)
+{
+	int res = -1;
+	gchar **items;
+	items = g_strsplit(sipmsg_find_header(msg, "CSeq"), " ", 1);
+	if (items[0]) {
+		res = atoi(items[0]);
+	}
+	g_strfreev(items);
+	return res;
+}
+
 /**
 * Parse EndPoints header from INVITE request
 * Returns a list of end points: contact URI plus optional epid.
@@ -443,7 +462,14 @@
 	return NULL;
 }
 
-gchar *sipmsg_get_x_mms_im_format(gchar *msgr) {
+/**
+ * Parses headers-like 'msgr' attribute of INVITE's 'ms_text_format' header.
+ * Then retrieves value of 'X-MMS-IM-Format'.
+
+ * 'msgr' typically looks like:
+ * X-MMS-IM-Format: FN=Microsoft%20Sans%20Serif; EF=BI; CO=800000; CS=0; PF=22
+ */
+static gchar *sipmsg_get_x_mms_im_format(gchar *msgr) {
 	gchar *msgr2;
 	gsize msgr_dec64_len;
 	guchar *msgr_dec64;
@@ -501,7 +527,12 @@
 	return res;
 }
 
-gchar *sipmsg_apply_x_mms_im_format(const char *x_mms_im_format, gchar *body) {
+static void msn_parse_format(const char *mime, char **pre_ret, char **post_ret);
+
+/**
+ * Translates X-MMS-IM format to HTML presentation.
+ */
+static gchar *sipmsg_apply_x_mms_im_format(const char *x_mms_im_format, gchar *body) {
 	char *pre, *post;
 	gchar *res;
 
@@ -591,7 +622,23 @@
 		}
 	}
 
-	if (!g_str_has_prefix(ms_text_format, "text/html")) { // NOT html
+	if (g_str_has_prefix(ms_text_format, "text/html")) {
+		/*
+		 * HTML uses tags for formatting, not line breaks. But
+		 * clients still might render them, so we need to remove
+		 * them to avoid incorrect text rendering.
+		 */
+		gchar *d = res;
+		const gchar *s = res;
+		gchar c;
+
+		/* No ANSI C nor glib function seems to exist for this :-( */
+		while ((c = *s++))
+			if ((c != '\n') && (c != '\r'))
+				*d++ = c;
+		*d = c;
+
+	} else {
 		char *tmp = res;
 		res = g_markup_escape_text(res, -1); // as this is not html
 		g_free(tmp);
@@ -612,56 +659,70 @@
 	return res;
 }
 
+static gchar *
+get_reason(struct sipmsg *msg, const gchar *header)
+{
+	const gchar *diagnostics = sipmsg_find_header(msg, header);
+	if (diagnostics)
+		return sipmsg_find_part_of_header(diagnostics, "reason=\"", "\"", NULL);
 
+	return NULL;
+}
 
+gchar *
+sipmsg_get_ms_diagnostics_reason(struct sipmsg *msg)
+{
+	return get_reason(msg, "ms-diagnostics");
+}
 
+gchar *
+sipmsg_get_ms_diagnostics_public_reason(struct sipmsg *msg)
+{
+	return get_reason(msg, "ms-diagnostics-public");
+}
 
-//------------------------------------------------------------------------------------------
-//TEMP solution to include it here (copy from purple's msn protocol
-//How to reuse msn's util methods from sipe?
-
-/* from internal.h */
-#define MSG_LEN 2048
-#define BUF_LEN MSG_LEN
-
-static
-gchar *sipmsg_uri_unescape(const gchar *string)
+int
+sipmsg_parse_warning(struct sipmsg *msg, gchar **reason)
 {
-	gchar *unescaped, *tmp;
+	/*
+	 * Example header:
+	 * Warning: 310 lcs.microsoft.com "You are currently not using the recommended version of the client"
+	 */
+	const gchar *hdr = sipmsg_find_header(msg, "Warning");
+	int code = -1;
 
-	if (!string) return(NULL);
+	if (reason)
+		*reason = NULL;
 
-#if GLIB_CHECK_VERSION(2,16,0)
-	unescaped = g_uri_unescape_string(string, NULL);
-#else
-	/* loosely based on libpurple/util.c:purple_url_decode() */
-	{
-		gsize i = 0;
-		gsize len = strlen(string);
+	if (hdr) {
+		gchar **parts = g_strsplit(hdr, " ", 3);
 
-		unescaped = g_malloc(len + 1);
-		while (len-- > 0) {
-			gchar c = *string++;
-			if ((len >= 2) && (c == '%')) {
-				char hex[3];
-				strncpy(hex, string, 2);
-				hex[2] = '\0';
-				c = strtol(hex, NULL, 16);
-				string += 2;
-				len -= 2;
-			}
-			unescaped[i++] = c;
+		if (parts[0]) {
+			code = atoi(parts[0]);
+
+			if (reason && parts[1] && parts[2]) {
+				size_t len = strlen(parts[2]);
+				if (len > 2 && parts[2][0] == '"' && parts[2][len - 1] == '"')
+					*reason = g_strndup(parts[2] + 1, len - 2);
 		}
-		unescaped[i] = '\0';
 	}
-#endif
 
-	if (!g_utf8_validate(unescaped, -1, (const gchar **)&tmp))
-		*tmp = '\0';
+		g_strfreev(parts);
+	}
 
-	return(unescaped);
+	return code;
 }
 
+
+
+//------------------------------------------------------------------------------------------
+//TEMP solution to include it here (copy from purple's msn protocol
+//How to reuse msn's util methods from sipe?
+
+/* from internal.h */
+#define MSG_LEN 2048
+#define BUF_LEN MSG_LEN
+
 void
 msn_parse_format(const char *mime, char **pre_ret, char **post_ret)
 {
@@ -763,7 +824,7 @@
 		}
 	}
 
-	cur = sipmsg_uri_unescape(pre->str);
+	cur = sipe_utils_uri_unescape(pre->str);
 	g_string_free(pre, TRUE);
 
 	if (pre_ret != NULL)
@@ -771,7 +832,7 @@
 	else
 		g_free(cur);
 
-	cur = sipmsg_uri_unescape(post->str);
+	cur = sipe_utils_uri_unescape(post->str);
 	g_string_free(post, TRUE);
 
 	if (post_ret != NULL)
@@ -806,7 +867,7 @@
 }
 
 void
-msn_import_html(const char *html, char **attributes, char **message)
+sipe_parse_html(const char *html, char **attributes, char **message)
 {
 	int len, retcount = 0;
 	const char *c;
--- pidgin-sipe-1.11.2/src/core/sipmsg.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sipmsg.h	2011-06-14 14:40:36.000000000 +0200
@@ -28,6 +28,8 @@
 * <glib.h>
 */
 
+#define SIPMSG_BODYLEN_CHUNKED -1
+
 struct sipmsg {
 	int response; /* 0 means request, otherwise response code */
 	gchar *responsestr;
@@ -57,6 +59,16 @@
 void sipmsg_strip_headers(struct sipmsg *msg, const gchar *keepers[]);
 void sipmsg_merge_new_headers(struct sipmsg *msg);
 void sipmsg_free(struct sipmsg *msg);
+
+/**
+ * Parses CSeq from SIP message
+ *
+ * @param msg (in) SIP message
+ *
+ * @return int type CSeq value (i.e. without method).
+ */
+int sipmsg_parse_cseq(struct sipmsg *msg);
+
 GSList *sipmsg_parse_endpoints_header(const gchar *header);
 /**
 * Parses sip: and tel: URI out of P-Asserted-Identity header from INVITE request.
@@ -92,27 +104,12 @@
 gchar *get_html_message(const gchar *ms_text_format, const gchar *body);
 
 /**
- * Parses headers-like 'msgr' attribute of INVITE's 'ms_text_format' header.
- * Then retrieves value of 'X-MMS-IM-Format'.
-
- * 'msgr' typically looks like:
- * X-MMS-IM-Format: FN=Microsoft%20Sans%20Serif; EF=BI; CO=800000; CS=0; PF=22
- */
-gchar *sipmsg_get_x_mms_im_format(gchar *msgr);
-
-/**
 * Returns UTF-16LE/'modified base64' encoded X-MMS-IM-Format
 * based on input x_mms_im_format.
 */
 gchar *sipmsg_get_msgr_string(gchar *x_mms_im_format);
 
 /**
- * Translates X-MMS-IM format to HTML presentation.
- */
-gchar *sipmsg_apply_x_mms_im_format(const char *x_mms_im_format, gchar *body);
-
-#define sipe_parse_html msn_import_html
-/**
 * Parses the Purple message formatting (html) into the MSN format.
 *
 * @param html			The html message to format.
@@ -123,5 +120,31 @@
 */
 void sipe_parse_html(const char *html, char **attributes, char **message);
 
-void msn_parse_format(const char *mime, char **pre_ret, char **post_ret);
-void msn_import_html(const char *html, char **attributes, char **message);
+/**
+ * Extracts reason string from ms-diagnostics header of SIP message
+ *
+ * @param msg SIP message
+ *
+ * @return reason string. Must be g_free()'d after use.
+ */
+gchar *sipmsg_get_ms_diagnostics_reason(struct sipmsg *msg);
+
+/**
+ * Extracts reason string from ms-diagnostics-public header of SIP message
+ *
+ * @param msg SIP message
+ *
+ * @return reason string. Must be g_free()'d after use.
+ */
+gchar *sipmsg_get_ms_diagnostics_public_reason(struct sipmsg *msg);
+
+/**
+ * Parses Warning header of SIP message, if present.
+ *
+ * @param msg (in) SIP message
+ * @param reason (out) parsed warning text or NULL if missing. Must be g_free()'d
+ * after use.
+ *
+ * @return warning code or -1 if warning header is not present in message.
+ */
+int sipmsg_parse_warning(struct sipmsg *msg, gchar **reason);
--- pidgin-sipe-1.11.2/src/core/sip-sec.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sip-sec.c	2011-06-14 14:40:36.000000000 +0200
@@ -141,14 +141,16 @@
 			g_free(in_buff.value);
 
 		if (ret == SIP_SEC_E_OK || ret == SIP_SEC_I_CONTINUE_NEEDED) {
-			*output_toked_base64 = g_base64_encode(out_buff.value, out_buff.length);
 
 			if (out_buff.length > 0 && out_buff.value) {
+				*output_toked_base64 = g_base64_encode(out_buff.value, out_buff.length);
 				tmp = sip_sec_ntlm_message_describe(out_buff);
 				if (tmp) {
 					SIPE_DEBUG_INFO("sip_sec_init_context_step: Negotiate or Authenticate message is:\n%s", tmp);
 				}
 				g_free(tmp);
+			} else {
+				*output_toked_base64 = NULL;
 			}
 
 			g_free(out_buff.value);
--- pidgin-sipe-1.11.2/src/core/sip-sec-krb5.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sip-sec-krb5.c	2011-06-14 14:40:36.000000000 +0200
@@ -281,13 +281,12 @@
 			 OM_uint32 status,
 			 int type)
 {
-	OM_uint32 ret;
 	OM_uint32 minor;
 	OM_uint32 message_context = 0;
 	gss_buffer_desc status_string;
 
 	do {
-		ret = gss_display_status(&minor,
+		gss_display_status(&minor,
 					 status,
 					 type,
 					 GSS_C_NO_OID,
--- pidgin-sipe-1.11.2/src/core/sip-sec-ntlm.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sip-sec-ntlm.c	2011-06-14 14:40:36.000000000 +0200
@@ -46,6 +46,10 @@
 * not in NTLM (LE) structures.
 */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
@@ -288,8 +292,12 @@
 };
 
 #ifndef HAVE_LANGINFO_CODESET
+#ifdef __sun__
+static char SIPE_DEFAULT_CODESET[] = "US-ASCII";
+#else
 static char SIPE_DEFAULT_CODESET[] = "ANSI_X3.4-1968";
 #endif
+#endif
 
 /* Private Methods */
 
@@ -302,6 +310,7 @@
 {
 	gsize inbytes = strlen(source);
 	gsize outbytes = remlen;
+	if (remlen)
 	g_iconv(convert_to_utf16le, (gchar **)&source, &inbytes, &dest, &outbytes);
 	return(remlen - outbytes);
 }
@@ -590,23 +599,23 @@
 
 		/* client_challenge (8) & temp (temp_len) buff */
 		int temp_len = 8+8+8+4+target_info_len+4;
-		guint8 *temp2 = g_malloc(8 + temp_len);
-		memset(temp2, 0, 8 + temp_len); /* init to 0 */
-		temp2[8+0] = 1;
-		temp2[8+1] = 1;
-		*((guint64 *)(temp2+8+8)) = GUINT64_TO_LE(time_val); /* should be int64 aligned: OK for sparc */
-		memcpy(temp2+8+16, client_challenge, 8);
-		memcpy(temp2+8+28, target_info, target_info_len);
+		guint64 *temp2 = g_malloc0(8 + temp_len);
+		((guint8 *) temp2)[8+0] = 1;
+		((guint8 *) temp2)[8+1] = 1;
+		temp2[2] = GUINT64_TO_LE(time_val); /* should be int64 aligned: OK for sparc */
+		memcpy(((guint8 *) temp2)+8+16, client_challenge, 8);
+		memcpy(((guint8 *) temp2)+8+28, target_info, target_info_len);
 
 		/* NTProofStr */
 		//Set NTProofStr to HMAC_MD5(ResponseKeyNT, ConcatenationOf(CHALLENGE_MESSAGE.ServerChallenge,temp))
 		memcpy(temp2, server_challenge, 8);
-		HMAC_MD5(response_key_nt, 16, temp2, 8+temp_len, nt_proof_str);
+		HMAC_MD5(response_key_nt, 16, (guint8*)temp2, 8+temp_len, nt_proof_str);
 
 		/* NtChallengeResponse */
 		//Set NtChallengeResponse to ConcatenationOf(NTProofStr, temp)
 		memcpy(nt_challenge_response, nt_proof_str, 16);
-		memcpy(nt_challenge_response+16, temp2+8, temp_len);
+		memcpy(nt_challenge_response+16, temp2+1, temp_len);
+		g_free(temp2);
 
 		/* SessionBaseKey */
 		//SessionBaseKey to HMAC_MD5(ResponseKeyNT, NTProofStr)
@@ -618,8 +627,6 @@
 		HMAC_MD5(response_key_lm, 16, tmp, 16, lm_challenge_response);
 		memcpy(lm_challenge_response+16, client_challenge, 8);
 
-		g_free(temp2);
-
 #ifndef _SIPE_COMPILING_TESTS
 		/* Not used in NTLMv2 */
 		(void)neg_flags;
@@ -827,7 +834,7 @@
 unsigned long seal_key_len,
 guint32 random_pad,
 guint32 sequence,
- unsigned char *result)
+ guint32 *result)
 {
 	guint32 *res_ptr;
 
@@ -853,41 +860,41 @@
 
 		unsigned char seal_key_ [16];
 		guchar hmac[16];
-		guchar *tmp = g_malloc(4 + buf_len);
+		guint32 *tmp = g_malloc(4 + buf_len);
 
 		/* SealingKey' = MD5(ConcatenationOf(SealingKey, SequenceNumber))
 		 RC4Init(Handle, SealingKey')
 		 */
 		if (IS_FLAG(flags, NTLMSSP_NEGOTIATE_DATAGRAM)) {
-			unsigned char tmp2 [16+4];
+			guint32 tmp2[4+1];
 
 			memcpy(tmp2, seal_key, seal_key_len);
-			*((guint32 *)(tmp2+16)) = GUINT32_TO_LE(sequence);
-			MD5 (tmp2, 16+4, seal_key_);
+			tmp2[4] = GUINT32_TO_LE(sequence);
+			MD5 ((guchar *)tmp2, sizeof(tmp2), seal_key_);
 		} else {
 			memcpy(seal_key_, seal_key, seal_key_len);
 		}
 
 		SIPE_DEBUG_INFO_NOFORMAT("NTLM MAC(): Extented Session Security");
 
-		res_ptr = (guint32 *)result;
+		res_ptr = result;
 		res_ptr[0] = GUINT32_TO_LE(1); // 4 bytes
 		res_ptr[3] = GUINT32_TO_LE(sequence);
 
-		res_ptr = (guint32 *)tmp;
+		res_ptr = tmp;
 		res_ptr[0] = GUINT32_TO_LE(sequence);
-		memcpy(tmp+4, buf, buf_len);
+		memcpy(tmp+1, buf, buf_len);
 
-		HMAC_MD5(sign_key, sign_key_len, tmp, 4 + buf_len, hmac);
+		HMAC_MD5(sign_key, sign_key_len, (guchar *)tmp, 4 + buf_len, hmac);
+		g_free(tmp);
 
 		if (IS_FLAG(flags, NTLMSSP_NEGOTIATE_KEY_EXCH)) {
 			SIPE_DEBUG_INFO_NOFORMAT("NTLM MAC(): Key Exchange");
-			RC4K(seal_key_, seal_key_len, hmac, 8, result+4);
+			RC4K(seal_key_, seal_key_len, hmac, 8, (guchar *)(result+1));
 		} else {
 			SIPE_DEBUG_INFO_NOFORMAT("NTLM MAC(): *NO* Key Exchange");
-			memcpy(result+4, hmac, 8);
+			memcpy(result+1, hmac, 8);
 		}
-		g_free(tmp);
 	} else {
 		/* The content of the first 4 bytes is irrelevant */
 		guint32 crc = CRC32(buf, strlen(buf));
@@ -899,9 +906,9 @@
 
 		SIPE_DEBUG_INFO_NOFORMAT("NTLM MAC(): *NO* Extented Session Security");
 
-		RC4K(seal_key, seal_key_len, (const guchar *)plaintext, 12, result+4);
+		RC4K(seal_key, seal_key_len, (const guchar *)plaintext, 12, (guchar *)(result+1));
 
-		res_ptr = (guint32 *)result;
+		res_ptr = result;
 		// Highest four bytes are the Version
 		res_ptr[0] = GUINT32_TO_LE(0x00000001); // 4 bytes
 
@@ -925,7 +932,8 @@
 			 guchar **target_info,
 			 int *target_info_len)
 {
-	struct challenge_message *cmsg = (struct challenge_message*)in_buff.value;
+	/* SipSecBuffer.value is g_malloc()'d: use (void *) to remove guint8 alignment */
+	struct challenge_message *cmsg = (void *)in_buff.value;
 	guint32 host_flags = GUINT32_FROM_LE(cmsg->flags);
 
 	/* server challenge (nonce) */
@@ -1270,13 +1278,13 @@
 				 guint32 random_pad,
 				 unsigned char *sign_key,
 				 unsigned char *seal_key,
-				 unsigned char *result)
+				 guint32 *result)
 {
 	char *res;
 
 	MAC(flags, msg,strlen(msg), sign_key,16, seal_key,16, random_pad, 100, result);
 
-	res = buff_to_hex_str(result, 16);
+	res = buff_to_hex_str((guint8 *)result, 16);
 	SIPE_DEBUG_INFO("NTLM calculated MAC: %s", res);
 	g_free(res);
 }
@@ -1645,7 +1653,8 @@
 
 	if (buff.length == 0 || buff.value == NULL || buff.length < 12) return NULL;
 
-	msg = (struct ntlm_message *)buff.value;
+	/* SipSecBuffer.value is g_malloc()'d: use (void *) to remove guint8 alignment */
+	msg = (void *)buff.value;
 	if(!sipe_strequal("NTLMSSP", (char*)msg)) return NULL;
 
 	switch (GUINT32_FROM_LE(msg->type)) {
@@ -1685,8 +1694,8 @@
 {
 	context_ntlm ctx = (context_ntlm)context;
 
-	/* NTLM requires a domain, username & password */
-	if (!domain || !username || !password)
+	/* NTLM requires a username & password. Domain may be empty */
+	if (!domain || is_empty(username) || is_empty(password))
 		return SIP_SEC_E_INTERNAL_ERROR;
 
 	ctx->domain = g_strdup(domain);
@@ -1803,7 +1812,10 @@
 					 0,
 					 ((context_ntlm) context)->client_sign_key,
 					 ((context_ntlm) context)->client_seal_key,
-					 signature->value);
+					 /* SipSecBuffer.value is g_malloc()'d: 
+					 * use (void *) to remove guint8 alignment
+					 */
+					 (void *)signature->value);
 	return SIP_SEC_E_OK;
 }
 
@@ -1816,8 +1828,9 @@
 			 const char *message,
 			 SipSecBuffer signature)
 {
-	guint8 mac[16];
-	guint32 random_pad = GUINT32_FROM_LE(((guint32 *) signature.value)[1]);
+	guint32 mac[4];
+	/* SipSecBuffer.value is g_malloc()'d: use (void *) to remove guint8 alignment */
+	guint32 random_pad = GUINT32_FROM_LE(((guint32 *)((void *)signature.value))[1]);
 
 	sip_sec_ntlm_sipe_signature_make(((context_ntlm) context)->flags,
 								 message,
@@ -1878,7 +1891,7 @@
 	}
 
 	convert_to_utf16le = g_iconv_open("UTF-16LE", sys_cp);
-	if (convert_from_utf16le == (GIConv)-1) {
+	if (convert_to_utf16le == (GIConv)-1) {
 		SIPE_DEBUG_ERROR("g_iconv_open from %s to UTF-16LE failed",
 				 sys_cp);
 	}
--- pidgin-sipe-1.11.2/src/core/sip-sec-ntlm-tests.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sip-sec-ntlm-tests.c	2011-06-14 14:40:36.000000000 +0200
@@ -53,15 +53,16 @@
 
 gboolean sip_sec_ntlm_tests(void);
 
-static void assert_equal(const char * expected, const guchar * got, int len, gboolean stringify)
+static void assert_equal(const char * expected, gpointer got, int len, gboolean stringify)
 {
 	const gchar * res = (gchar *) got;
 	gchar to_str[len*2 + 1];
 
 	if (stringify) {
+		const guint8 *bin = got;
 		int i, j;
 		for (i = 0, j = 0; i < len; i++, j+=2) {
-			g_sprintf(&to_str[j], "%02X", (got[i]&0xff));
+			g_sprintf(&to_str[j], "%02X", (bin[i]&0xff));
 		}
 		len *= 2;
 		res = to_str;
@@ -119,12 +120,11 @@
 	guchar client_sign_key [16];
 	guchar server_sign_key [16];
 	guchar server_seal_key [16];
-	guchar mac [16];
+	guint32 mac [4];
 	guchar text_enc [18 + 12];
 	struct sipmsg *msg;
 	struct sipmsg_breakdown msgbd;
 	gchar *msg_str;
-	gchar *sig;
 	const char *password2;
 	const char *user2;
 	const char *domain2;
@@ -508,7 +508,7 @@
 		msg_str, 0, exported_session_key2, exported_session_key2, mac);
 	sipmsg_breakdown_free(&msgbd);
 	assert_equal ("0100000000000000BF2E52667DDF6DED", mac, 16, TRUE);
-	sig = buff_to_hex_str(mac, 16);
+	/* sig = buff_to_hex_str((guint8 *)mac, 16); */
 	}
 
 
@@ -693,17 +693,19 @@
 	int target_info2_len;
 	guint8 *nonce2;
 	guint8 *target_info2;
-	guint8 *buff2;
-	hex_str_to_buff("59519A1727B9CA01", &buff2);
+	guint64 *buff2;
+	/* buff2 points to correctly aligned memory. Disable alignment check */
+	hex_str_to_buff("59519A1727B9CA01", (void *)&buff2);
 	/* global var */
-	test_time_val = GUINT64_FROM_LE(*((guint64 *)buff2));
+	test_time_val = GUINT64_FROM_LE(*buff2);
 	g_free(buff2);
 
 	target_info2_len = hex_str_to_buff("02000A0043004F0053004D004F000100180043004F0053004D004F002D004F00430053002D00520032000400160063006F0073006D006F002E006C006F00630061006C000300300063006F0073006D006F002D006F00630073002D00720032002E0063006F0073006D006F002E006C006F00630061006C000500160063006F0073006D006F002E006C006F00630061006C0000000000", &target_info2);
 
 	hex_str_to_buff("DD1BAAF4E7E218D1", &nonce2);
 
-	hex_str_to_buff("D6AE875CB0FDAA41", &buff2);
+	/* buff2 points to correctly aligned memory. Disable alignment check */
+	hex_str_to_buff("D6AE875CB0FDAA41", (void *)&buff2);
 	/* global buff */
 	memcpy(test_client_challenge, buff2, 8);
 	g_free(buff2);
@@ -762,7 +764,7 @@
 	sip_sec_ntlm_sipe_signature_make (flags, msg_str, 0, client_sign_key, client_seal_key, mac);
 	sipmsg_breakdown_free(&msgbd);
 	assert_equal ("0100000029618e9651b65a7764000000", mac, 16, TRUE);
-	sig = buff_to_hex_str(mac, 16);
+	/* sig = buff_to_hex_str((guint8 *)mac, 16); */
 
 	printf ("\n\nTesting (NTLMv2 / OC 2007 R2) Message Parsing, Signing, and Verification\nServer response\n(Authentication Protocol version 4)\n");
 	msg = sipmsg_parse_msg(response);
@@ -774,7 +776,7 @@
 	sip_sec_ntlm_sipe_signature_make (flags, msg_str, 0, server_sign_key, server_seal_key, mac);
 	sipmsg_breakdown_free(&msgbd);
 	assert_equal ("01000000E615438A917661BE64000000", mac, 16, TRUE);
-	sig = buff_to_hex_str(mac, 16);
+	/* sig = buff_to_hex_str((guint8 *)mac, 16); */
 
 	printf ("\n\nTesting (NTLMv2 / OC 2007 R2) MAC - client signing\n");
 	MAC (flags, (gchar*)request_sig,strlen(request_sig), client_sign_key,16, client_seal_key,16, 0, 100, mac);
--- pidgin-sipe-1.11.2/src/core/sip-transport.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sip-transport.c	2011-06-14 14:40:36.000000000 +0200
@@ -106,6 +106,7 @@
 	struct sip_auth proxy;
 
 	guint cseq;
+	guint register_attempt;
 
 	gboolean processing_input; /* whether full header received */
 	gboolean reregister_set; /* whether reregister timer set */
@@ -410,6 +411,71 @@
 	}
 }
 
+static const gchar *sip_transport_user_agent(struct sipe_core_private *sipe_private)
+{
+	struct sip_transport *transport = sipe_private->transport;
+
+	if (!transport->user_agent) {
+		const gchar *useragent = sipe_backend_setting(SIPE_CORE_PUBLIC,
+							 SIPE_SETTING_USER_AGENT);
+		if (is_empty(useragent)) {
+/*@TODO: better approach to define _user_ OS, it's version and host architecture */
+/* ref: lzodefs.h */
+#if defined(__linux__) || defined(__linux) || defined(__LINUX__)
+ #define SIPE_TARGET_PLATFORM "linux"
+#elif defined(__NetBSD__) ||defined( __OpenBSD__) || defined(__FreeBSD__)
+ #define SIPE_TARGET_PLATFORM "bsd"
+#elif defined(__APPLE__) || defined(__MACOS__)
+ #define SIPE_TARGET_PLATFORM "macosx"
+#elif defined(_AIX) || defined(__AIX__) || defined(__aix__)
+ #define SIPE_TARGET_PLATFORM "aix"
+#elif defined(__solaris__) || defined(__sun)
+ #define SIPE_TARGET_PLATFORM "sun"
+#elif defined(_WIN32)
+ #define SIPE_TARGET_PLATFORM "win"
+#elif defined(__CYGWIN__)
+ #define SIPE_TARGET_PLATFORM "cygwin"
+#elif defined(__hpux__)
+ #define SIPE_TARGET_PLATFORM "hpux"
+#elif defined(__sgi__)
+ #define SIPE_TARGET_PLATFORM "irix"
+#else
+ #define SIPE_TARGET_PLATFORM "unknown"
+#endif
+
+#if defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64)
+ #define SIPE_TARGET_ARCH "x86_64"
+#elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386)
+ #define SIPE_TARGET_ARCH "i386"
+#elif defined(__ppc64__)
+ #define SIPE_TARGET_ARCH "ppc64"
+#elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR)
+ #define SIPE_TARGET_ARCH "ppc"
+#elif defined(__hppa__) || defined(__hppa)
+ #define SIPE_TARGET_ARCH "hppa"
+#elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000)
+ #define SIPE_TARGET_ARCH "mips"
+#elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x)
+ #define SIPE_TARGET_ARCH "s390"
+#elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8)
+ #define SIPE_TARGET_ARCH "sparc"
+#elif defined(__arm__)
+ #define SIPE_TARGET_ARCH "arm"
+#else
+ #define SIPE_TARGET_ARCH "other"
+#endif
+			gchar *backend = sipe_backend_version();
+			transport->user_agent = g_strdup_printf("%s Sipe/" PACKAGE_VERSION " (" SIPE_TARGET_PLATFORM "-" SIPE_TARGET_ARCH "; %s)",
+								backend,
+								transport->server_version ? transport->server_version : "");
+			g_free(backend);
+		} else {
+			transport->user_agent = g_strdup(useragent);
+		}
+	}
+	return(transport->user_agent);
+}
+
 void sip_transport_response(struct sipe_core_private *sipe_private,
 			 struct sipmsg *msg,
 			 guint code,
@@ -438,6 +504,8 @@
 		sipmsg_add_header(msg, "Content-Length", "0");
 	}
 
+	sipmsg_add_header(msg, "User-Agent", sip_transport_user_agent(sipe_private));
+
 	msg->response = code;
 
 	sipmsg_strip_headers(msg, keepers);
@@ -459,9 +527,10 @@
 	g_string_free(outstr, TRUE);
 }
 
-static void transactions_remove(struct sip_transport *transport,
+static void transactions_remove(struct sipe_core_private *sipe_private,
 				struct transaction *trans)
 {
+	struct sip_transport *transport = sipe_private->transport;
 	if (transport->transactions) {
 		transport->transactions = g_slist_remove(transport->transactions,
 							 trans);
@@ -473,6 +542,10 @@
 			g_free(trans->payload);
 		}
 		g_free(trans->key);
+		if (trans->timeout_key) {
+			sipe_schedule_cancel(sipe_private, trans->timeout_key);
+			g_free(trans->timeout_key);
+		}
 		g_free(trans);
 	}
 }
@@ -504,79 +577,24 @@
 	return NULL;
 }
 
-const gchar *sip_transport_user_agent(struct sipe_core_private *sipe_private)
+static void transaction_timeout_cb(struct sipe_core_private *sipe_private,
+				 gpointer data)
 {
-	struct sip_transport *transport = sipe_private->transport;
-
-	if (!transport->user_agent) {
-		const gchar *useragent = sipe_backend_setting(SIPE_CORE_PUBLIC,
-							 SIPE_SETTING_USER_AGENT);
-		if (is_empty(useragent)) {
-/*@TODO: better approach to define _user_ OS, it's version and host architecture */
-/* ref: lzodefs.h */
-#if defined(__linux__) || defined(__linux) || defined(__LINUX__)
- #define SIPE_TARGET_PLATFORM "linux"
-#elif defined(__NetBSD__) ||defined( __OpenBSD__) || defined(__FreeBSD__)
- #define SIPE_TARGET_PLATFORM "bsd"
-#elif defined(__APPLE__) || defined(__MACOS__)
- #define SIPE_TARGET_PLATFORM "macosx"
-#elif defined(_AIX) || defined(__AIX__) || defined(__aix__)
- #define SIPE_TARGET_PLATFORM "aix"
-#elif defined(__solaris__) || defined(__sun)
- #define SIPE_TARGET_PLATFORM "sun"
-#elif defined(_WIN32)
- #define SIPE_TARGET_PLATFORM "win"
-#elif defined(__CYGWIN__)
- #define SIPE_TARGET_PLATFORM "cygwin"
-#elif defined(__hpux__)
- #define SIPE_TARGET_PLATFORM "hpux"
-#elif defined(__sgi__)
- #define SIPE_TARGET_PLATFORM "irix"
-#else
- #define SIPE_TARGET_PLATFORM "unknown"
-#endif
-
-#if defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64)
- #define SIPE_TARGET_ARCH "x86_64"
-#elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386)
- #define SIPE_TARGET_ARCH "i386"
-#elif defined(__ppc64__)
- #define SIPE_TARGET_ARCH "ppc64"
-#elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR)
- #define SIPE_TARGET_ARCH "ppc"
-#elif defined(__hppa__) || defined(__hppa)
- #define SIPE_TARGET_ARCH "hppa"
-#elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000)
- #define SIPE_TARGET_ARCH "mips"
-#elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x)
- #define SIPE_TARGET_ARCH "s390"
-#elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8)
- #define SIPE_TARGET_ARCH "sparc"
-#elif defined(__arm__)
- #define SIPE_TARGET_ARCH "arm"
-#else
- #define SIPE_TARGET_ARCH "other"
-#endif
-			gchar *backend = sipe_backend_version();
-			transport->user_agent = g_strdup_printf("%s Sipe/" PACKAGE_VERSION " (" SIPE_TARGET_PLATFORM "-" SIPE_TARGET_ARCH "; %s)",
-								backend,
-								transport->server_version ? transport->server_version : "");
-			g_free(backend);
-		} else {
-			transport->user_agent = g_strdup(useragent);
-		}
-	}
-	return(transport->user_agent);
+	struct transaction *trans = data;
+	(trans->timeout_callback)(sipe_private, trans->msg, trans);
+	transactions_remove(sipe_private, trans);
 }
 
-struct transaction *sip_transport_request(struct sipe_core_private *sipe_private,
+struct transaction *sip_transport_request_timeout(struct sipe_core_private *sipe_private,
 					 const gchar *method,
 					 const gchar *url,
 					 const gchar *to,
 					 const gchar *addheaders,
 					 const gchar *body,
 					 struct sip_dialog *dialog,
-					 TransCallback callback)
+						 TransCallback callback,
+						 guint timeout,
+						 TransCallback timeout_callback)
 {
 	struct sip_transport *transport = sipe_private->transport;
 	struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
@@ -599,7 +617,7 @@
 		while(iter)
 		{
 			char *tmp = route;
-			route = g_strdup_printf("%sRoute: <%s>\r\n", route, (char *)iter->data);
+			route = g_strdup_printf("%sRoute: %s\r\n", route, (char *)iter->data);
 			g_free(tmp);
 			iter = g_slist_next(iter);
 		}
@@ -677,6 +695,16 @@
 		trans->callback = callback;
 		trans->msg = msg;
 		trans->key = g_strdup_printf("<%s><%d %s>", callid, cseq, method);
+		if (timeout_callback) {
+			trans->timeout_callback = timeout_callback;
+			trans->timeout_key = g_strdup_printf("<transaction timeout>%s", trans->key);
+			sipe_schedule_seconds(sipe_private,
+					 trans->timeout_key,
+					 trans,
+					 timeout,
+					 transaction_timeout_cb,
+					 NULL);
+		}
 		transport->transactions = g_slist_append(transport->transactions,
 							 trans);
 		SIPE_DEBUG_INFO("SIP transactions count:%d after addition", g_slist_length(transport->transactions));
@@ -692,6 +720,27 @@
 	return trans;
 }
 
+struct transaction *sip_transport_request(struct sipe_core_private *sipe_private,
+					 const gchar *method,
+					 const gchar *url,
+					 const gchar *to,
+					 const gchar *addheaders,
+					 const gchar *body,
+					 struct sip_dialog *dialog,
+					 TransCallback callback)
+{
+	return sip_transport_request_timeout(sipe_private,
+					 method,
+					 url,
+					 to,
+					 addheaders,
+					 body,
+					 dialog,
+					 callback,
+					 0,
+					 NULL);
+}
+
 static void sip_transport_simple_request(struct sipe_core_private *sipe_private,
 					 const gchar *method,
 					 struct sip_dialog *dialog)
@@ -718,13 +767,13 @@
 	sip_transport_simple_request(sipe_private, "BYE", dialog);
 }
 
-void sip_transport_info(struct sipe_core_private *sipe_private,
+struct transaction *sip_transport_info(struct sipe_core_private *sipe_private,
 			const gchar *addheaders,
 			const gchar *body,
 			struct sip_dialog *dialog,
 			TransCallback callback)
 {
-	sip_transport_request(sipe_private,
+	return sip_transport_request(sipe_private,
 			 "INFO",
 			 dialog->with,
 			 dialog->with,
@@ -800,13 +849,6 @@
 static void do_register(struct sipe_core_private *sipe_private,
 			gboolean deregister);
 
-static void do_register_cb(struct sipe_core_private *sipe_private,
-			 SIPE_UNUSED_PARAMETER void *unused)
-{
-	do_register(sipe_private, FALSE);
-	sipe_private->transport->reregister_set = FALSE;
-}
-
 static void do_reauthenticate_cb(struct sipe_core_private *sipe_private,
 				 SIPE_UNUSED_PARAMETER gpointer unused)
 {
@@ -818,15 +860,13 @@
 	SIPE_DEBUG_INFO_NOFORMAT("do a full reauthentication");
 	sipe_auth_free(&transport->registrar);
 	sipe_auth_free(&transport->proxy);
+	sipe_schedule_cancel(sipe_private, "<registration>");
+	transport->reregister_set = FALSE;
+	transport->register_attempt = 0;
 	do_register(sipe_private, FALSE);
 	transport->reauthenticate_set = FALSE;
 }
 
-static void sipe_server_register(struct sipe_core_private *sipe_private,
-				 guint type,
-				 gchar *server_name,
-				 guint server_port);
-
 static void sip_transport_default_contact(struct sipe_core_private *sipe_private)
 {
 	struct sip_transport *transport = sipe_private->transport;
@@ -837,8 +877,13 @@
 						TRANSPORT_DESCRIPTOR);
 }
 
+static void do_register_cb(struct sipe_core_private *sipe_private,
+			 SIPE_UNUSED_PARAMETER void *unused)
+{
+	do_register(sipe_private, FALSE);
+}
+
 static void sip_transport_set_reregister(struct sipe_core_private *sipe_private,
-					 struct sip_transport *transport,
 					 int expires)
 {
 	sipe_schedule_seconds(sipe_private,
@@ -847,9 +892,13 @@
 			 expires,
 			 do_register_cb,
 			 NULL);
-	transport->reregister_set = TRUE;
 }
 
+static void sipe_server_register(struct sipe_core_private *sipe_private,
+				 guint type,
+				 gchar *server_name,
+				 guint server_port);
+
 static gboolean process_register_response(struct sipe_core_private *sipe_private,
 					 struct sipmsg *msg,
 					 SIPE_UNUSED_PARAMETER struct transaction *trans)
@@ -879,8 +928,8 @@
 
 				if (!transport->reregister_set) {
 					sip_transport_set_reregister(sipe_private,
-								 transport,
 								 expires);
+					transport->reregister_set = TRUE;
 				}
 
 				if (server_hdr && !transport->server_version) {
@@ -948,6 +997,7 @@
 					sip_transport_default_contact(sipe_private);
 				}
 SIPE_CORE_PRIVATE_FLAG_UNSET(OCS2007);
+				SIPE_CORE_PRIVATE_FLAG_UNSET(REMOTE_USER);
 				sip->batched_support = FALSE;
 
 while(hdr)
@@ -974,6 +1024,13 @@
 						}
 						g_strfreev(caps);
 }
+					if (sipe_strcase_equal(elem->name, "ms-user-logon-data")) {
+						if (sipe_strcase_equal(elem->value, "RemoteUser")) {
+							SIPE_CORE_PRIVATE_FLAG_SET(REMOTE_USER);
+							SIPE_DEBUG_INFO_NOFORMAT("ms-user-logon-data: RemoteUser (connected "
+										 "via Edge Server)");
+						}
+					}
 hdr = g_slist_next(hdr);
 }
 
@@ -1125,24 +1182,21 @@
 					return TRUE;
 				}
 				fill_auth(tmp, &transport->registrar);
+				transport->reregister_set = FALSE;
+				transport->register_attempt = 0;
 				do_register(sipe_private,
 					 sipe_backend_connection_is_disconnecting(SIPE_CORE_PUBLIC));
 			}
 			break;
 		case 403:
 			{
-				const gchar *diagnostics = sipmsg_find_header(msg, "Warning");
-				gchar **reason = NULL;
+				gchar *reason;
 				gchar *warning;
-				if (diagnostics != NULL) {
-					/* Example header:
-					 Warning: 310 lcs.microsoft.com "You are currently not using the recommended version of the client"
-					*/
-					reason = g_strsplit(diagnostics, "\"", 0);
-				}
+				sipmsg_parse_warning(msg, &reason);
+				reason = reason ? reason : sipmsg_get_ms_diagnostics_public_reason(msg);
 				warning = g_strdup_printf(_("You have been rejected by the server: %s"),
-							 (reason && reason[1]) ? reason[1] : _("no reason given"));
-				g_strfreev(reason);
+							 reason ? reason : _("no reason given"));
+				g_free(reason);
 
 				sipe_backend_connection_error(SIPE_CORE_PUBLIC,
 							 SIPE_CONNECTION_ERROR_INVALID_SETTINGS,
@@ -1154,11 +1208,8 @@
 		case 404:
 			{
 				const gchar *diagnostics = sipmsg_find_header(msg, "ms-diagnostics");
-				gchar *reason = NULL;
+				gchar *reason = sipmsg_get_ms_diagnostics_reason(msg);
 				gchar *warning;
-				if (diagnostics != NULL) {
-					reason = sipmsg_find_part_of_header(diagnostics, "reason=\"", "\"", NULL);
-				}
 				warning = g_strdup_printf(_("Not found: %s. Please contact your Administrator"),
 							 diagnostics ? (reason ? reason : _("no reason given")) :
 							 _("SIP is either not enabled for the destination URI or it does not exist"));
@@ -1172,22 +1223,18 @@
 			}
 			break;
 		case 504: /* Server time-out */
-			if (transport->reauthenticate_set) {
-				SIPE_DEBUG_ERROR_NOFORMAT("process_register_response: RE-REGISTER timeout, retrying later");
-				sip_transport_set_reregister(sipe_private,
-							 transport,
-							 60);
+			/* first attempt + 5 retries */
+			if (transport->register_attempt < 6) {
+				SIPE_DEBUG_INFO("process_register_response: RE-REGISTER timeout on attempt %d, retrying later",
+						transport->register_attempt);
+				sip_transport_set_reregister(sipe_private, 60);
 				return TRUE;
 			}
 			/* FALLTHROUGH */
 case 503:
 {
-				const gchar *diagnostics = sipmsg_find_header(msg, "ms-diagnostics");
-				gchar *reason = NULL;
+				gchar *reason = sipmsg_get_ms_diagnostics_reason(msg);
 				gchar *warning;
-				if (diagnostics != NULL) {
-					reason = sipmsg_find_part_of_header(diagnostics, "reason=\"", "\"", NULL);
-				}
 				warning = g_strdup_printf(_("Service unavailable: %s"), reason ? reason : _("no reason given"));
 				g_free(reason);
 
@@ -1202,6 +1249,25 @@
 	return TRUE;
 }
 
+static gboolean register_response_timeout(struct sipe_core_private *sipe_private,
+					 SIPE_UNUSED_PARAMETER struct sipmsg *msg,
+					 SIPE_UNUSED_PARAMETER struct transaction *trans)
+{
+	struct sip_transport *transport = sipe_private->transport;
+	if (transport->register_attempt < 6) {
+		SIPE_DEBUG_INFO("register_response_timeout: no answer to attempt %d, retrying",
+				transport->register_attempt);
+		do_register(sipe_private, FALSE);
+	} else {
+		gchar *warning = g_strdup_printf(_("Service unavailable: %s"), _("no reason given"));
+		sipe_backend_connection_error(SIPE_CORE_PUBLIC,
+					 SIPE_CONNECTION_ERROR_NETWORK,
+					 warning);
+		g_free(warning);
+	}
+	return TRUE;
+}
+
 static void do_register(struct sipe_core_private *sipe_private,
 			gboolean deregister)
 {
@@ -1214,6 +1280,15 @@
 
 	if (!sipe_private->public.sip_domain) return;
 
+	if (!deregister) {
+		if (transport->reregister_set) {
+			transport->reregister_set = FALSE;
+			transport->register_attempt = 1;
+		} else {
+			transport->register_attempt++;
+		}
+	}
+
 	epid = get_epid(sipe_private);
 	uuid = generateUUIDfromEPID(epid);
 	hdr = g_strdup_printf("Contact: <sip:%s:%d;transport=%s;ms-opaque=d3470f2e1d>;methods=\"INVITE, MESSAGE, INFO, SUBSCRIBE, OPTIONS, BYE, CANCEL, NOTIFY, ACK, REFER, BENOTIFY\";proxy=replace;+sip.instance=\"<urn:uuid:%s>\"\r\n"
@@ -1232,14 +1307,16 @@
 
 	uri = sip_uri_from_name(sipe_private->public.sip_domain);
 	to = sip_uri_self(sipe_private);
-	sip_transport_request(sipe_private,
+	sip_transport_request_timeout(sipe_private,
 			 "REGISTER",
 			 uri,
 			 to,
 			 hdr,
 			 "",
 			 NULL,
-			 process_register_response);
+				 process_register_response,
+				 60,
+				 deregister ? NULL : register_response_timeout);
 	g_free(to);
 	g_free(uri);
 	g_free(hdr);
@@ -1271,13 +1348,17 @@
 	g_free(transport->user_agent);
 
 	while (transport->transactions)
-		transactions_remove(transport,
+		transactions_remove(sipe_private,
 				 transport->transactions->data);
 
 	g_free(transport);
 
 	sipe_private->transport = NULL;
 	sipe_private->service_data = NULL;
+
+	if (sipe_private->dns_query)
+		sipe_backend_dns_query_cancel(sipe_private->dns_query);
+
 }
 
 guint sip_transport_port(struct sipe_core_private *sipe_private)
@@ -1343,16 +1424,55 @@
 					SIPE_DEBUG_INFO("process_input_message: got provisional (%d) response, ignoring", msg->response);
 				}
 
-			} else if (msg->response == 407) {
+				/* Transaction not yet completed */
+				trans = NULL;
+
+			} else if (msg->response == 401) { /* Unauthorized */
+
+				if (sipe_strequal(trans->msg->method, "REGISTER")) {
+					/* Expected response during authentication handshake */
+					transport->registrar.retries++;
+					SIPE_DEBUG_INFO("process_input_message: RE-REGISTER CSeq: %d", transport->cseq);
+				} else {
+					gchar *resend;
+
+					/* Are we registered? */
+					if (transport->reregister_set) {
+						SIPE_DEBUG_INFO_NOFORMAT("process_input_message: 401 response to non-REGISTER message. Retrying with new authentication.");
+						sign_outgoing_message(trans->msg,
+								 sipe_private,
+								 trans->msg->method);
+					} else {
+						/**
+						 * We don't have a valid authentication at the moment.
+						 * Resend message unchanged. It will be rejected again
+						 * and hopefully by then we have a valid authentication.
+						 */
+						SIPE_DEBUG_INFO_NOFORMAT("process_input_message: 401 response to non-REGISTER message. Bouncing...");
+					}
+
+					/* Resend request */
+					resend = sipmsg_to_string(trans->msg);
+					sipe_utils_message_debug("SIP", resend, NULL, TRUE);
+					sipe_backend_transport_message(sipe_private->transport->connection, resend);
+					g_free(resend);
+
+					/* Transaction not yet completed */
+					trans = NULL;
+				}
+
+			} else if (msg->response == 407) { /* Proxy Authentication Required */
+
+				if (transport->proxy.retries > 30) {
+					SIPE_DEBUG_ERROR_NOFORMAT("process_input_message: too many proxy authentication retries. Giving up.");
+				} else {
 				gchar *resend, *auth;
 				const gchar *ptmp;
 
-				if (transport->proxy.retries > 30) return;
 				transport->proxy.retries++;
-				/* do proxy authentication */
 
+					/* do proxy authentication */
 				ptmp = sipmsg_find_header(msg, "Proxy-Authenticate");
-
 				fill_auth(ptmp, &transport->proxy);
 				auth = auth_header(sipe_private, &transport->proxy, trans->msg);
 				sipmsg_remove_header_now(trans->msg, "Proxy-Authorization");
@@ -1358,68 +1478,33 @@
 				sipmsg_remove_header_now(trans->msg, "Proxy-Authorization");
 				sipmsg_add_header_now_pos(trans->msg, "Proxy-Authorization", auth, 5);
 				g_free(auth);
-				resend = sipmsg_to_string(trans->msg);
+
 				/* resend request */
+					resend = sipmsg_to_string(trans->msg);
 				sipe_utils_message_debug("SIP", resend, NULL, TRUE);
 				sipe_backend_transport_message(sipe_private->transport->connection, resend);
 				g_free(resend);
 
-			} else {
-				transport->proxy.retries = 0;
+					/* Transaction not yet completed */
+					trans = NULL;
+				}
 
-				if (sipe_strequal(trans->msg->method, "REGISTER")) {
-					if (msg->response == 401) {
-						transport->registrar.retries++;
 					} else {
 						transport->registrar.retries = 0;
-					}
-					SIPE_DEBUG_INFO("process_input_message: RE-REGISTER CSeq: %d", transport->cseq);
-
-				} else if (msg->response == 401) {
-					gchar *resend, *auth, *ptmp;
-					const char* auth_scheme;
-
-					if (transport->registrar.retries > 4) return;
-					transport->registrar.retries++;
-
-					auth_scheme = sipe_get_auth_scheme_name(sipe_private);
-					ptmp = sipmsg_find_auth_header(msg, auth_scheme);
-
-					SIPE_DEBUG_INFO("process_input_message: Auth header: %s", ptmp ? ptmp : "");
-					if (!ptmp) {
-						char *tmp2 = g_strconcat(_("Incompatible authentication scheme chosen"), ": ", auth_scheme, NULL);
-						sipe_backend_connection_error(SIPE_CORE_PUBLIC,
-									 SIPE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE,
-									 tmp2);
-						g_free(tmp2);
-						return;
-					}
-
-					fill_auth(ptmp, &transport->registrar);
-					auth = auth_header(sipe_private, &transport->registrar, trans->msg);
-					sipmsg_remove_header_now(trans->msg, "Authorization");
-					sipmsg_add_header_now_pos(trans->msg, "Authorization", auth, 5);
-					g_free(auth);
-					resend = sipmsg_to_string(trans->msg);
-					/* resend request */
-					sipe_utils_message_debug("SIP", resend, NULL, TRUE);
-					sipe_backend_transport_message(sipe_private->transport->connection, resend);
-					g_free(resend);
+				transport->proxy.retries = 0;
 				}
 
+			/* Is transaction completed? */
+			if (trans) {
 				if (trans->callback) {
 					SIPE_DEBUG_INFO_NOFORMAT("process_input_message: we have a transaction callback");
 					/* call the callback to process response*/
 					(trans->callback)(sipe_private, msg, trans);
 				}
 
-				/* Redirect: old content of "transport" is no longer valid */
-				transport = sipe_private->transport;
-
 				SIPE_DEBUG_INFO("process_input_message: removing CSeq %d", transport->cseq);
-				transactions_remove(transport, trans);
+				transactions_remove(sipe_private, trans);
 			}
-
 		} else {
 			SIPE_DEBUG_INFO_NOFORMAT("process_input_message: received response to unknown transaction");
 			notfound = TRUE;
@@ -1500,21 +1585,18 @@
 								 SIPE_CONNECTION_ERROR_NETWORK,
 								 _("Invalid message signature received"));
 				}
-			} else if (sipe_strequal(msg->method, "REGISTER")) {
-				/* We must always process REGISTER responses */
+			} else if ((msg->response == 401) ||
+				 sipe_strequal(msg->method, "REGISTER")) {
+				/* a) Retry non-REGISTER requests with updated authentication */
+				/* b) We must always process REGISTER responses */
 				process_input_message(sipe_private, msg);
-			} else if (msg->response == 401) {
-				SIPE_DEBUG_ERROR_NOFORMAT("sip_transport_input: 401 Unauthorized response to non-REGISTER message");
-				sipe_backend_connection_error(SIPE_CORE_PUBLIC,
-							 SIPE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
-							 _("Authentication failed"));
 			} else {
 				/* OCS sends provisional messages that are *not* signed */
 				if (msg->response >= 200) {
 					/* We are not calling process_input_message(),
 					 so we need to drop the transaction here. */
 					struct transaction *trans = transactions_find(transport, msg);
-					if (trans) transactions_remove(transport, trans);
+					if (trans) transactions_remove(sipe_private, trans);
 				}
 				SIPE_DEBUG_INFO_NOFORMAT("sip_transport_input: message without authentication data - ignoring");
 			}
@@ -1617,6 +1699,24 @@
 	service_tcp /* SIPE_TRANSPORT_TCP */
 };
 
+static void sipe_core_dns_resolved(struct sipe_core_public *sipe_public,
+				 const gchar *hostname, guint port)
+{
+	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
+
+	sipe_private->dns_query = NULL;
+
+	if (hostname) {
+		SIPE_DEBUG_INFO("sipe_core_dns_resolved - SRV hostname: %s port: %d",
+				hostname, port);
+		sipe_server_register(sipe_private,
+				 sipe_private->service_data->type,
+				 g_strdup(hostname), port);
+	} else {
+		resolve_next_service(SIPE_CORE_PRIVATE, NULL);
+	}
+}
+
 static void resolve_next_service(struct sipe_core_private *sipe_private,
 				 const struct sip_service_data *start)
 {
@@ -1643,26 +1743,12 @@
 	}
 
 	/* Try to resolve next service */
-	sipe_backend_dns_query(SIPE_CORE_PUBLIC,
+	sipe_private->dns_query = sipe_backend_dns_query_srv(
 			 sipe_private->service_data->protocol,
 			 sipe_private->service_data->transport,
-			 sipe_private->public.sip_domain);
-}
-
-void sipe_core_dns_resolved(struct sipe_core_public *sipe_public,
-			 const gchar *hostname, guint port)
-{
-	struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
-	SIPE_DEBUG_INFO("sipe_core_dns_resolved - SRV hostname: %s port: %d",
-			hostname, port);
-	sipe_server_register(sipe_private,
-			 sipe_private->service_data->type,
-			 g_strdup(hostname), port);
-}
-
-void sipe_core_dns_resolve_failure(struct sipe_core_public *sipe_public)
-{
-	resolve_next_service(SIPE_CORE_PRIVATE, NULL);
+					sipe_private->public.sip_domain,
+					(sipe_dns_resolved_cb) sipe_core_dns_resolved,
+					SIPE_CORE_PUBLIC);
 }
 
 void sipe_core_transport_sip_connect(struct sipe_core_public *sipe_public,
@@ -1702,6 +1788,16 @@
 				 "\r\n\r\n");
 }
 
+int sip_transaction_cseq(struct transaction *trans)
+{
+	int cseq;
+
+	g_return_val_if_fail(trans && trans->key, 0);
+
+	sscanf(trans->key, "<%*[a-zA-Z0-9]><%d INVITE>", &cseq);
+	return cseq;
+}
+
 /*
 Local Variables:
 mode: c
--- pidgin-sipe-1.11.2/src/core/sip-transport.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/core/sip-transport.h	2011-06-14 14:40:36.000000000 +0200
@@ -38,12 +38,14 @@
 
 struct transaction {
 	TransCallback callback;
+	TransCallback timeout_callback;
 
 	/** Not yet perfect, but surely better then plain CSeq
 	 * Format is: <Call-ID><CSeq>
 	 * (RFC3261 17.2.3 for matching server transactions: Request-URI, To tag, From tag, Call-ID, CSeq, and top Via)
 	 */
 	gchar *key;
+	gchar *timeout_key;
 struct sipmsg *msg;
 	struct transaction_payload *payload;
 };
@@ -65,12 +67,24 @@
 					 struct sip_dialog *dialog,
 					 TransCallback callback);
 
+/* Send SIP request with timeout [in seconds] */
+struct transaction *sip_transport_request_timeout(struct sipe_core_private *sipe_private,
+						 const gchar *method,
+						 const gchar *url,
+						 const gchar *to,
+						 const gchar *addheaders,
+						 const gchar *body,
+						 struct sip_dialog *dialog,
+						 TransCallback callback,
+						 guint timeout,
+						 TransCallback timeout_callback);
+
 /* Common SIP request types */
 void sip_transport_ack(struct sipe_core_private *sipe_private,
 		 struct sip_dialog *dialog);
 void sip_transport_bye(struct sipe_core_private *sipe_private,
 		 struct sip_dialog *dialog);
-void sip_transport_info(struct sipe_core_private *sipe_private,
+struct transaction *sip_transport_info(struct sipe_core_private *sipe_private,
 			const gchar *addheaders,
 			const gchar *body,
 			struct sip_dialog *dialog,
@@ -93,11 +107,12 @@
 			 TransCallback callback);
 
 /* Misc. SIP transport stuff */
-const gchar *sip_transport_user_agent(struct sipe_core_private *sipe_private);
 guint sip_transport_port(struct sipe_core_private *sipe_private);
 void sip_transport_deregister(struct sipe_core_private *sipe_private);
 void sip_transport_disconnect(struct sipe_core_private *sipe_private);
 
+int sip_transaction_cseq(struct transaction *trans);
+
 /*
 Local Variables:
 mode: c
--- pidgin-sipe-1.11.2/src/Makefile.am	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/Makefile.am	2011-06-14 14:40:36.000000000 +0200
@@ -12,5 +12,8 @@
 SUBDIRS += kopete
 endif
 
+EXTRA_DIST = \
+	miranda
+
 MAINTAINERCLEANFILES = \
 	Makefile.in
--- pidgin-sipe-1.11.2/src/purple/Makefile.am	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/Makefile.am	2011-06-14 14:40:36.000000000 +0200
@@ -9,19 +9,21 @@
 
 libsipe_backend_la_SOURCES = \
 	purple-private.h \
+	purple-buddy.c \
 	purple-chat.c \
 	purple-connection.c \
 	purple-debug.c \
 	purple-dnsquery.c \
 	purple-ft.c \
+	purple-groupchat.c \
 	purple-im.c \
 	purple-markup.c \
 	purple-network.c \
+	purple-notify.c \
 	purple-schedule.c \
 	purple-setting.c \
 	purple-transport.c \
-	purple-user.c \
-	purple-notify.c
+	purple-user.c
 
 libsipe_la_SOURCES = \
 	purple-plugin.c
@@ -89,8 +91,8 @@
 
 if SIPE_WITH_VV
 libsipe_backend_la_SOURCES += purple-media.c
-libsipe_backend_la_CFLAGS += $(NICE_CFLAGS)
-libsipe_la_LIBADD += $(NICE_LIBS)
+libsipe_backend_la_CFLAGS += $(NICE_CFLAGS) $(GSTREAMER_CFLAGS) 
+libsipe_la_LIBADD += $(NICE_LIBS) $(GSTREAMER_LIBS)
 endif
 
 TESTS = $(check_PROGRAMS)
--- pidgin-sipe-1.11.2/src/purple/purple-buddy.c	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-buddy.c	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,322 @@
+/**
+ * @file purple-buddy.c
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2010 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <glib.h>
+
+#include "purple-private.h"
+
+#include "blist.h"
+#include "privacy.h"
+
+#include "sipe-common.h"
+#include "sipe-backend.h"
+#include "sipe-core.h"
+#include "sipe-nls.h"
+
+static GHashTable *info_to_property_table = NULL;
+
+/** Property names to store in blist.xml */
+#define ALIAS_PROP			"alias"
+#define EMAIL_PROP			"email"
+#define PHONE_PROP			"phone"
+#define PHONE_DISPLAY_PROP		"phone-display"
+#define PHONE_MOBILE_PROP		"phone-mobile"
+#define PHONE_MOBILE_DISPLAY_PROP	"phone-mobile-display"
+#define PHONE_HOME_PROP			"phone-home"
+#define PHONE_HOME_DISPLAY_PROP		"phone-home-display"
+#define PHONE_OTHER_PROP		"phone-other"
+#define PHONE_OTHER_DISPLAY_PROP	"phone-other-display"
+#define PHONE_CUSTOM1_PROP		"phone-custom1"
+#define PHONE_CUSTOM1_DISPLAY_PROP	"phone-custom1-display"
+#define SITE_PROP			"site"
+#define COMPANY_PROP			"company"
+#define DEPARTMENT_PROP			"department"
+#define TITLE_PROP			"title"
+#define OFFICE_PROP			"office"
+/** implies work address */
+#define ADDRESS_STREET_PROP		"address-street"
+#define ADDRESS_CITY_PROP		"address-city"
+#define ADDRESS_STATE_PROP		"address-state"
+#define ADDRESS_ZIPCODE_PROP		"address-zipcode"
+#define ADDRESS_COUNTRYCODE_PROP	"address-country-code"
+
+#define ADD_PROP(key,value) g_hash_table_insert(info_to_property_table, (gpointer)key, value)
+
+static void
+init_property_hash(void)
+{
+	info_to_property_table = g_hash_table_new(NULL, NULL);
+
+	ADD_PROP(SIPE_BUDDY_INFO_DISPLAY_NAME , ALIAS_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_EMAIL , EMAIL_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_WORK_PHONE , PHONE_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY , PHONE_DISPLAY_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_SITE , SITE_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_COMPANY , COMPANY_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_DEPARTMENT , DEPARTMENT_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_JOB_TITLE , TITLE_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_OFFICE , OFFICE_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_STREET , ADDRESS_STREET_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_CITY , ADDRESS_CITY_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_STATE , ADDRESS_STATE_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_ZIPCODE , ADDRESS_ZIPCODE_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_COUNTRY , ADDRESS_COUNTRYCODE_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_MOBILE_PHONE , PHONE_MOBILE_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_MOBILE_PHONE_DISPLAY , PHONE_MOBILE_DISPLAY_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_HOME_PHONE , PHONE_HOME_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_HOME_PHONE_DISPLAY , PHONE_HOME_DISPLAY_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_OTHER_PHONE , PHONE_OTHER_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_OTHER_PHONE_DISPLAY , PHONE_OTHER_DISPLAY_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_CUSTOM1_PHONE , PHONE_CUSTOM1_PROP);
+	ADD_PROP(SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY, PHONE_CUSTOM1_DISPLAY_PROP);
+}
+
+static gchar *
+sipe_buddy_info_to_purple_property(sipe_buddy_info_fields info)
+{
+	if (!info_to_property_table)
+		init_property_hash();
+	return g_hash_table_lookup(info_to_property_table, (gpointer)info);
+}
+
+sipe_backend_buddy sipe_backend_buddy_find(struct sipe_core_public *sipe_public,
+					 const gchar *buddy_name,
+					 const gchar *group_name)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+	PurpleGroup *purple_group;
+
+	if (group_name)
+	{
+		purple_group = purple_find_group(group_name);
+		if (!purple_group)
+			return NULL;
+
+		return purple_find_buddy_in_group(purple_private->account,
+						 buddy_name,
+						 purple_group);
+	} else {
+		return purple_find_buddy(purple_private->account,
+					 buddy_name);
+	}
+}
+
+GSList* sipe_backend_buddy_find_all(struct sipe_core_public *sipe_public,
+				 const gchar *buddy_name,
+				 const gchar *group_name)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+
+	if (group_name)
+	{
+		SIPE_DEBUG_ERROR_NOFORMAT("Finding all buddies in a group not supported on purple");
+		return NULL;
+	}
+
+	return purple_find_buddies(purple_private->account, buddy_name);
+}
+
+gchar* sipe_backend_buddy_get_name(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+				 const sipe_backend_buddy who)
+{
+	return g_strdup(((PurpleBuddy*)who)->name);
+}
+
+gchar* sipe_backend_buddy_get_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+				 const sipe_backend_buddy who)
+{
+	return g_strdup(purple_buddy_get_alias(who));
+}
+
+gchar* sipe_backend_buddy_get_server_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+					 const sipe_backend_buddy who)
+{
+	return g_strdup(purple_buddy_get_server_alias(who));
+}
+
+gchar* sipe_backend_buddy_get_group_name(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+					 const sipe_backend_buddy who)
+{
+	return g_strdup(purple_buddy_get_group((PurpleBuddy*)who)->name);
+}
+
+void sipe_backend_buddy_set_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+				 const sipe_backend_buddy who,
+				 const gchar *alias)
+{
+	purple_blist_alias_buddy(who, alias);
+}
+
+void sipe_backend_buddy_set_server_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+					 const sipe_backend_buddy who,
+					 const gchar *alias)
+{
+	purple_blist_server_alias_buddy(who, alias);
+}
+
+gchar* sipe_backend_buddy_get_string(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+				 sipe_backend_buddy buddy,
+				 const sipe_buddy_info_fields key)
+{
+	PurpleBuddy *b = (PurpleBuddy*) buddy;
+	return g_strdup(purple_blist_node_get_string(&b->node, sipe_buddy_info_to_purple_property(key)));
+}
+
+void sipe_backend_buddy_set_string(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+				 sipe_backend_buddy buddy,
+				 const sipe_buddy_info_fields key,
+				 const gchar *val)
+{
+	PurpleBuddy *b = (PurpleBuddy*) buddy;
+	purple_blist_node_set_string(&b->node, sipe_buddy_info_to_purple_property(key), val);
+}
+
+sipe_backend_buddy sipe_backend_buddy_add(struct sipe_core_public *sipe_public,
+					 const gchar *name,
+					 const gchar *alias,
+					 const gchar *groupname)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+	PurpleBuddy *b;
+	PurpleGroup *purple_group = purple_find_group(groupname);
+
+	if (!purple_group)
+		return NULL;
+
+	b = purple_buddy_new(purple_private->account, name, alias);
+	purple_blist_add_buddy(b, NULL, purple_group, NULL);
+	return b;
+}
+
+void sipe_backend_buddy_remove(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+			 const sipe_backend_buddy who)
+{
+	purple_blist_remove_buddy(who);
+}
+
+void sipe_backend_buddy_request_authorization(struct sipe_core_public *sipe_public,
+					 const gchar *who,
+					 const gchar *alias,
+					 gboolean on_list,
+					 sipe_backend_buddy_request_authorization_cb auth_cb,
+					 sipe_backend_buddy_request_authorization_cb deny_cb,
+					 gpointer data)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+
+	purple_account_request_authorization(
+		purple_private->account,
+		who,
+		_("you"), /* id */
+		alias,
+		NULL, /* message */
+		on_list,
+		auth_cb,
+		deny_cb,
+		data);
+
+}
+
+void sipe_backend_buddy_request_add(struct sipe_core_public *sipe_public,
+				 const gchar *who,
+				 const gchar *alias)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+
+	purple_account_request_add(purple_private->account,
+				 who,
+				 _("you"),
+				 alias,
+				 NULL);
+
+}
+
+gboolean sipe_backend_buddy_is_blocked(struct sipe_core_public *sipe_public,
+				 const gchar *who)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+
+	return !purple_privacy_check(purple_private->account, who);
+}
+
+void sipe_backend_buddy_set_blocked_status(struct sipe_core_public *sipe_public,
+				 const gchar *who,
+				 gboolean blocked)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+
+	if (blocked) {
+		purple_privacy_deny_add(purple_private->account, who, TRUE);
+	} else {
+		purple_privacy_deny_remove(purple_private->account, who, TRUE);
+	}
+
+	/* stupid workaround to make pidgin re-render screen to reflect our changes */
+	{
+		PurpleBuddy *pbuddy = purple_find_buddy(purple_private->account, who);
+		const PurplePresence *presence = purple_buddy_get_presence(pbuddy);
+		const PurpleStatus *pstatus = purple_presence_get_active_status(presence);
+
+		SIPE_DEBUG_INFO_NOFORMAT("sipe_backend_buddy_set_blocked_status: forcefully refreshing screen.");
+		sipe_core_buddy_got_status(sipe_public, who, purple_status_get_id(pstatus));
+	}
+
+}
+
+void sipe_backend_buddy_set_status(struct sipe_core_public *sipe_public,
+				 const gchar *who,
+				 const gchar *status_id)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+
+	purple_prpl_got_user_status(purple_private->account, who, status_id, NULL);
+}
+
+gboolean sipe_backend_buddy_group_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
+				 const gchar *group_name)
+{
+	PurpleGroup * purple_group = purple_find_group(group_name);
+	if (!purple_group) {
+		purple_group = purple_group_new(group_name);
+		purple_blist_add_group(purple_group, NULL);
+	}
+
+	return (purple_group != NULL);
+}
+
+void sipe_purple_group_buddy(PurpleConnection *gc,
+			 const char *who,
+			 const char *old_group_name,
+			 const char *new_group_name)
+{
+	sipe_core_buddy_group(PURPLE_GC_TO_SIPE_CORE_PUBLIC, who, old_group_name, new_group_name);
+}
+
+
+/*
+ Local Variables:
+ mode: c
+ c-file-style: "bsd"
+ indent-tabs-mode: t
+ tab-width: 8
+ End:
+*/
--- pidgin-sipe-1.11.2/src/purple/purple-chat.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-chat.c	2011-06-14 14:40:36.000000000 +0200
@@ -22,22 +22,268 @@
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
 #include <time.h>
+#include <errno.h>
 
 #include <glib.h>
 
+#include "blist.h"
 #include "conversation.h"
 #include "server.h"
+/* for ENOTCONN */
+#ifdef _WIN32
+#include "win32/win32dep.h"
+#endif 
 
+#include "sipe-common.h"
 #include "sipe-backend.h"
 #include "sipe-core.h"
+#include "sipe-nls.h"
 
+#define _PurpleMessageFlags PurpleMessageFlags
 #include "purple-private.h"
 
+/**
+ * Mapping between chat sessions in SIPE core and libpurple backend
+ *
+ * PurpleAccount
+ * This data structure is created when the user creates the account or at
+ * startup. It lives as long as the account exists, i.e. until the user
+ * deletes it or shutdown.
+ *
+ * Value does not change when connection is dropped & re-created.
+ * HAS: gc (PurpleConnection *)
+ *
+ * PurpleConversation / PurpleConvChat (sub-type)
+ * This data structure is created by serv_got_join_chat(). It lives as long
+ * as the user doesn't leave the chat or until shutdown.
+ *
+ * Value does not change when connection is dropped & re-created.
+ * HAS: account (PurpleAccount *)
+ * HAS: chat ID (int), must be unique
+ * HAS: name (char *), must be unique
+ * HAS: data (GHashTable *)
+ *
+ * PurpleConnection
+ * This data structure is created when the connection to the service is
+ * set up. It lives as long as the connection stays open, the user disables
+ * the account or until shutdown.
+ *
+ * Value *DOES NOT* survive a connection drop & re-creation.
+ * ASSOCIATED TO: account
+ *
+ * SIPE -> libpurple API
+ * add user: purple_conv_chat_add_user(conv, ...)
+ * create: serv_got_joined_chat(gc, chat ID, name)
+ * find user: purple_conv_chat_find_user(conv, ...)
+ * message: serv_got_chat_in(gc, chat ID, ...)
+ * remove user: purple_conv_chat_remove_user(conv, ...)
+ * topic: purple_conv_chat_set_topic(conv, ...)
+ *
+ * libpurple -> SIPE API
+ * join_chat(gc, params (GHashTable *))
+ * request to join a channel (again) [only Group Chat]
+ * SIPE must call serv_got_joined_chat() on join response
+ *
+ * reject_chat(gc, params (GHashTable *)) NOT IMPLEMENTED
+ * get_chat_name(params (GHashTable *)) NOT IMPLEMENTED
+ *
+ * chat_invite(gc, chat ID,...)
+ * invite a user to a join a chat
+ *
+ * chat_leave(gc, chat ID)
+ * request to leave a channel, also called on conversation destroy
+ * SIPE must call serv_got_chat_left() immediately!
+ *
+ * chat_whisper(gc, chat ID, ...) NOT IMPLEMENTED
+ *
+ * chat_send(gc, chat ID, ...)
+ * send a message to the channel
+ *
+ * set_chat_topic(gc, chat ID, ...) NOT IMPLEMENTED
+ * set channel topic [@TODO: for Group Chat]
+ *
+ *
+ * struct sipe_chat_session
+ * Same life span as PurpleConversation
+ * Pointer stored under key "sipe" in PurpleConversation->data
+ * Contains information private to core to identify chat session on server
+ *
+ * If connection is closed and THEN the conversation, then libpurple will
+ * not call chat_leave() and this will be a dangling data structure! Core
+ * must take care to release them at unload.
+ *
+ * HAS: backend_session (gpointer) -> PurpleConversation
+ *
+ * struct sipe_backend_private
+ *
+ * HAS: rejoin_chats (GList *)
+ * created on login() for existing chats
+ * initiate re-join calls to core (sipe_backend_chat_rejoin_all)
+ */
+
+#define SIPE_PURPLE_KEY_CHAT_SESSION "sipe"
+
 #define BACKEND_SESSION_TO_PURPLE_CONV_CHAT(s) \
 	(PURPLE_CONV_CHAT(((PurpleConversation *)s)))
 
-void sipe_backend_chat_add(struct sipe_backend_session *backend_session,
+#define PURPLE_CONV_TO_SIPE_CORE_PUBLIC ((struct sipe_core_public *) conv->account->gc->proto_data)
+
+static struct sipe_chat_session *sipe_purple_chat_get_session(PurpleConversation *conv)
+{
+	return purple_conversation_get_data(conv,
+					 SIPE_PURPLE_KEY_CHAT_SESSION);
+}
+
+static struct sipe_chat_session *sipe_purple_chat_find(PurpleConnection *gc,
+						 int id)
+{
+	PurpleConversation *conv = purple_find_chat(gc, id);
+
+	if (!conv) {
+		SIPE_DEBUG_ERROR("sipe_purple_chat_find: can't find chat with ID %d?!?",
+				 id);
+		return NULL;
+	}
+
+	return sipe_purple_chat_get_session(conv);
+}
+
+void sipe_purple_chat_setup_rejoin(struct sipe_backend_private *purple_private)
+{
+	GList *entry = purple_get_chats();
+
+	while (entry) {
+		PurpleConversation *conv = entry->data;
+		if (purple_conversation_get_gc(conv) == purple_private->gc)
+			purple_private->rejoin_chats = g_list_prepend(purple_private->rejoin_chats,
+								 sipe_purple_chat_get_session(conv));
+		entry = entry->next;
+	}
+}
+
+void sipe_purple_chat_destroy_rejoin(struct sipe_backend_private *purple_private)
+{
+	g_list_free(purple_private->rejoin_chats);
+	purple_private->rejoin_chats = NULL;
+}
+
+void sipe_purple_chat_invite(PurpleConnection *gc, int id,
+			 SIPE_UNUSED_PARAMETER const char *message,
+			 const char *name)
+{
+	struct sipe_chat_session *session = sipe_purple_chat_find(gc, id);
+	if (!session) return;
+
+	sipe_core_chat_invite(PURPLE_GC_TO_SIPE_CORE_PUBLIC, session, name);
+}
+
+void sipe_purple_chat_leave(PurpleConnection *gc, int id)
+{
+	struct sipe_chat_session *session = sipe_purple_chat_find(gc, id);
+	if (!session) return;
+
+	sipe_core_chat_leave(PURPLE_GC_TO_SIPE_CORE_PUBLIC, session);
+}
+
+int sipe_purple_chat_send(PurpleConnection *gc,
+			 int id,
+			 const char *what,
+			 SIPE_UNUSED_PARAMETER PurpleMessageFlags flags)
+{
+	struct sipe_chat_session *session = sipe_purple_chat_find(gc, id);
+	if (!session) return -ENOTCONN;
+	sipe_core_chat_send(PURPLE_GC_TO_SIPE_CORE_PUBLIC, session, what);
+	return 1;
+}
+
+static void sipe_purple_chat_menu_unlock_cb(SIPE_UNUSED_PARAMETER PurpleChat *chat,
+					 PurpleConversation *conv)
+{
+	struct sipe_core_public *sipe_public = PURPLE_CONV_TO_SIPE_CORE_PUBLIC;
+	struct sipe_chat_session *chat_session = sipe_purple_chat_get_session(conv);
+	SIPE_DEBUG_INFO("sipe_purple_chat_menu_lock_cb: %p %p", conv, chat_session);
+	sipe_core_chat_modify_lock(sipe_public, chat_session, FALSE);
+}
+
+static void sipe_purple_chat_menu_lock_cb(SIPE_UNUSED_PARAMETER PurpleChat *chat,
+					 PurpleConversation *conv)
+{
+	struct sipe_core_public *sipe_public = PURPLE_CONV_TO_SIPE_CORE_PUBLIC;
+	struct sipe_chat_session *chat_session = sipe_purple_chat_get_session(conv);
+	SIPE_DEBUG_INFO("sipe_purple_chat_menu_lock_cb: %p %p", conv, chat_session);
+	sipe_core_chat_modify_lock(sipe_public, chat_session, TRUE);
+}
+
+#ifdef HAVE_VV
+
+static void sipe_purple_chat_menu_join_call_cb(SIPE_UNUSED_PARAMETER PurpleChat *chat,
+					 PurpleConversation *conv)
+{
+	struct sipe_core_public *sipe_public = PURPLE_CONV_TO_SIPE_CORE_PUBLIC;
+	struct sipe_chat_session *chat_session = sipe_purple_chat_get_session(conv);
+	SIPE_DEBUG_INFO("sipe_purple_chat_join_call_cb: %p %p", conv, chat_session);
+	sipe_core_media_connect_conference(sipe_public, chat_session);
+}
+
+#endif
+
+GList *
+sipe_purple_chat_menu(PurpleChat *chat)
+{
+	PurpleConversation *conv = g_hash_table_lookup(chat->components,
+						 SIPE_PURPLE_COMPONENT_KEY_CONVERSATION);
+	GList *menu = NULL;
+
+	if (conv) {
+		PurpleMenuAction *act = NULL;
+
+		SIPE_DEBUG_INFO("sipe_purple_chat_menu: %p", conv);
+
+		switch (sipe_core_chat_lock_status(PURPLE_CONV_TO_SIPE_CORE_PUBLIC,
+						 sipe_purple_chat_get_session(conv))) {
+		case SIPE_CHAT_LOCK_STATUS_UNLOCKED:
+			act = purple_menu_action_new(_("Lock"),
+						 PURPLE_CALLBACK(sipe_purple_chat_menu_lock_cb),
+						 conv, NULL);
+			break;
+		case SIPE_CHAT_LOCK_STATUS_LOCKED:
+			act = purple_menu_action_new(_("Unlock"),
+						 PURPLE_CALLBACK(sipe_purple_chat_menu_unlock_cb),
+						 conv, NULL);
+			break;
+		default:
+			/* Not allowed */
+			break;
+		}
+
+		if (act)
+			menu = g_list_prepend(menu, act);
+#ifdef HAVE_VV
+		if (!sipe_core_media_in_call(PURPLE_CONV_TO_SIPE_CORE_PUBLIC)) {
+			act = NULL;
+			act = purple_menu_action_new(_("Join conference call"),
+						 PURPLE_CALLBACK(sipe_purple_chat_menu_join_call_cb),
+						 conv, NULL);
+			if (act)
+				menu = g_list_prepend(menu, act);
+		}
+#endif
+	}
+
+	return menu;
+}
+
+void sipe_backend_chat_session_destroy(SIPE_UNUSED_PARAMETER struct sipe_backend_chat_session *session)
+{
+	/* Nothing to do here */
+}
+
+void sipe_backend_chat_add(struct sipe_backend_chat_session *backend_session,
 			 const gchar *uri,
 			 gboolean is_new)
 {
@@ -45,49 +291,51 @@
 				 uri, NULL, PURPLE_CBFLAGS_NONE, is_new);
 }
 
-void sipe_backend_chat_close(struct sipe_backend_session *backend_session)
+void sipe_backend_chat_close(struct sipe_backend_chat_session *backend_session)
 {
 	purple_conv_chat_clear_users(BACKEND_SESSION_TO_PURPLE_CONV_CHAT(backend_session));
 }
 
-struct sipe_backend_session *sipe_backend_chat_create(struct sipe_core_public *sipe_public,
-						 int id,
-						 const gchar *title,
-						 const gchar *nick,
-						 gboolean rejoin)
+static int sipe_purple_chat_id(PurpleConnection *gc)
 {
-	struct sipe_backend_private *purple_private = sipe_public->backend_private;
-	PurpleConversation *conv = NULL;
+	/**
+	 * A non-volatile ID counter.
+	 * Should survive connection drop & reconnect.
+	 */
+	static int chat_id = 0;
 
-	if (rejoin) {
-		/* can't be find by chat id as it won't survive acc reinstantation */
-		if (title) {
-			conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
-								 title,
-								 purple_private->account);
-		}
-		/* to be able to rejoin existing chat/window */
-		if (conv && !purple_conv_chat_has_left(PURPLE_CONV_CHAT(conv))) {
-			PURPLE_CONV_CHAT(conv)->left = TRUE;
-		}
+	/* Find next free ID */
+	do {
+		if (++chat_id < 0) chat_id = 0;
+	} while (purple_find_chat(gc, chat_id) != NULL)
+;
+	return chat_id;
 	}
 
-	/* create prpl chat */
-	conv = serv_got_joined_chat(purple_private->gc,
-				 id,
+struct sipe_backend_chat_session *sipe_backend_chat_create(struct sipe_core_public *sipe_public,
+							 struct sipe_chat_session *session,
+							 const gchar *title,
+							 const gchar *nick)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+	PurpleConversation *conv = serv_got_joined_chat(purple_private->gc,
+							sipe_purple_chat_id(purple_private->gc),
 				 title);
+	purple_conversation_set_data(conv,
+				 SIPE_PURPLE_KEY_CHAT_SESSION,
+				 session);
 	purple_conv_chat_set_nick(PURPLE_CONV_CHAT(conv), nick);
-	return((struct sipe_backend_session *) conv);
+	return((struct sipe_backend_chat_session *) conv);
 }
 
-gboolean sipe_backend_chat_find(struct sipe_backend_session *backend_session,
+gboolean sipe_backend_chat_find(struct sipe_backend_chat_session *backend_session,
 			 const gchar *uri)
 {
 	return purple_conv_chat_find_user(BACKEND_SESSION_TO_PURPLE_CONV_CHAT(backend_session),
 					 uri);
 }
 
-gboolean sipe_backend_chat_is_operator(struct sipe_backend_session *backend_session,
+gboolean sipe_backend_chat_is_operator(struct sipe_backend_chat_session *backend_session,
 				 const gchar *uri)
 {
 	return (purple_conv_chat_user_get_flags(BACKEND_SESSION_TO_PURPLE_CONV_CHAT(backend_session),
@@ -96,20 +344,20 @@
 }
 
 void sipe_backend_chat_message(struct sipe_core_public *sipe_public,
-			 int id,
+			 struct sipe_backend_chat_session *backend_session,
 			 const gchar *from,
 			 const gchar *html)
 {
 	struct sipe_backend_private *purple_private = sipe_public->backend_private;
 	serv_got_chat_in(purple_private->gc,
-			 id,
+			 purple_conv_chat_get_id(BACKEND_SESSION_TO_PURPLE_CONV_CHAT(backend_session)),
 			 from,
 			 PURPLE_MESSAGE_RECV,
 			 html,
 			 time(NULL));
 }
 						 
-void sipe_backend_chat_operator(struct sipe_backend_session *backend_session,
+void sipe_backend_chat_operator(struct sipe_backend_chat_session *backend_session,
 				const gchar *uri)
 {
 	purple_conv_chat_user_set_flags(BACKEND_SESSION_TO_PURPLE_CONV_CHAT(backend_session),
@@ -117,32 +365,44 @@
 					PURPLE_CBFLAGS_NONE | PURPLE_CBFLAGS_OP);
 }
 
+void sipe_backend_chat_rejoin(struct sipe_core_public *sipe_public,
+			 struct sipe_backend_chat_session *backend_session,
+			 const gchar *nick,
+			 const gchar *title)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+	PurpleConvChat *chat = BACKEND_SESSION_TO_PURPLE_CONV_CHAT(backend_session);
+	PurpleConversation *new;
+
 /**
- * Allows to send typed messages from chat window again after
- * account reinstantiation.
- *
- * @TODO: is this really necessary? No other purple protocol plugin
- * seems to have this kind of code...
+	 * As the chat is marked as "left", serv_got_joined_chat() will
+	 * do a "rejoin cleanup" and return the same conversation.
 */
-void sipe_backend_chat_rejoin_all(struct sipe_core_public *sipe_public)
+	new = serv_got_joined_chat(purple_private->gc,
+				 purple_conv_chat_get_id(chat),
+				 title);
+	SIPE_DEBUG_INFO("sipe_backend_chat_rejoin: old %p (%p) == new %p (%p)",
+			backend_session, chat,
+			new, PURPLE_CONV_CHAT(new));
+	purple_conv_chat_set_nick(chat, nick);
+}
 	
+/**
+ * Connection re-established: tell core what chats need to be rejoined
+ */
+void sipe_backend_chat_rejoin_all(struct sipe_core_public *sipe_public)
 {
 	struct sipe_backend_private *purple_private = sipe_public->backend_private;
-	GList *entry = purple_get_chats();
+	GList *entry = purple_private->rejoin_chats;
 
 	while (entry) {
-		PurpleConversation *conv = entry->data;
-		if ((purple_conversation_get_gc(conv) == purple_private->gc) &&
-		 purple_conv_chat_has_left(PURPLE_CONV_CHAT(conv))) {
-			PURPLE_CONV_CHAT(conv)->left = FALSE;
-			purple_conversation_update(conv,
-						 PURPLE_CONV_UPDATE_CHATLEFT);
-		}
+		sipe_core_chat_rejoin(sipe_public, entry->data);
 		entry = entry->next;
 	}
+	sipe_purple_chat_destroy_rejoin(purple_private);
 }
 
-void sipe_backend_chat_remove(struct sipe_backend_session *backend_session,
+void sipe_backend_chat_remove(struct sipe_backend_chat_session *backend_session,
 			 const gchar *uri)
 {
 	purple_conv_chat_remove_user(BACKEND_SESSION_TO_PURPLE_CONV_CHAT(backend_session),
@@ -150,7 +410,15 @@
 				 NULL /* reason */);
 }
 
-void sipe_backend_chat_topic(struct sipe_backend_session *backend_session,
+void sipe_backend_chat_show(struct sipe_backend_chat_session *backend_session)
+{
+	/* Bring existing purple chat to the front */
+	/* @TODO: This seems to the trick, but is it the correct way? */
+	purple_conversation_update((PurpleConversation *) backend_session,
+				 PURPLE_CONV_UPDATE_TOPIC);
+}
+
+void sipe_backend_chat_topic(struct sipe_backend_chat_session *backend_session,
 			 const gchar *topic)
 {
 	purple_conv_chat_set_topic(BACKEND_SESSION_TO_PURPLE_CONV_CHAT(backend_session),
--- pidgin-sipe-1.11.2/src/purple/purple-crypt.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-crypt.c	2011-06-14 14:40:36.000000000 +0200
@@ -29,11 +29,10 @@
 		 const guchar *plaintext, gsize plaintext_length,
 		 guchar *encrypted_text)
 {
-	size_t dummy;
-	size_t p_length = plaintext_length; /* libpurple API makes this necessary :-( */
+	gsize dummy;
 	PurpleCipherContext *context = purple_cipher_context_new_by_name("des", NULL);
 	purple_cipher_context_set_key(context, key);
-	purple_cipher_context_encrypt(context, plaintext, p_length, encrypted_text, &dummy);
+	purple_cipher_context_encrypt(context, plaintext, plaintext_length, encrypted_text, &dummy);
 	purple_cipher_context_destroy(context);
 }
 
@@ -41,12 +40,11 @@
 		 const guchar *plaintext, gsize plaintext_length,
 		 guchar *encrypted_text)
 {
-	size_t dummy;
-	size_t p_length = plaintext_length; /* libpurple API makes this necessary :-( */
+	gsize dummy;
 	PurpleCipherContext *context = purple_cipher_context_new_by_name("rc4", NULL);
 	purple_cipher_context_set_option(context, "key_len", (gpointer)key_length);
 	purple_cipher_context_set_key(context, key);
-	purple_cipher_context_encrypt(context, plaintext, p_length, encrypted_text, &dummy);
+	purple_cipher_context_encrypt(context, plaintext, plaintext_length, encrypted_text, &dummy);
 	purple_cipher_context_destroy(context);
 }
 
@@ -64,8 +62,7 @@
 			 const guchar *in, gsize length,
 			 guchar *out)
 {
-	size_t tmp = length; /* libpurple API makes this necessary :-( */
-	purple_cipher_context_encrypt(context, in, tmp, out, NULL);
+	purple_cipher_context_encrypt(context, in, length, out, NULL);
 }
 
 void sipe_crypt_ft_destroy(gpointer context)
--- pidgin-sipe-1.11.2/src/purple/purple-dnsquery.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-dnsquery.c	2011-06-14 14:40:36.000000000 +0200
@@ -20,48 +20,135 @@
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "glib.h"
+#ifdef _WIN32
+#include "win32/win32dep.h" /* for inet_ntop() */
+#include <ws2tcpip.h>
+#else
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#endif
 
+#include <glib.h>
+
+#include "dnsquery.h"
 #include "dnssrv.h"
 
 #include "sipe-backend.h"
-#include "sipe-core.h"
 
-#include "purple-private.h"
+struct sipe_dns_query {
+	enum {
+		A,
+		SRV
+	} type;
+	sipe_dns_resolved_cb callback;
+	gpointer	 extradata;
+	gpointer	 purple_query_data;
+};
+
+static void dns_a_response(GSList *hosts,
+			 struct sipe_dns_query *query,
+			 const char *error_message)
+{
+	char ipstr[INET6_ADDRSTRLEN];
+	struct sockaddr *addr;
+	const void *addrdata;
+	int port;
+
+	if (error_message || !g_slist_next(hosts)) {
+		query->callback(query->extradata, NULL, 0);
+		g_slist_free(hosts);
+		return;
+	}
 
-static void dns_srv_response(PurpleSrvResponse *resp,
-			 int results,
+	addr = g_slist_next(hosts)->data;
+	if (addr->sa_family == AF_INET6) {
+		/* OS provides addr so it must be properly aligned */
+		struct sockaddr_in6 *sin6 = (void *) addr;
+		addrdata = &sin6->sin6_addr;
+		port = sin6->sin6_port;
+	} else {
+		/* OS provides addr so it must be properly aligned */
+		struct sockaddr_in *sin = (void *) addr;
+		addrdata = &sin->sin_addr;
+		port = sin->sin_port;
+	}
+
+	inet_ntop(addr->sa_family, addrdata, ipstr, sizeof (ipstr));
+
+	query->callback(query->extradata, ipstr, port);
+
+	for (; hosts; hosts = g_slist_delete_link(hosts, hosts)) {
+		// Free the addrlen, no data in this link
+		hosts = g_slist_delete_link(hosts, hosts);
+		// Free the address
+		g_free(hosts->data);
+	}
+
+	g_free(query);
+}
+
+struct sipe_dns_query *sipe_backend_dns_query_a(const gchar *hostname,
+						int port,
+						sipe_dns_resolved_cb callback,
 			 gpointer data)
 {
-	struct sipe_backend_private *purple_private = data;
+	struct sipe_dns_query *query = g_new(struct sipe_dns_query, 1);
+	query->type = A;
+	query->callback = callback;
+	query->extradata = data;
+	query->purple_query_data = purple_dnsquery_a(hostname,
+						 port,
+						 (PurpleDnsQueryConnectFunction) dns_a_response,
+						 query);
+
+	return query;
+}
+
 
-	/* data no longer needed and free'd by libpurple */
-	purple_private->dns_query = NULL;
+static void dns_srv_response(PurpleSrvResponse *resp,
+			 int results,
+			 struct sipe_dns_query *query)
+{
+	if (results)
+		query->callback(query->extradata, resp->hostname, resp->port);
+	else
+		query->callback(query->extradata, NULL, 0);
 
-	/* find the host to connect to */
-	if (results) {
-		sipe_core_dns_resolved(purple_private->public,
-				 resp->hostname,
-				 resp->port);
+	g_free(query);
 		g_free(resp);
-	} else {
-		sipe_core_dns_resolve_failure(purple_private->public);
-	}
 }
 
-void sipe_backend_dns_query(struct sipe_core_public *sipe_public,
-			 const gchar *protocol,
+struct sipe_dns_query *sipe_backend_dns_query_srv(const gchar *protocol,
 			 const gchar *transport,
-			 const gchar *domain)
+						 const gchar *domain,
+						 sipe_dns_resolved_cb callback,
+						 gpointer data)
 {
-	struct sipe_backend_private *purple_private = sipe_public->backend_private;
-
-	/* Try to resolve next service */
-	purple_private->dns_query = purple_srv_resolve(protocol,
+	struct sipe_dns_query *query = g_new(struct sipe_dns_query, 1);
+	query->type = SRV;
+	query->callback = callback;
+	query->extradata = data;
+	query->purple_query_data = purple_srv_resolve(protocol,
 						 transport,
 						 domain,
-						 dns_srv_response,
-						 purple_private);
+						 (PurpleSrvCallback) dns_srv_response,
+						 query);
+
+	return query;
+}
+
+void sipe_backend_dns_query_cancel(struct sipe_dns_query *query)
+{
+	switch (query->type) {
+		case A:
+			purple_dnsquery_destroy(query->purple_query_data);
+			break;
+		case SRV:
+			purple_srv_cancel(query->purple_query_data);
+			break;
+	}
+
+	g_free(query);
 }
 
 /*
--- pidgin-sipe-1.11.2/src/purple/purple-ft.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-ft.c	2011-06-14 14:40:36.000000000 +0200
@@ -29,50 +29,29 @@
 #include <string.h>
 #include <fcntl.h>
 #include <errno.h>
-#include <time.h>
 
 #include <glib.h>
 
-#include "connection.h"
-#include "eventloop.h"
 #include "ft.h"
-#include "network.h"
-#include "request.h"
 
 #ifdef _WIN32
-/* for network */
 #include "win32/libc_interface.h"
-#include <nspapi.h>
-#else
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <net/if.h>
-#include <arpa/inet.h>
-#ifdef HAVE_SYS_SOCKIO_H
-#include <sys/sockio.h> /* SIOCGIFCONF for Solaris */
-#endif
 #endif
 
 #include "sipe-common.h"
 #include "sipe-backend.h"
 #include "sipe-core.h"
-#include "sipe-nls.h"
 
 #include "purple-private.h"
 
-struct sipe_backend_file_transfer {
-	PurpleXfer *xfer;
-	PurpleNetworkListenData *listener;
-	int listenfd;
-};
+#define PURPLE_XFER ((PurpleXfer *) ft->backend_private)
 #define PURPLE_XFER_TO_SIPE_FILE_TRANSFER ((struct sipe_file_transfer *) xfer->data)
 #define PURPLE_XFER_TO_SIPE_CORE_PUBLIC ((struct sipe_core_public *) xfer->account->gc->proto_data)
 
 void sipe_backend_ft_error(struct sipe_file_transfer *ft,
 			 const char *errmsg)
 {
-	PurpleXfer *xfer = ft->backend_private->xfer;
+	PurpleXfer *xfer = PURPLE_XFER;
 	purple_xfer_error(purple_xfer_get_type(xfer),
 			 xfer->account, xfer->who,
 			 errmsg);
@@ -85,18 +64,9 @@
 
 void sipe_backend_ft_deallocate(struct sipe_file_transfer *ft)
 {
-	struct sipe_backend_file_transfer *backend_ft = ft->backend_private;
-	PurpleXfer *xfer = backend_ft->xfer;
+	PurpleXfer *xfer = PURPLE_XFER;
 	PurpleXferStatusType status = purple_xfer_get_status(xfer);
 
-	if (backend_ft->listenfd >= 0) {
-		SIPE_DEBUG_INFO("sipe_ft_free_xfer_struct: closing listening socket %d",
-				backend_ft->listenfd);
-		close(backend_ft->listenfd);
-	}
-	if (backend_ft->listener)
-		purple_network_listen_cancel(backend_ft->listener);
-
 	// If file transfer is not finished, cancel it
 	if ( status != PURPLE_XFER_STATUS_DONE
 		&& status != PURPLE_XFER_STATUS_CANCEL_LOCAL
@@ -105,15 +75,13 @@
 		purple_xfer_set_cancel_send_fnc(xfer, NULL);
 		purple_xfer_cancel_remote(xfer);
 	}
-
-	g_free(backend_ft);
 }
 
 gssize sipe_backend_ft_read(struct sipe_file_transfer *ft,
 			 guchar *data,
 			 gsize size)
 {
-	gssize bytes_read = read(ft->backend_private->xfer->fd, data, size);
+	gssize bytes_read = read(PURPLE_XFER->fd, data, size);
 	if (bytes_read == 0) {
 		/* Sender canceled transfer before it was finished */
 		return -2;
@@ -130,8 +98,7 @@
 			 const guchar *data,
 			 gsize size)
 {
-	gssize bytes_written = write(ft->backend_private->xfer->fd,
-				 data, size);
+	gssize bytes_written = write(PURPLE_XFER->fd, data, size);
 	if (bytes_written == -1) {
 		if (errno == EAGAIN)
 			return 0;
@@ -143,16 +110,16 @@
 
 void sipe_backend_ft_cancel_local(struct sipe_file_transfer *ft)
 {
-	purple_xfer_cancel_local(ft->backend_private->xfer);
+	purple_xfer_cancel_local(PURPLE_XFER);
 }
 
 void sipe_backend_ft_cancel_remote(struct sipe_file_transfer *ft)
 {
-	purple_xfer_cancel_remote(ft->backend_private->xfer);
+	purple_xfer_cancel_remote(PURPLE_XFER);
 }
 
 static void
-sipe_ft_free_xfer_struct(PurpleXfer *xfer)
+ft_free_xfer_struct(PurpleXfer *xfer)
 {
 	struct sipe_file_transfer *ft = PURPLE_XFER_TO_SIPE_FILE_TRANSFER;
 
@@ -167,48 +134,48 @@
 }
 
 static void
-sipe_ft_request_denied(PurpleXfer *xfer)
+ft_request_denied(PurpleXfer *xfer)
 {
 	if (xfer->type == PURPLE_XFER_RECEIVE)
 		sipe_core_ft_cancel(PURPLE_XFER_TO_SIPE_FILE_TRANSFER);
-	sipe_ft_free_xfer_struct(xfer);
+	ft_free_xfer_struct(xfer);
 }
 
 static void
-sipe_ft_incoming_init(PurpleXfer *xfer)
+ft_incoming_init(PurpleXfer *xfer)
 {
 	sipe_core_ft_incoming_init(PURPLE_XFER_TO_SIPE_FILE_TRANSFER);
 }
 
 static void
-sipe_ft_incoming_start(PurpleXfer *xfer)
+tftp_incoming_start(PurpleXfer *xfer)
 {
-	sipe_core_ft_incoming_start(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
+	sipe_core_tftp_incoming_start(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 				 xfer->size);
 }
 
 static void
-sipe_ft_incoming_stop(PurpleXfer *xfer)
+tftp_incoming_stop(PurpleXfer *xfer)
 {
-	if (sipe_core_ft_incoming_stop(PURPLE_XFER_TO_SIPE_FILE_TRANSFER)) {
+	if (sipe_core_tftp_incoming_stop(PURPLE_XFER_TO_SIPE_FILE_TRANSFER)) {
 		/* We're done with this transfer */
-		sipe_ft_free_xfer_struct(xfer);
+		ft_free_xfer_struct(xfer);
 	} else {
 		unlink(xfer->local_filename);
 	}
 }
 
 static gssize
-sipe_ft_read(guchar **buffer, PurpleXfer *xfer)
+tftp_read(guchar **buffer, PurpleXfer *xfer)
 {
-	return sipe_core_ft_read(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
+	return sipe_core_tftp_read(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 				 buffer,
 				 purple_xfer_get_bytes_remaining(xfer),
 				 xfer->current_buffer_size);
 }
 
 static void
-sipe_ft_outgoing_init(PurpleXfer *xfer)
+ft_outgoing_init(PurpleXfer *xfer)
 {
 	sipe_core_ft_outgoing_init(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 				 purple_xfer_get_filename(xfer),
@@ -217,7 +184,7 @@
 }
 
 static void
-sipe_ft_outgoing_start(PurpleXfer *xfer)
+tftp_outgoing_start(PurpleXfer *xfer)
 {
 	/* Set socket to non-blocking mode */
 	int flags = fcntl(xfer->fd, F_GETFL, 0);
@@ -225,25 +192,24 @@
 		flags = 0;
 	fcntl(xfer->fd, F_SETFL, flags | O_NONBLOCK);
 
-	sipe_core_ft_outgoing_start(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
+	sipe_core_tftp_outgoing_start(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
 				 xfer->size); 
 }
 
 static void
-sipe_ft_outgoing_stop(PurpleXfer *xfer)
+tftp_outgoing_stop(PurpleXfer *xfer)
 {
-	if (sipe_core_ft_outgoing_stop(PURPLE_XFER_TO_SIPE_FILE_TRANSFER)) {
+	if (sipe_core_tftp_outgoing_stop(PURPLE_XFER_TO_SIPE_FILE_TRANSFER)) {
 		/* We're done with this transfer */
-		sipe_ft_free_xfer_struct(xfer);
+		ft_free_xfer_struct(xfer);
 	}
 }
 
 static gssize
-sipe_ft_write(const guchar *buffer, size_t size, PurpleXfer *xfer)
+tftp_write(const guchar *buffer, size_t size, PurpleXfer *xfer)
 {
-	gssize bytes_written = sipe_core_ft_write(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
-						 buffer,
-						 size);
+	gssize bytes_written = sipe_core_tftp_write(PURPLE_XFER_TO_SIPE_FILE_TRANSFER,
+						 buffer, size);
 
 	if ((xfer->bytes_remaining - bytes_written) == 0)
 		purple_xfer_set_completed(xfer, TRUE);
@@ -253,18 +219,6 @@
 
 //******************************************************************************
 
-static void sipe_backend_private_init(struct sipe_file_transfer *ft,
-				 PurpleXfer *xfer)
-{
-	struct sipe_backend_file_transfer *backend_ft = g_new0(struct sipe_backend_file_transfer, 1);
-
-	ft->backend_private = backend_ft;
-	backend_ft->xfer = xfer;
-	backend_ft->listenfd = -1;
-
-	xfer->data = ft;
-}
-
 void sipe_backend_ft_incoming(struct sipe_core_public *sipe_public,
 			 struct sipe_file_transfer *ft,
 			 const gchar *who,
@@ -279,96 +233,59 @@
 			 who);
 
 	if (xfer) {
-		sipe_backend_private_init(ft, xfer);
+		ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
+		xfer->data = ft;
 
 		purple_xfer_set_filename(xfer, file_name);
 		purple_xfer_set_size(xfer, file_size);
 
-		purple_xfer_set_init_fnc(xfer, sipe_ft_incoming_init);
-		purple_xfer_set_start_fnc(xfer, sipe_ft_incoming_start);
-		purple_xfer_set_end_fnc(xfer, sipe_ft_incoming_stop);
-		purple_xfer_set_request_denied_fnc(xfer, sipe_ft_request_denied);
-		purple_xfer_set_read_fnc(xfer, sipe_ft_read);
-		purple_xfer_set_cancel_send_fnc(xfer, sipe_ft_free_xfer_struct);
-		purple_xfer_set_cancel_recv_fnc(xfer, sipe_ft_free_xfer_struct);
+		purple_xfer_set_init_fnc(xfer, ft_incoming_init);
+		purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
+		purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
+		purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
+		purple_xfer_set_start_fnc(xfer, tftp_incoming_start);
+		purple_xfer_set_end_fnc(xfer, tftp_incoming_stop);
+		purple_xfer_set_read_fnc(xfer, tftp_read);
 
 		purple_xfer_request(xfer);
 	}
 }
 
-static
-void sipe_ft_client_connected(gpointer data, gint listenfd,
-			 SIPE_UNUSED_PARAMETER PurpleInputCondition cond)
+static void
+connect_cb(gpointer data, gint fd, SIPE_UNUSED_PARAMETER const gchar *error_message)
 {
 	struct sipe_file_transfer *ft = data;
-	struct sipe_backend_file_transfer *backend_ft = ft->backend_private;
-	PurpleXfer *xfer = backend_ft->xfer;
-	struct sockaddr_in saddr;
-	socklen_t slen = sizeof (saddr);
-
-	int fd = accept(listenfd, (struct sockaddr*)&saddr, &slen);
-
-	purple_input_remove(xfer->watcher);
-	xfer->watcher = 0;
-	close(listenfd);
-	backend_ft->listenfd = -1;
 
 	if (fd < 0) {
-		sipe_backend_ft_error(ft, _("Socket read failed"));
-		sipe_backend_ft_cancel_local(ft);
-	} else {
-		purple_xfer_start(xfer, fd, NULL, 0);
+		purple_xfer_cancel_local(PURPLE_XFER);
+		return;
 	}
-}
-
-static
-void sipe_ft_listen_socket_created(int listenfd, gpointer data)
-{
-	struct sipe_file_transfer *ft = data;
-	struct sipe_backend_file_transfer *backend_ft = ft->backend_private;
-	struct sockaddr_in addr;
-	socklen_t socklen = sizeof (addr);
-
-	backend_ft->listener = NULL;
-	backend_ft->listenfd = listenfd;
-
-	getsockname(listenfd, (struct sockaddr*)&addr, &socklen);
 
-	backend_ft->xfer->watcher = purple_input_add(listenfd,
-						 PURPLE_INPUT_READ,
-						 sipe_ft_client_connected,
-						 ft);
-
-	sipe_core_ft_incoming_accept(ft,
-				 backend_ft->xfer->who,
-				 listenfd,
-				 ntohs(addr.sin_port));
+	purple_xfer_start(PURPLE_XFER, fd, NULL, 0);
 }
 
-gboolean sipe_backend_ft_incoming_accept(struct sipe_file_transfer *ft,
-					 const gchar *ip,
-					 unsigned short port_min,
-					 unsigned short port_max)
+void
+sipe_backend_ft_start(struct sipe_file_transfer *ft, struct sipe_backend_fd *fd,
+		 const char* ip, unsigned port)
 {
-	struct sipe_backend_file_transfer *backend_ft = ft->backend_private;
-
-	if (ip && (port_min == port_max)) {
-		purple_xfer_start(backend_ft->xfer, -1, ip, port_min);
-	} else {
-		backend_ft->listener = purple_network_listen_range(port_min,
-								 port_max,
-								 SOCK_STREAM,
-								 sipe_ft_listen_socket_created,
-								 ft);
-		if (!backend_ft->listener)
-			return FALSE;
+	if (ip && port && !sipe_backend_ft_is_incoming(ft)) {
+		/* Purple accepts ip & port only for incoming file transfers.
+		 * If we want to send file with Sender-Connect = TRUE negotiated,
+		 * we have to open the connection ourselves and pass the file
+		 * descriptor to purple_xfer_start. */
+		purple_proxy_connect(NULL, PURPLE_XFER->account, ip, port,
+				 connect_cb, ft);
+		return;
 	}
-	return(TRUE);
+
+	purple_xfer_start(PURPLE_XFER, fd ? fd->fd : -1, ip, port);
 }
 
-void sipe_ft_send_file(PurpleConnection *gc, const char *who, const char *file)
+void sipe_purple_ft_send_file(PurpleConnection *gc,
+			 const char *who,
+			 const char *file)
 {
-	PurpleXfer *xfer = sipe_ft_new_xfer(gc, who);
+	PurpleXfer *xfer = sipe_purple_ft_new_xfer(gc, who);
 
 	if (xfer) {
 		if (file != NULL)
@@ -378,7 +295,7 @@
 	}
 }
 
-PurpleXfer *sipe_ft_new_xfer(PurpleConnection *gc, const char *who)
+PurpleXfer *sipe_purple_ft_new_xfer(PurpleConnection *gc, const char *who)
 {
 	PurpleXfer *xfer = NULL;
 
@@ -389,21 +306,28 @@
 		if (xfer) {
 			struct sipe_file_transfer *ft = sipe_core_ft_allocate(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
 
-			sipe_backend_private_init(ft, xfer);
+			ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
+			xfer->data = ft;
 
-			purple_xfer_set_init_fnc(xfer, sipe_ft_outgoing_init);
-			purple_xfer_set_start_fnc(xfer, sipe_ft_outgoing_start);
-			purple_xfer_set_end_fnc(xfer, sipe_ft_outgoing_stop);
-			purple_xfer_set_request_denied_fnc(xfer, sipe_ft_request_denied);
-			purple_xfer_set_write_fnc(xfer, sipe_ft_write);
-			purple_xfer_set_cancel_send_fnc(xfer, sipe_ft_free_xfer_struct);
-			purple_xfer_set_cancel_recv_fnc(xfer, sipe_ft_free_xfer_struct);
+			purple_xfer_set_init_fnc(xfer, ft_outgoing_init);
+			purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
+			purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
+			purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
+			purple_xfer_set_start_fnc(xfer, tftp_outgoing_start);
+			purple_xfer_set_end_fnc(xfer, tftp_outgoing_stop);
+			purple_xfer_set_write_fnc(xfer, tftp_write);
 		}
 	}
 
 	return xfer;
 }
 
+gboolean
+sipe_backend_ft_is_incoming(struct sipe_file_transfer *ft)
+{
+	return purple_xfer_get_type(PURPLE_XFER) == PURPLE_XFER_RECEIVE;
+}
+
 /*
 Local Variables:
 mode: c
--- pidgin-sipe-1.11.2/src/purple/purple-groupchat.c	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-groupchat.c	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,231 @@
+/**
+ * @file purple-groupchat.c
+ *
+ * pidgin-sipe
+ *
+ * Copyright (C) 2010 SIPE Project <http://sipe.sourceforge.net/>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib.h>
+
+#include "sipe-common.h"
+
+#include "conversation.h"
+#include "roomlist.h"
+
+#include "sipe-backend.h"
+#include "sipe-core.h"
+#include "sipe-nls.h"
+
+#include "purple-private.h"
+
+GList *sipe_purple_chat_info(SIPE_UNUSED_PARAMETER PurpleConnection *gc)
+{
+	GList *m = NULL;
+	struct proto_chat_entry *pce;
+
+	pce = g_new0(struct proto_chat_entry, 1);
+	pce->label = _("_URI:");
+	pce->identifier = "uri";
+	pce->required = TRUE;
+	m = g_list_append(m, pce);
+
+	return m;
+}
+
+/**
+ * This callback is called for two reasons:
+ *
+ * a) generate the defaults for the "Add chat..." dialog initiated from the
+ * roomlist (applies only to group chat)
+ * b) generate the components for the creation of a PurpleChat object
+ *
+ */
+GHashTable *sipe_purple_chat_info_defaults(PurpleConnection *gc,
+					 const char *chat_name)
+{
+	GHashTable *defaults = g_hash_table_new(g_str_hash, g_str_equal);
+
+	if (chat_name != NULL) {
+		struct sipe_core_public *sipe_public = PURPLE_GC_TO_SIPE_CORE_PUBLIC;
+		struct sipe_backend_private *purple_private = sipe_public->backend_private;
+		GHashTable *uri_map = purple_private->roomlist_map;
+		const gchar *uri = uri_map != NULL ?
+			g_hash_table_lookup(uri_map, chat_name) :
+			NULL;
+		PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
+										 chat_name,
+										 purple_private->account);
+		/* Group Chat rooms have a valid URI */
+		if (uri) {
+			g_hash_table_insert(defaults, "uri", (gpointer)uri);
+		}
+
+		/**
+		 * Remember the PurpleConversation
+		 *
+		 * libpurple API is so brain-dead that we don't receive this
+		 * information when it is known and we need it. Make our life
+		 * easier by remembering it here for later lookup....
+		 */
+		if (conv) {
+			g_hash_table_insert(defaults,
+					 SIPE_PURPLE_COMPONENT_KEY_CONVERSATION,
+					 conv);
+		}
+	}
+
+	return defaults;
+}
+
+void sipe_purple_chat_join(PurpleConnection *gc, GHashTable *data)
+{
+	struct sipe_core_public *sipe_public = PURPLE_GC_TO_SIPE_CORE_PUBLIC;
+	const gchar *uri = g_hash_table_lookup(data, "uri");
+
+	if (uri) {
+		SIPE_DEBUG_INFO("sipe_purple_chat_join: uri '%s'", uri);
+		sipe_core_groupchat_join(sipe_public, uri);
+	}
+}
+
+PurpleRoomlist *sipe_purple_roomlist_get_list(PurpleConnection *gc)
+{
+	struct sipe_core_public *sipe_public = PURPLE_GC_TO_SIPE_CORE_PUBLIC;
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+	PurpleAccount *account = purple_private->account;
+	PurpleRoomlist *roomlist;
+	GList *fields = NULL;
+	PurpleRoomlistField *f;
+
+	SIPE_DEBUG_INFO_NOFORMAT("sipe_purple_roomlist_get_list");
+
+	if (purple_private->roomlist)
+		purple_roomlist_unref(purple_private->roomlist);
+	if (purple_private->roomlist_map)
+		g_hash_table_destroy(purple_private->roomlist_map);
+
+	purple_private->roomlist = roomlist = purple_roomlist_new(account);
+	purple_private->roomlist_map = g_hash_table_new_full(g_str_hash,
+							 g_str_equal,
+							 g_free, g_free);
+
+	/* The order needs to be kept in-sync with sipe_backend_groupchat_room_add() */
+	f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_STRING,
+				 "", "uri", TRUE);
+	fields = g_list_append(fields, f);
+	f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_INT,
+				 _("Users"), "users", FALSE);
+	fields = g_list_append(fields, f);
+	f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_BOOL,
+				 _("Invite"), "invite", FALSE);
+	fields = g_list_append(fields, f);
+	f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_BOOL,
+				 _("Private"), "private", FALSE);
+	fields = g_list_append(fields, f);
+	f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_BOOL,
+				 _("Log"), "logged", FALSE);
+	fields = g_list_append(fields, f);
+	f = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_STRING,
+				 _("Description"), "description", FALSE);
+	fields = g_list_append(fields, f);
+
+	purple_roomlist_set_fields(roomlist, fields);
+	purple_roomlist_set_in_progress(roomlist, TRUE);
+
+	if (!sipe_core_groupchat_query_rooms(sipe_public)) {
+		sipe_purple_roomlist_cancel(roomlist);
+		roomlist = NULL;
+	}
+
+	return roomlist;
+}
+
+void sipe_purple_roomlist_cancel(PurpleRoomlist *roomlist)
+{
+	PurpleAccount *account = roomlist->account;
+	struct sipe_core_public *sipe_public = PURPLE_ACCOUNT_TO_SIPE_CORE_PUBLIC;
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+
+	SIPE_DEBUG_INFO_NOFORMAT("sipe_purple_roomlist_cancel");
+
+	purple_roomlist_set_in_progress(roomlist, FALSE);
+
+	if (purple_private->roomlist == roomlist) {
+		purple_roomlist_unref(roomlist);
+		purple_private->roomlist = NULL;
+	}
+}
+
+void sipe_backend_groupchat_room_add(struct sipe_core_public *sipe_public,
+				 const gchar *uri,
+				 const gchar *name,
+				 const gchar *description,
+				 guint users,
+				 guint32 flags)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+	PurpleRoomlist *roomlist = purple_private->roomlist;
+	if (roomlist) {
+		PurpleRoomlistRoom *room = purple_roomlist_room_new(PURPLE_ROOMLIST_ROOMTYPE_ROOM,
+								 name, NULL);
+
+		/* The order needs to be kept in-sync with sipe_roomlist_get_list() */
+		purple_roomlist_room_add_field(roomlist, room,
+					 uri);
+		purple_roomlist_room_add_field(roomlist, room,
+					 GUINT_TO_POINTER(users));
+		purple_roomlist_room_add_field(roomlist, room,
+					 GUINT_TO_POINTER(flags & SIPE_GROUPCHAT_ROOM_INVITE));
+		purple_roomlist_room_add_field(roomlist, room,
+					 GUINT_TO_POINTER(flags & SIPE_GROUPCHAT_ROOM_PRIVATE));
+		purple_roomlist_room_add_field(roomlist, room,
+					 GUINT_TO_POINTER(flags & SIPE_GROUPCHAT_ROOM_LOGGED));
+		purple_roomlist_room_add_field(roomlist, room,
+					 description);
+
+		/* libpurple API only gives us the channel name */
+		g_hash_table_insert(purple_private->roomlist_map,
+				 g_strdup(name), g_strdup(uri));
+
+		purple_roomlist_room_add(roomlist, room);
+	}
+}
+
+void sipe_backend_groupchat_room_terminate(struct sipe_core_public *sipe_public)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+	PurpleRoomlist *roomlist = purple_private->roomlist;
+	if (roomlist) {
+		purple_roomlist_set_in_progress(roomlist, FALSE);
+		purple_roomlist_unref(roomlist);
+		purple_private->roomlist = NULL;
+	}
+}
+
+/*
+ Local Variables:
+ mode: c
+ c-file-style: "bsd"
+ indent-tabs-mode: t
+ tab-width: 8
+ End:
+*/
--- pidgin-sipe-1.11.2/src/purple/purple-im.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-im.c	2011-06-14 14:40:36.000000000 +0200
@@ -30,6 +30,7 @@
 
 #include "sipe-backend.h"
 #include "sipe-core.h"
+#include "sipe-nls.h"
 
 void sipe_backend_im_message(struct sipe_core_public *sipe_public,
 			 const gchar *from,
@@ -43,6 +44,34 @@
 		 time(NULL));
 }
 
+void sipe_backend_im_topic(struct sipe_core_public *sipe_public,
+			 const gchar *with,
+			 const gchar *topic)
+{
+	PurpleAccount *account = sipe_public->backend_private->account;
+	PurpleConversation *conv;
+	gchar *msg;
+
+	/*
+	 * Ensure we have an open conversation with the buddy, otherwise
+	 * message would be lost.
+	 */
+	conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY,
+						 with,
+						 account);
+	if (!conv)
+		conv = purple_conversation_new(PURPLE_CONV_TYPE_IM,
+					 account,
+					 with);
+
+	msg = g_strdup_printf(_("Conversation subject: %s"), topic);
+	sipe_backend_notify_message_info(sipe_public,
+					 (struct sipe_backend_chat_session *)conv,
+					 with,
+					 msg);
+	g_free(msg);
+}
+
 /*
 Local Variables:
 mode: c
--- pidgin-sipe-1.11.2/src/purple/purple-media.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-media.c	2011-06-14 14:40:36.000000000 +0200
@@ -29,6 +29,7 @@
 #include "sipe-common.h"
 
 #include "mediamanager.h"
+#include "media-gst.h"
 #include "request.h"
 #include "agent.h"
 
@@ -40,6 +41,10 @@
 struct sipe_backend_media {
 	PurpleMedia *m;
 	GSList *streams;
+	/**
+	 * Number of media streams that were not yet locally accepted or rejected.
+	 */
+	guint unconfirmed_streams;
 };
 
 struct sipe_backend_stream {
@@ -72,19 +77,13 @@
 			 SIPE_UNUSED_PARAMETER gchar *participant,
 			 struct sipe_media_call *call)
 {
-	struct sipe_backend_media *backend_media = call->backend_private;
 	struct sipe_backend_stream *stream;
-	stream = sipe_backend_media_get_stream_by_id(backend_media, sessionid);
+	stream = sipe_backend_media_get_stream_by_id(call->backend_private, sessionid);
 
 	stream->candidates_prepared = TRUE;
 
-	if (call->candidates_prepared_cb) {
-		GSList *streams = backend_media->streams;
-		for (; streams; streams = streams->next) {
-			struct sipe_backend_stream *s = streams->data;
-			if (!s->candidates_prepared)
-				return;
-		}
+	if (call->candidates_prepared_cb &&
+	 sipe_backend_candidates_prepared(call->backend_private)) {
 		call->candidates_prepared_cb(call, stream);
 	}
 }
@@ -97,8 +96,30 @@
 		 struct sipe_media_call *call)
 {
 	SIPE_DEBUG_INFO("sipe_media_state_changed_cb: %d %s %s\n", state, sessionid, participant);
-	if (state == PURPLE_MEDIA_STATE_CONNECTED && call->media_connected_cb)
-		call->media_connected_cb(call);
+	if (state == PURPLE_MEDIA_STATE_END &&
+	 !sessionid && !participant && call->media_end_cb)
+		call->media_end_cb(call);
+}
+
+/* Used externally in purple-plugin.c. This declaration stops the compiler
+ * complaining about missing prototype. */
+void capture_pipeline(gchar *label);
+
+void
+capture_pipeline(gchar *label) {
+	PurpleMediaManager *manager = purple_media_manager_get();
+	GstElement *pipeline = purple_media_manager_get_pipeline(manager);
+	GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(GST_BIN(pipeline), GST_DEBUG_GRAPH_SHOW_ALL, label);
+}
+
+static void
+on_error_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media, gchar *message,
+	 struct sipe_media_call *call)
+{
+	capture_pipeline("ERROR");
+
+	if (call->error_cb)
+		call->error_cb(call, message);
 }
 
 static void
@@ -109,19 +130,20 @@
 		 gboolean local,
 		 struct sipe_media_call *call)
 {
-	struct sipe_backend_media *m = call->backend_private;
-
-	if (type == PURPLE_MEDIA_INFO_ACCEPT && call->call_accept_cb
-	 && !sessionid && !participant)
+	if (type == PURPLE_MEDIA_INFO_ACCEPT) {
+		if (call->call_accept_cb && !sessionid && !participant)
 		call->call_accept_cb(call, local);
-	else if (type == PURPLE_MEDIA_INFO_HOLD || type == PURPLE_MEDIA_INFO_UNHOLD) {
+		else if (sessionid && participant && local)
+			--call->backend_private->unconfirmed_streams;
+	} else if (type == PURPLE_MEDIA_INFO_HOLD || type == PURPLE_MEDIA_INFO_UNHOLD) {
 
 		gboolean state = (type == PURPLE_MEDIA_INFO_HOLD);
 
 		if (sessionid) {
 			// Hold specific stream
 			struct sipe_backend_stream *stream;
-			stream = sipe_backend_media_get_stream_by_id(m, sessionid);
+			stream = sipe_backend_media_get_stream_by_id(call->backend_private,
+								 sessionid);
 
 			if (local)
 				stream->local_on_hold = state;
@@ -129,7 +151,7 @@
 				stream->remote_on_hold = state;
 		} else {
 			// Hold all streams
-			GSList *i = sipe_backend_media_get_streams(m);
+			GSList *i = sipe_backend_media_get_streams(call->backend_private);
 			for (; i; i = i->next) {
 				struct sipe_backend_stream *stream = i->data;
 
@@ -146,15 +168,19 @@
 		if (!sessionid && !participant) {
 			if (type == PURPLE_MEDIA_INFO_HANGUP && call->call_hangup_cb)
 				call->call_hangup_cb(call, local);
-			else if (type == PURPLE_MEDIA_INFO_REJECT && call->call_reject_cb)
+			else if (type == PURPLE_MEDIA_INFO_REJECT && call->call_reject_cb && !local)
 				call->call_reject_cb(call, local);
 		} else if (sessionid && participant) {
 			struct sipe_backend_stream *stream;
-			stream = sipe_backend_media_get_stream_by_id(m, sessionid);
+			stream = sipe_backend_media_get_stream_by_id(call->backend_private,
+								 sessionid);
 
 			if (stream) {
-				m->streams = g_slist_remove(m->streams, stream);
+				call->backend_private->streams = g_slist_remove(call->backend_private->streams, stream);
 				backend_stream_free(stream);
+				if (local && --call->backend_private->unconfirmed_streams == 0 &&
+				 call->call_reject_cb)
+					call->call_reject_cb(call, local);
 			}
 		}
 	}
@@ -169,6 +195,7 @@
 	struct sipe_backend_media *media = g_new0(struct sipe_backend_media, 1);
 	struct sipe_backend_private *purple_private = sipe_public->backend_private;
 	PurpleMediaManager *manager = purple_media_manager_get();
+	GstElement *pipeline;
 
 	media->m = purple_media_manager_create_media(manager,
 						 purple_private->account,
@@ -179,28 +206,65 @@
 			 G_CALLBACK(on_candidates_prepared_cb), call);
 	g_signal_connect(G_OBJECT(media->m), "stream-info",
 			 G_CALLBACK(on_stream_info_cb), call);
+	g_signal_connect(G_OBJECT(media->m), "error",
+			 G_CALLBACK(on_error_cb), call);
 	g_signal_connect(G_OBJECT(media->m), "state-changed",
 			 G_CALLBACK(on_state_changed_cb), call);
 
+	/* On error, the pipeline is no longer in PLAYING state and libpurple
+	 * will not switch it back to PLAYING, preventing any more calls until
+	 * application restart. We switch the state ourselves here to negate
+	 * effect of any error in previous call (if any). */
+	pipeline = purple_media_manager_get_pipeline(manager);
+	gst_element_set_state(pipeline, GST_STATE_PLAYING);
+
 	return media;
 }
 
 void
 sipe_backend_media_free(struct sipe_backend_media *media)
 {
+	if (media) {
 	GSList *stream = media->streams;
-	g_object_unref(media->m);
 
 	for (; stream; stream = g_slist_delete_link(stream, stream))
 		backend_stream_free(stream->data);
 
 	g_free(media);
 }
+}
+
+void
+sipe_backend_media_set_cname(struct sipe_backend_media *media, gchar *cname)
+{
+	if (media) {
+		guint num_params = 3;
+		GParameter *params = g_new0(GParameter, num_params);
+		params[0].name = "sdes-cname";
+		g_value_init(&params[0].value, G_TYPE_STRING);
+		g_value_set_string(&params[0].value, cname);
+		params[1].name = "sdes-name";
+		g_value_init(&params[1].value, G_TYPE_STRING);
+		params[2].name = "sdes-tool";
+		g_value_init(&params[2].value, G_TYPE_STRING);
+
+		purple_media_set_params(media->m, num_params, params);
+
+		g_value_unset(&params[0].value);
+		g_free(params);
+	}
+}
 
 #define FS_CODECS_CONF \
 	"# Automatically created by SIPE plugin\n" \
 	"[video/H263]\n" \
-	"farsight-send-profile=videoscale ! ffmpegcolorspace ! fsvideoanyrate ! ffenc_h263 rtp-payload-size=512 ! rtph263pay mtu=512\n";
+	"farsight-send-profile=videoscale ! ffmpegcolorspace ! fsvideoanyrate ! ffenc_h263 rtp-payload-size=30 ! rtph263pay\n" \
+	"\n" \
+	"[audio/PCMA]\n" \
+	"farsight-send-profile=audioconvert ! audioresample ! audioconvert ! alawenc ! rtppcmapay min-ptime=20000000 max-ptime=20000000\n" \
+	"\n" \
+	"[audio/PCMU]\n" \
+	"farsight-send-profile=audioconvert ! audioresample ! audioconvert ! mulawenc ! rtppcmupay min-ptime=20000000 max-ptime=20000000\n";
 
 static void
 ensure_codecs_conf()
@@ -219,13 +283,57 @@
 	g_free(filename);
 }
 
+struct sipe_backend_media_relays *
+sipe_backend_media_relays_convert(GSList *media_relays, gchar *username, gchar *password)
+{
+	GValueArray *relay_info = g_value_array_new(0);
+
+	for (; media_relays; media_relays = media_relays->next) {
+		struct sipe_media_relay *relay = media_relays->data;
+		GValue value;
+		GstStructure *gst_relay_info;
+
+		/* Skip relays where IP could not be resolved. */
+		if (!relay->hostname)
+			continue;
+
+		gst_relay_info = gst_structure_new("relay-info",
+				"ip", G_TYPE_STRING, relay->hostname,
+				"port", G_TYPE_UINT, relay->udp_port,
+				"username", G_TYPE_STRING, username,
+				"password", G_TYPE_STRING, password,
+				NULL);
+
+		if (!gst_relay_info) {
+			g_value_array_free(relay_info);
+			return NULL;
+		}
+
+		memset(&value, 0, sizeof(GValue));
+		g_value_init(&value, GST_TYPE_STRUCTURE);
+		gst_value_set_structure(&value, gst_relay_info);
+
+		relay_info = g_value_array_append(relay_info, &value);
+		gst_structure_free(gst_relay_info);
+	}
+
+	return (struct sipe_backend_media_relays *)relay_info;
+}
+
+void
+sipe_backend_media_relays_free(struct sipe_backend_media_relays *media_relays)
+{
+	g_value_array_free((GValueArray *)media_relays);
+}
+
 struct sipe_backend_stream *
 sipe_backend_media_add_stream(struct sipe_backend_media *media,
 			 const gchar *id,
 			 const gchar *participant,
 			 SipeMediaType type,
-			 gboolean use_nice,
-			 gboolean initiator)
+			 SipeIceVersion ice_version,
+			 gboolean initiator,
+			 struct sipe_backend_media_relays *media_relays)
 {
 	struct sipe_backend_stream *stream = NULL;
 	PurpleMediaSessionType prpl_type = sipe_media_to_purple(type);
@@ -233,14 +341,25 @@
 	guint params_cnt = 0;
 	gchar *transmitter;
 
-	if (use_nice) {
+	if (ice_version != SIPE_ICE_NO_ICE) {
 		transmitter = "nice";
-		params_cnt = 1;
+		params_cnt = 2;
 
 		params = g_new0(GParameter, params_cnt);
+
 		params[0].name = "compatibility-mode";
 		g_value_init(&params[0].value, G_TYPE_UINT);
-		g_value_set_uint(&params[0].value, NICE_COMPATIBILITY_OC2007R2);
+		g_value_set_uint(&params[0].value,
+				 ice_version == SIPE_ICE_DRAFT_6 ?
+				 NICE_COMPATIBILITY_OC2007 :
+				 NICE_COMPATIBILITY_OC2007R2);
+
+		if (media_relays) {
+			params[1].name = "relay-info";
+			g_value_init(&params[1].value, G_TYPE_VALUE_ARRAY);
+			g_value_set_boxed(&params[1].value, media_relays);
+		} else
+			--params_cnt;
 	} else {
 		// TODO: session naming here, Communicator needs audio/video
 		transmitter = "rawudp";
@@ -250,15 +369,21 @@
 	ensure_codecs_conf();
 
 	if (purple_media_add_stream(media->m, id, participant, prpl_type,
-				 initiator, transmitter, params_cnt, params)) {
+				 initiator, transmitter, params_cnt,
+				 params)) {
 		stream = g_new0(struct sipe_backend_stream, 1);
 		stream->sessionid = g_strdup(id);
 		stream->participant = g_strdup(participant);
 		stream->candidates_prepared = FALSE;
 
 		media->streams = g_slist_append(media->streams, stream);
+		if (!initiator)
+			++media->unconfirmed_streams;
 	}
 
+	if (media_relays)
+		g_value_unset(&params[1].value);
+
 	g_free(params);
 
 	return stream;
@@ -315,6 +440,18 @@
 	return purple_media_accepted(media->m, NULL, NULL);
 }
 
+gboolean
+sipe_backend_candidates_prepared(struct sipe_backend_media *media)
+{
+	GSList *streams = media->streams;
+	for (; streams; streams = streams->next) {
+		struct sipe_backend_stream *s = streams->data;
+		if (!s->candidates_prepared)
+			return FALSE;
+	}
+	return TRUE;
+}
+
 GList *
 sipe_backend_media_get_active_local_candidates(struct sipe_backend_media *media,
 					 struct sipe_backend_stream *stream)
@@ -423,23 +560,34 @@
 }
 
 GList*
-sipe_backend_get_local_codecs(struct sipe_media_call *call,
+sipe_backend_get_local_codecs(struct sipe_backend_media *media,
 			 struct sipe_backend_stream *stream)
 {
-	GList *codecs = purple_media_get_codecs(call->backend_private->m,
+	GList *codecs = purple_media_get_codecs(media->m,
 						stream->sessionid);
 	GList *i = codecs;
+	gboolean is_conference = (g_strstr_len(stream->participant,
+					 strlen(stream->participant),
+					 "app:conf:audio-video:") != NULL);
 
 	/*
 	 * Do not announce Theora. Its optional parameters are too long,
 	 * Communicator rejects such SDP message and does not support the codec
 	 * anyway.
+	 *
+	 * For some yet unknown reason, A/V conferencing server does not accept
+	 * voice stream sent by SIPE when SIREN codec is in use. Nevertheless,
+	 * we are able to decode incoming SIREN from server and with MSOC
+	 * client, bidirectional call using the codec works. Until resolved,
+	 * do not try to negotiate SIREN usage when conferencing. PCMA or PCMU
+	 * seems to work properly in this scenario.
 	 */
 	while (i) {
 		PurpleMediaCodec *codec = i->data;
 		gchar *encoding_name = purple_media_codec_get_encoding_name(codec);
 
-		if (sipe_strequal(encoding_name,"THEORA")) {
+		if (sipe_strequal(encoding_name,"THEORA") ||
+		 (is_conference && sipe_strequal(encoding_name,"SIREN"))) {
 			GList *tmp;
 			g_object_unref(codec);
 			tmp = i->next;
@@ -458,15 +606,27 @@
 sipe_backend_candidate_new(const gchar *foundation,
 			 SipeComponentType component,
 			 SipeCandidateType type, SipeNetworkProtocol proto,
-			 const gchar *ip, guint port)
+			 const gchar *ip, guint port,
+			 const gchar *username,
+			 const gchar *password)
 {
-	return (struct sipe_backend_candidate *)purple_media_candidate_new(
-		foundation,
+	PurpleMediaCandidate *c = purple_media_candidate_new(
+		/* Libnice and Farsight rely on non-NULL foundation to
+		 * distinguish between candidates of a component. When NULL
+		 * foundation is passed (ie. ICE draft 6 does not use foudation),
+		 * use username instead. If no foundation is provided, Farsight
+		 * may signal an active candidate different from the one actually
+		 * in use. See Farsight's agent_new_selected_pair() in
+		 * fs-nice-stream-transmitter.h where first candidate in the
+		 * remote list is always selected when no foundation. */
+		foundation ? foundation : username,
 		component,
 		sipe_candidate_type_to_purple(type),
 		sipe_network_protocol_to_purple(proto),
 		ip,
 		port);
+	g_object_set(c, "username", username, "password", password, NULL);
+	return (struct sipe_backend_candidate *)c;
 }
 
 void
@@ -557,14 +717,6 @@
 	return purple_network_protocol_to_sipe(proto);
 }
 
-void
-sipe_backend_candidate_set_username_and_pwd(struct sipe_backend_candidate *candidate,
-					 const gchar *username,
-					 const gchar *password)
-{
-	g_object_set(candidate, "username", username, "password", password, NULL);
-}
-
 static void
 remove_lone_candidate_cb(SIPE_UNUSED_PARAMETER gpointer key,
 			 gpointer value,
@@ -626,6 +778,7 @@
 void
 sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local)
 {
+	if (media)
 	purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_ACCEPT,
 				 NULL, NULL, local);
 }
@@ -633,6 +786,7 @@
 void
 sipe_backend_media_hangup(struct sipe_backend_media *media, gboolean local)
 {
+	if (media)
 	purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_HANGUP,
 				 NULL, NULL, local);
 }
@@ -640,6 +794,7 @@
 void
 sipe_backend_media_reject(struct sipe_backend_media *media, gboolean local)
 {
+	if (media)
 	purple_media_stream_info(media->m, PURPLE_MEDIA_INFO_REJECT,
 				 NULL, NULL, local);
 }
--- pidgin-sipe-1.11.2/src/purple/purple-network.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-network.c	2011-06-14 14:40:36.000000000 +0200
@@ -20,14 +20,232 @@
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+
 #include "glib.h"
 #include "network.h"
+#include "eventloop.h"
+
+#ifdef _WIN32
+/* for network */
+#include "win32/libc_interface.h"
+#include <nspapi.h>
+#else
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <net/if.h>
+#include <arpa/inet.h>
+#ifdef HAVE_SYS_SOCKIO_H
+#include <sys/sockio.h> /* SIOCGIFCONF for Solaris */
+#endif
+#endif
 
+#include <unistd.h>
+
+#include "sipe-common.h"
 #include "sipe-backend.h"
+#include "purple-private.h"
+
+#if 0
+/**
+ * @TODO: get_suitable_local_ip()
+ * 
+ * The code is most likely broken for Mac OS X as it seems that that platform
+ * returns variable-sized "struct ifreq". The new, alignment compliant code
+ * assumes a fix-sized "struct ifreq", i.e. it uses array access.
+ *
+ * If somebody is bothered by this, please provide a *VERIFIED* alternative
+ * implementation for platforms that define _SIZEOF_ADDR_IFREQ().
+ *
+ **/
+
+/*
+ * Calling sizeof(struct ifreq) isn't always correct on
+ * Mac OS X (and maybe others).
+ */
+#ifdef _SIZEOF_ADDR_IFREQ
+# define HX_SIZE_OF_IFREQ(a) _SIZEOF_ADDR_IFREQ(a)
+#else
+# define HX_SIZE_OF_IFREQ(a) sizeof(a)
+#endif
+#endif
+
+#define IFREQ_MAX 32
+
+/**
+ * Returns local IP address suitable for connection.
+ *
+ * purple_network_get_my_ip() will not do this, because it might return an
+ * address within 169.254.x.x range that was assigned to interface disconnected
+ * from the network (when multiple network adapters are available). This is a
+ * copy-paste from libpurple's network.c, only change is that link local addresses
+ * are ignored.
+ *
+ * Maybe this should be fixed in libpurple or some better solution found.
+ */
+static const gchar *get_suitable_local_ip(void)
+{
+	int source = socket(PF_INET,SOCK_STREAM, 0);
+
+	if (source >= 0) {
+		struct ifreq *buffer = g_new0(struct ifreq, IFREQ_MAX);
+		struct ifconf ifc;
+		guint32 lhost = htonl(127 * 256 * 256 * 256 + 1);
+		guint32 llocal = htonl((169 << 24) + (254 << 16));
+		guint i;
+		static char ip[16];
+
+		/* @TODO: assumes constant sizeof(struct ifreq) [see above] */
+		ifc.ifc_len = sizeof(struct ifreq) * IFREQ_MAX;
+		ifc.ifc_req = buffer;
+		ioctl(source, SIOCGIFCONF, &ifc);
+
+		close(source);
+
+		for (i = 0; i < IFREQ_MAX; i++)
+		{
+			/* @TODO: assumes constant sizeof(struct ifreq) [see above] */
+			struct ifreq *ifr = &buffer[i];
+
+			if (ifr->ifr_addr.sa_family == AF_INET)
+			{
+				struct sockaddr_in sin;
+				memcpy(&sin, &ifr->ifr_addr, sizeof(struct sockaddr_in));
+				if (sin.sin_addr.s_addr != lhost
+				 && (sin.sin_addr.s_addr & htonl(0xFFFF0000)) != llocal)
+				{
+					long unsigned int add = ntohl(sin.sin_addr.s_addr);
+					g_snprintf(ip, 16, "%lu.%lu.%lu.%lu",
+						 ((add >> 24) & 255),
+						 ((add >> 16) & 255),
+						 ((add >> 8) & 255),
+						 add & 255);
+
+					g_free(buffer);
+					return ip;
+				}
+			}
+		}
+		g_free(buffer);
+	}
+
+	return "0.0.0.0";
+}
 
 const gchar *sipe_backend_network_ip_address(void)
 {
-	return purple_network_get_my_ip(-1);
+	const gchar *ip = purple_network_get_my_ip(-1);
+	if (g_str_has_prefix(ip, "169.254."))
+		ip = get_suitable_local_ip();
+	return ip;
+}
+
+struct sipe_backend_listendata {
+	sipe_listen_start_cb listen_cb;
+	sipe_client_connected_cb connect_cb;
+
+	PurpleNetworkListenData *listener;
+	int watcher;
+
+	int listenfd;
+	gpointer data;
+};
+
+static void
+client_connected_cb(struct sipe_backend_listendata *ldata, gint listenfd,
+		 SIPE_UNUSED_PARAMETER PurpleInputCondition cond)
+{
+	struct sockaddr_in saddr;
+	socklen_t slen = sizeof (saddr);
+
+	int fd = accept(listenfd, (struct sockaddr*)&saddr, &slen);
+
+	purple_input_remove(ldata->watcher);
+	ldata->watcher = 0;
+	close(listenfd);
+	ldata->listenfd = -1;
+
+	if (ldata->connect_cb) {
+		struct sipe_backend_fd *sipe_fd = g_new(struct sipe_backend_fd, 1);
+		sipe_fd->fd = fd;
+		ldata->connect_cb(sipe_fd, ldata->data);
+	}
+
+	g_free(ldata);
+}
+
+static void
+backend_listen_cb(int listenfd, struct sipe_backend_listendata *ldata)
+{
+	struct sockaddr_in addr;
+	socklen_t socklen = sizeof (addr);
+
+	ldata->listenfd = -1;
+	ldata->listener = NULL;
+	ldata->listenfd = listenfd;
+
+	getsockname(listenfd, (struct sockaddr*)&addr, &socklen);
+	if (ldata->listen_cb)
+		ldata->listen_cb(ntohs(addr.sin_port), ldata->data);
+
+	ldata->watcher = purple_input_add(listenfd, PURPLE_INPUT_READ,
+					 (PurpleInputFunction)client_connected_cb,
+					 ldata);
+}
+
+struct sipe_backend_listendata *
+sipe_backend_network_listen_range(unsigned short port_min,
+				 unsigned short port_max,
+				 sipe_listen_start_cb listen_cb,
+				 sipe_client_connected_cb connect_cb,
+				 gpointer data)
+{
+	struct sipe_backend_listendata *ldata;
+	ldata = g_new0(struct sipe_backend_listendata, 1);
+
+	ldata->listen_cb = listen_cb;
+	ldata->connect_cb = connect_cb;
+	ldata->data = data;
+	ldata->listener = purple_network_listen_range(port_min, port_max,
+						 SOCK_STREAM,
+						 (PurpleNetworkListenCallback)backend_listen_cb,
+						 ldata);
+
+	if (!ldata->listener) {
+		g_free(ldata);
+		return NULL;
+	}
+
+	return ldata;
+}
+
+void sipe_backend_network_listen_cancel(struct sipe_backend_listendata *ldata)
+{
+	g_return_if_fail(ldata);
+
+	if (ldata->listener)
+		purple_network_listen_cancel(ldata->listener);
+	if (ldata->listenfd)
+		close(ldata->listenfd);
+	g_free(ldata);
+}
+
+gboolean
+sipe_backend_fd_is_valid(struct sipe_backend_fd *fd)
+{
+	return fd && fd->fd >= 0;
+}
+
+void
+sipe_backend_fd_free(struct sipe_backend_fd *fd)
+{
+	g_free(fd);
 }
 
 /*
--- pidgin-sipe-1.11.2/src/purple/purple-notify.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-notify.c	2011-06-14 14:40:36.000000000 +0200
@@ -20,10 +20,57 @@
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+#include <time.h>
+
 #include <glib.h>
 
+#include "conversation.h"
 #include "notify.h"
 
+#include "sipe-backend.h"
+#include "sipe-core.h"
+
+#include "purple-private.h"
+
+static void notify_message(struct sipe_core_public *sipe_public,
+			 PurpleMessageFlags flags,
+			 struct sipe_backend_chat_session *backend_session,
+			 const gchar *who,
+			 const gchar *message)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+	PurpleConversation *conv;
+
+	if (backend_session) {
+		conv = (PurpleConversation *) backend_session;
+	} else {
+		conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY,
+							 who,
+							 purple_private->account);
+	}
+	if (conv)
+		purple_conversation_write(conv, NULL, message, flags,
+					 time(NULL));
+}
+			 
+void sipe_backend_notify_message_error(struct sipe_core_public *sipe_public,
+				 struct sipe_backend_chat_session *backend_session,
+				 const gchar *who,
+				 const gchar *message)
+{
+	notify_message(sipe_public, PURPLE_MESSAGE_ERROR,
+		 backend_session, who, message);
+}
+
+void sipe_backend_notify_message_info(struct sipe_core_public *sipe_public,
+				 struct sipe_backend_chat_session *backend_session,
+				 const gchar *who,
+				 const gchar *message)
+{
+	notify_message(sipe_public, PURPLE_MESSAGE_SYSTEM,
+		 backend_session, who, message);
+}
+
 void sipe_backend_notify_error(const gchar *title, const gchar *msg)
 {
 	purple_notify_error(NULL, NULL, title, msg);
--- pidgin-sipe-1.11.2/src/purple/purple-plugin.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-plugin.c	2011-06-14 14:40:36.000000000 +0200
@@ -57,14 +57,15 @@
 #include "status.h"
 #include "version.h"
 
-#include "purple-private.h"
-
 #include "sipe-backend.h"
 #include "sipe-core.h"
 #include "sipe-nls.h"
 
 #include "core-depurple.h"
 
+#define _PurpleMessageFlags PurpleMessageFlags
+#include "purple-private.h"
+
 /* Backward compatibility when compiling against 2.4.x API */
 #if !PURPLE_VERSION_CHECK(2,5,0)
 #define PURPLE_CONNECTION_ALLOW_CUSTOM_SMILEY 0x0100
@@ -98,7 +99,7 @@
 #define PURPLE_STATUS_TO_ACTIVITY(x) \
 	GPOINTER_TO_UINT(g_hash_table_lookup(purple_to_activity, (x)))
 
-static void purple_activity_init(void)
+static void sipe_purple_activity_init(void)
 {
 	sipe_activity index = SIPE_ACTIVITY_UNSET;
 	purple_to_activity = g_hash_table_new(g_str_hash, g_str_equal);
@@ -115,7 +116,7 @@
 	return(g_strdup_printf("Purple/%s", purple_core_get_version()));
 }
 
-static void purple_activity_destroy(void)
+static void sipe_purple_activity_destroy(void)
 {
 	g_hash_table_destroy(purple_to_activity);
 	purple_to_activity = NULL;
@@ -128,7 +129,7 @@
 	return "sipe";
 }
 
-static gchar *sipe_status_text(PurpleBuddy *buddy)
+static gchar *sipe_purple_status_text(PurpleBuddy *buddy)
 {
 	const PurpleStatus *status = purple_presence_get_active_status(purple_buddy_get_presence(buddy));
 	return sipe_core_buddy_status(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
@@ -137,7 +138,7 @@
 				 purple_status_get_name(status));
 }
 
-static void sipe_tooltip_text(PurpleBuddy *buddy,
+static void sipe_purple_tooltip_text(PurpleBuddy *buddy,
 			 PurpleNotifyUserInfo *user_info,
 			 SIPE_UNUSED_PARAMETER gboolean full)
 {
@@ -157,7 +158,7 @@
 	}
 }
 
-static GList *sipe_status_types(SIPE_UNUSED_PARAMETER PurpleAccount *acc)
+static GList *sipe_purple_status_types(SIPE_UNUSED_PARAMETER PurpleAccount *acc)
 {
 	PurpleStatusType *type;
 	GList *types = NULL;
@@ -221,18 +222,18 @@
 	return types;
 }
 
-static GList *sipe_blist_node_menu(PurpleBlistNode *node)
+static GList *sipe_purple_blist_node_menu(PurpleBlistNode *node)
 {
 	if(PURPLE_BLIST_NODE_IS_BUDDY(node)) {
 		return sipe_buddy_menu((PurpleBuddy *) node);
 	} else if(PURPLE_BLIST_NODE_IS_CHAT(node)) {
-		return sipe_chat_menu((PurpleChat *)node);
+		return sipe_purple_chat_menu((PurpleChat *)node);
 	} else {
 		return NULL;
 	}
 }
 
-static void sipe_login(PurpleAccount *account)
+static void sipe_purple_login(PurpleAccount *account)
 {
 	PurpleConnection *gc = purple_account_get_connection(account);
 	const gchar *username = purple_account_get_username(account);
@@ -248,7 +249,7 @@
 	struct sipe_backend_private *purple_private;
 
 	/* username format: <username>,[<optional login>] */
-	SIPE_DEBUG_INFO("sipe_login: username '%s'", username);
+	SIPE_DEBUG_INFO("sipe_purple_login: username '%s'", username);
 	username_split = g_strsplit(username, ",", 2);
 
 	/* login name specified? */
@@ -256,10 +257,10 @@
 		/* Allowed domain-account separators are / or \ */
 		gchar **domain_user = g_strsplit_set(username_split[1], "/\\", 2);
 		gboolean has_domain = domain_user[1] != NULL;
-		SIPE_DEBUG_INFO("sipe_login: login '%s'", username_split[1]);
+		SIPE_DEBUG_INFO("sipe_purple_login: login '%s'", username_split[1]);
 		login_domain = has_domain ? g_strdup(domain_user[0]) : NULL;
 		login_account = g_strdup(domain_user[has_domain ? 1 : 0]);
-		SIPE_DEBUG_INFO("sipe_login: auth domain '%s' user '%s'",
+		SIPE_DEBUG_INFO("sipe_purple_login: auth domain '%s' user '%s'",
 				login_domain ? login_domain : "",
 				login_account);
 		g_strfreev(domain_user);
@@ -287,6 +288,8 @@
 	purple_private->gc = gc;
 	purple_private->account = account;
 
+	sipe_purple_chat_setup_rejoin(purple_private);
+
 #ifdef HAVE_LIBKRB5
 	if (purple_account_get_bool(account, "krb5", FALSE))
 		SIPE_CORE_FLAG_SET(KRB5);
@@ -319,7 +322,7 @@
 	g_strfreev(username_split);
 }
 
-static void sipe_close(PurpleConnection *gc)
+static void sipe_purple_close(PurpleConnection *gc)
 {
 	struct sipe_core_public *sipe_public = PURPLE_GC_TO_SIPE_CORE_PUBLIC;
 
@@ -328,16 +331,26 @@
 
 		sipe_core_deallocate(sipe_public);
 
-		if (purple_private->dns_query)
-			purple_srv_cancel(purple_private->dns_query);
+		if (purple_private->roomlist_map)
+			g_hash_table_destroy(purple_private->roomlist_map);
+		sipe_purple_chat_destroy_rejoin(purple_private);
 		g_free(purple_private);
 		gc->proto_data = NULL;
 	}
 }
 
+static int sipe_purple_send_im(PurpleConnection *gc,
+			 const char *who,
+			 const char *what,
+			 SIPE_UNUSED_PARAMETER PurpleMessageFlags flags)
+{
+	sipe_core_im_send(PURPLE_GC_TO_SIPE_CORE_PUBLIC, who, what);
+	return 1;
+}
+
 #define SIPE_TYPING_SEND_TIMEOUT 4
 
-static unsigned int sipe_send_typing(PurpleConnection *gc,
+static unsigned int sipe_purple_send_typing(PurpleConnection *gc,
 				 const char *who,
 				 PurpleTypingState state)
 {
@@ -350,24 +363,17 @@
 	return SIPE_TYPING_SEND_TIMEOUT;
 }
 
-static void sipe_add_permit(PurpleConnection *gc, const char *name)
+static void sipe_purple_add_permit(PurpleConnection *gc, const char *name)
 {
 	sipe_core_contact_allow_deny(PURPLE_GC_TO_SIPE_CORE_PUBLIC, name, TRUE);
 }
 
-static void sipe_add_deny(PurpleConnection *gc, const char *name)
+static void sipe_purple_add_deny(PurpleConnection *gc, const char *name)
 {
 	sipe_core_contact_allow_deny(PURPLE_GC_TO_SIPE_CORE_PUBLIC, name, FALSE);
 }
 
-static void sipe_chat_invite(PurpleConnection *gc, int id,
-			 SIPE_UNUSED_PARAMETER const char *message,
-			 const char *name)
-{
-	sipe_core_chat_create(PURPLE_GC_TO_SIPE_CORE_PUBLIC, id, name);
-}
-
-static void sipe_keep_alive(PurpleConnection *gc)
+static void sipe_purple_keep_alive(PurpleConnection *gc)
 {
 	struct sipe_core_public *sipe_public = PURPLE_GC_TO_SIPE_CORE_PUBLIC;
 	struct sipe_backend_private *purple_private = sipe_public->backend_private;
@@ -382,15 +388,28 @@
 	}
 }
 
-static void sipe_alias_buddy(PurpleConnection *gc, const char *name,
+static void sipe_purple_alias_buddy(PurpleConnection *gc, const char *name,
 			 SIPE_UNUSED_PARAMETER const char *alias)
 {
 	sipe_core_group_set_user(PURPLE_GC_TO_SIPE_CORE_PUBLIC, name);
 }
 
+static void sipe_purple_group_rename(PurpleConnection *gc,
+				 const char *old_name,
+				 PurpleGroup *group,
+				 SIPE_UNUSED_PARAMETER GList *moved_buddies)
+{
+	sipe_core_group_rename(PURPLE_GC_TO_SIPE_CORE_PUBLIC, old_name, group->name);
+}
+
+static void sipe_purple_group_remove(PurpleConnection *gc, PurpleGroup *group)
+{
+	sipe_core_group_remove(PURPLE_GC_TO_SIPE_CORE_PUBLIC, group->name);
+}
+
 #if PURPLE_VERSION_CHECK(2,5,0)
 static GHashTable *
-sipe_get_account_text_table(SIPE_UNUSED_PARAMETER PurpleAccount *account)
+sipe_purple_get_account_text_table(SIPE_UNUSED_PARAMETER PurpleAccount *account)
 {
 	GHashTable *table;
 	table = g_hash_table_new(g_str_hash, g_str_equal);
@@ -400,7 +419,16 @@
 
 #if PURPLE_VERSION_CHECK(2,6,0)
 #ifdef HAVE_VV
-static gboolean sipe_initiate_media(PurpleAccount *account, const char *who,
+
+extern void capture_pipeline(gchar *label);
+
+static void
+sipe_purple_sigusr1_handler(SIPE_UNUSED_PARAMETER int signum)
+{
+	capture_pipeline("PURPLE_SIPE_PIPELINE");
+}
+
+static gboolean sipe_purple_initiate_media(PurpleAccount *account, const char *who,
 				 SIPE_UNUSED_PARAMETER PurpleMediaSessionType type)
 {
 	sipe_core_media_initiate_call(PURPLE_ACCOUNT_TO_SIPE_CORE_PUBLIC,
@@ -409,7 +437,7 @@
 	return TRUE;
 }
 
-static PurpleMediaCaps sipe_get_media_caps(SIPE_UNUSED_PARAMETER PurpleAccount *account,
+static PurpleMediaCaps sipe_purple_get_media_caps(SIPE_UNUSED_PARAMETER PurpleAccount *account,
 					 SIPE_UNUSED_PARAMETER const char *who)
 {
 	return PURPLE_MEDIA_CAPS_AUDIO
@@ -420,7 +448,7 @@
 #endif
 #endif
 
-static PurplePluginProtocolInfo prpl_info =
+static PurplePluginProtocolInfo sipe_prpl_info =
 {
 	OPT_PROTO_CHAT_TOPIC,
 	NULL,					/* user_splits */
@@ -428,17 +456,17 @@
 	NO_BUDDY_ICONS,				/* icon_spec */
 	sipe_list_icon,				/* list_icon */
 	NULL,					/* list_emblems */
-	sipe_status_text,			/* status_text */
-	sipe_tooltip_text,			/* tooltip_text */	// add custom info to contact tooltip
-	sipe_status_types,			/* away_states */
-	sipe_blist_node_menu,			/* blist_node_menu */
-	NULL,					/* chat_info */
-	NULL,					/* chat_info_defaults */
-	sipe_login,				/* login */
-	sipe_close,				/* close */
-	sipe_im_send,				/* send_im */
+	sipe_purple_status_text,		/* status_text */
+	sipe_purple_tooltip_text,		/* tooltip_text */	// add custom info to contact tooltip
+	sipe_purple_status_types,		/* away_states */
+	sipe_purple_blist_node_menu,		/* blist_node_menu */
+	sipe_purple_chat_info,			/* chat_info */
+	sipe_purple_chat_info_defaults,		/* chat_info_defaults */
+	sipe_purple_login,			/* login */
+	sipe_purple_close,			/* close */
+	sipe_purple_send_im,			/* send_im */
 	NULL,					/* set_info */		// TODO maybe
-	sipe_send_typing,			/* send_typing */
+	sipe_purple_send_typing,		/* send_typing */
 	sipe_get_info,				/* get_info */
 	sipe_set_status,			/* set_status */
 	sipe_set_idle,				/* set_idle */
@@ -447,39 +475,39 @@
 	NULL,					/* add_buddies */
 	sipe_remove_buddy,			/* remove_buddy */
 	NULL,					/* remove_buddies */
-	sipe_add_permit,			/* add_permit */
-	sipe_add_deny,				/* add_deny */
-	sipe_add_deny,				/* rem_permit */
-	sipe_add_permit,			/* rem_deny */
+	sipe_purple_add_permit,			/* add_permit */
+	sipe_purple_add_deny,			/* add_deny */
+	sipe_purple_add_deny,			/* rem_permit */
+	sipe_purple_add_permit,			/* rem_deny */
 	NULL,					/* set_permit_deny */
-	NULL,					/* join_chat */
+	sipe_purple_chat_join,			/* join_chat */
 	NULL,					/* reject_chat */
 	NULL,					/* get_chat_name */
-	sipe_chat_invite,			/* chat_invite */
-	sipe_chat_leave,			/* chat_leave */
+	sipe_purple_chat_invite,		/* chat_invite */
+	sipe_purple_chat_leave,			/* chat_leave */
 	NULL,					/* chat_whisper */
-	sipe_chat_send,				/* chat_send */
-	sipe_keep_alive,			/* keepalive */
+	sipe_purple_chat_send,			/* chat_send */
+	sipe_purple_keep_alive,			/* keepalive */
 	NULL,					/* register_user */
 	NULL,					/* get_cb_info */	// deprecated
 	NULL,					/* get_cb_away */	// deprecated
-	sipe_alias_buddy,			/* alias_buddy */
-	sipe_group_buddy,			/* group_buddy */
-	sipe_rename_group,			/* rename_group */
+	sipe_purple_alias_buddy,		/* alias_buddy */
+	sipe_purple_group_buddy,		/* group_buddy */
+	sipe_purple_group_rename,		/* rename_group */
 	NULL,					/* buddy_free */
 	sipe_convo_closed,			/* convo_closed */
 	purple_normalize_nocase,		/* normalize */
 	NULL,					/* set_buddy_icon */
-	sipe_remove_group,			/* remove_group */
+	sipe_purple_group_remove,		/* remove_group */
 	NULL,					/* get_cb_real_name */	// TODO?
 	NULL,					/* set_chat_topic */
 	NULL,					/* find_blist_chat */
-	NULL,					/* roomlist_get_list */
-	NULL,					/* roomlist_cancel */
+	sipe_purple_roomlist_get_list,		/* roomlist_get_list */
+	sipe_purple_roomlist_cancel,		/* roomlist_cancel */
 	NULL,					/* roomlist_expand_category */
 	NULL,					/* can_receive_file */
-	sipe_ft_send_file,			/* send_file */
-	sipe_ft_new_xfer,			/* new_xfer */
+	sipe_purple_ft_send_file,		/* send_file */
+	sipe_purple_ft_new_xfer,		/* new_xfer */
 	NULL,					/* offline_message */
 	NULL,					/* whiteboard_prpl_ops */
 	NULL,					/* send_raw */
@@ -493,11 +521,11 @@
 #endif
 	sizeof(PurplePluginProtocolInfo), /* struct_size */
 #if PURPLE_VERSION_CHECK(2,5,0)
-	sipe_get_account_text_table,		/* get_account_text_table */
+	sipe_purple_get_account_text_table,	/* get_account_text_table */
 #if PURPLE_VERSION_CHECK(2,6,0)
 #ifdef HAVE_VV
-	sipe_initiate_media,			/* initiate_media */
-	sipe_get_media_caps,			/* get_media_caps */
+	sipe_purple_initiate_media,		/* initiate_media */
+	sipe_purple_get_media_caps,		/* get_media_caps */
 #else
 	NULL,					/* initiate_media */
 	NULL,					/* get_media_caps */
@@ -506,45 +534,61 @@
 	NULL,					/* get_moods */
 	NULL,					/* set_public_alias */
 	NULL,					/* get_public_alias */
+#if PURPLE_VERSION_CHECK(2,8,0)
+	NULL,					/* add_buddy_with_invite */
+	NULL,					/* add_buddies_with_invite */
+#endif
 #endif
 #endif
 #endif
 };
 
 /* PurplePluginInfo function calls & data structure */
-static gboolean sipe_plugin_load(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
+static gboolean sipe_purple_plugin_load(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
 {
+#ifdef HAVE_VV
+	struct sigaction action;
+	memset(&action, 0, sizeof (action));
+	action.sa_handler = sipe_purple_sigusr1_handler;
+	sigaction(SIGUSR1, &action, NULL);
+#endif
 	return TRUE;
 }
 
-static gboolean sipe_plugin_unload(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
+static gboolean sipe_purple_plugin_unload(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
 {
+#ifdef HAVE_VV
+	struct sigaction action;
+	memset(&action, 0, sizeof (action));
+	action.sa_handler = SIG_DFL;
+	sigaction(SIGUSR1, &action, NULL);
+#endif
 	return TRUE;
 }
 
-static void sipe_plugin_destroy(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
+static void sipe_purple_plugin_destroy(SIPE_UNUSED_PARAMETER PurplePlugin *plugin)
 {
 	GList *entry;
 
-	purple_activity_destroy();
+	sipe_purple_activity_destroy();
 	sipe_core_destroy();
 
-	entry = prpl_info.protocol_options;
+	entry = sipe_prpl_info.protocol_options;
 	while (entry) {
 		purple_account_option_destroy(entry->data);
 		entry = g_list_delete_link(entry, entry);
 	}
-	prpl_info.protocol_options = NULL;
+	sipe_prpl_info.protocol_options = NULL;
 
-	entry = prpl_info.user_splits;
+	entry = sipe_prpl_info.user_splits;
 	while (entry) {
 		purple_account_user_split_destroy(entry->data);
 		entry = g_list_delete_link(entry, entry);
 	}
-	prpl_info.user_splits = NULL;
+	sipe_prpl_info.user_splits = NULL;
 }
 
-static void sipe_show_about_plugin(PurplePluginAction *action)
+static void sipe_purple_show_about_plugin(PurplePluginAction *action)
 {
 	gchar *tmp = sipe_core_about();
 	purple_notify_formatted((PurpleConnection *) action->context,
@@ -552,7 +596,7 @@
 	g_free(tmp);
 }
 
-static void sipe_show_find_contact(PurplePluginAction *action)
+static void sipe_purple_show_find_contact(PurplePluginAction *action)
 {
 	PurpleConnection *gc = (PurpleConnection *) action->context;
 	PurpleRequestFields *fields;
@@ -582,40 +626,87 @@
 		purple_connection_get_account(gc), NULL, NULL, gc);
 }
 
-static void sipe_republish_calendar(PurplePluginAction *action)
+static void sipe_purple_join_conference_cb(PurpleConnection *gc,
+					 PurpleRequestFields *fields)
+{
+	GList *entries = purple_request_field_group_get_fields(purple_request_fields_get_groups(fields)->data);
+
+	if (entries) {
+		PurpleRequestField *field = entries->data;
+		const char *id = purple_request_field_get_id(field);
+		const char *value = purple_request_field_string_get_value(field);
+
+		if (!sipe_strequal(id, "meetingLocation"))
+			return;
+
+		sipe_core_conf_create(PURPLE_GC_TO_SIPE_CORE_PUBLIC, value);
+	}
+}
+
+static void sipe_purple_show_join_conference(PurplePluginAction *action)
+{
+	PurpleConnection *gc = (PurpleConnection *) action->context;
+	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_string_new("meetingLocation", _("Meeting location"), NULL, FALSE);
+	purple_request_field_group_add_field(group, field);
+
+	purple_request_fields(gc,
+		_("Join conference"),
+		_("Join scheduled conference"),
+		_("Enter meeting location string you received in the invitation.\n"
+		 "\n"
+		 "Valid location will be something like\n"
+		 "meet:sip:someone@company.com;gruu;opaque=app:conf:focus:id:abcdef1234"),
+		fields,
+		_("_Join"), G_CALLBACK(sipe_purple_join_conference_cb),
+		_("_Cancel"), NULL,
+		purple_connection_get_account(gc), NULL, NULL, gc);
+}
+
+static void sipe_purple_republish_calendar(PurplePluginAction *action)
 {
 	PurpleConnection *gc = (PurpleConnection *) action->context;
 	sipe_core_update_calendar(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
 }
 
-static void sipe_reset_status(PurplePluginAction *action)
+static void sipe_purple_reset_status(PurplePluginAction *action)
 {
 	PurpleConnection *gc = (PurpleConnection *) action->context;
 	sipe_core_reset_status(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
 }
 
-static GList *sipe_actions(SIPE_UNUSED_PARAMETER PurplePlugin *plugin,
+static GList *sipe_purple_actions(SIPE_UNUSED_PARAMETER PurplePlugin *plugin,
 			 SIPE_UNUSED_PARAMETER gpointer context)
 {
 	GList *menu = NULL;
 	PurplePluginAction *act;
 
-	act = purple_plugin_action_new(_("About SIPE plugin..."), sipe_show_about_plugin);
+	act = purple_plugin_action_new(_("About SIPE plugin..."), sipe_purple_show_about_plugin);
 	menu = g_list_prepend(menu, act);
 
-	act = purple_plugin_action_new(_("Contact search..."), sipe_show_find_contact);
+	act = purple_plugin_action_new(_("Contact search..."), sipe_purple_show_find_contact);
 	menu = g_list_prepend(menu, act);
 
-	act = purple_plugin_action_new(_("Republish Calendar"), sipe_republish_calendar);
+	act = purple_plugin_action_new(_("Join scheduled conference..."), sipe_purple_show_join_conference);
 	menu = g_list_prepend(menu, act);
 
-	act = purple_plugin_action_new(_("Reset status"), sipe_reset_status);
+	act = purple_plugin_action_new(_("Republish Calendar"), sipe_purple_republish_calendar);
+	menu = g_list_prepend(menu, act);
+
+	act = purple_plugin_action_new(_("Reset status"), sipe_purple_reset_status);
 	menu = g_list_prepend(menu, act);
 
 	return g_list_reverse(menu);
 }
 
-static PurplePluginInfo info = {
+static PurplePluginInfo sipe_purple_info = {
 	PURPLE_PLUGIN_MAGIC,
 	PURPLE_MAJOR_VERSION,
 	PURPLE_MINOR_VERSION,
@@ -635,27 +726,27 @@
 	"Stefan Becker <stefan.becker@nokia.com>, " /**< author */
 	"pier11 <pier11@operamail.com>", /**< author */
 	PACKAGE_URL, /**< homepage */
-	sipe_plugin_load, /**< load */
-	sipe_plugin_unload, /**< unload */
-	sipe_plugin_destroy, /**< destroy */
+	sipe_purple_plugin_load, /**< load */
+	sipe_purple_plugin_unload, /**< unload */
+	sipe_purple_plugin_destroy, /**< destroy */
 	NULL, /**< ui_info */
-	&prpl_info, /**< extra_info */
+	&sipe_prpl_info, /**< extra_info */
 	NULL,
-	sipe_actions,
+	sipe_purple_actions,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 
-static void init_plugin(PurplePlugin *plugin)
+static void sipe_purple_init_plugin(PurplePlugin *plugin)
 {
 	PurpleAccountUserSplit *split;
 	PurpleAccountOption *option;
 
 	/* This needs to be called first */
 	sipe_core_init(LOCALEDIR);
-	purple_activity_init();
+	sipe_purple_activity_init();
 
 	purple_plugin_register(plugin);
 
@@ -668,57 +759,63 @@
 	 */
 	split = purple_account_user_split_new(_("Login\n user or DOMAIN\\user or\n user@company.com"), NULL, ',');
 	purple_account_user_split_set_reverse(split, FALSE);
-	prpl_info.user_splits = g_list_append(prpl_info.user_splits, split);
+	sipe_prpl_info.user_splits = g_list_append(sipe_prpl_info.user_splits, split);
 
 	option = purple_account_option_string_new(_("Server[:Port]\n(leave empty for auto-discovery)"), "server", "");
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 
 	option = purple_account_option_list_new(_("Connection type"), "transport", NULL);
 	purple_account_option_add_list_item(option, _("Auto"), "auto");
 	purple_account_option_add_list_item(option, _("SSL/TLS"), "tls");
 	purple_account_option_add_list_item(option, _("TCP"), "tcp");
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 
 	/*option = purple_account_option_bool_new(_("Publish status (note: everyone may watch you)"), "doservice", TRUE);
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);*/
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);*/
 
 	option = purple_account_option_string_new(_("User Agent"), "useragent", "");
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 
 #ifdef HAVE_LIBKRB5
 	option = purple_account_option_bool_new(_("Use Kerberos"), "krb5", FALSE);
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 
 	/* Suitable for sspi/NTLM, sspi/Kerberos and krb5 security mechanisms
 	 * No login/password is taken into account if this option present,
 	 * instead used default credentials stored in OS.
 	 */
 	option = purple_account_option_bool_new(_("Use Single Sign-On"), "sso", TRUE);
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 #endif
 
 	/** Example (Exchange): https://server.company.com/EWS/Exchange.asmx
 	 * Example (Domino) : https://[domino_server]/[mail_database_name].nsf
 	 */
 	option = purple_account_option_string_new(_("Email services URL\n(leave empty for auto-discovery)"), "email_url", "");
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 
 	option = purple_account_option_string_new(_("Email address\n(if different from Username)"), "email", "");
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 
 	/** Example (Exchange): DOMAIN\user or user@company.com
 	 * Example (Domino) : email_address
 	 */
 	option = purple_account_option_string_new(_("Email login\n(if different from Login)"), "email_login", "");
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 
 	option = purple_account_option_string_new(_("Email password\n(if different from Password)"), "email_password", "");
 	purple_account_option_set_masked(option, TRUE);
-	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
+
+	/** Example (federated domain): company.com (i.e. ocschat@company.com)
+	 * Example (non-default user): user@company.com
+	 */
+	option = purple_account_option_string_new(_("Group Chat Proxy\n company.com or user@company.com\n(leave empty to determine from Username)"), "groupchat_user", "");
+	sipe_prpl_info.protocol_options = g_list_append(sipe_prpl_info.protocol_options, option);
 }
 
 /* This macro makes the code a purple plugin */
-PURPLE_INIT_PLUGIN(sipe, init_plugin, info);
+PURPLE_INIT_PLUGIN(sipe, sipe_purple_init_plugin, sipe_purple_info);
 
 /*
 Local Variables:
--- pidgin-sipe-1.11.2/src/purple/purple-private.h	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-private.h	2011-06-14 14:40:36.000000000 +0200
@@ -23,18 +23,29 @@
 /* Forward declarations */
 struct sipe_core_public;
 struct _PurpleAccount;
+struct _PurpleChat;
 struct _PurpleConnection;
-struct _PurpleSrvQueryData;
+struct _PurpleRoomlist;
 struct _PurpleXfer;
 
+#ifndef _PurpleMessageFlags
+#define _PurpleMessageFlags int
+#endif
+
 struct sipe_backend_private {
 	struct sipe_core_public *public;
 	struct _PurpleConnection *gc;
 	struct _PurpleAccount *account;
-	struct _PurpleSrvQueryData *dns_query;
+	struct _PurpleRoomlist *roomlist;
+	GHashTable *roomlist_map; /* name -> uri */
+	GList *rejoin_chats;
 	time_t last_keepalive;
 };
 
+struct sipe_backend_fd {
+	int fd;
+};
+
 /**
 * Initiates outgoing file transfer, sending @c file to remote peer identified
 * by @c who.
@@ -43,7 +54,7 @@
 * @param who string identifying receiver of the file
 * @param file local file system path of the file to send
 */
-void sipe_ft_send_file(struct _PurpleConnection *gc,
+void sipe_purple_ft_send_file(struct _PurpleConnection *gc,
 		 const char *who,
 		 const char *file);
 
@@ -53,9 +64,39 @@
 * @param gc a PurpleConnection
 * @param who remote participant in the file transfer session
 */
-struct _PurpleXfer *sipe_ft_new_xfer(struct _PurpleConnection *gc,
+struct _PurpleXfer *sipe_purple_ft_new_xfer(struct _PurpleConnection *gc,
 				 const char *who);
 
+/* libpurple chat callbacks */
+#define SIPE_PURPLE_COMPONENT_KEY_CONVERSATION "_conv"
+
+void sipe_purple_chat_setup_rejoin(struct sipe_backend_private *purple_private);
+void sipe_purple_chat_destroy_rejoin(struct sipe_backend_private *purple_private);
+void sipe_purple_chat_invite(struct _PurpleConnection *gc,
+			 int id,
+			 const char *message,
+			 const char *name);
+void sipe_purple_chat_leave(struct _PurpleConnection *gc, int id);
+int sipe_purple_chat_send(struct _PurpleConnection *gc,
+			 int id,
+			 const char *what,
+			 _PurpleMessageFlags flags);
+GList *sipe_purple_chat_menu(struct _PurpleChat *chat);
+
+/* libpurple chat room callbacks */
+GList *sipe_purple_chat_info(struct _PurpleConnection *gc);
+GHashTable *sipe_purple_chat_info_defaults(struct _PurpleConnection *gc,
+					 const char *chat_name);
+void sipe_purple_chat_join(struct _PurpleConnection *gc, GHashTable *data);
+struct _PurpleRoomlist *sipe_purple_roomlist_get_list(struct _PurpleConnection *gc);
+void sipe_purple_roomlist_cancel(struct _PurpleRoomlist *list);
+
+/* libpurple buddy callbacks */
+void sipe_purple_group_buddy(struct _PurpleConnection *gc,
+			 const char *who,
+			 const char *old_group_name,
+			 const char *new_group_name);
+
 /* Convenience macros */
 #define PURPLE_ACCOUNT_TO_SIPE_CORE_PUBLIC ((struct sipe_core_public *) account->gc->proto_data)
 #define PURPLE_GC_TO_SIPE_CORE_PUBLIC ((struct sipe_core_public *) gc->proto_data)
--- pidgin-sipe-1.11.2/src/purple/purple-setting.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-setting.c	2011-06-14 14:40:36.000000000 +0200
@@ -42,6 +42,7 @@
 	"email_url", /* SIPE_SETTING_EMAIL_URL */
 	"email_login", /* SIPE_SETTING_EMAIL_LOGIN */
 	"email_password", /* SIPE_SETTING_EMAIL_PASSWORD */
+	"groupchat_user", /* SIPE_SETTING_GROUPCHAT_USER */
 	"useragent" /* SIPE_SETTING_USER_AGENT */
 };
 
--- pidgin-sipe-1.11.2/src/purple/purple-user.c	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/src/purple/purple-user.c	2011-06-14 14:40:36.000000000 +0200
@@ -22,6 +22,7 @@
 
 #include <glib.h>
 
+#include "request.h"
 #include "server.h"
 
 #include "purple-private.h"
@@ -46,6 +47,31 @@
 	serv_got_typing_stopped(purple_private->gc, from);
 }
 
+static void ask_cb(gpointer key, int choice)
+{
+	sipe_core_user_ask_cb(key, choice == 1);
+}
+
+void sipe_backend_user_ask(struct sipe_core_public *sipe_public,
+			 const gchar *message,
+			 const gchar *accept_label,
+			 const gchar *decline_label,
+			 gpointer key)
+{
+	struct sipe_backend_private *purple_private = sipe_public->backend_private;
+
+	purple_request_action(key, "Office Communicator", message,
+			 NULL, 0, purple_private->account,
+			 NULL, NULL, key, 2,
+			 accept_label, (PurpleRequestActionCb) ask_cb,
+			 decline_label, (PurpleRequestActionCb) ask_cb);
+}
+
+void sipe_backend_user_close_ask(gpointer key)
+{
+	purple_request_close_with_handle(key);
+}
+
 /*
 Local Variables:
 mode: c
--- pidgin-sipe-1.11.2/TODO	2010-11-03 05:13:51.000000000 +0100
+++ pidgin-sipe-1.11.2/TODO	2011-06-14 14:40:36.000000000 +0200
@@ -5,19 +5,7 @@
 	- Native backends other than Purple.
 	 * Separate Sipe core and Purple plugin functionality.
 	 * New backends: Telepathy, Kopete, Miranda, ???
-	- Voice and Video support.
 	- Desktop sharing/Live Meeting integration on Windows platform.
-	- (?) Email notification.
-	- Refactoring to decouple transport/SIP layer (like has been done in http-conn.c)
-from SIP-protocol's extensions in form of XML exchange (most notably presense).
-So Sofia-SIP could serve as a backend for SIPE. Or otherwise improve SIPE transport 
-layer - timeouts.
-(In http-conn.c inputs are XML requests, outputs - XML responces or error codes.
-All lower level things like socket read/write operations, HTTP message forming, 
-NTLM/etc. authertication are all hidded behind http-conn.h API.
-So sip-ews.c and sipe-domino.c clients only operate with XML request/responce, they don't care what
-is underneath transport at all.) http://www.networkdictionary.com/protocols/osimodel.php - 7 layer
-model - that must be taught at university.
 	- Update projects site with
 	 * SIPE features
 * better/more complete screenshots
@@ -29,3 +17,9 @@
 	- answer incoming call (logs required)
 	- (?) work with multiple phone lines (not the first one)
 	- (?) Call transfer set up, other RCC features from Communicator.
+
+Group Chat:
+ - channel management: add, delete
+ - (?) lock/unlock channel (is this possible?)
+ - file sharing: up & downloading from web server
+ - ??? (unknown as we don't have XCCOS protocol specification)
--- pidgin-sipe-1.11.2/.tx/config	1970-01-01 01:00:00.000000000 +0100
+++ pidgin-sipe-1.11.2/.tx/config	2011-06-14 14:40:36.000000000 +0200
@@ -0,0 +1,8 @@
+[main]
+host = http://www.transifex.net
+
+[pidgin-sipe.mob]
+file_filter = po/<lang>.po
+source_file = po/pidgin-sipe.pot
+source_lang = en
+

Places

File pidgin-sipe-1.11.2-mob.patch of Package mingw64-pidgin-sipe (Revision 374c6ac20e08139a1c2d8f2088846a2d)

Places