changeset 8675:9ee2542d1104

[gaim-migrate @ 9428] A GroupWise plugin from Novell. committer: Tailor Script <[e-mail]>

--- a/Makefile.mingw	Fri Apr 16 23:32:46 2004 +0000
+++ b/Makefile.mingw	Sat Apr 17 13:55:28 2004 +0000
@@ -23,6 +23,7 @@
 NAPSTER = $(GAIM_PROTOS)/napster
 TREPIA = $(GAIM_PROTOS)/trepia
 GG = $(GAIM_PROTOS)/gg
+NOVELL = $(GAIM_PROTOS)/novell
 PO = ./po
 
 VERSION := $(shell cat ./VERSION)
@@ -50,6 +51,7 @@
 JABBER_TYPE = PLUGIN
 NAPSTER_TYPE = PLUGIN
 GG_TYPE = PLUGIN
+NOVELL_TYPE = PLUGIN
 TREPIA_TYPE = PLUGIN
 
 all:
@@ -60,6 +62,7 @@
 	$(MAKE) TYPE='$(IRC_TYPE)' -C $(IRC) -f Makefile.mingw
 	$(MAKE) TYPE='$(JABBER_TYPE)' -C $(JABBER) -f Makefile.mingw
 	$(MAKE) TYPE='$(GG_TYPE)' -C $(GG) -f Makefile.mingw
+	$(MAKE) TYPE='$(NOVELL_TYPE)' -C $(NOVELL) -f Makefile.mingw
 	$(MAKE) -C $(GAIM_SRC) -f Makefile.mingw
 	$(MAKE) -C $(GAIM_PLUGINS) -f Makefile.mingw
 
@@ -77,6 +80,7 @@
 	$(MAKE) TYPE='$(IRC_TYPE)' -C $(IRC) -f Makefile.mingw install
 	$(MAKE) TYPE='$(JABBER_TYPE)' -C $(JABBER) -f Makefile.mingw install
 	$(MAKE) TYPE='$(GG_TYPE)' -C $(GG) -f Makefile.mingw install
+	$(MAKE) TYPE='$(NOVELL_TYPE)' -C $(NOVELL) -f Makefile.mingw install
 	cp $(NEEDED_DLLS) $(GAIM_INSTALL_DIR)
 	cp $(SOUNDS) $(GAIM_INSTALL_DIR)/sounds/gaim
 
@@ -100,6 +104,7 @@
 	$(MAKE) -C $(IRC) -f Makefile.mingw clean
 	$(MAKE) -C $(JABBER) -f Makefile.mingw clean
 	$(MAKE) -C $(GG) -f Makefile.mingw clean
+	$(MAKE) -C $(NOVELL) -f Makefile.mingw clean
 	$(MAKE) -C $(GAIM_SRC) -f Makefile.mingw clean
 	$(MAKE) -C $(GAIM_PLUGINS) -f Makefile.mingw clean
 	rm -rf config.h $(GAIM_INSTALL_DIR)

--- a/configure.ac	Fri Apr 16 23:32:46 2004 +0000
+++ b/configure.ac	Sat Apr 17 13:55:28 2004 +0000
@@ -102,7 +102,7 @@
 fi
 
 if test "x$STATIC_PRPLS" = "xall" ; then
-	STATIC_PRPLS="gg irc jabber msn napster oscar yahoo zephyr"
+	STATIC_PRPLS="gg irc jabber msn napster novell oscar yahoo zephyr"
 fi
 AC_SUBST(STATIC_PRPLS)
 STATIC_LINK_LIBS=
@@ -118,6 +118,7 @@
 		jabber)		static_jabber=yes ;;
 		msn)		static_msn=yes ;;
 		napster)	static_napster=yes ;;
+		novell)		static_novell=yes ;;
 		oscar)		static_oscar=yes ;;
 		rendezvous)	static_rendezvous=yes ;;
 		toc)		static_toc=yes ;;
@@ -132,6 +133,7 @@
 AM_CONDITIONAL(STATIC_JABBER, test "x$static_jabber" = "xyes")
 AM_CONDITIONAL(STATIC_MSN, test "x$static_msn" = "xyes")
 AM_CONDITIONAL(STATIC_NAPSTER, test "x$static_napster" = "xyes")
+AM_CONDITIONAL(STATIC_NOVELL, test "x$static_novell" = "xyes")
 AM_CONDITIONAL(STATIC_OSCAR, test "x$static_oscar" = "xyes")
 AM_CONDITIONAL(STATIC_RENDEZVOUS, test "x$static_rendezvous" = "xyes")
 AM_CONDITIONAL(STATIC_TOC, test "x$static_toc" = "xyes")
@@ -144,7 +146,7 @@
 
 AC_ARG_WITH(dynamic_prpls,   [  --with-dynamic-prpls    specify which protocols to build dynamically],[DYNAMIC_PRPLS=`echo $withval | $sedpath 's/,/ /g'`])
 if test "x$DYNAMIC_PRPLS" = "xall" ; then
-	DYNAMIC_PRPLS="gg irc jabber msn napster oscar yahoo zephyr"
+	DYNAMIC_PRPLS="gg irc jabber msn napster novell oscar yahoo zephyr"
 fi
 AC_SUBST(DYNAMIC_PRPLS)
 for i in $DYNAMIC_PRPLS ; do
@@ -154,6 +156,7 @@
 		jabber)		dynamic_jabber=yes ;;
 		msn)		dynamic_msn=yes ;;
 		napster)	dynamic_napster=yes ;;
+		novell)		dynamic_novell=yes ;;
 		oscar)		dynamic_oscar=yes ;;
 		rendezvous)	dynamic_rendezvous=yes ;;
 		toc)		dynamic_toc=yes ;;
@@ -168,6 +171,7 @@
 AM_CONDITIONAL(DYNAMIC_JABBER, test "x$dynamic_jabber" = "xyes")
 AM_CONDITIONAL(DYNAMIC_MSN, test "x$dynamic_msn" = "xyes")
 AM_CONDITIONAL(DYNAMIC_NAPSTER, test "x$dynamic_napster" = "xyes")
+AM_CONDITIONAL(DYNAMIC_NOVELL, test "x$dynamic_novell" = "xyes")
 AM_CONDITIONAL(DYNAMIC_OSCAR, test "x$dynamic_oscar" = "xyes")
 AM_CONDITIONAL(DYNAMIC_RENDEZVOUS, test "x$dynamic_rendezvous" = "xyes")
 AM_CONDITIONAL(DYNAMIC_TOC, test "x$dynamic_toc" = "xyes")
@@ -1097,6 +1101,7 @@
 		   src/protocols/jabber/Makefile
 		   src/protocols/msn/Makefile
 		   src/protocols/napster/Makefile
+   		   src/protocols/novell/Makefile
 		   src/protocols/oscar/Makefile
 		   src/protocols/rendezvous/Makefile
 		   src/protocols/toc/Makefile

--- a/pixmaps/status/default/Makefile.am	Fri Apr 16 23:32:46 2004 +0000
+++ b/pixmaps/status/default/Makefile.am	Sat Apr 17 13:55:28 2004 +0000
@@ -22,6 +22,7 @@
 	na.png \
 	napster.png \
 	notauthorized.png \
+	novell.png \
 	occupied.png \
 	offline.png \
 	rendezvous.png \

Binary file pixmaps/status/default/novell.png has changed

--- a/src/blist.c	Fri Apr 16 23:32:46 2004 +0000
+++ b/src/blist.c	Sat Apr 17 13:55:28 2004 +0000
@@ -348,6 +348,17 @@
 void  gaim_blist_rename_buddy (GaimBuddy *buddy, const char *name)
 {
 	GaimBlistUiOps *ops = gaimbuddylist->ui_ops;
+	struct _gaim_hbuddy *hb = g_new(struct _gaim_hbuddy, 1);
+
+	hb->name = g_strdup(gaim_normalize(buddy->account, buddy->name));
+	hb->account = buddy->account;
+	hb->group = ((GaimBlistNode *)buddy)->parent->parent;
+	g_hash_table_remove(gaimbuddylist->buddies, hb);
+
+	g_free(hb->name);
+	hb->name = g_strdup(gaim_normalize(buddy->account, name));
+	g_hash_table_replace(gaimbuddylist->buddies, hb, buddy);
+
 	g_free(buddy->name);
 	buddy->name = g_strdup(name);
 	if (ops)

--- a/src/protocols/Makefile.am	Fri Apr 16 23:32:46 2004 +0000
+++ b/src/protocols/Makefile.am	Sat Apr 17 13:55:28 2004 +0000
@@ -1,3 +1,3 @@
-DIST_SUBDIRS = gg irc jabber msn napster oscar rendezvous toc trepia yahoo zephyr
+DIST_SUBDIRS = gg irc jabber msn napster novell oscar rendezvous toc trepia yahoo zephyr
 
 SUBDIRS = $(DYNAMIC_PRPLS) $(STATIC_PRPLS)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/Makefile.am	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,53 @@
+EXTRA_DIST = \
+		Makefile.mingw
+
+pkgdir = $(libdir)/gaim
+
+NOVELLSOURCES = \
+		nmfield.h \
+		nmfield.c \
+		nmconn.h \
+		nmconn.c \
+		nmconference.h \
+		nmconference.c \
+		nmcontact.h \
+		nmcontact.c \
+		nmevent.h \
+		nmevent.c \
+		nmmessage.h \
+		nmmessage.c \
+		nmrequest.h \
+		nmrequest.c \
+		nmuser.h \
+		nmuser.c \
+		nmuserrecord.h \
+		nmuserrecord.c \
+		novell.c
+
+AM_CFLAGS = $(st)
+
+libnovell_la_LDFLAGS = -module -avoid-version
+
+if STATIC_NOVELL
+
+st = -DSTATIC
+noinst_LIBRARIES = libnovell.a
+pkg_LTLIBRARIES =
+
+libnovell_a_SOURCES = $(NOVELLSOURCES)
+libnovell_a_CFLAGS = $(AM_CFLAGS)
+
+else
+
+st =
+pkg_LTLIBRARIES = libnovell.la
+noinst_LIBRARIES =
+
+libnovell_la_SOURCES = $(NOVELLSOURCES)
+
+endif
+
+AM_CPPFLAGS = \
+	-I$(top_srcdir)/src \
+	$(DEBUG_CFLAGS) \
+	$(GLIB_CFLAGS)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/Makefile.mingw	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,142 @@
+#
+# Makefile.mingw
+#
+# Description: Makefile for win32 (mingw) version of libnovell
+#
+
+#
+# PATHS
+#
+
+INCLUDE_DIR :=		.
+GTK_TOP :=		../../../../win32-dev/gtk_2_0
+GAIM_TOP :=		../../..
+NOVELL_ROOT :=		.
+GAIM_INSTALL_DIR :=	$(GAIM_TOP)/win32-install-dir
+
+##
+## VARIABLE DEFINITIONS
+##
+
+TARGET = libnovell
+
+# Compiler Options
+
+CFLAGS =
+
+DEFINES =
+
+# Static or Plugin... 
+ifeq ($(TYPE),STATIC)
+  DEFINES += -DSTATIC
+  DLL_INSTALL_DIR =	$(GAIM_INSTALL_DIR)
+else
+ifeq ($(TYPE),PLUGIN)
+  DLL_INSTALL_DIR =	$(GAIM_INSTALL_DIR)/plugins
+endif
+endif
+
+
+##
+## INCLUDE  MAKEFILES
+##
+
+include $(GAIM_TOP)/src/win32/global.mak
+
+##
+## INCLUDE PATHS
+##
+
+INCLUDE_PATHS +=	-I$(NOVELL_ROOT) \
+			-I$(GTK_TOP)/include \
+			-I$(GTK_TOP)/include/gtk-2.0 \
+			-I$(GTK_TOP)/include/glib-2.0 \
+			-I$(GTK_TOP)/include/pango-1.0 \
+			-I$(GTK_TOP)/include/atk-1.0 \
+			-I$(GTK_TOP)/lib/glib-2.0/include \
+			-I$(GTK_TOP)/lib/gtk-2.0/include \
+			-I$(GAIM_TOP)/src \
+			-I$(GAIM_TOP)/src/win32 \
+			-I$(GAIM_TOP)
+
+
+LIB_PATHS =		-L$(GTK_TOP)/lib \
+			-L$(GAIM_TOP)/src
+
+
+##
+##  SOURCES, OBJECTS
+##
+
+C_SRC =	nmfield.c \
+		nmconn.c \
+		nmconference.c \
+		nmcontact.c \
+		nmevent.c \
+		nmmessage.c \
+		nmrequest.c \
+		nmuser.c \
+		nmuserrecord.c \
+		novell.c
+
+OBJECTS = $(C_SRC:%.c=%.o)
+
+
+##
+## LIBRARIES
+##
+
+LIBS =			-lgtk-win32-2.0 \
+			-lglib-2.0 \
+			-lgdk-win32-2.0 \
+			-lgmodule-2.0 \
+			-lgobject-2.0 \
+			-lws2_32 \
+			-lintl \
+			-lgaim
+
+
+##
+## RULES
+##
+
+# How to make a C file
+
+%.o: %.c
+	$(CC) $(CFLAGS) $(DEFINES) $(INCLUDE_PATHS) -o $@ -c $<
+
+##
+## TARGET DEFINITIONS
+##
+
+.PHONY: all clean
+
+all: $(TARGET).dll
+
+install:
+	cp $(NOVELL_ROOT)/$(TARGET).dll $(DLL_INSTALL_DIR)
+
+
+##
+## BUILD Dependencies
+##
+
+$(GAIM_TOP)/src/gaim.lib:
+	$(MAKE) -C $(GAIM_TOP)/src -f Makefile.mingw gaim.lib
+
+##
+## BUILD DLL
+##
+
+$(TARGET).dll: $(OBJECTS) $(GAIM_TOP)/src/gaim.lib
+	$(CC) -shared $(OBJECTS) $(LIB_PATHS) $(LIBS) $(DLL_LD_FLAGS) -Wl,--out-implib,$(TARGET).lib -o $(TARGET).dll
+
+
+##
+## CLEAN RULES
+##
+
+clean:
+	rm -rf *.o
+	rm -rf $(TARGET).dll
+	rm -rf $(TARGET).lib

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmconference.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,232 @@
+/*
+ * nmconference.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include <string.h>
+#include "nmconference.h"
+
+static int conf_count = 0;
+
+struct _NMConference
+{
+
+	/* The conference identifier */
+	char *guid;
+
+	/* The list of participants for the conference */
+	GSList *participants;
+
+	/* Flags for the conference */
+	guint32 flags;
+
+	/* User defined data */
+	gpointer data;
+
+	/* Reference count for this object */
+	int ref_count;
+
+};
+
+
+/*******************************************************************************
+ * Conference API -- see header file for comments
+ ******************************************************************************/
+
+NMConference *
+nm_create_conference(const char *guid)
+{
+	NMConference *conf = g_new0(NMConference, 1);
+
+	if (guid) {
+		conf->guid = g_strdup(guid);
+	} else {
+		conf->guid = g_strdup(BLANK_GUID);
+	}
+	conf->ref_count = 1;
+
+	gaim_debug(GAIM_DEBUG_INFO, "novell",
+			   "Creating a conference 0x%x, total=%d\n",
+			   (guint32) conf, conf_count++);
+
+	return conf;
+}
+
+void
+nm_release_conference(NMConference * conference)
+{
+	GSList *node;
+
+	gaim_debug(GAIM_DEBUG_INFO, "novell",
+			   "In release conference 0x%x, refs=%d\n",
+			   (guint32) conference, conference->ref_count);
+	if (conference != NULL && (--conference->ref_count == 0)) {
+
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "Releasing conference 0x%x, total=%d\n",
+				   (guint32) conference, --conf_count);
+
+		if (conference->guid)
+			g_free(conference->guid);
+
+		if (conference->participants) {
+			for (node = conference->participants; node; node = node->next) {
+				if (node->data) {
+					NMUserRecord *user_record = node->data;
+
+					nm_release_user_record(user_record);
+					node->data = NULL;
+				}
+			}
+
+			g_slist_free(conference->participants);
+		}
+
+		g_free(conference);
+	}
+}
+
+gboolean
+nm_conference_is_instantiated(NMConference * conference)
+{
+	if (conference == NULL)
+		return FALSE;
+
+	return (strncmp(conference->guid, BLANK_GUID, CONF_GUID_END) != 0);
+}
+
+int
+nm_conference_get_participant_count(NMConference * conference)
+{
+	if (conference == NULL)
+		return 0;
+
+	return g_slist_length(conference->participants);
+}
+
+NMUserRecord *
+nm_conference_get_participant(NMConference * conference, int index)
+{
+	if (conference == NULL)
+		return NULL;
+
+	return (NMUserRecord *) g_slist_nth_data(conference->participants, index);
+}
+
+void
+nm_conference_add_participant(NMConference * conference,
+							  NMUserRecord * user_record)
+{
+	if (conference == NULL || user_record == NULL) {
+		return;
+	}
+
+	nm_user_record_add_ref(user_record);
+	conference->participants = g_slist_append(conference->participants, user_record);
+}
+
+void
+nm_conference_remove_participant(NMConference * conference, const char *dn)
+{
+	GSList *node, *element = NULL;
+
+	if (conference == NULL || dn == NULL) {
+		return;
+	}
+
+	for (node = conference->participants; node; node = node->next) {
+		NMUserRecord *user_record = node->data;
+
+		if (user_record) {
+			if (nm_utf8_str_equal(dn, nm_user_record_get_dn(user_record))) {
+				element = node;
+				break;
+			}
+		}
+	}
+
+	if (element) {
+		nm_release_user_record((NMUserRecord *) element->data);
+		element->data = NULL;
+		conference->participants =
+			g_slist_remove_link(conference->participants, element);
+		g_slist_free_1(element);
+	}
+}
+
+void
+nm_conference_add_ref(NMConference * conference)
+{
+	if (conference)
+		conference->ref_count++;
+}
+
+void
+nm_conference_set_flags(NMConference * conference, guint32 flags)
+{
+	if (conference) {
+		conference->flags = flags;
+	}
+}
+
+void
+nm_conference_set_guid(NMConference * conference, const char *guid)
+{
+	if (conference) {
+
+		/* Release memory for old guid */
+		if (conference->guid) {
+			g_free(conference->guid);
+		}
+
+		/* Set the new guid */
+		if (guid)
+			conference->guid = g_strdup(guid);
+		else
+			conference->guid = g_strdup(BLANK_GUID);
+	}
+}
+
+void
+nm_conference_set_data(NMConference * conference, gpointer data)
+{
+	if (conference == NULL)
+		return;
+
+	conference->data = data;
+}
+
+gpointer
+nm_conference_get_data(NMConference * conference)
+{
+	if (conference == NULL)
+		return NULL;
+
+	return conference->data;
+}
+
+const char *
+nm_conference_get_guid(NMConference * conference)
+{
+	if (conference == NULL)
+		return NULL;
+
+	return conference->guid;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmconference.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,169 @@
+/*
+ * nmconference.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef __NM_CONFERENCE_H__
+#define __NM_CONFERENCE_H__
+
+typedef struct _NMConference NMConference;
+
+#include "nmuserrecord.h"
+
+/* A blank GUID -- represents an uninstatiated conference */
+#define BLANK_GUID "[00000000-00000000-00000000-0000-0000]"
+
+/* This is how much of the conference GUIDs to compare when testing
+ * to see if two conferences are the same. We cannot compare the
+ * entire GUID because the last part is the session count.
+ */
+#define CONF_GUID_END 27
+
+/**
+ * Creates an conference object.
+ *
+ * The conference should be released by calling
+ * nm_release_conference
+ *
+ * @param guid		The GUID for the conference.
+ *
+ * @return 			The new NMConference
+ */
+NMConference *nm_create_conference(const char *guid);
+
+/**
+ * Increments the reference count for the conference.
+ *
+ * The reference to the conference should be released 
+ * by calling nm_release_conference
+ *
+ * @param conference	The conference to reference
+ */
+void nm_conference_add_ref(NMConference * conference);
+
+/**
+ * Releases the resources associated with the conference 
+ * if there are no more references to it, otherwise just
+ * decrements the reference count.
+ *
+ * @param conf		The conference to release
+ *
+ */
+void nm_release_conference(NMConference * conf);
+
+/**
+ * Set the GUID for the conference.  
+ *
+ * @param conference	The conference
+ * @param guid			The new conference GUID
+ *
+ */
+void nm_conference_set_guid(NMConference * conference, const char *guid);
+
+/**
+ * Return the GUID for the conference.  
+ *
+ * @param conference	The conference
+ *
+ * @return				The GUID for the conference
+ */
+const char *nm_conference_get_guid(NMConference * conference);
+
+/**
+ * Add a participant to the conference.
+ *
+ * @param conference	The conference
+ * @param user_record	The user record to add as a participant
+ *
+ * @return				
+ */
+void nm_conference_add_participant(NMConference * conference,
+								   NMUserRecord * user_record);
+
+/**
+ * Remove a participant to the conference.
+ *
+ * @param conference	The conference
+ * @param dn			The dn of the participant to remove
+ *
+ */
+void nm_conference_remove_participant(NMConference * conference, const char *dn);
+
+/**
+ * Return the total number of participants in the conference.
+ *
+ * @param conference	The conference
+ *
+ * @return				The number of participants for the conference
+ *
+ */
+int nm_conference_get_participant_count(NMConference * conference);
+
+/**
+ * Return a participant given an index.
+ *
+ * @param conference	The conference
+ * @param index			The index of the participant to get
+ *
+ * @return				The participant or NULL if the index is out of range.
+ *
+ */
+NMUserRecord *nm_conference_get_participant(NMConference * conference, int index);
+
+/**
+ * Check to see if the conference has been instantiated
+ *
+ * @param conference	The conference
+ *
+ * @return				TRUE if the conference has been instantiated, 
+ *						FALSE otherwise.
+ *
+ */
+gboolean nm_conference_is_instantiated(NMConference * conf);
+
+/**
+ * Set the flags for the conference.
+ *
+ * @param conference	The conference
+ * @param flags			The conference flags.
+ *
+ */
+void nm_conference_set_flags(NMConference * conference, guint32 flags);
+
+/**
+ * Set the user defined data for the conference.
+ *
+ * @param conference	The conference
+ * @param data			User defined data
+ *
+ */
+void nm_conference_set_data(NMConference * conference, gpointer data);
+
+/**
+ * Get the user defined data for the conference.
+ *
+ * @param conference	The conference
+ *
+ * @return				The data if it has been set, NULL otherwise.
+ *
+ */
+gpointer nm_conference_get_data(NMConference * conference);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmconn.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,631 @@
+/*
+ * nmconn.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include <glib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include "nmconn.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#define NO_ESCAPE(ch) ((ch == 0x20) || (ch >= 0x30 && ch <= 0x39) || \
+					(ch >= 0x41 && ch <= 0x5a) || (ch >= 0x61 && ch <= 0x7a))
+
+/* Read data from conn until the end of a line */
+static NMERR_T
+read_line(NMConn * conn, char *buff, int len)
+{
+	NMERR_T rc = NM_OK;
+	int total_bytes = 0;
+
+	while ((rc == NM_OK) && (total_bytes < (len - 1))) {
+		rc = nm_read_all(conn, &buff[total_bytes], 1);
+		if (rc == NM_OK) {
+			total_bytes += 1;
+			if (buff[total_bytes - 1] == '\n') {
+				break;
+			}
+		}
+	}
+	buff[total_bytes] = '\0';
+
+	return rc;
+}
+
+static char *
+url_escape_string(char *src)
+{
+	guint32 escape = 0;
+	char *p;
+	char *q;
+	char *encoded = NULL;
+	int ch;
+
+	static const char hex_table[16] = "0123456789abcdef";
+
+	if (src == NULL) {
+		return NULL;
+	}
+
+	/* Find number of chars to escape */
+	for (p = src; *p != '\0'; p++) {
+		ch = (guchar) *p;
+		if (!NO_ESCAPE(ch)) {
+			escape++;
+		}
+	}
+
+	encoded = g_malloc((p - src) + (escape * 2) + 1);
+
+	/* Escape the string */
+	for (p = src, q = encoded; *p != '\0'; p++) {
+		ch = (guchar) * p;
+		if (NO_ESCAPE(ch)) {
+			if (ch != 0x20) {
+				*q = ch;
+				q++;
+			} else {
+				*q = '+';
+				q++;
+			}
+		} else {
+			*q = '%';
+			q++;
+			
+			*q = hex_table[ch >> 4];
+			q++;
+			
+			*q = hex_table[ch & 15];
+			q++;
+		}
+	}
+	*q = '\0';
+
+	return encoded;
+}
+
+static char *
+encode_method(guint8 method)
+{
+	char *str;
+
+	switch (method) {
+		case NMFIELD_METHOD_EQUAL:
+			str = "G";
+			break;
+		case NMFIELD_METHOD_UPDATE:
+			str = "F";
+			break;
+		case NMFIELD_METHOD_GTE:
+			str = "E";
+			break;
+		case NMFIELD_METHOD_LTE:
+			str = "D";
+			break;
+		case NMFIELD_METHOD_NE:
+			str = "C";
+			break;
+		case NMFIELD_METHOD_EXIST:
+			str = "B";
+			break;
+		case NMFIELD_METHOD_NOTEXIST:
+			str = "A";
+			break;
+		case NMFIELD_METHOD_SEARCH:
+			str = "9";
+			break;
+		case NMFIELD_METHOD_MATCHBEGIN:
+			str = "8";
+			break;
+		case NMFIELD_METHOD_MATCHEND:
+			str = "7";
+			break;
+		case NMFIELD_METHOD_NOT_ARRAY:
+			str = "6";
+			break;
+		case NMFIELD_METHOD_OR_ARRAY:
+			str = "5";
+			break;
+		case NMFIELD_METHOD_AND_ARRAY:
+			str = "4";
+			break;
+		case NMFIELD_METHOD_DELETE_ALL:
+			str = "3";
+			break;
+		case NMFIELD_METHOD_DELETE:
+			str = "2";
+			break;
+		case NMFIELD_METHOD_ADD:
+			str = "1";
+			break;
+		default:					/* NMFIELD_METHOD_VALID */
+			str = "0";
+			break;
+	}
+	
+	return str;
+}
+
+int
+nm_tcp_write(NMConn * conn, const void *buff, int len)
+{
+	if (conn == NULL || buff == NULL)
+		return -1;
+
+	if (!conn->use_ssl)
+		return (write(conn->fd, buff, len));
+	else if (conn->ssl_conn && conn->ssl_conn->write)
+		return (conn->ssl_conn->write(conn->ssl_conn->data, buff, len));
+	else
+		return -1;
+}
+
+int
+nm_tcp_read(NMConn * conn, void *buff, int len)
+{
+	if (conn == NULL || buff == NULL)
+		return -1;
+
+	if (!conn->use_ssl)
+		return (read(conn->fd, buff, len));
+	else if (conn->ssl_conn && conn->ssl_conn->read)
+		return (conn->ssl_conn->read(conn->ssl_conn->data, buff, len));
+	else
+		return -1;
+}
+
+NMERR_T
+nm_read_all(NMConn * conn, char *buff, int len)
+{
+	NMERR_T rc = NM_OK;
+	int bytes_left = len;
+	int bytes_read;
+	int total_bytes = 0;
+	int retry = 10;
+
+	if (conn == NULL || buff == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Keep reading until buffer is full */
+	while (bytes_left) {
+		bytes_read = nm_tcp_read(conn, &buff[total_bytes], bytes_left);
+		if (bytes_read > 0) {
+			bytes_left -= bytes_read;
+			total_bytes += bytes_read;
+		} else {
+			if (errno == EAGAIN) {
+				if (--retry == 0) {
+					rc = NMERR_TCP_READ;
+					break;
+				}
+#ifdef _WIN32
+				Sleep(1000);
+#else
+				usleep(1000);
+#endif
+			} else {
+				rc = NMERR_TCP_READ;
+				break;
+			}
+		}
+	}
+	return rc;
+}
+
+NMERR_T
+nm_write_fields(NMConn * conn, NMField * fields)
+{
+	NMERR_T rc = NM_OK;
+	NMField *field;
+	char *value = NULL;
+	char *method = NULL;
+	char buffer[512];
+	int ret;
+	int bytes_to_send;
+	int val = 0;
+
+	if (conn == NULL || fields == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	/* Format each field as valid "post" data and write it out */
+	for (field = fields; (rc == NM_OK) && (field->tag); field++) {
+
+		/* We don't currently handle binary types */
+		if (field->method == NMFIELD_METHOD_IGNORE ||
+			field->type == NMFIELD_TYPE_BINARY) {
+			continue;
+		}
+
+		/* Write the field tag */
+		bytes_to_send = g_snprintf(buffer, sizeof(buffer), "&tag=%s", field->tag);
+		ret = nm_tcp_write(conn, buffer, bytes_to_send);
+		if (ret < 0) {
+			rc = NMERR_TCP_WRITE;
+		}
+
+		/* Write the field method */
+		if (rc == NM_OK) {
+			method = encode_method(field->method);
+			bytes_to_send = g_snprintf(buffer, sizeof(buffer), "&cmd=%s", method);
+			ret = nm_tcp_write(conn, buffer, bytes_to_send);
+			if (ret < 0) {
+				rc = NMERR_TCP_WRITE;
+			}
+		}
+
+		/* Write the field value */
+		if (rc == NM_OK) {
+			switch (field->type) {
+				case NMFIELD_TYPE_UTF8:
+				case NMFIELD_TYPE_DN:
+					
+					value = url_escape_string((char *) field->value);
+					bytes_to_send = g_snprintf(buffer, sizeof(buffer),
+											   "&val=%s", value);
+					ret = nm_tcp_write(conn, buffer, bytes_to_send);
+					if (ret < 0) {
+						rc = NMERR_TCP_WRITE;
+					}
+					
+					g_free(value);
+					
+					break;
+					
+				case NMFIELD_TYPE_ARRAY:
+				case NMFIELD_TYPE_MV:
+					
+					val = nm_count_fields((NMField *) field->value);
+					bytes_to_send = g_snprintf(buffer, sizeof(buffer),
+											   "&val=%u", val);
+					ret = nm_tcp_write(conn, buffer, bytes_to_send);
+					if (ret < 0) {
+						rc = NMERR_TCP_WRITE;
+					}
+					
+					break;
+					
+				default:
+					
+					bytes_to_send = g_snprintf(buffer, sizeof(buffer),
+											   "&val=%u", field->value);
+					ret = nm_tcp_write(conn, buffer, bytes_to_send);
+					if (ret < 0) {
+						rc = NMERR_TCP_WRITE;
+					}
+					
+					break;
+			}
+		}
+		
+		/* Write the field type */
+		if (rc == NM_OK) {
+			bytes_to_send = g_snprintf(buffer, sizeof(buffer),
+									   "&type=%u", field->type);
+			ret = nm_tcp_write(conn, buffer, bytes_to_send);
+			if (ret < 0) {
+				rc = NMERR_TCP_WRITE;
+			}
+		}
+
+		/* If the field is a sub array then post its fields */
+		if (rc == NM_OK && val > 0) {
+			if (field->type == NMFIELD_TYPE_ARRAY ||
+				field->type == NMFIELD_TYPE_MV) {
+
+				rc = nm_write_fields(conn, (NMField *) field->value);
+
+			}
+		}
+	}
+
+	return rc;
+}
+
+NMERR_T
+nm_send_request(NMConn * conn, char *cmd, NMField * fields, NMRequest ** req)
+{
+	NMERR_T rc = NM_OK;
+	char buffer[512];
+	int bytes_to_send;
+	int ret;
+	NMField *request = NULL;
+
+	if (conn == NULL || cmd == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Write the post */
+	bytes_to_send = g_snprintf(buffer, sizeof(buffer),
+							   "POST /%s HTTP/1.0\r\n", cmd);
+	ret = nm_tcp_write(conn, buffer, bytes_to_send);
+	if (ret < 0) {
+		rc = NMERR_TCP_WRITE;
+	}
+
+	/* Write headers */
+	if (rc == NM_OK) {
+		if (strcmp("login", cmd) == 0) {
+			bytes_to_send = g_snprintf(buffer, sizeof(buffer),
+									   "Host: %s:%d\r\n\r\n", conn->addr, conn->port);
+			ret = nm_tcp_write(conn, buffer, bytes_to_send);
+			if (ret < 0) {
+				rc = NMERR_TCP_WRITE;
+			}
+		} else {
+			bytes_to_send = g_snprintf(buffer, sizeof(buffer), "\r\n");
+			ret = nm_tcp_write(conn, buffer, bytes_to_send);
+			if (ret < 0) {
+				rc = NMERR_TCP_WRITE;
+			}
+		}
+	}
+
+	/* Add the transaction id to the request fields */
+	if (rc == NM_OK) {
+		request = nm_copy_field_array(fields);
+		if (request) {
+			char *str = g_strdup_printf("%d", ++(conn->trans_id));
+			
+			request = nm_add_field(request, NM_A_SZ_TRANSACTION_ID, 0,
+								   NMFIELD_METHOD_VALID, 0,
+								   (guint32) str, NMFIELD_TYPE_UTF8);
+		}
+	}
+
+	/* Send the request to the server */
+	if (rc == NM_OK) {
+		rc = nm_write_fields(conn, request);
+	}
+
+	/* Write the CRLF to terminate the data */
+	if (rc == NM_OK) {
+		ret = nm_tcp_write(conn, "\r\n", strlen("\r\n"));
+		if (ret < 0) {
+			rc = NMERR_TCP_WRITE;
+		}
+	}
+
+	/* Create a request struct and return it */
+	if (rc == NM_OK) {
+		*req = nm_create_request(cmd, conn->trans_id, time(0));
+	}
+
+	if (request != NULL) {
+		nm_free_fields(&request);
+	}
+
+	return rc;
+}
+
+NMERR_T
+nm_read_header(NMConn * conn)
+{
+	NMERR_T rc = NM_OK;
+	char buffer[512];
+	char *ptr = NULL;
+	int i;
+	char rtn_buf[8];
+	int rtn_code = 0;
+
+	if (conn == NULL)
+		return NMERR_BAD_PARM;
+
+	*buffer = '\0';
+	rc = read_line(conn, buffer, sizeof(buffer));
+	if (rc == NM_OK) {
+
+		/* Find the return code */
+		ptr = strchr(buffer, ' ');
+		if (ptr != NULL) {
+			ptr++;
+
+			i = 0;
+			while (isdigit(*ptr) && (i < 3)) {
+				rtn_buf[i] = *ptr;
+				i++;
+				ptr++;
+			}
+			rtn_buf[i] = '\0';
+			
+			if (i > 0)
+				rtn_code = atoi(rtn_buf);
+		}
+	}
+
+	/* Finish reading header, in the future we might want to do more processing here */
+	/* TODO: handle more general redirects in the future */
+	while ((rc == NM_OK) && (strcmp(buffer, "\r\n") != 0)) {
+		rc = read_line(conn, buffer, sizeof(buffer));
+	}
+
+	if (rc == NM_OK && rtn_code == 301) {
+		conn->use_ssl = TRUE;
+		conn->redirect = TRUE;
+		rc = NMERR_SSL_REDIRECT;
+	}
+
+	return rc;
+}
+
+NMERR_T
+nm_read_fields(NMConn * conn, int count, NMField ** fields)
+{
+	NMERR_T rc = NM_OK;
+	guint8 type;
+	guint8 method;
+	guint32 val;
+	char tag[64];
+	NMField *sub_fields = NULL;
+	char *str = NULL;
+
+	if (conn == NULL || fields == NULL)
+		return NMERR_BAD_PARM;
+
+	do {
+		if (count !=  -1) {
+			count--;
+		}
+
+		/* Read the field type, method, and tag */
+		rc = nm_read_all(conn, &type, sizeof(type));
+		if (rc != NM_OK || type == 0)
+			break;
+
+		rc = nm_read_all(conn, &method, sizeof(method));
+		if (rc != NM_OK)
+			break;
+
+		rc = nm_read_all(conn, (char *) &val, sizeof(val));
+		if (rc != NM_OK)
+			break;
+
+		if (val > sizeof(tag)) {
+			rc = NMERR_PROTOCOL;
+			break;
+		}
+
+		rc = nm_read_all(conn, tag, val);
+		if (rc != NM_OK)
+			break;
+
+		if (type == NMFIELD_TYPE_MV || type == NMFIELD_TYPE_ARRAY) {
+
+			/* Read the subarray (first read the number of items in the array) */
+			rc = nm_read_all(conn, (char *) &val, sizeof(val));
+			if (rc != NM_OK)
+				break;
+
+			if (val > 0) {
+				rc = nm_read_fields(conn, val, &sub_fields);
+				if (rc != NM_OK)
+					break;
+			}
+
+			*fields = nm_add_field(*fields, tag, 0, method, 0,
+								   (guint32) sub_fields, type);
+
+			sub_fields = NULL;
+
+		} else if (type == NMFIELD_TYPE_UTF8 || type == NMFIELD_TYPE_DN) {
+
+			/* Read the string (first read the length) */
+			rc = nm_read_all(conn, (char *) &val, sizeof(val));
+			if (rc != NM_OK)
+				break;
+
+			if (val > 0) {
+				str = g_new0(char, val + 1);
+
+				rc = nm_read_all(conn, str, val);
+				if (rc != NM_OK)
+					break;
+			}
+
+			*fields = nm_add_field(*fields, tag, 0, method, 0,
+								   (guint32) str, type);
+			str = NULL;
+		} else {
+
+			/* Read the numerical value */
+			rc = nm_read_all(conn, (char *) &val, sizeof(val));
+			if (rc != NM_OK)
+				break;
+
+			*fields = nm_add_field(*fields, tag, 0, method, 0, val, type);
+		}
+
+	} while ((type != 0) && (count != 0));
+
+
+	if (str != NULL) {
+		g_free(str);
+	}
+
+	if (sub_fields != NULL) {
+		nm_free_fields(&sub_fields);
+	}
+
+	return rc;
+}
+
+void
+nm_conn_add_request_item(NMConn * conn, NMRequest * request)
+{
+	if (conn == NULL || request == NULL)
+		return;
+
+	nm_request_add_ref(request);
+	conn->requests = g_slist_append(conn->requests, request);
+}
+
+void
+nm_conn_remove_request_item(NMConn * conn, NMRequest * request)
+{
+	if (conn == NULL || request == NULL)
+		return;
+
+	conn->requests = g_slist_remove(conn->requests, request);
+	nm_release_request(request);
+}
+
+NMRequest *
+nm_conn_find_request(NMConn * conn, int trans_id)
+{
+	NMRequest *req = NULL;
+	GSList *itr = NULL;
+
+	if (conn == NULL)
+		return NULL;
+
+	itr = conn->requests;
+	while (itr) {
+		req = (NMRequest *) itr->data;
+		if (req != NULL && nm_request_get_trans_id(req) == trans_id) {
+			return req;
+		}
+		itr = g_slist_next(itr);
+	}
+	return NULL;
+}
+
+const char *
+nm_conn_get_addr(NMConn * conn)
+{
+	if (conn == NULL)
+		return NULL;
+	else
+		return conn->addr;
+}
+
+int
+nm_conn_get_port(NMConn * conn)
+{
+	if (conn == NULL)
+		return -1;
+	else
+		return conn->port;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmconn.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,204 @@
+/*
+ * nmconn.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef __NM_CONN_H__
+#define __NM_CONN_H__
+
+typedef struct _NMConn NMConn;
+typedef struct _NMSSLConn NMSSLConn;
+
+#include "nmfield.h"
+#include "nmuser.h"
+
+typedef int (*nm_ssl_read_cb) (gpointer ssl_data, void *buff, int len);
+typedef int (*nm_ssl_write_cb) (gpointer ssl_data, const void *buff, int len);
+
+struct _NMConn
+{
+
+	/* The address of the server that we are connecting to. */
+	char *addr;
+
+	/* The port that we are connecting to. */
+	int port;
+
+	/* The file descriptor of the socket for the connection. */
+	int fd;
+
+	/* The transaction counter. */
+	int trans_id;
+
+	/* A list of requests currently awaiting a response. */
+	GSList *requests;
+
+	/* Are we connected? TRUE if so, FALSE if not. */
+	gboolean connected;
+
+	/* Are we running in secure mode? */
+	gboolean use_ssl;
+
+	/* Have we been redirected? */
+	gboolean redirect;
+
+	/* SSL connection  */
+	NMSSLConn *ssl_conn;
+
+};
+
+struct _NMSSLConn
+{
+
+	/*  Data to pass to the callbacks */
+	gpointer data;
+
+	/* Callbacks for reading/writing */
+	nm_ssl_read_cb read;
+	nm_ssl_write_cb write;
+
+};
+
+/**
+ * Write len bytes from the given buffer.
+ *
+ * @param conn	The connection to write to.
+ * @param buff	The buffer to write from.
+ * @param len	The number of bytes to write.
+ *
+ * @return		The number of bytes written.
+ */
+int nm_tcp_write(NMConn * conn, const void *buff, int len);
+
+/**
+ * Read at most len bytes into the given buffer.
+ *
+ * @param conn	The connection to read from.
+ * @param buff	The buffer to write to.
+ * @param len	The maximum number of bytes to read.
+ *
+ * @return		The number of bytes read.
+ */
+int nm_tcp_read(NMConn * conn, void *buff, int len);
+
+/**
+ * Read exactly len bytes into the given buffer.
+ *
+ * @param conn	The connection to read from.
+ * @param buff	The buffer to write to.
+ * @param len	The number of bytes to read.
+ *
+ * @return		NM_OK on success, NMERR_TCP_READ if read fails.
+ */
+NMERR_T nm_read_all(NMConn * conn, char *buf, int len);
+
+/**
+ * Dispatch a request to the server.
+ *
+ * @param conn		The connection.
+ * @param cmd		The request to dispatch.
+ * @param fields	The field list for the request.
+ * @param req		The request. Should be freed with nm_release_request.
+ *
+ * @return			NM_OK on success.
+ */
+NMERR_T nm_send_request(NMConn * conn, char *cmd, NMField * fields,
+						NMRequest ** req);
+
+/**
+ * Write out the given field list.
+ *
+ * @param conn		The connection to write to.
+ * @param fields	The field list to write.
+ *
+ * @return			NM_OK on success.
+ */
+NMERR_T nm_write_fields(NMConn * conn, NMField * fields);
+
+/**
+ * Read the headers for a response.
+ *
+ * @param conn		The connection to read from.
+ *
+ * @return			NM_OK on success.
+ */
+NMERR_T nm_read_header(NMConn * conn);
+
+/**
+ * Read a field list from the connection.
+ *
+ * @param conn		The connection to read from.
+ * @param count		The maximum number of fields to read (or -1 for no max).
+ * @param fields	The field list. This is an out param. It
+ *					should be freed by calling nm_free_fields
+ *					when finished.
+ *
+ * @return			NM_OK on success.
+ */
+NMERR_T nm_read_fields(NMConn * conn, int count, NMField ** fields);
+
+/**
+ * Add a request to the connections request list.
+ *
+ * @param conn		The connection.
+ * @param request	The request to add to the list.
+ */
+void nm_conn_add_request_item(NMConn * conn, NMRequest * request);
+
+/**
+ * Remove a request from the connections list.
+ *
+ * @param conn		The connection.
+ * @param request	The request to remove from the list.
+ */
+void nm_conn_remove_request_item(NMConn * conn, NMRequest * request);
+
+/**
+ * Find the request with the given transaction id in the connections
+ * request list.
+ *
+ * @param conn		The connection.
+ * @param trans_id	The transaction id of the request to return.
+ *
+ * @return 			The request, or NULL if a matching request is not
+ *					found.
+ */
+NMRequest *nm_conn_find_request(NMConn * conn, int trans_id);
+
+/**
+ * Get the server address for the connection.
+ *
+ * @param conn		The connection.
+ *
+ * @return 			The server address for the connection.
+ *
+ */
+const char *nm_conn_get_addr(NMConn * conn);
+
+/**
+ * Get the port for the connection.
+ *
+ * @param conn		The connection.
+ *
+ * @return 			The port that we are connected to.
+ */
+int nm_conn_get_port(NMConn * conn);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmcontact.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,962 @@
+/*
+ * nmcontact.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include <glib.h>
+#include <string.h>
+#include "nmcontact.h"
+#include "nmfield.h"
+#include "nmuser.h"
+
+struct _NMContact
+{
+	int id;
+	int parent_id;
+	int seq;
+	char *dn;
+	char *display_name;
+	NMUserRecord *user_record;
+	gpointer data;
+	int ref_count;
+};
+
+struct _NMFolder
+{
+	int id;
+	int seq;
+	char *name;
+	GSList *folders;
+	GSList *contacts;
+	int ref_count;
+};
+
+static int count = 0;
+
+static void _release_folder_contacts(NMFolder * folder);
+static void _release_folder_folders(NMFolder * folder);
+static void _add_contacts(NMUser * user, NMFolder * folder, NMField * fields);
+static void _add_folders(NMFolder * root, NMField * fields);
+
+/*********************************************************************
+ * Contact API 
+ *********************************************************************/
+
+NMContact *
+nm_create_contact()
+{
+	NMContact *contact = g_new0(NMContact, 1);
+
+	contact->ref_count = 1;
+
+	gaim_debug(GAIM_DEBUG_INFO, "novell", "Creating contact, total=%d\n",
+			   count++);
+
+	return contact;
+}
+
+/*
+ * This creates a contact for the contact list. The 
+ * field array that is passed in should be a 
+ * NM_A_FA_CONTACT array.
+ *
+ */
+NMContact *
+nm_create_contact_from_fields(NMField * fields)
+{
+	NMContact *contact;
+	NMField *field;
+
+	if ( fields == NULL || fields->tag == NULL || fields->value == 0 ||
+		 strcmp(fields->tag, NM_A_FA_CONTACT) )
+	{
+		return NULL;
+	}
+
+	contact = nm_create_contact();
+
+	if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->value))) {
+
+		if (field->value)
+			contact->id = atoi((char *) field->value);
+
+	}
+
+	if ((field = nm_locate_field(NM_A_SZ_PARENT_ID, (NMField *) fields->value))) {
+
+		if (field->value)
+			contact->parent_id = atoi((char *) field->value);
+
+	}
+
+	if ((field =
+		 nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->value))) {
+		
+		if (field->value)
+			contact->seq = atoi((char *) field->value);
+
+	}
+
+	if ((field =
+		 nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->value))) {
+		
+		if (field->value)
+			contact->display_name = g_strdup((char *) field->value);
+
+	}
+
+	if ((field = nm_locate_field(NM_A_SZ_DN, (NMField *) fields->value))) {
+
+		if (field->value)
+			contact->dn = g_strdup((char *) field->value);
+
+	}
+
+	return contact;
+}
+
+void
+nm_contact_update_list_properties(NMContact * contact, NMField * fields)
+{
+	NMField *field;
+
+	if (contact == NULL || fields == NULL || fields->value == 0)
+		return;
+
+	if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->value))) {
+		
+		if (field->value)
+			contact->id = atoi((char *)field->value);
+
+	}
+
+	if ((field = nm_locate_field(NM_A_SZ_PARENT_ID, (NMField *) fields->value))) {
+		
+		if (field->value)
+			contact->parent_id = atoi((char *) field->value);
+
+	}
+
+	if ((field =
+		 nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->value))) {
+
+		if (field->value)
+			contact->seq = atoi((char *) field->value);
+
+	}
+
+	if ((field =
+		 nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->value))) {
+		
+		if (field->value) {
+			if (contact->display_name)
+				g_free(contact->display_name);
+
+			contact->display_name = g_strdup((char *) field->value);
+		}
+
+	}
+
+	if ((field = nm_locate_field(NM_A_SZ_DN, (NMField *) fields->value))) {
+
+		if (field->value) {
+			if (contact->dn)
+				g_free(contact->dn);
+			
+			contact->dn = g_strdup((char *) field->value);
+		}
+
+	}
+}
+
+NMField *
+nm_contact_to_fields(NMContact * contact)
+{
+	NMField *fields = NULL;
+
+	if (contact == NULL)
+		return NULL;
+
+	fields = nm_add_field(fields, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup_printf("%d", contact->id),
+						  NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup_printf("%d", contact->parent_id),
+						  NMFIELD_TYPE_UTF8);
+
+	fields =
+		nm_add_field(fields, NM_A_SZ_SEQUENCE_NUMBER, 0, NMFIELD_METHOD_VALID, 0,
+					 (guint32) g_strdup_printf("%d", contact->seq),
+					 NMFIELD_TYPE_UTF8);
+
+	if (contact->display_name != NULL) {
+		fields =
+			nm_add_field(fields, NM_A_SZ_DISPLAY_NAME, 0, NMFIELD_METHOD_VALID, 0,
+						 (guint32) g_strdup(contact->display_name),
+						 NMFIELD_TYPE_UTF8);
+	}
+
+	if (contact->dn != NULL) {
+		fields = nm_add_field(fields, NM_A_SZ_DN, 0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup(contact->dn), NMFIELD_TYPE_UTF8);
+	}
+
+	return fields;
+}
+
+void
+nm_contact_add_ref(NMContact * contact)
+{
+	if (contact)
+		contact->ref_count++;
+}
+
+void
+nm_release_contact(NMContact * contact)
+{
+	if (contact == NULL)
+		return;
+
+	if (--(contact->ref_count) == 0) {
+
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "Releasing contact, total=%d\n", --count);
+
+		if (contact->display_name) {
+			g_free(contact->display_name);
+		}
+
+		if (contact->dn) {
+			g_free(contact->dn);
+		}
+
+		if (contact->user_record) {
+			nm_release_user_record(contact->user_record);
+		}
+
+		g_free(contact);
+	}
+
+}
+
+const char *
+nm_contact_get_display_name(NMContact * contact)
+{
+	if (contact == NULL)
+		return NULL;
+
+	if (contact->user_record != NULL && contact->display_name == NULL) {
+		const char *full_name, *lname, *fname, *cn, *display_id;
+
+		full_name = nm_user_record_get_full_name(contact->user_record);
+		fname = nm_user_record_get_first_name(contact->user_record);
+		lname = nm_user_record_get_last_name(contact->user_record);
+		cn = nm_user_record_get_userid(contact->user_record);
+		display_id = nm_user_record_get_display_id(contact->user_record);
+
+		/* Try to build a display name. */
+		if (full_name) {
+
+			contact->display_name = g_strdup(full_name);
+
+		} else if (fname && lname) {
+
+			contact->display_name = g_strdup_printf("%s %s", fname, lname);
+
+		} else {
+
+			/* If auth attribute is set use it */
+			if (nm_user_record_get_auth_attr(contact->user_record) && 
+				display_id != NULL)	{
+
+				contact->display_name = g_strdup(display_id);
+
+			} else {
+
+				/* Use CN or display id */
+				if (cn) {
+
+					contact->display_name = g_strdup(cn);
+
+				} else if (display_id) {
+
+					contact->display_name = g_strdup(display_id);
+
+				}
+
+			}
+
+		}
+	}
+
+	return contact->display_name;
+}
+
+void
+nm_contact_set_display_name(NMContact * contact, const char *display_name)
+{
+	if (contact == NULL)
+		return;
+
+	if (contact->display_name) {
+		g_free(contact->display_name);
+		contact->display_name = NULL;
+	}
+	
+	if (display_name)
+		contact->display_name = g_strdup(display_name);
+}
+
+void
+nm_contact_set_dn(NMContact * contact, const char *dn)
+{
+	if (contact == NULL)
+		return;
+
+	if (contact->dn) {
+		g_free(contact->dn);
+		contact->dn = NULL;
+	}
+
+	if (dn)
+		contact->dn = g_strdup(dn);
+}
+
+const char *
+nm_contact_get_dn(NMContact * contact)
+{
+	if (contact == NULL)
+		return NULL;
+
+	return contact->dn;
+}
+
+gpointer
+nm_contact_get_data(NMContact * contact)
+{
+	if (contact == NULL)
+		return NULL;
+
+	return contact->data;
+}
+
+int
+nm_contact_get_id(NMContact * contact)
+{
+	if (contact == NULL)
+		return -1;
+
+	return contact->id;
+}
+
+int
+nm_contact_get_parent_id(NMContact * contact)
+{
+	if (contact == NULL)
+		return -1;
+
+	return contact->parent_id;
+}
+
+void
+nm_contact_set_data(NMContact * contact, gpointer data)
+{
+	if (contact == NULL)
+		return;
+
+	contact->data = data;
+}
+
+void
+nm_contact_set_user_record(NMContact * contact, NMUserRecord * user_record)
+{
+	if (contact == NULL)
+		return;
+
+	if (contact->user_record) {
+		nm_release_user_record(contact->user_record);
+	}
+
+	nm_user_record_add_ref(user_record);
+	contact->user_record = user_record;
+}
+
+NMUserRecord *
+nm_contact_get_user_record(NMContact * contact)
+{
+	if (contact == NULL)
+		return NULL;
+
+	return contact->user_record;
+}
+
+const char *
+nm_contact_get_userid(NMContact * contact)
+{
+	NMUserRecord *user_record;
+	const char *userid = NULL;
+
+	if (contact == NULL)
+		return NULL;
+
+	user_record = nm_contact_get_user_record(contact);
+	if (user_record) {
+		userid = nm_user_record_get_userid(user_record);
+	}
+
+	return userid;
+}
+
+const char *
+nm_contact_get_display_id(NMContact * contact)
+{
+	NMUserRecord *user_record;
+	const char *id = NULL;
+
+	if (contact == NULL)
+		return NULL;
+
+	user_record = nm_contact_get_user_record(contact);
+	if (user_record) {
+		id = nm_user_record_get_display_id(user_record);
+	}
+
+	return id;
+}
+
+
+/*********************************************************************
+ * Folder API 
+ *********************************************************************/
+
+NMFolder *
+nm_create_folder(const char *name)
+{
+	NMFolder *folder = g_new0(NMFolder, 1);
+
+	if (name)
+		folder->name = g_strdup(name);
+
+	folder->ref_count = 1;
+
+	return folder;
+}
+
+NMFolder *
+nm_create_folder_from_fields(NMField * fields)
+{
+	NMField *field;
+	NMFolder *folder;
+
+	if (fields == NULL || fields->value == 0)
+		return NULL;
+
+	folder = g_new0(NMFolder, 1);
+
+	if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->value))) {
+		
+		if (field->value)
+			folder->id = atoi((char *) field->value);
+	}
+
+	if ((field =
+		 nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->value))) {
+		
+		if (field->value)
+			folder->seq = atoi((char *) field->value);
+	}
+
+	if ((field =
+		 nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->value))) {
+
+		if (field->value)
+			folder->name = g_strdup((char *) field->value);
+	}
+
+	folder->ref_count = 1;
+	return folder;
+}
+
+NMField *
+nm_folder_to_fields(NMFolder * folder)
+{
+	NMField *fields = NULL;
+
+	if (folder == NULL)
+		return NULL;
+
+	fields = nm_add_field(fields, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup_printf("%d", folder->id),
+						  NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup("0"), NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_SZ_TYPE, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup("1"), NMFIELD_TYPE_UTF8);
+
+	fields =
+		nm_add_field(fields, NM_A_SZ_SEQUENCE_NUMBER, 0, NMFIELD_METHOD_VALID, 0,
+					 (guint32) g_strdup_printf("%d", folder->seq),
+					 NMFIELD_TYPE_UTF8);
+
+	if (folder->name != NULL) {
+		fields =
+			nm_add_field(fields, NM_A_SZ_DISPLAY_NAME, 0, NMFIELD_METHOD_VALID, 0,
+						 (guint32) g_strdup(folder->name), NMFIELD_TYPE_UTF8);
+	}
+
+
+	return fields;
+}
+
+void
+nm_folder_update_list_properties(NMFolder * folder, NMField * fields)
+{
+	NMField *field;
+
+	if (folder == NULL || fields == NULL || fields->value == 0)
+		return;
+
+	if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->value))) {
+		
+		if (field->value)
+			folder->id = atoi((char *) field->value);
+
+	}
+
+	if ((field =
+		 nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->value))) {
+		
+		if (field->value)
+			folder->seq = atoi((char *) field->value);
+
+	}
+
+	if ((field =
+		 nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->value))) {
+
+		if (field->value) {
+			if (folder->name)
+				g_free(folder->name);
+			
+			folder->name = g_strdup((char *) field->value);
+		}
+
+	}
+
+}
+
+void
+nm_release_folder(NMFolder * folder)
+{
+	if (folder == NULL)
+		return;
+
+	if (--(folder->ref_count) == 0) {
+		if (folder->name) {
+			g_free(folder->name);
+		}
+
+		if (folder->folders) {
+			_release_folder_folders(folder);
+		}
+
+		if (folder->contacts) {
+			_release_folder_contacts(folder);
+		}
+
+		g_free(folder);
+	}
+}
+
+
+void
+nm_folder_add_ref(NMFolder * folder)
+{
+	if (folder)
+		folder->ref_count++;
+}
+
+int
+nm_folder_get_subfolder_count(NMFolder * folder)
+{
+	if (folder == NULL)
+		return 0;
+
+	if (folder->folders)
+		return g_slist_length(folder->folders);
+	else
+		return 0;
+}
+
+NMFolder *
+nm_folder_get_subfolder(NMFolder * folder, int index)
+{
+	if (folder == NULL)
+		return NULL;
+
+	if (folder->folders)
+		return (NMFolder *) g_slist_nth_data(folder->folders, index);
+	else
+		return NULL;
+}
+
+int
+nm_folder_get_contact_count(NMFolder * folder)
+{
+	if (folder == NULL)
+		return 0;
+
+	if (folder->contacts != NULL)
+		return g_slist_length(folder->contacts);
+	else
+		return 0;
+}
+
+NMContact *
+nm_folder_get_contact(NMFolder * folder, int index)
+{
+	if (folder == NULL)
+		return NULL;
+
+	if (folder->contacts)
+		return (NMContact *) g_slist_nth_data(folder->contacts, index);
+	else
+		return NULL;
+}
+
+const char *
+nm_folder_get_name(NMFolder * folder)
+{
+	if (folder == NULL)
+		return NULL;
+
+	return folder->name;
+}
+
+void
+nm_folder_set_name(NMFolder * folder, const char *name)
+{
+	if (folder == NULL || name == NULL)
+		return;
+
+	if (folder->name)
+		g_free(folder->name);
+
+	folder->name = g_strdup(name);
+}
+
+int
+nm_folder_get_id(NMFolder * folder)
+{
+	if (folder == NULL) {
+		return  -1;
+	}
+
+	return folder->id;
+}
+
+void
+nm_folder_add_folder_to_list(NMFolder * root, NMFolder * folder)
+{
+	GSList *node;
+
+	if (root == NULL || folder == NULL)
+		return;
+
+	node = root->folders;
+	while (node) {
+		if (folder->seq <= ((NMFolder *) node->data)->seq) {
+			nm_folder_add_ref(folder);
+			root->folders = g_slist_insert_before(root->folders, node, folder);
+			break;
+		}
+		node = g_slist_next(node);
+	}
+	if (node == NULL) {
+		nm_folder_add_ref(folder);
+		root->folders = g_slist_append(root->folders, folder);
+	}
+}
+
+void
+nm_folder_remove_contact(NMFolder * folder, NMContact * contact)
+{
+	if (folder == NULL || contact == NULL)
+		return;
+
+	GSList *node = folder->contacts;
+
+	while (node) {
+		if (contact->id == ((NMContact *) (node->data))->id) {
+			folder->contacts = g_slist_remove(folder->contacts, node->data);
+			nm_release_contact(contact);
+			break;
+		}
+		node = g_slist_next(node);
+	}
+}
+
+void
+nm_folder_add_contact_to_list(NMFolder * root_folder, NMContact * contact)
+{
+	GSList *node = NULL;
+	NMFolder *folder = root_folder;
+	
+	if (folder == NULL || contact == NULL)
+		return;
+
+	/* Find folder to add contact to */
+	if (contact->parent_id != 0) {
+		node = folder->folders;
+		while (node) {
+			folder = (NMFolder *) node->data;
+			if (contact->parent_id == folder->id) {
+				break;
+			}
+			folder = NULL;
+			node = g_slist_next(node);
+		}
+	}
+
+	/* Add contact to list */
+	if (folder) {
+		node = folder->contacts;
+		while (node) {
+			if (contact->seq <= ((NMContact *) (node->data))->seq) {
+				nm_contact_add_ref(contact);
+				folder->contacts =
+					g_slist_insert_before(folder->contacts, node, contact);
+				break;
+			}
+			node = g_slist_next(node);
+		}
+
+		if (node == NULL) {
+			nm_contact_add_ref(contact);
+			folder->contacts = g_slist_append(folder->contacts, contact);
+		}
+	}
+}
+
+void
+nm_folder_add_contacts_and_folders(NMUser * user, NMFolder * root,
+								   NMField * fields)
+{
+	/* Add the contacts and folders from the field array */
+	if (user && root && fields) {
+		_add_folders(root, fields);
+		_add_contacts(user, root, fields);
+	}
+}
+
+gpointer
+nm_folder_find_item_by_object_id(NMFolder * root_folder, int object_id)
+{
+	int cnt, cnt2, i, j;
+	gpointer item = NULL;
+	NMFolder *folder;
+	NMContact *contact;
+
+	if (root_folder == NULL)
+		return NULL;
+
+	/* Check all contacts for the top level folder */
+	cnt = nm_folder_get_contact_count(root_folder);
+	for (i = 0; i < cnt; i++) {
+		contact = nm_folder_get_contact(root_folder, i);
+		if (contact && (contact->id == object_id)) {
+			item = contact;
+			break;
+		}
+	}
+
+	/* If we haven't found the item yet, check the subfolders */
+	if (item == NULL) {
+		cnt = nm_folder_get_subfolder_count(root_folder);
+		for (i = 0; (i < cnt) && (item == NULL); i++) {
+			folder = nm_folder_get_subfolder(root_folder, i);
+
+			/* Check the id of this folder */
+			if (folder && (folder->id == object_id)) {
+				item = folder;
+				break;
+			}
+
+			/* Check all contacts for this folder */
+			cnt2 = nm_folder_get_contact_count(folder);
+			for (j = 0; j < cnt2; j++) {
+				contact = nm_folder_get_contact(folder, j);
+				if (contact && (contact->id == object_id)) {
+					item = contact;
+					break;
+				}
+			}
+		}
+	}
+
+	return item;
+}
+
+NMContact *
+nm_folder_find_contact_by_userid(NMFolder * folder, const char *userid)
+{
+	int cnt, i;
+	NMContact *tmp, *contact = NULL;
+
+	if (folder == NULL || userid == NULL)
+		return NULL;
+
+	cnt = nm_folder_get_contact_count(folder);
+	for (i = 0; i < cnt; i++) {
+		tmp = nm_folder_get_contact(folder, i);
+		if (tmp && nm_utf8_str_equal(nm_contact_get_userid(tmp), userid)) {
+			contact = tmp;
+			break;
+		}
+	}
+
+	return contact;
+}
+
+NMContact *
+nm_folder_find_contact(NMFolder * folder, const char *dn)
+{
+	int cnt, i;
+	NMContact *tmp, *contact = NULL;
+	
+	if (folder == NULL || dn == NULL)
+		return NULL;
+
+	cnt = nm_folder_get_contact_count(folder);
+	for (i = 0; i < cnt; i++) {
+		tmp = nm_folder_get_contact(folder, i);
+		if (tmp && nm_utf8_str_equal(nm_contact_get_dn(tmp), dn)) {
+			contact = tmp;
+			break;
+		}
+	}
+
+	return contact;
+}
+
+
+/*********************************************************************
+ * Utility functions
+ *********************************************************************/
+
+static void
+_release_folder_contacts(NMFolder * folder)
+{
+	GSList *cnode;
+	NMContact *contact;
+
+	for (cnode = folder->contacts; cnode; cnode = cnode->next) {
+		contact = cnode->data;
+		cnode->data = NULL;
+		nm_release_contact(contact);
+	}
+
+	g_slist_free(folder->contacts);
+	folder->contacts = NULL;
+}
+
+static void
+_release_folder_folders(NMFolder * folder)
+{
+	GSList *fnode;
+	NMFolder *subfolder;
+	
+	if (folder == NULL)
+		return;
+
+	for (fnode = folder->folders; fnode; fnode = fnode->next) {
+		subfolder = fnode->data;
+		fnode->data = NULL;
+		nm_release_folder(subfolder);
+	}
+
+	g_slist_free(folder->folders);
+	folder->folders = NULL;
+}
+
+static void
+_add_folders(NMFolder * root, NMField * fields)
+{
+	NMFolder *folder = NULL;
+	NMField *locate = NULL;
+
+	locate = nm_locate_field(NM_A_FA_FOLDER, fields);
+	while (locate != NULL) {
+
+		/* Create a new folder */
+		folder = nm_create_folder_from_fields(locate);
+
+		/* Add subfolder to roots folder list */
+		nm_folder_add_folder_to_list(root, folder);
+
+		/* Decrement the ref count */
+		nm_release_folder(folder);
+
+		/* Find the next folder */
+		locate = nm_locate_field(NM_A_FA_FOLDER, locate+1);
+
+	}
+}
+
+static void
+_add_contacts(NMUser * user, NMFolder * folder, NMField * fields)
+{
+	NMContact *contact = NULL;
+	NMField *locate = NULL,  *details;
+	NMUserRecord *user_record = NULL;
+
+	locate = nm_locate_field(NM_A_FA_CONTACT, fields);
+	while (locate != NULL) {
+
+		/* Create a new contact from the fields */
+		contact = nm_create_contact_from_fields(locate);
+
+		/* Add it to our contact list */
+		nm_folder_add_contact_to_list(folder, contact);
+
+		/* Update the contact cache */
+		nm_user_add_contact(user, contact);
+
+		/* Update the user record cache */
+		if ((details = nm_locate_field(NM_A_FA_USER_DETAILS,
+									   (NMField *) locate->value))) {
+			user_record = nm_find_user_record(user, nm_contact_get_dn(contact));
+			if (user_record == NULL) {
+				user_record = nm_create_user_record_from_fields(details);
+				nm_user_record_set_dn(user_record, nm_contact_get_dn(contact));
+				nm_user_add_user_record(user, user_record);
+				nm_release_user_record(user_record);
+			}
+			nm_contact_set_user_record(contact, user_record);
+		}
+
+		nm_release_contact(contact);
+
+		locate = nm_locate_field(NM_A_FA_CONTACT, locate+1);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmcontact.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,403 @@
+/*
+ * nmcontact.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef __NM_CONTACT_H__
+#define __NM_CONTACT_H__
+
+#include <glib.h>
+
+typedef struct _NMContact NMContact;
+typedef struct _NMContactProperty NMContactProperty;
+typedef struct _NMFolder NMFolder;
+
+#include "nmfield.h"
+#include "nmuser.h"
+
+/**
+ * Creates a contact
+ *
+ * Should be released by calling nm_release_contact
+ *
+ * @return 			The new NMContact
+ *
+ */
+NMContact *nm_create_contact();
+
+/**
+ * Creates a contact from a field array representing the
+ * contact
+ *
+ * Should be released by calling nm_release_contact 
+ *
+ * @param	fields	Should be the NM_A_FA_CONTACT for
+ *					the contact
+ *
+ * @return	The new contact
+ *
+ */
+NMContact *nm_create_contact_from_fields(NMField * fields);
+
+/**
+ * Add a reference to an existing contact
+ *
+ * The reference should be released by calling
+ * nm_release_contact 
+ *
+ * @param	contact	The contact
+ *
+ */
+void nm_contact_add_ref(NMContact * contact);
+
+/**
+ * Update the contact list properties of the contact (sequence, parent id, etc.)
+ *
+ * @param	contact	The contact to update
+ * @param	fields	The fields to update from (should be a NM_A_FA_CONTACT array)
+ *
+ */
+void nm_contact_update_list_properties(NMContact * contact, NMField * fields);
+
+/**
+ * Release a contact reference
+ *
+ * @param	contact	The contact to release.
+ *
+ */
+void nm_release_contact(NMContact * contact);
+
+/**
+ * Get the display name of a contact
+ *
+ * @param	contact	The contact
+ *
+ * @return	The display name of a contact
+ *
+ */
+const char *nm_contact_get_display_name(NMContact * contact);
+
+/**
+ * Get the DN of a contact
+ *
+ * @param	contact	The contact
+ *
+ * @return	The DN of the contact
+ */
+const char *nm_contact_get_dn(NMContact * contact);
+
+/**
+ * Set the display name for a contact. This is called
+ * by nm_send_rename_contact. It should not be called 
+ * directly (it does not change the display name on the
+ * server side list -- nm_send_rename_conact does).
+ *
+ * @param	contact			The contact
+ * @param	display_name	The new display name
+ *
+ */
+void nm_contact_set_display_name(NMContact * contact, const char * display_name);
+
+/**
+ * Set the DN for the contact
+ *
+ * @param	contact	The contact
+ * @param	dn		The new DN for the contact
+ *
+ */
+void nm_contact_set_dn(NMContact * contact, const char * dn);
+
+/**
+ * Return a field array (NM_A_FA_CONTACT) representing the contact
+ *
+ * @param	contact	The contact
+ *
+ * @return	A field array representing the contact
+ */
+NMField *nm_contact_to_fields(NMContact * contact);
+
+/**
+ * Set the user record for the contact
+ *
+ * @param	contact			The contact
+ * @param	user_record		The user record
+ *
+ */
+void nm_contact_set_user_record(NMContact * contact, NMUserRecord * user_record);
+
+/**
+ * Get the user record for the contact
+ *
+ * @param	contact	The contact
+ *
+ * @return	The user record associated with the contact
+ *
+ */
+NMUserRecord *nm_contact_get_user_record(NMContact * contact);
+
+/**
+ * Get the user defined data for the contact
+ *
+ * @param	contact	The contact
+ *
+ * @return	The user defined data for the contact
+ *
+ */
+gpointer nm_contact_get_data(NMContact * contact);
+
+/**
+ * Get the Object ID for the contact
+ *
+ * @param	contact	The contact
+ *
+ * @return	The ID for the contact
+ */
+int nm_contact_get_id(NMContact * contact);
+
+/**
+ * Get the ID for the folder that the contact is in
+ *
+ * @param	contact	The contact
+ *
+ * @return	The ID of the folder that contains the contact
+ *
+ */
+int nm_contact_get_parent_id(NMContact * contact);
+
+/**
+ * Get The userid of the contact.
+ *
+ * @param	contact	The contact
+ *
+ * @return	The userid of the contact
+ *
+ */
+const char *nm_contact_get_userid(NMContact * contact);
+
+/**
+ * Get the display id of the contact
+ *
+ * @param	contact	The contact
+ *
+ * @return	The display id of the contact
+ */
+const char *nm_contact_get_display_id(NMContact * contact);
+
+/**
+ * Set the user defined data for the contact
+ *
+ * @param	contact	The contact
+ * @param	data	The user defined data
+ *
+ */
+void nm_contact_set_data(NMContact * contact, gpointer data);
+
+/**
+ * Create a folder with the given name 
+ *
+ * @param	name	The name of the folder
+ *
+ * @return 	The new folder
+ *
+ */
+NMFolder *nm_create_folder(const char *name);
+
+/**
+ * Create a folder from a NM_A_FA_FOLDER field array
+ *
+ * @param	fields	The NM_A_FA_FOLDER field array
+ *
+ * @return	The new folder
+ *
+ */
+NMFolder *nm_create_folder_from_fields(NMField * fields);
+
+/**
+ * Release a reference to a folder.
+ *
+ * @param	folder	The folder to release
+ *
+ */
+void nm_release_folder(NMFolder * folder);
+
+/**
+ * Return the number of subfolders for the given
+ * folder
+ *
+ * @param	folder	The folder
+ *
+ * @return	The number of subfolders contained by folder
+ */
+int nm_folder_get_subfolder_count(NMFolder * folder);
+
+/**
+ * Get a subfolder
+ *
+ * @param	folder	The root folder
+ * @param	index	The index of the folder to get
+ *
+ * @return	The subfolder at the given index
+ *
+ */
+NMFolder *nm_folder_get_subfolder(NMFolder * folder, int index);
+
+/**
+ * Get the number of contacts in the given folder
+ *
+ * @param	folder	The folder
+ *
+ * @return	The number of contacts contained by folder
+ *
+ */
+int nm_folder_get_contact_count(NMFolder * folder);
+
+/**
+ * Get a contact in the given folder
+ *
+ * @param	folder	The folder
+ * @param	index	The index of the contact to get
+ *
+ * @return	The contact at the given index
+ *
+ */
+NMContact *nm_folder_get_contact(NMFolder * folder, int index);
+
+/**
+ * Get the name of the folder
+ *
+ * @param	folder	The folder
+ *
+ * @return	The name of the folder.
+ *
+ */
+const char *nm_folder_get_name(NMFolder * folder);
+
+/**
+ * Set the name of a folder. Do not call this directly.
+ * It does not change the name of the folder in the
+ * server side contact list. You must call 
+ * nm_send_set_folder_name().
+ *
+ * @param	folder	The folder
+ * @param	name	The new name for the folder
+ *
+ */
+void nm_folder_set_name(NMFolder * folder, const char *name);
+
+/**
+ * Get Object ID for folder
+ *
+ * @param	folder	The folder
+ *
+ * @return	The ID of the folder
+ *
+ */
+int nm_folder_get_id(NMFolder * folder);
+
+/**
+ * Add contacts and folders from fields into root
+ *
+ * @param	user	The logged in user
+ * @param	root	The root folder
+ * @param	fields	The contact list field array
+ * 
+ */
+void nm_folder_add_contacts_and_folders(NMUser * user, NMFolder * root,
+										NMField * fields);
+/**
+ * Add a contact to the contact list.
+ *
+ * @param	root_folder	The root folder of the contact list
+ * @param	contact		The contact to add
+ *
+ */
+void nm_folder_add_contact_to_list(NMFolder * root_folder,
+									  NMContact * contact);
+
+/**
+ * Update the contact list properties of the folder (sequence, parent id, etc.)
+ *
+ * @param	folder	The folder to update
+ * @param	fields	The fields to update from (should be a NM_A_FA_FOLDER array)
+ *
+ */
+void nm_folder_update_list_properties(NMFolder * folder, NMField * fields);
+
+/**
+ * Add folder to the contact list
+ *
+ * @param	root_folder	The root folder of the contact list
+ * @param	folder		The folder to add to the contact list
+ *
+ */
+void nm_folder_add_folder_to_list(NMFolder * root_folder, NMFolder * folder);
+
+/**
+ * Find the object with the given id
+ *
+ * @param	root_folder	The root folder of the contact list
+ * @param	object_id	The object id of the object to find
+ *
+ * @return	The object with object id (either a contact or a folder)
+ */
+gpointer nm_folder_find_item_by_object_id(NMFolder * root_folder,
+										  int object_id);
+
+/**
+ * Remove a contact from the folder
+ *
+ * @param	folder	The folder
+ * @param	contact	The contact to remove
+ *
+ */
+void nm_folder_remove_contact(NMFolder * folder, NMContact * contact);
+
+/**
+ * Find a contact in a folder by DN
+ *
+ * @param	folder	The folder to search
+ * @param	dn		The DN of the contact to find
+ *
+ * @return	The contact if found, NULL otherwise
+ *
+ */
+NMContact *nm_folder_find_contact(NMFolder * folder, const char *dn);
+
+/**
+ * Find a contact in a folder by userid
+ *
+ * @param	folder	The folder to search
+ * @param	userid	The userid of the contact to find
+ *
+ * @return	The contact if found, NULL otherwise
+ *
+ */
+NMContact *nm_folder_find_contact_by_userid(NMFolder * folder,
+											const char *userid);
+/**
+ * Return a field array (NM_A_FA_FOLDER) representing the folder
+ *
+ * @param	folder	The folder
+ *
+ * @return	A field array representing the folder
+ */
+NMField *nm_folder_to_fields(NMFolder * folder);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmevent.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,973 @@
+/*
+ * nmevent.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include <glib.h>
+#include <string.h>
+#include <time.h>
+#include "nmevent.h"
+#include "nmfield.h"
+#include "nmconn.h"
+#include "nmuserrecord.h"
+
+struct _NMEvent
+{
+
+	/* Event type */
+	int type;
+
+	/* The DN of the event source */
+	char *source;
+
+	/* Timestamp of the event */
+	guint32 gmt;
+
+	/* Conference to associate with the event */
+	NMConference *conference;
+
+	/* User record to associate with the event */
+	NMUserRecord *user_record;
+
+	/* Text associated with the event */
+	char *text;
+
+	/* Reference count for event structure */
+	int ref_count;
+
+};
+
+/* Return a copy of src minus the RTF  */
+static char *
+_strip_rtf(const char *src, int len)
+{
+	const char *p = src;
+	char *q;
+	char *dest = g_new0(char, len + 1);
+	int level = 0;
+
+	/* Make sure we are dealing with rtf */
+	if (strncmp("{\\rtf1", src, strlen("{\\rtf1")) != 0) {
+		strncpy(dest, src, len);
+		return dest;
+	}
+	p += strlen("{\\rtf1");
+
+	q = dest;
+	while (*p != '\0') {
+		if (*p == '\\') {
+			if (level == 0) {
+				if (*(p + 1) == '\\' || *(p + 1) == '{' || *(p + 1) == '}') {
+					*q++ = *(p + 1);
+					p++;
+				} else if (*(p + 1) == 't' && *(p + 2) == 'a' && *(p + 3) == 'b') {
+					*q++ = '\t';
+					p++;
+				}
+			}
+			p++;
+		} else if (*p == '{') {
+			level++;
+			p++;
+		} else if (*p == '}') {
+			level--;
+			p++;
+		} else if (level == 0) {
+			if ((*p == ' ' || *p == '\r') && (*(p + 1) != '\\')) {
+				p++;
+
+				if (*p == '\n' &&
+					(*(p + 1) == '{' || *(p + 1) == '}' || *(p + 1) == '\\')) {
+					p++;
+				} else {
+					/* We found some text */
+					while (*p != '\0' && *p != '\\' && *p != '{' && *p != '}') {
+						*q++ = *p;
+						p++;
+					}
+				}
+			} else {
+				p++;
+			}
+		} else {
+			p++;
+		}
+	}
+
+	return dest;
+}
+
+/* Handle getdetails response and set the new user record into the event */
+static void
+_got_user_for_event(NMUser * user, NMERR_T ret_val,
+					gpointer resp_data, gpointer user_data)
+{
+	NMUserRecord *user_record;
+	NMEvent *event;
+	nm_event_cb cb;
+
+	if (user == NULL)
+		return;
+
+	user_record = resp_data;
+	event = user_data;
+
+	if (ret_val == NM_OK) {
+		if (event && user_record) {
+
+			/* Add the user record to the event structure 
+			 * and make the callback.
+			 */
+			nm_event_set_user_record(event, user_record);
+			if ((cb = nm_user_get_event_callback(user))) {
+				cb(user, event);
+			}
+		}
+
+	} else {
+		/* Cleanup resp_data */
+
+	}
+
+	/* Clean up */
+	if (event)
+		nm_release_event(event);
+
+}
+
+/* Handle getdetails response, set the new user record into the event
+ * and add the user record as a participant in the conference
+ */
+static void
+_got_user_for_conference(NMUser * user, NMERR_T ret_val,
+						 gpointer resp_data, gpointer user_data)
+{
+	NMUserRecord *user_record = resp_data;
+	NMEvent *event = user_data;
+	NMConference *conference;
+	nm_event_cb cb;
+
+	if (user == NULL)
+		return;
+
+	if (event && user_record) {
+
+		conference = nm_event_get_conference(event);
+		if (conference) {
+
+			/* Add source of event as recip of the conference */
+			nm_conference_add_participant(conference, user_record);
+
+			/* Add the user record to the event structure 
+			 * and make the callback.
+			 */
+			nm_event_set_user_record(event, user_record);
+			if ((cb = nm_user_get_event_callback(user))) {
+				cb(user, event);
+			}
+		}
+	}
+
+	if (event)
+		nm_release_event(event);
+}
+
+/* Read the receive message event, set up the event object, and
+ * get details for the event source if we don't have them yet.
+ */
+static NMERR_T
+handle_receive_message(NMUser * user, NMEvent * event, gboolean autoreply)
+{
+	NMConference *conference;
+	NMUserRecord *user_record;
+	NMConn *conn;
+	NMERR_T rc = NM_OK;
+	guint32 size = 0, flags = 0;
+	char *msg = NULL;
+	char *nortf = NULL;
+	char *guid = NULL;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	/* Read the conference flags */
+	if (rc == NM_OK) {
+		rc = nm_read_all(conn, (char *) &flags, sizeof(flags));
+	}
+
+	/* Read the message text */
+	if (rc == NM_OK) {
+		rc = nm_read_all(conn, (char *) &size, sizeof(size));
+		if (rc == NM_OK) {
+
+			msg = g_new0(char, size + 1);
+			rc = nm_read_all(conn, msg, size);
+
+			gaim_debug(GAIM_DEBUG_INFO, "novell", "Message is %s\n", msg);
+
+			/* Auto replies are not in RTF format! */
+			if (!autoreply) {
+
+				nortf = _strip_rtf((const char *) msg, size);
+
+				gaim_debug(GAIM_DEBUG_INFO, "novell",
+						   "Message without RTF is %s\n", nortf);
+
+				/* Store the event data */
+				nm_event_set_text(event, nortf);
+
+			} else {
+
+				/* Store the event data */
+				nm_event_set_text(event, msg);
+			}
+		}
+	}
+
+	/* Check to see if we already know about the conference */
+	conference = nm_conference_list_find(user, guid);
+	if (conference) {
+
+		nm_conference_set_flags(conference, flags);
+		nm_event_set_conference(event, conference);
+
+		/* Add a reference to the user record in our event object */
+		user_record = nm_find_user_record(user, nm_event_get_source(event));
+		if (user_record) {
+			nm_event_set_user_record(event, user_record);
+		}
+
+	} else {
+
+		/* This is a new conference, so create one and add it to our list */
+		conference = nm_create_conference(guid);
+		nm_conference_set_flags(conference, flags);
+
+		/* Add a reference to the conference in the event */
+		nm_event_set_conference(event, conference);
+
+		/* Add new conference to the conference list */
+		nm_conference_list_add(user, conference);
+
+		/* Check to see if we have details for the event source yet */
+		user_record = nm_find_user_record(user, nm_event_get_source(event));
+		if (user_record) {
+
+			/* We do so add the user record as a recipient of the conference */
+			nm_conference_add_participant(conference, user_record);
+
+			/* Add a reference to the user record in our event object */
+			nm_event_set_user_record(event, user_record);
+
+		} else {
+
+			/* Need to go to the server to get details for the user */
+			rc = nm_send_get_details(user, nm_event_get_source(event),
+									 _got_user_for_conference, event);
+			if (rc == NM_OK)
+				rc = -1;		/* Not done processing the event yet! */
+		}
+
+		nm_release_conference(conference);
+	}
+
+	if (msg)
+		g_free(msg);
+
+	if (nortf)
+		g_free(nortf);
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/* Read the invite event, set up the event object, and
+ * get details for the event source if we don't have them yet.
+ */
+static NMERR_T
+handle_conference_invite(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0;
+	char *guid = NULL;
+	char *msg = NULL;
+	NMConn *conn;
+	NMUserRecord *user_record;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	/* Read the the message */
+	if (rc == NM_OK) {
+		rc = nm_read_all(conn, (char *) &size, sizeof(size));
+		if (rc == NM_OK) {
+			msg = g_new0(char, size + 1);
+			rc = nm_read_all(conn, msg, size);
+		}
+	}
+
+	/* Store the event data */
+	if (rc == NM_OK) {
+		NMConference *conference;
+
+		nm_event_set_text(event, msg);
+
+		conference = nm_conference_list_find(user, guid);
+		if (conference == NULL) {
+			conference = nm_create_conference(guid);
+
+			/* Add new conference to the list and the event */
+			nm_conference_list_add(user, conference);
+			nm_event_set_conference(event, conference);
+
+			/* Check to see if we have details for the event source yet */
+			user_record = nm_find_user_record(user, nm_event_get_source(event));
+			if (user_record) {
+
+				/* Add a reference to the user record in our event object */
+				nm_event_set_user_record(event, user_record);
+
+			} else {
+
+				/* Need to go to the server to get details for the user */
+				rc = nm_send_get_details(user, nm_event_get_source(event),
+										 _got_user_for_event, event);
+				if (rc == NM_OK)
+					rc = -1;	/* Not done processing the event yet! */
+			}
+
+			nm_release_conference(conference);
+
+		}
+	}
+
+	if (msg)
+		g_free(msg);
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/* Read the invite notify event, set up the event object, and
+ * get details for the event source if we don't have them yet.
+ */
+static NMERR_T
+handle_conference_invite_notify(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0;
+	char *guid = NULL;
+	NMConn *conn;
+	NMConference *conference;
+	NMUserRecord *user_record;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	conference = nm_conference_list_find(user, guid);
+	if (conference) {
+		nm_event_set_conference(event, conference);
+
+		/* Check to see if we have details for the event source yet */
+		user_record = nm_find_user_record(user, nm_event_get_source(event));
+		if (user_record) {
+
+			/* Add a reference to the user record in our event object */
+			nm_event_set_user_record(event, user_record);
+
+		} else {
+
+			/* Need to go to the server to get details for the user */
+			rc = nm_send_get_details(user, nm_event_get_source(event),
+									 _got_user_for_event, event);
+			if (rc == NM_OK)
+				rc = -1;		/* Not done processing the event yet! */
+		}
+
+	} else {
+		rc = NMERR_CONFERENCE_NOT_FOUND;
+	}
+
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/* Read the conference reject event and set up the event object */
+static NMERR_T
+handle_conference_reject(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0;
+	char *guid = NULL;
+	NMConn *conn;
+	NMConference *conference;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	if (rc == NM_OK) {
+		conference = nm_conference_list_find(user, guid);
+		if (conference) {
+			nm_event_set_conference(event, conference);
+		} else {
+			rc = NMERR_CONFERENCE_NOT_FOUND;
+		}
+	}
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/* Read the conference left event, set up the event object, and
+ * remove the conference from the list if there are no more 
+ * participants
+ */
+static NMERR_T
+handle_conference_left(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0, flags = 0;
+	char *guid = NULL;
+	NMConference *conference;
+	NMConn *conn;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	/* Read the conference flags */
+	if (rc == NM_OK) {
+		rc = nm_read_all(conn, (char *) &flags, sizeof(flags));
+	}
+
+	if (rc == NM_OK) {
+		conference = nm_conference_list_find(user, guid);
+		if (conference) {
+			nm_event_set_conference(event, conference);
+			nm_conference_set_flags(conference, flags);
+			
+			nm_conference_remove_participant(conference, nm_event_get_source(event));
+			if (nm_conference_get_participant_count(conference) == 0) {
+				nm_conference_list_remove(user, conference);
+			}
+			
+		} else {
+			rc = NMERR_CONFERENCE_NOT_FOUND;
+		}
+	}
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/* Read the conference closed, set up the event object, and
+ * remove the conference from the list
+ */
+static NMERR_T
+handle_conference_closed(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0;
+	char *guid = NULL;
+	NMConference *conference;
+	NMConn *conn;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	if (rc == NM_OK) {
+		conference = nm_conference_list_find(user, guid);
+		if (conference) {
+			nm_event_set_conference(event, conference);
+			nm_conference_list_remove(user, conference);
+		} else {
+			rc = NMERR_CONFERENCE_NOT_FOUND;
+		}
+	}
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/* Read the conference joined event, set up the event object, and
+ * get details for the event source if we don't have them yet.
+ */
+static NMERR_T
+handle_conference_joined(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0, flags = 0;
+	char *guid = NULL;
+	NMConn *conn;
+	NMConference *conference;
+	NMUserRecord *user_record;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	/* Read the conference flags */
+	if (rc == NM_OK) {
+		rc = nm_read_all(conn, (char *) &flags, sizeof(flags));
+	}
+
+	if (rc == NM_OK) {
+		conference = nm_conference_list_find(user, guid);
+		if (conference) {
+			nm_conference_set_flags(conference, flags);
+			
+			nm_event_set_conference(event, conference);
+			
+			/* Add the new user to the participants list */
+			user_record = nm_find_user_record(user, nm_event_get_source(event));
+			if (user_record) {
+				nm_conference_add_participant(conference, user_record);
+			} else {
+				
+				/* Need to go to the server to get details for the user */
+				rc = nm_send_get_details(user, nm_event_get_source(event),
+										 _got_user_for_conference, event);
+				if (rc == NM_OK)
+					rc = -1;		/* Not done processing the event yet! */
+			}
+			
+		} else {
+			rc = NMERR_CONFERENCE_NOT_FOUND;
+		}
+	}
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/* Read the typing event and set up the event object */
+static NMERR_T
+handle_typing(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0;
+	char *guid = NULL;
+	NMConference *conference;
+	NMConn *conn;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	if (rc == NM_OK) {
+		conference = nm_conference_list_find(user, guid);
+		if (conference) {
+			nm_event_set_conference(event, conference);
+		} else {
+			rc = NMERR_CONFERENCE_NOT_FOUND;
+		}
+	}
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/* Read the event, set up the event object, and update
+ * the status in the user record (for the event source)
+ */
+static NMERR_T
+handle_status_change(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint16 status;
+	guint32 size;
+	char *text = NULL;
+	NMUserRecord *user_record;
+	NMConn *conn;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read new status */
+	rc = nm_read_all(conn, (char *) &status, sizeof(status));
+	if (rc == NM_OK) {
+
+		/* Read the status text */
+		rc = nm_read_all(conn, (char *) &size, sizeof(size));
+		if (rc == NM_OK) {
+			if (size > 0) {
+				text = g_new0(char, size + 1);
+				rc = nm_read_all(conn, text, size);
+			}
+		}
+	}
+
+	if (rc == NM_OK) {
+		nm_event_set_text(event, text);
+
+		/* Get a reference to the user record and store the new status */
+		user_record = nm_find_user_record(user, nm_event_get_source(event));
+		if (user_record) {
+			nm_event_set_user_record(event, user_record);
+			nm_user_record_set_status(user_record, status, text);
+		}
+	}
+
+	if (text)
+		g_free(text);
+
+	return rc;
+}
+
+/* Read the undeliverable event */
+static NMERR_T
+handle_undeliverable_status(NMUser * user, NMEvent * event)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0;
+	char *guid = NULL;
+	NMConn *conn;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the conference guid */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		guid = g_new0(char, size + 1);
+		rc = nm_read_all(conn, guid, size);
+	}
+
+	if (guid)
+		g_free(guid);
+
+	return rc;
+}
+
+/*******************************************************************************
+ * Event API -- see header file for comments
+ ******************************************************************************/
+
+NMEvent *
+nm_create_event(int type, const char *source, guint32 gmt)
+{
+	NMEvent *event = g_new0(NMEvent, 1);
+
+	event->type = type;
+	event->gmt = gmt;
+
+	if (source)
+		event->source = g_strdup(source);
+
+	event->ref_count = 1;
+
+	return event;
+}
+
+void
+nm_release_event(NMEvent * event)
+{
+	if (event == NULL) {
+		return;
+	}
+
+	if (--(event->ref_count) == 0) {
+
+		if (event->source)
+			g_free(event->source);
+
+		if (event->conference)
+			nm_release_conference(event->conference);
+
+		if (event->user_record)
+			nm_release_user_record(event->user_record);
+
+		if (event->text)
+			g_free(event->text);
+
+		g_free(event);
+	}
+}
+
+
+NMConference *
+nm_event_get_conference(NMEvent * event)
+{
+	if (event)
+		return event->conference;
+	else
+		return NULL;
+}
+
+void
+nm_event_set_conference(NMEvent * event, NMConference * conference)
+{
+	if (event && conference) {
+		nm_conference_add_ref(conference);
+		event->conference = conference;
+	}
+}
+
+NMUserRecord *
+nm_event_get_user_record(NMEvent * event)
+{
+	if (event)
+		return event->user_record;
+	else
+		return NULL;
+}
+
+void
+nm_event_set_user_record(NMEvent * event, NMUserRecord * user_record)
+{
+	if (event && user_record) {
+		nm_user_record_add_ref(user_record);
+		event->user_record = user_record;
+	}
+}
+
+const char *
+nm_event_get_text(NMEvent * event)
+{
+	if (event)
+		return event->text;
+	else
+		return NULL;
+}
+
+void
+nm_event_set_text(NMEvent * event, const char *text)
+{
+	if (event) {
+		if (text)
+			event->text = g_strdup(text);
+		else
+			event->text = NULL;
+	}
+}
+
+const char *
+nm_event_get_source(NMEvent * event)
+{
+	if (event)
+		return event->source;
+	else
+		return NULL;
+}
+
+int
+nm_event_get_type(NMEvent * event)
+{
+	if (event)
+		return event->type;
+	else
+		return -1;
+}
+
+guint32
+nm_event_get_gmt(NMEvent * event)
+{
+	if (event)
+		return event->gmt;
+	else
+		return (guint32)-1;
+}
+
+NMERR_T
+nm_process_event(NMUser * user, int type)
+{
+	NMERR_T rc = NM_OK;
+	guint32 size = 0;
+	NMEvent *event = NULL;
+	char *source = NULL;
+	nm_event_cb cb;
+	NMConn *conn;
+
+	if (user == NULL)
+		return NMERR_BAD_PARM;
+
+	if (type < NMEVT_START || type > NMEVT_STOP)
+		return NMERR_PROTOCOL;
+
+	conn = nm_user_get_conn(user);
+
+	/* Read the event source */
+	rc = nm_read_all(conn, (char *) &size, sizeof(size));
+	if (rc == NM_OK) {
+		if (size > 0) {
+			source = g_new0(char, size);
+
+			rc = nm_read_all(conn, source, size);
+		}
+	}
+
+	/* Read the event data */
+	if (rc == NM_OK) {
+		event = nm_create_event(type, source, time(0));
+
+		if (event) {
+
+			switch (type) {
+			case NMEVT_STATUS_CHANGE:
+				rc = handle_status_change(user, event);
+				break;
+
+			case NMEVT_RECEIVE_MESSAGE:
+				rc = handle_receive_message(user, event, FALSE);
+				break;
+
+			case NMEVT_RECEIVE_AUTOREPLY:
+				rc = handle_receive_message(user, event, TRUE);
+				break;
+
+			case NMEVT_USER_TYPING:
+			case NMEVT_USER_NOT_TYPING:
+				rc = handle_typing(user, event);
+				break;
+
+			case NMEVT_CONFERENCE_LEFT:
+				rc = handle_conference_left(user, event);
+				break;
+
+			case NMEVT_CONFERENCE_CLOSED:
+				rc = handle_conference_closed(user, event);
+				break;
+
+			case NMEVT_CONFERENCE_JOINED:
+				rc = handle_conference_joined(user, event);
+				break;
+
+			case NMEVT_CONFERENCE_INVITE:
+				rc = handle_conference_invite(user, event);
+				break;
+
+			case NMEVT_CONFERENCE_REJECT:
+				rc = handle_conference_reject(user, event);
+				break;
+
+			case NMEVT_CONFERENCE_INVITE_NOTIFY:
+				rc = handle_conference_invite_notify(user, event);
+				break;
+
+			case NMEVT_UNDELIVERABLE_STATUS:
+				rc = handle_undeliverable_status(user, event);
+				break;
+
+			case NMEVT_INVALID_RECIPIENT:
+				/* Nothing else to read, just callback */
+				break;
+
+			case NMEVT_USER_DISCONNECT:
+				/* Nothing else to read, just callback */
+				break;
+
+			case NMEVT_SERVER_DISCONNECT:
+				/* Nothing else to read, just callback */
+				break;
+
+			case NMEVT_RECEIVE_FILE:
+			case NMEVT_CONTACT_ADD:
+				/* Safely ignored for now */
+				break;
+
+			default:
+				gaim_debug(GAIM_DEBUG_INFO, "novell",
+						   "Unknown event %d received.\n", type);
+				rc = NMERR_PROTOCOL;
+				break;
+			}
+		}
+	}
+
+	if (rc == (NMERR_T)-1) {
+		/* -1 means that we are not ready to callback yet. */
+		rc = NM_OK;
+	} else if (rc == NM_OK && (cb = nm_user_get_event_callback(user))) {
+
+		cb(user, event);
+
+		if (event)
+			nm_release_event(event);
+	} else {
+		if (event)
+			nm_release_event(event);
+	}
+
+	/* Cleanup */
+	if (source)
+		g_free(source);
+
+	return rc;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmevent.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,181 @@
+/*
+ * nmevent.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef __NM_EVENT_H__
+#define __NM_EVENT_H__
+
+typedef struct _NMEvent NMEvent;
+
+#include "nmuser.h"
+
+/**
+ * Defines for the event types 
+ */
+#define	NMEVT_INVALID_RECIPIENT			101
+#define	NMEVT_UNDELIVERABLE_STATUS		102
+#define	NMEVT_STATUS_CHANGE				103
+#define	NMEVT_CONTACT_ADD				104
+#define	NMEVT_CONFERENCE_CLOSED			105
+#define	NMEVT_CONFERENCE_JOINED			106
+#define	NMEVT_CONFERENCE_LEFT			107
+#define	NMEVT_RECEIVE_MESSAGE			108
+#define	NMEVT_RECEIVE_FILE				109
+#define NMEVT_USER_TYPING				112
+#define NMEVT_USER_NOT_TYPING			113
+#define NMEVT_USER_DISCONNECT			114
+#define NMEVT_SERVER_DISCONNECT			115
+#define NMEVT_CONFERENCE_RENAME			116
+#define NMEVT_CONFERENCE_INVITE			117
+#define NMEVT_CONFERENCE_INVITE_NOTIFY	118
+#define NMEVT_CONFERENCE_REJECT			119
+#define NMEVT_RECEIVE_AUTOREPLY			121
+#define NMEVT_START						NMEVT_INVALID_RECIPIENT
+#define NMEVT_STOP						NMEVT_RECEIVE_AUTOREPLY
+
+/**
+ * Process the event. The event will be read, an NMEvent will
+ * be created, and the event callback will be called.
+ *
+ * @param user		The main user structure.
+ * @param type		The type of the event to read.
+ *
+ * @return			NM_OK on success
+ */
+NMERR_T nm_process_event(NMUser * user, int type);
+
+/**
+ * Creates an NMEvent
+ *
+ * The NMEvent should be released by calling
+ * nm_release_event.
+ *
+ * @param type		The event type, see defines above.
+ * @param source	The DN of the event source.
+ * @param gmt		The time that the event occurred.
+ *
+ * @return 			The new NMEvent
+ */
+NMEvent *nm_create_event(int type, const char *source, guint32 gmt);
+
+/**
+ * Releases an NMEvent
+ *
+ * @param event		The event to release
+ *
+ */
+void nm_release_event(NMEvent * event);
+
+/**
+ * Sets the conference object for the given event.
+ *
+ * @param event			The event.
+ * @param conference	The conference to associate with the event.
+ *
+ */
+void nm_event_set_conference(NMEvent * event, NMConference * conference);
+
+/**
+ * Returns the conference object associated with the given event. This should not
+ * be released. If it needs to be kept around call nm_conference_addref().
+ *
+ * @param event	The event.
+ *
+ * @return		The conference associated with the event, or NULL
+ *				if no conference has been set for the event.
+ */
+NMConference *nm_event_get_conference(NMEvent * event);
+
+/**
+ * Sets the NMUserRecord object for the given event.
+ * The user record represents the event source.
+ *
+ * @param event			The event.
+ * @param user_record	The user record to associate with the event.
+ *
+ */
+void nm_event_set_user_record(NMEvent * event, NMUserRecord * user_record);
+
+/**
+ * Returns the NMUserRecord object associated with the given event. 
+ * The user record represents the event source. This should not
+ * be released. If it needs to be kept around call
+ * nm_user_record_add_ref().
+ *
+ * @param event	The event.
+ *
+ * @return		The user record associated with the event, or NULL
+ *				if no user record has been set for the event.
+ */
+NMUserRecord *nm_event_get_user_record(NMEvent * event);
+
+/**
+ * Sets the text to associate with the given event.
+ *
+ * @param event	The event.
+ * @param text	The text to associate with the event.
+ *
+ */
+void nm_event_set_text(NMEvent * event, const char *text);
+
+/**
+ * Returns the text associated with the given event.
+ *
+ * @param event	The event.
+ *
+ * @return		The text associated with the event, or NULL
+ *				if no text has been set for the event.
+ */
+const char *nm_event_get_text(NMEvent * event);
+
+/**
+ * Returns the source of the event (this will be the full DN of the
+ * event source).
+ *
+ * @param event	The event.
+ *
+ * @return		The full DN of the event's source.
+ */
+const char *nm_event_get_source(NMEvent * event);
+
+/**
+ * Returns the type of the event. See the defines above for
+ * a list of possible event types.
+ *
+ * @param event	The event.
+ *
+ * @return		The type of the event.
+ *
+ */
+int nm_event_get_type(NMEvent * event);
+
+/**
+ * Returns the time that the event took place.
+ *
+ * @param event	The event.
+ *
+ * @return		The timestamp for the event. This is the number of
+ *			    seconds since 1/1/1970 (as returned by the time() 
+ *				system call).
+ */
+guint32 nm_event_get_gmt(NMEvent * event);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmfield.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,334 @@
+/*
+ * nmfield.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED, TRANSLATED,
+ * ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED, RECAST, TRANSFORMED
+ * OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL, INC. ANY USE OR
+ * EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT THE PERPETRATOR
+ * TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH THIS
+ * WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND LICENSES
+ * THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY FROM [GAIM]
+ * AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES GRANTED BY
+ * [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF ANYTHING IN
+ * THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS PREVAIL.
+ *
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include "nmfield.h"
+
+/* Free a field value and tag */
+static void _free_field(NMField * field);
+
+/* Free a field value */
+static void _free_field_value(NMField * field);
+
+/* Make a deep copy of the field */
+static void _copy_field(NMField * dest, NMField * src);
+
+/* Make a deep copy of the field's value */
+static void _copy_field_value(NMField * dest, NMField * src);
+
+/* Create a string from a value -- for debugging */
+static char *_value_to_string(NMField * field);
+
+NMField *
+nm_add_field(NMField * fields, char *tag, guint32 size, guint8 method,
+			 guint8 flags, guint32 value, guint8 type)
+{
+	guint32 count, new_len;
+	NMField *field = NULL;
+
+	if (fields == NULL) {
+		fields = g_new0(NMField, 10);
+		fields->len = 10;
+		count = 0;
+	} else {
+		count = nm_count_fields(fields);
+		if (fields->len < count + 2) {
+			new_len = count + 10;
+			fields = g_realloc(fields, new_len * sizeof(NMField));
+			fields->len = new_len;
+		}
+	}
+
+	field = &(fields[count]);
+	field->tag = g_strdup(tag);
+	field->size = size;
+	field->method = method;
+	field->flags = flags;
+	field->value = value;
+	field->type = type;
+
+	/* Null terminate the field array */
+	field = &((fields)[count + 1]);
+	field->tag = NULL;
+	field->value = 0;
+
+	return fields;
+}
+
+guint32
+nm_count_fields(NMField * fields)
+{
+	guint32 count = 0;
+
+	if (fields) {
+		while (fields->tag != NULL) {
+			count++;
+			fields++;
+		}
+	}
+
+	return count;
+}
+
+void
+nm_free_fields(NMField ** fields)
+{
+	NMField *field = NULL;
+
+	if ((fields == NULL) || (*fields == NULL))
+		return;
+
+	field = *fields;
+
+	while (field->tag != NULL) {
+		_free_field(field);
+		field++;
+	}
+
+	g_free(*fields);
+	*fields = NULL;
+}
+
+
+static void
+_free_field(NMField * field)
+{
+	if (field == NULL)
+		return;
+
+	_free_field_value(field);
+	g_free(field->tag);
+}
+
+static void
+_free_field_value(NMField * field)
+{
+	if (field == NULL)
+		return;
+
+	switch (field->type) {
+	case NMFIELD_TYPE_BINARY:
+	case NMFIELD_TYPE_UTF8:
+	case NMFIELD_TYPE_DN:
+		if ((gpointer) field->value != NULL) {
+			g_free((gpointer) field->value);
+		}
+		break;
+
+	case NMFIELD_TYPE_ARRAY:
+	case NMFIELD_TYPE_MV:
+		nm_free_fields((NMField **) & field->value);
+		break;
+
+	default:
+		break;
+	}
+
+	field->size = 0;
+	field->value = 0;
+}
+
+NMField *
+nm_locate_field(char *tag, NMField * fields)
+{
+	NMField *ret_fields = NULL;
+
+	if ((fields == NULL) || (tag == NULL)) {
+		return NULL;
+	}
+
+	while (fields->tag != NULL) {
+		if (g_ascii_strcasecmp(fields->tag, tag) == 0) {
+			ret_fields = fields;
+			break;
+		}
+		fields++;
+	}
+
+	return ret_fields;
+}
+
+NMField *
+nm_copy_field_array(NMField * src)
+{
+	NMField *ptr = NULL;
+	NMField *dest = NULL;
+	int count;
+
+	if (src != NULL) {
+		count = nm_count_fields(src) + 1;
+		dest = g_new0(NMField, count);
+		dest->len = count;
+		ptr = dest;
+		while (src->tag != NULL) {
+			_copy_field(ptr, src);
+			ptr++;
+			src++;
+		}
+	}
+
+	return dest;
+}
+
+static void
+_copy_field(NMField * dest, NMField * src)
+{
+	dest->type = src->type;
+	dest->flags = src->flags;
+	dest->method = src->method;
+	dest->tag = g_strdup(src->tag);
+	_copy_field_value(dest, src);
+}
+
+static void
+_copy_field_value(NMField * dest, NMField * src)
+{
+	dest->type = src->type;
+	switch (dest->type) {
+	case NMFIELD_TYPE_UTF8:
+	case NMFIELD_TYPE_DN:
+		if (src->size == 0 && src->value != 0) {
+			src->size = strlen((char *) src->value) + 1;
+		}
+		/* fall through */
+	case NMFIELD_TYPE_BINARY:
+		if (src->size != 0 && src->value != 0) {
+			dest->value = (guint32) g_new0(char, src->size);
+
+			memcpy((gpointer) dest->value, (gpointer) src->value, src->size);
+		}
+		break;
+
+	case NMFIELD_TYPE_ARRAY:
+	case NMFIELD_TYPE_MV:
+		dest->value = 0;
+		dest->value = (guint32) nm_copy_field_array((NMField *) src->value);
+		break;
+
+	default:
+		/* numeric value */
+		dest->value = src->value;
+		break;
+	}
+
+	dest->size = src->size;
+}
+
+void
+nm_remove_field(NMField * field)
+{
+	NMField *tmp;
+	guint32 len;
+
+	if ((field != NULL) && (field->tag != NULL)) {
+		_free_field(field);
+
+		/* Move fields down */
+		tmp = field + 1;
+		while (1) {
+			/* Don't overwrite the size of the array */
+			len = field->len;
+
+			*field = *tmp;
+
+			field->len = len;
+
+			if (tmp->tag == NULL)
+				break;
+
+			field++;
+			tmp++;
+		}
+	}
+}
+
+void
+nm_print_fields(NMField * fields)
+{
+	char *str = NULL;
+	NMField *field = fields;
+
+	if (fields == NULL)
+		return;
+
+	while (field->tag != NULL) {
+		if (field->type == NMFIELD_TYPE_ARRAY || field->type == NMFIELD_TYPE_MV) {
+			printf("Subarray START: %s Method = %d\n", field->tag, field->method);
+			nm_print_fields((NMField *) field->value);
+			printf("Subarray END: %s\n", field->tag);
+		} else {
+			str = _value_to_string(field);
+			printf("Tag=%s;Value=%s\n", field->tag, str);
+			g_free(str);
+			str = NULL;
+		}
+		field++;
+	}
+
+}
+
+static char *
+_value_to_string(NMField * field)
+{
+	char *value = NULL;
+
+	if (field == NULL)
+		return NULL;
+
+	/* This is a single value attribute */
+	if (((field->type == NMFIELD_TYPE_UTF8) ||
+		 (field->type == NMFIELD_TYPE_DN)) && (field->value != 0)) {
+		value = g_strdup((const char *) field->value);
+	} else if (field->type == NMFIELD_TYPE_BINARY && field->value != 0) {
+		value = g_new0(char, field->size);
+
+		memcpy(value, (const char *) field->value, field->size);
+	} else if (field->type == NMFIELD_TYPE_BOOL) {
+		if (field->value) {
+			value = g_strdup(NM_FIELD_TRUE);
+		} else {
+			value = g_strdup(NM_FIELD_FALSE);
+		}
+	} else {
+		/* assume it is a number */
+		value = g_new0(char, 20);
+
+		switch (field->type) {
+		case NMFIELD_TYPE_BYTE:
+		case NMFIELD_TYPE_WORD:
+		case NMFIELD_TYPE_DWORD:
+			value = g_strdup_printf("%ld", (long) field->value);
+			break;
+
+		case NMFIELD_TYPE_UBYTE:
+		case NMFIELD_TYPE_UWORD:
+		case NMFIELD_TYPE_UDWORD:
+			value = g_strdup_printf("%lu", (unsigned long) field->value);
+			break;
+		}
+	}
+
+	if (value == NULL)
+		value = g_strdup("NULL");
+
+	return value;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmfield.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,201 @@
+/*
+ * nmfield.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef NMFIELD_H
+#define NMFIELD_H
+
+#include <glib.h>
+
+typedef struct NMField_t
+{
+	char *tag;				/* Field tag */
+
+	guint8 method;			/* Method of the field */
+
+	guint8 flags;			/* Flags */
+
+	guint8 type;			/* Type of value */
+
+	guint32 size;			/* Size of value if binary */
+
+	guint32 value;			/* Value of field */
+
+	guint32 len;			/* Length of the array */
+
+} NMField;
+
+/* Field types */
+#define	NMFIELD_TYPE_INVALID			0
+#define	NMFIELD_TYPE_NUMBER				1
+#define	NMFIELD_TYPE_BINARY				2
+#define	NMFIELD_TYPE_BYTE				3
+#define	NMFIELD_TYPE_UBYTE				4
+#define	NMFIELD_TYPE_WORD				5
+#define	NMFIELD_TYPE_UWORD				6
+#define	NMFIELD_TYPE_DWORD				7
+#define	NMFIELD_TYPE_UDWORD				8
+#define	NMFIELD_TYPE_ARRAY				9
+#define	NMFIELD_TYPE_UTF8				10
+#define	NMFIELD_TYPE_BOOL				11
+#define	NMFIELD_TYPE_MV					12
+#define	NMFIELD_TYPE_DN					13
+
+/* Field methods */
+#define NMFIELD_METHOD_VALID			0
+#define NMFIELD_METHOD_IGNORE			1
+#define NMFIELD_METHOD_DELETE			2
+#define NMFIELD_METHOD_DELETE_ALL		3
+#define NMFIELD_METHOD_EQUAL			4
+#define NMFIELD_METHOD_ADD				5
+#define NMFIELD_METHOD_UPDATE			6
+#define NMFIELD_METHOD_GTE				10
+#define NMFIELD_METHOD_LTE				12
+#define NMFIELD_METHOD_NE				14
+#define NMFIELD_METHOD_EXIST			15
+#define NMFIELD_METHOD_NOTEXIST			16
+#define NMFIELD_METHOD_SEARCH			17
+#define NMFIELD_METHOD_MATCHBEGIN		19
+#define NMFIELD_METHOD_MATCHEND			20
+#define NMFIELD_METHOD_NOT_ARRAY		40
+#define NMFIELD_METHOD_OR_ARRAY			41
+#define NMFIELD_METHOD_AND_ARRAY		42
+
+/* Attribute Names (field tags) */
+#define NM_A_IP_ADDRESS					"nnmIPAddress"
+#define	NM_A_PORT						"nnmPort"
+#define	NM_A_FA_FOLDER					"NM_A_FA_FOLDER"
+#define	NM_A_FA_CONTACT					"NM_A_FA_CONTACT"
+#define	NM_A_FA_CONVERSATION			"NM_A_FA_CONVERSATION"
+#define	NM_A_FA_MESSAGE					"NM_A_FA_MESSAGE"
+#define	NM_A_FA_CONTACT_LIST			"NM_A_FA_CONTACT_LIST"
+#define	NM_A_FA_RESULTS					"NM_A_FA_RESULTS"
+#define	NM_A_FA_INFO_DISPLAY_ARRAY		"NM_A_FA_INFO_DISPLAY_ARRAY"
+#define	NM_A_FA_USER_DETAILS			"NM_A_FA_USER_DETAILS"
+#define	NM_A_SZ_OBJECT_ID				"NM_A_SZ_OBJECT_ID"
+#define	NM_A_SZ_PARENT_ID				"NM_A_SZ_PARENT_ID"
+#define	NM_A_SZ_SEQUENCE_NUMBER			"NM_A_SZ_SEQUENCE_NUMBER"
+#define	NM_A_SZ_TYPE					"NM_A_SZ_TYPE"
+#define	NM_A_SZ_STATUS					"NM_A_SZ_STATUS"
+#define	NM_A_SZ_STATUS_TEXT				"NM_A_SZ_STATUS_TEXT"
+#define	NM_A_SZ_DN						"NM_A_SZ_DN"
+#define	NM_A_SZ_DISPLAY_NAME			"NM_A_SZ_DISPLAY_NAME"
+#define	NM_A_SZ_USERID					"NM_A_SZ_USERID"
+#define NM_A_SZ_CREDENTIALS				"NM_A_SZ_CREDENTIALS"
+#define	NM_A_SZ_MESSAGE_BODY			"NM_A_SZ_MESSAGE_BODY"
+#define	NM_A_SZ_MESSAGE_TEXT			"NM_A_SZ_MESSAGE_TEXT"
+#define	NM_A_UD_MESSAGE_TYPE			"NM_A_UD_MESSAGE_TYPE"
+#define	NM_A_FA_PARTICIPANTS			"NM_A_FA_PARTICIPANTS"
+#define	NM_A_FA_INVITES					"NM_A_FA_INVITES"
+#define	NM_A_FA_EVENT					"NM_A_FA_EVENT"
+#define	NM_A_UD_COUNT					"NM_A_UD_COUNT"
+#define	NM_A_UD_DATE					"NM_A_UD_DATE"
+#define	NM_A_UD_EVENT					"NM_A_UD_EVENT"
+#define	NM_A_B_NO_CONTACTS				"NM_A_B_NO_CONTACTS"
+#define	NM_A_B_NO_CUSTOMS				"NM_A_B_NO_CUSTOMS"
+#define	NM_A_B_NO_PRIVACY				"NM_A_B_NO_PRIVACY"
+#define	NM_A_UW_STATUS					"NM_A_UW_STATUS"
+#define	NM_A_UD_OBJECT_ID				"NM_A_UD_OBJECT_ID"
+#define	NM_A_SZ_TRANSACTION_ID			"NM_A_SZ_TRANSACTION_ID"
+#define	NM_A_SZ_RESULT_CODE				"NM_A_SZ_RESULT_CODE"
+#define	NM_A_UD_BUILD					"NM_A_UD_BUILD"
+#define	NM_A_SZ_AUTH_ATTRIBUTE			"NM_A_SZ_AUTH_ATTRIBUTE"
+#define	NM_A_UD_KEEPALIVE				"NM_A_UD_KEEPALIVE"
+#define NM_A_SZ_USER_AGENT				"NM_A_SZ_USER_AGENT"
+
+#define NM_PROTOCOL_VERSION		 		2
+
+#define	NM_FIELD_TRUE					"1"
+#define	NM_FIELD_FALSE					"0"
+
+/**
+ * Count the number of fields 
+ *
+ * @param fields	Field array
+ *
+ * @return			The number of fields in the array.
+ *
+ */
+guint32 nm_count_fields(NMField * fields);
+
+/**
+ * Add a field to the field array. NOTE: field array that is passed
+ * in may be realloced so you should use the returned field array pointer
+ * not the passed in pointer after calling this function.
+ *
+ * @param fields	Field array
+ * @param tag		Tag for the new field
+ * @param size		Size of the field value (if type = binary)
+ * @param method	Field method (see method defines above)
+ * @param flags		Flags for new field
+ * @param value		The value of the field
+ * @param type		The type of the field value
+ *
+ * @return			Pointer to the updated field array
+ *
+ */
+NMField *nm_add_field(NMField * fields, char *tag, guint32 size, guint8 method,
+					  guint8 flags, guint32 value, guint8 type);
+
+/**
+ * Recursively free an array of fields and set pointer to NULL.
+ *
+ * @param fields	Pointer to a field array
+ *
+ */
+void nm_free_fields(NMField ** fields);
+
+/**
+ * Find first field with given tag in field array.
+ *
+ * Note: this will only work for 7-bit ascii tags (which is all that
+ * we use currently).
+ *
+ * @param tag		Tag to search for
+ * @param fields	Field array
+ *
+ * @return			The first matching field, or NULL if no fields match.
+ *
+ */
+NMField *nm_locate_field(char *tag, NMField * fields);
+
+/**
+ * Make a deep copy of a field array
+ *
+ * @param src		The array to copy
+ *
+ * @return			The new (copied) array, which must be freed.
+ *
+ */
+NMField *nm_copy_field_array(NMField * src);
+
+/**
+ * Remove a field and move other fields up to fill the gap
+ *
+ * @param field		The field to remove
+ *
+ */
+void nm_remove_field(NMField * field);
+
+/* Print a field array (for debugging purposes) */
+void nm_print_fields(NMField * fields);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmmessage.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,92 @@
+/*
+ * nmmessage.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include "nmmessage.h"
+
+struct _NMMessage
+{
+	NMConference *conference;
+	char *text;
+	gpointer data;
+	guint32 ref_count;
+};
+
+
+/** Message API **/
+
+NMMessage *
+nm_create_message(const char *text)
+{
+	NMMessage *msg = g_new0(NMMessage, 1);
+
+	if (text)
+		msg->text = g_strdup(text);
+
+	msg->ref_count = 1;
+	return msg;
+}
+
+void
+nm_release_message(NMMessage * msg)
+{
+	if (msg && (--(msg->ref_count) == 0)) {
+		if (msg->text)
+			g_free(msg->text);
+
+		if (msg->conference)
+			nm_release_conference(msg->conference);
+
+		g_free(msg);
+	}
+}
+
+const char *
+nm_message_get_text(NMMessage * msg)
+{
+	if (msg == NULL)
+		return NULL;
+
+	return msg->text;
+}
+
+void
+nm_message_set_conference(NMMessage * msg, NMConference * conf)
+{
+	if (msg == NULL || conf == NULL)
+		return;
+
+	/* Need to ref the conference first so that it doesn't
+	 * get released out from under us
+	 */
+	nm_conference_add_ref(conf);
+
+	msg->conference = conf;
+}
+
+NMConference *
+nm_message_get_conference(NMMessage * msg)
+{
+	if (msg == NULL)
+		return NULL;
+
+	return msg->conference;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmmessage.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,78 @@
+/*
+ * nmmessage.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef __NM_MESSAGE_H__
+#define __NM_MESSAGE_H__
+
+typedef struct _NMMessage NMMessage;
+
+#include "nmconference.h"
+
+/**
+ * Creates a new message. 
+ *
+ * The returned message should be released by calling
+ * nm_release_message
+ *
+ * @param	text	The message text
+ * @return			A newly allocated message	
+ */
+NMMessage *nm_create_message(const char *text);
+
+/**
+ * Releases a message.
+ *
+ * @param	msg		The message
+ */
+void nm_release_message(NMMessage * msg);
+
+/**
+ * Returns the message text
+ *
+ * @param	msg		The message
+ * @return 			The message text
+ */
+const char *nm_message_get_text(NMMessage * msg);
+
+/**
+ * Sets the conference object for a message
+ *
+ * @param	msg		The message
+ * @param	conf	The conference to associate with the message
+ * @return			RVALUE_OK on success
+ */
+void nm_message_set_conference(NMMessage * msg, NMConference * conf);
+
+/**
+ * Returns the conference object associated with the message
+ *
+ * Note: this does not increment the reference count for the 
+ * conference and the conference should NOT be released with 
+ * nm_release_conference. If the reference needs to be kept
+ * around nm_conference_add_ref should be called.
+ *
+ * @param	msg		The message
+ * @return			The conference associated with this message
+ */
+NMConference *nm_message_get_conference(NMMessage * msg);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmrequest.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,153 @@
+/*
+ * nmrequest.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include "nmrequest.h"
+
+struct _NMRequest
+{
+	int trans_id;
+	char *cmd;
+	int gmt;
+	gpointer data;
+	gpointer user_define;
+	nm_response_cb callback;
+	int ref_count;
+	NMERR_T ret_code;
+};
+
+
+NMRequest *
+nm_create_request(const char *cmd, int trans_id, int gmt)
+{
+	NMRequest *req;
+
+	if (cmd == NULL)
+		return NULL;
+
+	req  = g_new0(NMRequest, 1);
+	req->cmd = g_strdup(cmd);
+	req->trans_id = trans_id;
+	req->gmt = gmt;
+	req->ref_count = 1;
+
+	return req;
+}
+
+void
+nm_release_request(NMRequest * req)
+{
+	if (req && (--req->ref_count == 0)) {
+		if (req->cmd)
+			g_free(req->cmd);
+		g_free(req);
+	}
+}
+
+void
+nm_request_add_ref(NMRequest * req)
+{
+	if (req)
+		req->ref_count++;
+}
+
+void
+nm_request_set_callback(NMRequest * req, nm_response_cb callback)
+{
+	if (req)
+		req->callback = callback;
+}
+
+void
+nm_request_set_data(NMRequest * req, gpointer data)
+{
+	if (req)
+		req->data = data;
+}
+
+void
+nm_request_set_user_define(NMRequest * req, gpointer user_define)
+{
+	if (req)
+		req->user_define = user_define;
+}
+
+int
+nm_request_get_trans_id(NMRequest * req)
+{
+	if (req)
+		return req->trans_id;
+	else
+		return -1;
+}
+
+const char *
+nm_request_get_cmd(NMRequest * req)
+{
+	if (req == NULL)
+		return NULL;
+
+	return req->cmd;
+}
+
+gpointer
+nm_request_get_data(NMRequest * req)
+{
+	if (req == NULL)
+		return NULL;
+
+	return req->data;
+}
+
+gpointer
+nm_request_get_user_define(NMRequest * req)
+{
+	if (req == NULL)
+		return NULL;
+
+	return req->user_define;
+}
+
+nm_response_cb
+nm_request_get_callback(NMRequest * req)
+{
+	if (req == NULL)
+		return NULL;
+
+	return req->callback;
+}
+
+
+void
+nm_request_set_ret_code(NMRequest * req, NMERR_T rc)
+{
+	if (req)
+		req->ret_code = rc;
+}
+
+NMERR_T
+nm_request_get_ret_code(NMRequest * req)
+{
+	if (req)
+		return req->ret_code;
+	else
+		return (NMERR_T) - 1;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmrequest.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,151 @@
+/*
+ * nmrequest.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef __NM_REQUEST_H__
+#define __NM_REQUEST_H__
+
+typedef struct _NMRequest NMRequest;
+
+#include "nmuser.h"
+
+/** 
+ *	Create a new request object. Object must be release with nm_release_object.
+ *
+ *	@param	cmd				The request command string (e.g. "login")
+ *	@param	trans_id		The request transaction id
+ *	@param	gmt				The time in seconds that the request was created
+ *
+ *	@return The new request object
+ */
+NMRequest *nm_create_request(const char *cmd, int trans_id, int gmt);
+
+/** 
+ *	Release a request object.
+ *
+ *	@param	req		The request to release
+ */
+void nm_release_request(NMRequest * req);
+
+/** 
+ *  Add a new reference to this object. This reference must be released by
+ *  a call to nm_release_object.
+ *
+ *	@param	req				The request object
+ */
+void nm_request_add_ref(NMRequest * req);
+
+/** 
+ *	Set the response callback for this request object. This is the callback
+ *  that will be made when we get a response from the server.
+ *
+ *	@param	req			The request object
+ *	@param	callback	The response callback
+ *
+ */
+void nm_request_set_callback(NMRequest * req, nm_response_cb callback);
+
+/** 
+ *	Set the response data. This will be set differently depending on 
+ *  the request type (for example to nm_send_get_details will set this
+ *  to be the newly create NMUserRecord object).
+ *
+ *	@param	req			The request object
+ *	@param	data		Pointer to some data
+ *
+ */
+void nm_request_set_data(NMRequest * req, gpointer data);
+
+/** 
+ *	Set the user defined data. This is the data that the client
+ *  passes to the various nm_send_* functions. We will pass it
+ *  back when we make the callback.
+ *
+ *	@param	req				The request object
+ *	@param	user_define		Pointer to some data	
+ *
+ */
+void nm_request_set_user_define(NMRequest * req, gpointer user_define);
+
+/** 
+ *	Set the return code. This is the return code that we recieved in 
+ *  the server response fields.
+ *
+ *	@param	req			The request object
+ *	@param	rc			The return code to set
+ */
+void nm_request_set_ret_code(NMRequest * req, NMERR_T rc);
+
+/** 
+ *	Get the transaction id for this request.
+ *
+ *	@param	req			The request object
+ *
+ * 	@return	The transaction id.
+ */
+int nm_request_get_trans_id(NMRequest * req);
+
+/** 
+ *	Get the command (request type) for this request.
+ *
+ *	@param	req			The request object
+ *
+ * 	@return	The request cmd
+ */
+const char *nm_request_get_cmd(NMRequest * req);
+
+/** 
+ *	Get the response data for this request
+ *
+ *	@param	req			The request object
+ *
+ * 	@return	The response data
+ */
+gpointer nm_request_get_data(NMRequest * req);
+
+/** 
+ *	Get the user defined data for this request
+ *
+ *	@param	req			The request object
+ *
+ * 	@return	The user defined data
+ */
+gpointer nm_request_get_user_define(NMRequest * req);
+
+/** 
+ *	Get the response callback for this request
+ *
+ *	@param	req			The request object
+ *
+ * 	@return	The response callback
+ */
+nm_response_cb nm_request_get_callback(NMRequest * req);
+
+/** 
+ *	Get the return code
+ *
+ *	@param	req			The request object
+ *
+ * 	@return	The return code (from the response fields)
+ */
+NMERR_T nm_request_get_ret_code(NMRequest * req);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmuser.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,1777 @@
+/*
+ * nmuser.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include <glib.h>
+#include <string.h>
+#include "nmfield.h"
+#include "nmuser.h"
+#include "nmconn.h"
+#include "nmcontact.h"
+#include "nmuserrecord.h"
+#include "util.h"
+
+/* This is the template that we wrap outgoing messages in, since the other 
+ * GW Messenger clients expect messages to be in RTF.
+ */
+#define RTF_TEMPLATE 	"{\\rtf1\\fbidis\\ansi\\ansicpg1252\\deff0\\deflang1033"\
+                        "{\\fonttbl{\\f0\\fswiss\\fprq2\\fcharset0 "\
+                        "Microsoft Sans Serif;}}\n{\\colortbl ;\\red0"\
+                        "\\green0\\blue0;}\n\\viewkind4\\uc1\\pard\\ltrpar"\
+                        "\\li50\\ri50\\cf1\\f0\\fs20 %s\\par\n}"
+
+static NMERR_T nm_process_response(NMUser * user);
+
+static void _update_contact_list(NMUser * user, NMField * fields);
+
+/**
+ * See header for comments on on "public" functions
+ */
+
+NMUser *
+nm_initialize_user(const char *name, const char *server_addr,
+				   int port, gpointer data, nm_event_cb event_callback)
+{
+	if (name == NULL || server_addr == NULL || event_callback == NULL)
+		return NULL;
+
+	NMUser *user = g_new0(NMUser, 1);
+
+	user->conn = g_new0(NMConn, 1);
+
+	user->contacts =
+		g_hash_table_new_full(g_str_hash, nm_utf8_str_equal,
+							  g_free, (GDestroyNotify) nm_release_contact);
+
+	user->user_records =
+		g_hash_table_new_full(g_str_hash, nm_utf8_str_equal, g_free,
+							  (GDestroyNotify) nm_release_user_record);
+
+	user->display_id_to_dn = g_hash_table_new_full(g_str_hash, nm_utf8_str_equal,
+												   g_free, g_free);
+
+	user->name = g_strdup(name);
+	user->conn->addr = g_strdup(server_addr);
+	user->conn->port = port;
+	user->evt_callback = event_callback;
+	user->client_data = data;
+
+	return user;
+}
+
+
+void
+nm_deinitialize_user(NMUser * user)
+{
+	NMConn *conn = user->conn;
+
+	g_free(conn->addr);
+	g_free(conn);
+
+	if (user->contacts) {
+		g_hash_table_destroy(user->contacts);
+	}
+
+	if (user->user_records) {
+		g_hash_table_destroy(user->user_records);
+	}
+
+	if (user->display_id_to_dn) {
+		g_hash_table_destroy(user->display_id_to_dn);
+	}
+
+	if (user->name) {
+		g_free(user->name);
+	}
+
+	if (user->user_record) {
+		nm_release_user_record(user->user_record);
+	}
+
+	nm_conference_list_free(user);
+	nm_destroy_contact_list(user);
+
+	g_free(user);
+}
+
+NMERR_T
+nm_send_login(NMUser * user, const char *pwd, const char *my_addr,
+			  const char *user_agent, nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || pwd == NULL || user_agent == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	fields = nm_add_field(fields, NM_A_SZ_USERID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup(user->name), NMFIELD_TYPE_UTF8);
+	
+	fields = nm_add_field(fields, NM_A_SZ_CREDENTIALS, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup(pwd), NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_SZ_USER_AGENT, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup(user_agent), NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_UD_BUILD, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) NM_PROTOCOL_VERSION,
+						  NMFIELD_TYPE_UDWORD);
+	if (my_addr) {
+		fields = nm_add_field(fields, NM_A_IP_ADDRESS, 0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup(my_addr), NMFIELD_TYPE_UTF8);
+	}
+
+	/* Send the login */
+	rc = nm_send_request(user->conn, "login", fields, &req);
+	if (rc == NM_OK && req != NULL) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (fields) {
+		nm_free_fields(&fields);
+	}
+
+	if (req) {
+		nm_release_request(req);
+	}
+
+	return rc;
+}
+
+NMERR_T
+nm_send_set_status(NMUser * user, int status, const char *text,
+				   const char *auto_resp, nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Add the status */
+	fields = nm_add_field(fields, NM_A_SZ_STATUS, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup_printf("%d", status),
+						  NMFIELD_TYPE_UTF8);
+
+	/* Add the status text and auto reply text if there is any */
+	if (text) {
+		fields = nm_add_field(fields, NM_A_SZ_STATUS_TEXT,
+							  0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup(text), NMFIELD_TYPE_UTF8);
+	}
+
+	if (auto_resp) {
+		fields = nm_add_field(fields, NM_A_SZ_MESSAGE_BODY, 0,
+							  NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup(auto_resp), NMFIELD_TYPE_UTF8);
+	}
+
+	rc = nm_send_request(user->conn, "setstatus", fields, &req);
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (fields) {
+		nm_free_fields(&fields);
+	}
+
+	if (req) {
+		nm_release_request(req);
+	}
+
+	return rc;
+}
+
+NMERR_T
+nm_send_get_details(NMUser * user, const char *name,
+					nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || name == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Add in DN or display id */
+	if (strstr("=", name)) {
+		fields = nm_add_field(fields, NM_A_SZ_DN, 0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup(name), NMFIELD_TYPE_DN);
+	} else {
+
+		const char *dn = nm_lookup_dn(user, name);
+
+		if (dn) {
+			fields = nm_add_field(fields, NM_A_SZ_DN, 0, NMFIELD_METHOD_VALID, 0,
+								  (guint32) g_strdup(name), NMFIELD_TYPE_DN);
+		} else {
+			fields =
+				nm_add_field(fields, NM_A_SZ_USERID, 0, NMFIELD_METHOD_VALID, 0,
+							 (guint32) g_strdup(name), NMFIELD_TYPE_UTF8);
+		}
+
+	}
+
+	rc = nm_send_request(user->conn, "getdetails", fields, &req);
+	if (rc == NM_OK) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	if (req)
+		nm_release_request(req);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_create_conference(NMUser * user, NMConference * conference,
+						  nm_response_cb callback, gpointer message)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMField *tmp = NULL;
+	NMField *field = NULL;
+	NMRequest *req = NULL;
+	int count, i;
+
+	if (user == NULL || conference == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Add in a blank guid */
+	tmp = nm_add_field(tmp, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+					   (guint32) g_strdup(BLANK_GUID), NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_FA_CONVERSATION, 0,
+						  NMFIELD_METHOD_VALID, 0, (guint32) tmp,
+						  NMFIELD_TYPE_ARRAY);
+	tmp = NULL;
+
+	/* Add participants in */
+	count = nm_conference_get_participant_count(conference);
+	for (i = 0; i < count; i++) {
+		NMUserRecord *user_record = nm_conference_get_participant(conference, i);
+
+		if (user_record) {
+			fields = nm_add_field(fields, NM_A_SZ_DN,
+								  0, NMFIELD_METHOD_VALID, 0,
+								  (guint32)
+								  g_strdup(nm_user_record_get_dn(user_record)),
+								  NMFIELD_TYPE_DN);
+		}
+	}
+
+	/* Add our user in */
+	field = nm_locate_field(NM_A_SZ_DN, user->fields);
+	if (field) {
+		fields = nm_add_field(fields, NM_A_SZ_DN,
+							  0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup((char *) field->value),
+							  NMFIELD_TYPE_DN);
+	}
+
+	rc = nm_send_request(user->conn, "createconf", fields, &req);
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, conference);
+		nm_request_set_user_define(req, message);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (req)
+		nm_release_request(req);
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_leave_conference(NMUser * user, NMConference * conference,
+						 nm_response_cb callback, gpointer message)
+{
+
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMField *tmp = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || conference == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Add in the conference guid */
+	tmp = nm_add_field(tmp, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+					   (guint32) g_strdup(nm_conference_get_guid(conference)),
+					   NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_FA_CONVERSATION, 0,
+						  NMFIELD_METHOD_VALID, 0, (guint32) tmp,
+						  NMFIELD_TYPE_ARRAY);
+	tmp = NULL;
+	
+	/* Send the request to the server */
+	rc = nm_send_request(user->conn, "leaveconf", fields, &req);
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, conference);
+		nm_request_set_user_define(req, message);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (req)
+		nm_release_request(req);
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_join_conference(NMUser * user, NMConference * conference,
+						nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL, *tmp = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || conference == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Add in the conference guid */
+	tmp = nm_add_field(tmp, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+					   (guint32) g_strdup(nm_conference_get_guid(conference)),
+					   NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_FA_CONVERSATION, 0,
+						  NMFIELD_METHOD_VALID, 0, (guint32) tmp,
+						  NMFIELD_TYPE_ARRAY);
+	tmp = NULL;
+
+	/* Send the request to the server */
+	rc = nm_send_request(user->conn, "joinconf", fields, &req);
+
+	/* Set up the request object so that we know what to do
+	 * when we get a response
+	 */
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, conference);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (req)
+		nm_release_request(req);
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_reject_conference(NMUser * user, NMConference * conference,
+						  nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMField *tmp = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || conference == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Add in the conference guid */
+	tmp = nm_add_field(tmp, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+					   (guint32) g_strdup(nm_conference_get_guid(conference)),
+					   NMFIELD_TYPE_UTF8);
+
+	fields = nm_add_field(fields, NM_A_FA_CONVERSATION, 0,
+						  NMFIELD_METHOD_VALID, 0, (guint32) tmp,
+						  NMFIELD_TYPE_ARRAY);
+	tmp = NULL;
+
+	/* Send the request to the server */
+	rc = nm_send_request(user->conn, "rejectconf", fields, &req);
+
+	/* Set up the request object so that we know what to do
+	 * when we get a response
+	 */
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, conference);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (req)
+		nm_release_request(req);
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_message(NMUser * user, NMMessage * message, nm_response_cb callback)
+{
+	NMERR_T rc = NM_OK;
+	const char *text;
+	NMField *fields = NULL, *tmp = NULL;
+	NMRequest *req = NULL;
+	NMConference *conf;
+	NMUserRecord *user_record;
+	int count, i;
+
+	if (user == NULL || message == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	conf = nm_message_get_conference(message);
+	if (!nm_conference_is_instantiated(conf)) {
+		rc = NMERR_CONFERENCE_NOT_INSTANTIATED;
+	} else {
+
+		tmp = nm_add_field(tmp, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						   (guint32) g_strdup(nm_conference_get_guid(conf)),
+						   NMFIELD_TYPE_UTF8);
+
+		fields =
+			nm_add_field(fields, NM_A_FA_CONVERSATION, 0, NMFIELD_METHOD_VALID, 0,
+						 (guint32) tmp, NMFIELD_TYPE_ARRAY);
+		tmp = NULL;
+
+		/* Add RTF and plain text versions of the message */
+		text = nm_message_get_text(message);
+
+		tmp = nm_add_field(tmp, NM_A_SZ_MESSAGE_BODY, 0, NMFIELD_METHOD_VALID, 0,
+						   (guint32) g_strdup_printf(RTF_TEMPLATE, text),
+						   NMFIELD_TYPE_UTF8);
+
+		tmp = nm_add_field(tmp, NM_A_UD_MESSAGE_TYPE, 0, NMFIELD_METHOD_VALID, 0,
+						   (guint32) 0, NMFIELD_TYPE_UDWORD);
+
+		tmp = nm_add_field(tmp, NM_A_SZ_MESSAGE_TEXT, 0, NMFIELD_METHOD_VALID, 0,
+						   (guint32) g_strdup(text), NMFIELD_TYPE_UTF8);
+
+		fields = nm_add_field(fields, NM_A_FA_MESSAGE, 0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) tmp, NMFIELD_TYPE_ARRAY);
+		tmp = NULL;
+
+		/* Add participants */
+		count = nm_conference_get_participant_count(conf);
+		for (i = 0; i < count; i++) {
+			user_record = nm_conference_get_participant(conf, i);
+			if (user_record) {
+				fields =
+					nm_add_field(fields, NM_A_SZ_DN, 0, NMFIELD_METHOD_VALID, 0,
+								 (guint32)
+								 g_strdup(nm_user_record_get_dn(user_record)),
+								 NMFIELD_TYPE_DN);
+			}
+		}
+
+		/* Send the request */
+		rc = nm_send_request(user->conn, "sendmessage", fields, &req);
+		if (rc == NM_OK && req) {
+			nm_request_set_callback(req, callback);
+			nm_conn_add_request_item(user->conn, req);
+		}
+	}
+
+	if (fields) {
+		nm_free_fields(&fields);
+	}
+
+	if (req) {
+		nm_release_request(req);
+	}
+
+	return rc;
+}
+
+NMERR_T
+nm_send_typing(NMUser * user, NMConference * conf,
+			   gboolean typing, nm_response_cb callback)
+{
+	NMERR_T rc = NM_OK;
+	char *str = NULL;
+	NMField *fields = NULL, *tmp = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || conf == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	if (!nm_conference_is_instantiated(conf)) {
+		rc = NMERR_CONFERENCE_NOT_INSTANTIATED;
+	} else {
+		/* Add the conference GUID */
+		tmp = nm_add_field(tmp, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						   (guint32) g_strdup(nm_conference_get_guid(conf)),
+						   NMFIELD_TYPE_UTF8);
+
+		/* Add typing type */
+		str = g_strdup_printf("%d",
+							  (typing ? NMEVT_USER_TYPING :
+							   NMEVT_USER_NOT_TYPING));
+
+		tmp = nm_add_field(tmp, NM_A_SZ_TYPE, 0, NMFIELD_METHOD_VALID, 0,
+						   (guint32) str, NMFIELD_TYPE_UTF8);
+
+		fields =
+			nm_add_field(fields, NM_A_FA_CONVERSATION, 0, NMFIELD_METHOD_VALID, 0,
+						 (guint32) tmp, NMFIELD_TYPE_ARRAY);
+		tmp = NULL;
+
+		rc = nm_send_request(user->conn, "sendtyping", fields, &req);
+		if (rc == NM_OK && req) {
+			nm_request_set_callback(req, callback);
+			nm_conn_add_request_item(user->conn, req);
+		}
+	}
+
+	if (req)
+		nm_release_request(req);
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_create_contact(NMUser * user, NMFolder * folder,
+					   NMContact * contact, nm_response_cb callback,
+					   gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMRequest *req = NULL;
+	const char *name = NULL;
+	const char *display_name = NULL;
+
+	if (user == NULL || folder == NULL || contact == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	/* Add parent ID */
+	fields = nm_add_field(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup_printf("%d",
+													nm_folder_get_id(folder)),
+						  NMFIELD_TYPE_UTF8);
+
+	/* Check to see if userid is current user and return an error? */
+
+	/* Check to see if contact already exists and return an error? */
+
+	/* Add userid or dn */
+	name = nm_contact_get_dn(contact);
+	if (name == NULL)
+		return NMERR_BAD_PARM;
+
+	if (strstr("=", name)) {
+		fields = nm_add_field(fields, NM_A_SZ_DN, 0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup(name), NMFIELD_TYPE_DN);
+	} else {
+		fields = nm_add_field(fields, NM_A_SZ_USERID, 0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup(name), NMFIELD_TYPE_UTF8);
+	}
+
+	/* Add display name */
+	display_name = nm_contact_get_display_name(contact);
+	if (display_name)
+		fields = nm_add_field(fields, NM_A_SZ_DISPLAY_NAME, 0, NMFIELD_METHOD_VALID, 0,
+							  (guint32) g_strdup(display_name), NMFIELD_TYPE_UTF8);
+		
+	/* Dispatch the request */
+	rc = nm_send_request(user->conn, "createcontact", fields, &req);
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, contact);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	if (req)
+		nm_release_request(req);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_remove_contact(NMUser * user, NMFolder * folder,
+					   NMContact * contact, nm_response_cb callback,
+					   gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || folder == NULL || contact == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	/* Add parent id */
+	fields = nm_add_field(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup_printf("%d",
+													nm_folder_get_id(folder)),
+						  NMFIELD_TYPE_UTF8);
+
+	/* Add object id */
+	fields = nm_add_field(fields, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup_printf("%d",
+													nm_contact_get_id(contact)),
+						  NMFIELD_TYPE_UTF8);
+
+	/* Dispatch the request */
+	rc = nm_send_request(user->conn, "deletecontact", fields, &req);
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, contact);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	if (req)
+		nm_release_request(req);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_create_folder(NMUser * user, const char *name,
+					  nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || name == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	/* Add parent ID */
+	fields = nm_add_field(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup("0"), NMFIELD_TYPE_UTF8);
+
+	/* Add name of the folder to add */
+	fields =
+		nm_add_field(fields, NM_A_SZ_DISPLAY_NAME, 0, NMFIELD_METHOD_VALID, 0,
+					 (guint32) g_strdup(name), NMFIELD_TYPE_UTF8);
+
+	/* Add sequence, for now just put it at the bottom */
+	fields =
+		nm_add_field(fields, NM_A_SZ_SEQUENCE_NUMBER, 0, NMFIELD_METHOD_VALID, 0,
+					 (guint32) g_strdup("-1"), NMFIELD_TYPE_UTF8);
+
+	/* Dispatch the request */
+	rc = nm_send_request(user->conn, "createfolder", fields, &req);
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, g_strdup(name));
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	if (req)
+		nm_release_request(req);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_remove_folder(NMUser * user, NMFolder * folder,
+					  nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || folder == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	/* Add the object id */
+	fields = nm_add_field(fields, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup_printf("%d", nm_folder_get_id(folder)),
+						  NMFIELD_TYPE_UTF8);
+
+	/* Dispatch the request */
+	rc = nm_send_request(user->conn, "deletecontact", fields, &req);
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, folder);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	if (req)
+		nm_release_request(req);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_get_status(NMUser * user, NMUserRecord * user_record,
+				   nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMRequest *req = NULL;
+	const char *dn;
+
+	if (user == NULL || user_record == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Add DN to field list */
+	dn = nm_user_record_get_dn(user_record);
+	if (dn == NULL)
+		return (NMERR_T) -1;
+
+	fields = nm_add_field(fields, NM_A_SZ_DN, 0, NMFIELD_METHOD_VALID, 0,
+						  (guint32) g_strdup(dn), NMFIELD_TYPE_UTF8);
+
+	/* Dispatch the request */
+	rc = nm_send_request(user->conn, "getstatus", fields, &req);
+	if (rc == NM_OK && req) {
+		nm_request_set_callback(req, callback);
+		nm_request_set_data(req, user_record);
+		nm_request_set_user_define(req, data);
+		nm_conn_add_request_item(user->conn, req);
+	}
+
+	if (fields)
+		nm_free_fields(&fields);
+
+	if (req)
+		nm_release_request(req);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_rename_contact(NMUser * user, NMContact * contact,
+					   const char *new_name, nm_response_cb callback,
+					   gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *field = NULL, *fields = NULL, *list = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || contact == NULL || new_name == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Create field list for current contact */
+	field = nm_contact_to_fields(contact);
+	if (field) {
+
+		fields =
+			nm_add_field(fields, NM_A_FA_CONTACT, 0, NMFIELD_METHOD_DELETE, 0,
+						 (guint32) field, NMFIELD_TYPE_ARRAY);
+		field = NULL;
+
+		/* Update the contacts display name locally */
+		nm_contact_set_display_name(contact, new_name);
+
+		/* Create field list for updated contact */
+		field = nm_contact_to_fields(contact);
+		if (field) {
+			fields =
+				nm_add_field(fields, NM_A_FA_CONTACT, 0, NMFIELD_METHOD_ADD, 0,
+							 (guint32) field, NMFIELD_TYPE_ARRAY);
+			field = NULL;
+
+			/* Package it up */
+			list =
+				nm_add_field(list, NM_A_FA_CONTACT_LIST, 0, NMFIELD_METHOD_VALID,
+							 0, (guint32) fields, NMFIELD_TYPE_ARRAY);
+			fields = NULL;
+
+			rc = nm_send_request(user->conn, "updateitem", list, &req);
+			if (rc == NM_OK && req) {
+				nm_request_set_callback(req, callback);
+				nm_request_set_data(req, contact);
+				nm_request_set_user_define(req, data);
+				nm_conn_add_request_item(user->conn, req);
+			}
+		}
+	}
+
+	if (list)
+		nm_free_fields(&list);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_rename_folder(NMUser * user, NMFolder * folder, const char *new_name,
+					  nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *field = NULL, *fields = NULL, *list = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || folder == NULL || new_name == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Make sure folder does not already exist!? */
+	if (nm_find_folder(user, new_name))
+		return NMERR_FOLDER_EXISTS;
+
+	/* Create field list for current folder */
+	field = nm_folder_to_fields(folder);
+	if (field) {
+
+		fields = nm_add_field(fields, NM_A_FA_FOLDER, 0, NMFIELD_METHOD_DELETE, 0,
+							  (guint32) field, NMFIELD_TYPE_ARRAY);
+		field = NULL;
+
+		/* Update the folders display name locally */
+		nm_folder_set_name(folder, new_name);
+
+		/* Create field list for updated folder */
+		field = nm_folder_to_fields(folder);
+		if (field) {
+			fields =
+				nm_add_field(fields, NM_A_FA_FOLDER, 0, NMFIELD_METHOD_ADD, 0,
+							 (guint32) field, NMFIELD_TYPE_ARRAY);
+			field = NULL;
+
+			/* Package it up */
+			list =
+				nm_add_field(list, NM_A_FA_CONTACT_LIST, 0, NMFIELD_METHOD_VALID,
+							 0, (guint32) fields, NMFIELD_TYPE_ARRAY);
+			fields = NULL;
+
+			rc = nm_send_request(user->conn, "updateitem", list, &req);
+			if (rc == NM_OK && req) {
+				nm_request_set_callback(req, callback);
+				nm_request_set_data(req, folder);
+				nm_request_set_user_define(req, data);
+				nm_conn_add_request_item(user->conn, req);
+			}
+		}
+	}
+
+	if (list)
+		nm_free_fields(&list);
+
+	return rc;
+}
+
+NMERR_T
+nm_send_move_contact(NMUser * user, NMContact * contact, NMFolder * folder,
+					 nm_response_cb callback, gpointer data)
+{
+	NMERR_T rc = NM_OK;
+	NMField *field = NULL, *fields = NULL, *list = NULL;
+	NMRequest *req = NULL;
+
+	if (user == NULL || contact == NULL || folder == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Create field list for the contact */
+	field = nm_contact_to_fields(contact);
+	if (field) {
+
+		fields =
+			nm_add_field(fields, NM_A_FA_CONTACT, 0, NMFIELD_METHOD_DELETE, 0,
+						 (guint32) field, NMFIELD_TYPE_ARRAY);
+		field = NULL;
+
+		/* Wrap the contact up and add it to the request field list */
+		list =
+			nm_add_field(list, NM_A_FA_CONTACT_LIST, 0, NMFIELD_METHOD_VALID, 0,
+						 (guint32) fields, NMFIELD_TYPE_ARRAY);
+		fields = NULL;
+
+		/* Add sequence number */
+		list =
+			nm_add_field(list, NM_A_SZ_SEQUENCE_NUMBER, 0, NMFIELD_METHOD_VALID,
+						 0, (guint32) g_strdup("-1"), NMFIELD_TYPE_UTF8);
+
+		/* Add parent ID */
+		list = nm_add_field(list, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
+							(guint32) g_strdup_printf("%d",
+													  nm_folder_get_id(folder)),
+							NMFIELD_TYPE_UTF8);
+
+		/* Dispatch the request */
+		rc = nm_send_request(user->conn, "movecontact", list, &req);
+		if (rc == NM_OK && req) {
+			nm_request_set_callback(req, callback);
+			nm_request_set_data(req, contact);
+			nm_request_set_user_define(req, data);
+			nm_conn_add_request_item(user->conn, req);
+
+		}
+	}
+
+	if (list)
+		nm_free_fields(&list);
+
+	return rc;
+}
+
+
+NMERR_T
+nm_process_new_data(NMUser * user)
+{
+	NMConn *conn;
+	NMERR_T rc = NM_OK;
+	int ret;
+	guint32 val;
+
+	if (user == NULL)
+		return NMERR_BAD_PARM;
+
+	conn = user->conn;
+
+	/* Check to see if this is an event or a response */
+	ret = nm_tcp_read(conn, (char *) &val, sizeof(val));
+	if (ret == sizeof(val)) {
+
+		if (strncmp((char *) &val, "HTTP", strlen("HTTP")) == 0)
+			rc = nm_process_response(user);
+		else
+			rc = nm_process_event(user, val);
+
+	} else {
+		rc = NMERR_PROTOCOL;
+	}
+
+	return rc;
+}
+
+NMConference *
+nm_find_conversation(NMUser * user, const char *who)
+{
+	NMConference *conference = NULL;
+	NMConference *tmp;
+	GSList *cnode;
+
+	if (user && user->conferences) {
+		for (cnode = user->conferences; cnode; cnode = cnode->next) {
+			tmp = cnode->data;
+			if (nm_conference_get_participant_count(tmp) == 1) {
+				NMUserRecord *ur = nm_conference_get_participant(tmp, 0);
+
+				if (ur) {
+					if (nm_utf8_str_equal(nm_user_record_get_dn(ur), who)) {
+						conference = tmp;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	return conference;
+}
+
+void
+nm_conference_list_add(NMUser * user, NMConference * conf)
+{
+	if (user == NULL || conf == NULL)
+		return;
+
+	nm_conference_add_ref(conf);
+	user->conferences = g_slist_append(user->conferences, conf);
+}
+
+void
+nm_conference_list_remove(NMUser * user, NMConference * conf)
+{
+	if (user == NULL || conf == NULL)
+		return;
+
+	if (g_slist_find(user->conferences, conf)) {
+		user->conferences = g_slist_remove(user->conferences, conf);
+		nm_release_conference(conf);
+	}
+}
+
+void
+nm_conference_list_free(NMUser * user)
+{
+	GSList *cnode;
+	NMConference *conference;
+
+	if (user == NULL)
+		return;
+
+	if (user->conferences) {
+		for (cnode = user->conferences; cnode; cnode = cnode->next) {
+			conference = cnode->data;
+			cnode->data = NULL;
+			nm_release_conference(conference);
+		}
+
+		g_slist_free(user->conferences);
+		user->conferences = NULL;
+	}
+}
+
+NMConference *
+nm_conference_list_find(NMUser * user, const char *guid)
+{
+	GSList *cnode;
+	NMConference *conference = NULL, *tmp;
+
+	if (user == NULL || guid == NULL)
+		return NULL;
+
+	if (user->conferences) {
+		for (cnode = user->conferences; cnode; cnode = cnode->next) {
+			tmp = cnode->data;
+			if (nm_are_guids_equal(nm_conference_get_guid(tmp), guid)) {
+				conference = tmp;
+				break;
+			}
+		}
+	}
+
+	return conference;
+}
+
+gboolean
+nm_are_guids_equal(const char *guid1, const char *guid2)
+{
+	if (guid1 == NULL || guid2 == NULL)
+		return FALSE;
+
+	return (strncmp(guid1, guid2, CONF_GUID_END) == 0);
+}
+
+void
+nm_user_add_contact(NMUser * user, NMContact * contact)
+{
+	if (user == NULL || contact == NULL)
+		return;
+
+	nm_contact_add_ref(contact);
+
+	g_hash_table_insert(user->contacts,
+						g_utf8_strdown(nm_contact_get_dn(contact), -1), contact);
+}
+
+void
+nm_user_add_user_record(NMUser * user, NMUserRecord * user_record)
+{
+	nm_user_record_add_ref(user_record);
+
+	g_hash_table_insert(user->user_records,
+						g_utf8_strdown(nm_user_record_get_dn(user_record), -1),
+						user_record);
+
+	g_hash_table_insert(user->display_id_to_dn,
+						g_utf8_strdown(nm_user_record_get_display_id(user_record),
+									   -1),
+						g_utf8_strdown(nm_user_record_get_dn(user_record), -1));
+
+}
+
+nm_event_cb
+nm_user_get_event_callback(NMUser * user)
+{
+	if (user == NULL)
+		return NULL;
+
+	return user->evt_callback;
+}
+
+NMConn *
+nm_user_get_conn(NMUser * user)
+{
+	if (user == NULL)
+		return NULL;
+
+	return user->conn;
+}
+
+NMERR_T
+nm_create_contact_list(NMUser * user)
+{
+	NMERR_T rc = NM_OK;
+	NMField *locate = NULL;
+
+	if (user == NULL || user->fields == NULL) {
+		return NMERR_BAD_PARM;
+	}
+
+	/* Create the root folder */
+	user->root_folder = nm_create_folder("");
+
+	/* Find the contact list in the login fields */
+	locate = nm_locate_field(NM_A_FA_CONTACT_LIST, user->fields);
+	if (locate != NULL) {
+
+		/* Add the folders and then the contacts */
+		nm_folder_add_contacts_and_folders(user, user->root_folder,
+										   (NMField *) (locate->value));
+
+	}
+
+	return rc;
+}
+
+void
+nm_destroy_contact_list(NMUser * user)
+{
+	if (user == NULL)
+		return;
+
+	if (user->root_folder) {
+		nm_release_folder(user->root_folder);
+		user->root_folder = NULL;
+	}
+}
+
+NMFolder *
+nm_get_root_folder(NMUser * user)
+{
+	if (user == NULL)
+		return NULL;
+
+	if (user->root_folder == NULL)
+		nm_create_contact_list(user);
+
+	return user->root_folder;
+}
+
+NMContact *
+nm_find_contact(NMUser * user, const char *name)
+{
+	char *str;
+	const char *dn = NULL;
+	NMContact *contact = NULL;
+
+	if (user == NULL || name == NULL)
+		return NULL;
+
+	str = g_utf8_strdown(name, -1);
+	if (strstr(str, "=")) {
+		dn = str;
+	} else {
+		/* Assume that we have a display id instead of a dn */
+		dn = (const char *) g_hash_table_lookup(user->display_id_to_dn, str);
+	}
+
+	/* Find contact object in reference table */
+	if (dn) {
+		contact = (NMContact *) g_hash_table_lookup(user->contacts, dn);
+	}
+
+	g_free(str);
+	return contact;
+}
+
+GList *
+nm_find_contacts(NMUser * user, const char *dn)
+{
+	guint32 i, cnt;
+	NMFolder *folder;
+	NMContact *contact;
+	GList *contacts = NULL;
+
+	if (user == NULL || dn == NULL)
+		return NULL;
+
+	/* Check for contact at the root */
+	contact = nm_folder_find_contact(user->root_folder, dn);
+	if (contact) {
+		contacts = g_list_append(contacts, contact);
+		contact = NULL;
+	}
+
+	/* Check for contact in each subfolder */
+	cnt = nm_folder_get_subfolder_count(user->root_folder);
+	for (i = 0; i < cnt; i++) {
+		folder = nm_folder_get_subfolder(user->root_folder, i);
+		contact = nm_folder_find_contact(folder, dn);
+		if (contact) {
+			contacts = g_list_append(contacts, contact);
+			contact = NULL;
+		}
+	}
+
+	return contacts;
+}
+
+NMUserRecord *
+nm_find_user_record(NMUser * user, const char *name)
+{
+	char *str = NULL;
+	const char *dn = NULL;
+	NMUserRecord *user_record = NULL;
+
+	if (user == NULL || name == NULL)
+		return NULL;
+
+	str = g_utf8_strdown(name, -1);
+	if (strstr(str, "=")) {
+		dn = str;
+	} else {
+		/* Assume that we have a display id instead of a dn */
+		dn = (const char *) g_hash_table_lookup(user->display_id_to_dn, str);
+	}
+
+	/* Find user record in reference table */
+	if (dn) {
+		user_record =
+			(NMUserRecord *) g_hash_table_lookup(user->user_records, dn);
+	}
+
+	g_free(str);
+	return user_record;
+}
+
+const char *
+nm_lookup_dn(NMUser * user, const char *display_id)
+{
+	if (user == NULL || display_id == NULL)
+		return NULL;
+
+	return (const char *) g_hash_table_lookup(user->display_id_to_dn,
+											  g_utf8_strdown(display_id, -1));
+}
+
+NMFolder *
+nm_find_folder(NMUser * user, const char *name)
+{
+	NMFolder *folder = NULL, *temp;
+	int i, num_folders;
+	const char *tname = NULL;
+
+	if (user == NULL || name == NULL)
+		return NULL;
+
+	if (*name == '\0')
+		return user->root_folder;
+
+	num_folders = nm_folder_get_subfolder_count(user->root_folder);
+	for (i = 0; i < num_folders; i++) {
+		temp = nm_folder_get_subfolder(user->root_folder, i);
+		tname = nm_folder_get_name(temp);
+
+		if (tname && (strcmp(tname, name) == 0)) {
+			folder = temp;
+			break;
+		}
+	}
+
+	return folder;
+}
+
+NMFolder *
+nm_find_folder_by_id(NMUser * user, int object_id)
+{
+	NMFolder *folder = NULL, *temp;
+	int i, num_folders;
+
+	if (user == NULL)
+		return NULL;
+
+	if (object_id == 0)
+		return user->root_folder;
+
+	num_folders = nm_folder_get_subfolder_count(user->root_folder);
+	for (i = 0; i < num_folders; i++) {
+		temp = nm_folder_get_subfolder(user->root_folder, i);
+		if (nm_folder_get_id(temp) == object_id) {
+			folder = temp;
+			break;
+		}
+	}
+
+	return folder;
+}
+
+static void
+_handle_multiple_get_details_joinconf_cb(NMUser * user, NMERR_T ret_code,
+										 gpointer resp_data, gpointer user_data)
+{
+	NMRequest *request = user_data;
+	NMUserRecord *user_record = resp_data;
+	NMConference *conference;
+	GSList *list, *node;
+
+	if (user == NULL || resp_data == NULL || user_data == NULL)
+		return;
+
+	conference = nm_request_get_data(request);
+	list = nm_request_get_user_define(request);
+
+	if (ret_code == 0 && conference && list) {
+
+		/* Add the user to the conference */
+		nm_conference_add_participant(conference, user_record);
+
+		/* Find the user in the list and remove it */
+		for (node = list; node; node = node->next) {
+			if (nm_utf8_str_equal(nm_user_record_get_dn(user_record),
+								  (const char *) node->data)) {
+				list = g_slist_remove(list, node->data);
+				nm_request_set_user_define(request, list);
+				g_free(node->data);
+				break;
+			}
+		}
+
+		/* Time to callback? */
+		if (g_slist_length(list) == 0) {
+			nm_response_cb cb = nm_request_get_callback(request);
+
+			if (cb) {
+				cb(user, 0, conference, conference);
+			}
+			g_slist_free(list);
+			nm_release_request(request);
+		}
+	}
+}
+
+NMERR_T
+nm_call_handler(NMUser * user, NMRequest * request, NMField * fields)
+{
+	NMERR_T rc = NM_OK, ret_code = NM_OK;
+	NMConference *conf = NULL;
+	NMUserRecord *user_record = NULL;
+	NMField *locate = NULL;
+	NMField *field = NULL;
+	const char *cmd;
+	nm_response_cb cb;
+	gboolean done = TRUE;
+	
+	if (user == NULL || request == NULL || fields == NULL)
+		return NMERR_BAD_PARM;
+
+	/* Get the return code */
+	field = nm_locate_field(NM_A_SZ_RESULT_CODE, fields);
+	if (field) {
+		ret_code = atoi((char *) field->value);
+	} else {
+		ret_code = NMERR_PROTOCOL;
+	}
+	
+	cmd = nm_request_get_cmd(request);
+	if (ret_code == NM_OK && cmd != NULL) {
+
+		if (strcmp("login", cmd) == 0) {
+
+			user->user_record = nm_create_user_record_from_fields(fields);
+
+			/* Save the users fields */
+			user->fields = fields;
+
+		} else if (strcmp("setstatus", cmd) == 0) {
+
+			/* Nothing to do */
+
+		} else if (strcmp("createconf", cmd) == 0) {
+
+			conf = (NMConference *) nm_request_get_data(request);
+
+			/* get the convo guid */
+			locate = nm_locate_field(NM_A_FA_CONVERSATION, fields);
+			if (locate) {
+				field =
+					nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->value);
+				if (field) {
+					nm_conference_set_guid(conf, (char *) field->value);
+				}
+			}
+
+			nm_conference_list_add(user, conf);
+
+		} else if (strcmp("leaveconf", cmd) == 0) {
+
+			conf = (NMConference *) nm_request_get_data(request);
+			nm_conference_list_remove(user, conf);
+
+		} else if (strcmp("joinconf", cmd) == 0) {
+			GSList *list = NULL, *node;
+
+			nm_print_fields(fields);
+
+			conf = nm_request_get_data(request);
+
+			locate = nm_locate_field(NM_A_FA_CONTACT_LIST, fields);
+			if (locate && locate->value != 0) {
+
+				field = (NMField *) locate->value;
+				while ((field = nm_locate_field(NM_A_SZ_DN, field))) {
+					if (field && field->value != 0) {
+
+						if (nm_utf8_str_equal
+							(nm_user_record_get_dn(user->user_record),
+							 (const char *) field->value)) {
+							field++;
+							continue;
+						}
+
+						user_record =
+							nm_find_user_record(user,
+												(const char *) field->value);
+						if (user_record == NULL) {
+							list =
+								g_slist_append(list,
+											   g_strdup((char *) field->value));
+						} else {
+							nm_conference_add_participant(conf, user_record);
+						}
+					}
+					field++;
+				}
+
+				if (list != NULL) {
+
+					done = FALSE;
+					nm_request_add_ref(request);
+					nm_request_set_user_define(request, list);
+					for (node = list; node; node = node->next) {
+
+						nm_send_get_details(user, (const char *) node->data,
+											_handle_multiple_get_details_joinconf_cb,
+											request);
+					}
+				}
+			}
+
+		} else if (strcmp("getdetails", cmd) == 0) {
+
+			locate = nm_locate_field(NM_A_FA_RESULTS, fields);
+			if (locate && locate->value != 0) {
+
+				user_record = nm_create_user_record_from_fields(locate);
+				if (user_record) {
+					NMUserRecord *tmp;
+
+					tmp =
+						nm_find_user_record(user,
+											nm_user_record_get_dn(user_record));
+					if (tmp) {
+
+						/* Update the existing user record */
+						nm_user_record_copy(tmp, user_record);
+						nm_release_user_record(user_record);
+						user_record = tmp;
+
+					} else {
+
+						nm_user_add_user_record(user, user_record);
+						nm_release_user_record(user_record);
+
+					}
+
+					/* Response data is new user record */
+					nm_request_set_data(request, (gpointer) user_record);
+				}
+
+			}
+
+		} else if (strcmp("createfolder", cmd) == 0) {
+
+			_update_contact_list(user, fields);
+
+		} else if (strcmp("createcontact", cmd) == 0) {
+
+			_update_contact_list(user, fields);
+
+			locate =
+				nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->value);
+			if (locate) {
+
+				NMContact *new_contact =
+					nm_folder_find_item_by_object_id(user->root_folder,
+													 atoi((char *) locate->
+														  value));
+
+				if (new_contact) {
+
+					/* Add the contact to our cache */
+					nm_user_add_contact(user, new_contact);
+
+					/* Set the contact as the response data */
+					nm_request_set_data(request, (gpointer) new_contact);
+
+				}
+
+			}
+
+		} else if (strcmp("deletecontact", cmd) == 0) {
+
+			_update_contact_list(user, fields);
+
+		} else if (strcmp("movecontact", cmd) == 0) {
+
+			_update_contact_list(user, fields);
+
+		} else if (strcmp("getstatus", cmd) == 0) {
+
+			locate = nm_locate_field(NM_A_SZ_STATUS, fields);
+			if (locate) {
+				nm_user_record_set_status((NMUserRecord *)
+										  nm_request_get_data(request),
+										  atoi((char *) locate->value), NULL);
+			}
+
+		} else if (strcmp("updateitem", cmd) == 0) {
+
+			/* Nothing extra to do here */
+
+		} else {
+
+			/* Nothing to do, just print debug message  */
+			gaim_debug(GAIM_DEBUG_INFO, "novell",
+					   "nm_call_handler(): Unknown request command, %s\n", cmd);
+
+		}
+	}
+
+	if (done && (cb = nm_request_get_callback(request))) {
+
+		cb(user, ret_code, nm_request_get_data(request),
+		   nm_request_get_user_define(request));
+
+	}
+
+	return rc;
+}
+
+static NMERR_T
+nm_process_response(NMUser * user)
+{
+	NMERR_T rc = NM_OK;
+	NMField *fields = NULL;
+	NMField *field = NULL;
+	NMConn *conn = user->conn;
+	NMRequest *req = NULL;
+
+	rc = nm_read_header(conn);
+	if (rc == NM_OK) {
+		rc = nm_read_fields(conn, -1, &fields);
+	}
+
+	if (rc == NM_OK) {
+		field = nm_locate_field(NM_A_SZ_TRANSACTION_ID, fields);
+		if (field != NULL && field->value != 0) {
+			req = nm_conn_find_request(conn, atoi((char *) field->value));
+			if (req != NULL) {
+				rc = nm_call_handler(user, req, fields);
+			}
+		}
+	}
+
+	return rc;
+}
+
+/*
+ * Some utility functions...haven't figured out where
+ * they belong yet.
+ */
+gint
+nm_utf8_strcasecmp(gconstpointer str1, gconstpointer str2)
+{
+	gint rv;
+	char *str1_down = g_utf8_strdown(str1, -1);
+	char *str2_down = g_utf8_strdown(str2, -1);
+
+	rv = g_utf8_collate(str1_down, str2_down);
+
+	g_free(str1_down);
+	g_free(str2_down);
+
+	return rv;
+}
+
+gboolean
+nm_utf8_str_equal(gconstpointer str1, gconstpointer str2)
+{
+	return (nm_utf8_strcasecmp(str1, str2) == 0);
+}
+
+char *
+nm_typed_to_dotted(const char *typed)
+{
+	unsigned i = 0, j = 0;
+
+	if (typed == NULL)
+		return NULL;
+
+	char *dotted = g_new0(char, strlen(typed));
+
+	do {
+
+		/* replace comma with a dot */
+		if (j != 0) {
+			dotted[j] = '.';
+			j++;
+		}
+
+		/* skip the type */
+		while (typed[i] != '\0' && typed[i] != '=')
+			i++;
+
+		/* verify that we aren't running off the end */
+		if (typed[i] == '\0') {
+			dotted[j] = '\0';
+			break;
+		}
+
+		i++;
+
+		/* copy the object name to context */
+		while (typed[i] != '\0' && typed[i] != ',') {
+			dotted[j] = typed[i];
+			j++;
+			i++;
+		}
+
+	} while (typed[i] != '\0');
+
+	return dotted;
+}
+
+static void
+_update_contact_list(NMUser * user, NMField * fields)
+{
+	NMField *list, *cursor, *locate;
+	gint objid1;
+	NMContact *contact;
+	NMFolder *folder;
+
+	if (user == NULL || fields == NULL)
+		return;
+
+	/* Is it wrapped in a RESULTS array? */
+	if (strcmp(fields->tag, NM_A_FA_RESULTS) == 0) {
+		list = (NMField *) fields->value;
+	} else {
+		list = fields;
+	}
+
+	/* Update the cached contact list */
+	cursor = (NMField *) list->value;
+	while (cursor->tag != NULL) {
+		if ((g_ascii_strcasecmp(cursor->tag, NM_A_FA_CONTACT) == 0) ||
+			(g_ascii_strcasecmp(cursor->tag, NM_A_FA_FOLDER) == 0)) {
+
+			locate =
+				nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) cursor->value);
+			if (locate != NULL && locate->value != 0) {
+				objid1 = atoi((char *) locate->value);
+				gpointer item =
+					nm_folder_find_item_by_object_id(user->root_folder, objid1);
+				if (item != NULL) {
+					if (cursor->method == NMFIELD_METHOD_ADD) {
+						if (g_ascii_strcasecmp(cursor->tag, NM_A_FA_CONTACT) == 0) {
+							contact = (NMContact *) item;
+							nm_contact_update_list_properties(contact, cursor);
+						} else if (g_ascii_strcasecmp(cursor->tag, NM_A_FA_FOLDER)
+								   == 0) {
+							folder = (NMFolder *) item;
+							nm_folder_update_list_properties(folder, cursor);
+						}
+					} else if (cursor->method == NMFIELD_METHOD_DELETE) {
+						if (g_ascii_strcasecmp(cursor->tag, NM_A_FA_CONTACT) == 0) {
+							contact = (NMContact *) item;
+							folder =
+								nm_find_folder_by_id(user,
+													 nm_contact_get_parent_id
+													 (contact));
+							if (folder) {
+								nm_folder_remove_contact(folder, contact);
+							}
+						} else if (g_ascii_strcasecmp(cursor->tag, NM_A_FA_FOLDER)
+								   == 0) {
+							/* TODO: write nm_folder_remove_folder */
+							/* ignoring for now, should not be a big deal */
+/*								folder = (NMFolder *) item;*/
+/*								nm_folder_remove_folder(user->root_folder, folder);*/
+						}
+					}
+				} else {
+
+					if (cursor->method == NMFIELD_METHOD_ADD) {
+
+						/* Not found,  so we need to add it */
+						if (g_ascii_strcasecmp(cursor->tag, NM_A_FA_CONTACT) == 0) {
+
+							const char *dn = NULL;
+
+							locate =
+								nm_locate_field(NM_A_SZ_DN,
+												(NMField *) cursor->value);
+							if (locate != NULL && locate->value != 0) {
+								dn = (const char *) locate->value;
+								if (dn != NULL) {
+									contact =
+										nm_create_contact_from_fields(cursor);
+									if (contact) {
+										nm_folder_add_contact_to_list(user->
+																	  root_folder,
+																	  contact);
+										nm_release_contact(contact);
+									}
+								}
+							}
+						} else if (g_ascii_strcasecmp(cursor->tag, NM_A_FA_FOLDER)
+								   == 0) {
+							folder = nm_create_folder_from_fields(cursor);
+							nm_folder_add_folder_to_list(user->root_folder,
+														 folder);
+							nm_release_folder(folder);
+						}
+					}
+				}
+			}
+		}
+		cursor++;
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmuser.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,569 @@
+/*
+ * nmuser.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef __NM_USER_H__
+#define __NM_USER_H__
+
+#include <glib.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef guint32 NMERR_T;
+typedef int NMSTATUS_T;
+
+typedef struct _NMUser NMUser;
+
+typedef enum
+{
+	NMREQUEST_TYPE_LOGIN = 0,
+	NMREQUEST_TYPE_LOGOUT,
+	NMREQUEST_TYPE_SETSTATUS,
+	NMREQUEST_TYPE_GETDETAILS,
+	NMREQUEST_TYPE_CREATECONF,
+	NMREQUEST_TYPE_SENDMESSAGE,
+	NMREQUEST_TYPE_JOINCONF,
+	NMREQUEST_TYPE_LEAVECONF,
+	NMREQUEST_TYPE_REJECTCONF,
+	NMREQUEST_TYPE_SENDTYPING,
+	NMREQUEST_TYPE_CREATECONTACT,
+	NMREQUEST_TYPE_DELETECONTACT
+
+} NMRequestType;
+
+#include "debug.h"
+#include "nmmessage.h"
+#include "nmconference.h"
+#include "nmcontact.h"
+#include "nmuserrecord.h"
+#include "nmfield.h"
+#include "nmevent.h"
+
+/* Callback typedefs */
+typedef void (*nm_response_cb) (NMUser * user, NMERR_T ret_code,
+								gpointer resp_data, gpointer user_data);
+
+typedef void (*nm_event_cb) (NMUser * user, NMEvent * event);
+
+#include "nmrequest.h"
+#include "nmconn.h"
+
+/* This represents user that we are currently logged in as */
+struct _NMUser
+{
+
+	char *name;
+
+	NMSTATUS_T status;
+
+	/* A copy of the login response fields */
+	NMField *fields;
+
+	/* The user record for this user */
+	NMUserRecord *user_record;
+
+	/* Our connection information */
+	NMConn *conn;
+
+	/* Our public IP address */
+	char *address;
+
+	/* This is the contact list */
+	NMFolder *root_folder;
+
+	/* All contacts that we know about hashed by dn */
+	GHashTable *contacts;
+
+	/* All user records hashed by dn */
+	GHashTable *user_records;
+
+	/* DN lookup */
+	GHashTable *display_id_to_dn;
+
+	/* One on one conversations indexed by recipient's dn */
+	GSList *conferences;
+
+	guint32 conference_count;
+
+	/* Called when we receive an event */
+	nm_event_cb evt_callback;
+
+	/* Pending requests. If we need to go to the server to more info
+	 * before processing a request we will queue it up and process when
+	 * we get a response
+	 */
+	GSList *pending_requests;
+
+	/* Pending events. Same as above except for events. */
+	GSList *pending_events;
+
+	/* Generic pointer to data needed by the client
+	 * using the API
+	 */
+	gpointer client_data;
+
+};
+
+
+#define	NM_STATUS_UNKNOWN			0
+#define	NM_STATUS_OFFLINE			1
+#define NM_STATUS_AVAILABLE			2
+#define	NM_STATUS_BUSY				3
+#define	NM_STATUS_AWAY				4
+#define	NM_STATUS_AWAY_IDLE			5
+#define	NM_STATUS_INVALID			6
+
+#define NMERR_BASE							0x2000L
+#define NM_OK								0L
+#define NMERR_BAD_PARM						(NMERR_BASE + 0x0001)
+#define NMERR_TCP_WRITE						(NMERR_BASE + 0x0002)
+#define NMERR_TCP_READ						(NMERR_BASE + 0x0003)
+#define NMERR_PROTOCOL						(NMERR_BASE + 0x0004)
+#define NMERR_SSL_REDIRECT					(NMERR_BASE + 0x0005)
+#define NMERR_CONFERENCE_NOT_FOUND 			(NMERR_BASE + 0x0006)
+#define NMERR_CONFERENCE_NOT_INSTANTIATED 	(NMERR_BASE + 0x0007)
+#define NMERR_FOLDER_EXISTS					(NMERR_BASE + 0x0008)
+
+
+/** 
+ *	Initialize the user that we are going to login to the system as.
+ *
+ *	@param	name			The userid of the user
+ *	@param	server			IP Address of server
+ *	@param	port			Port to connect to on the server
+ *  @param 	data			Client data to associate with the user
+ *	@param	event_callback	Function to call when we recieve an event
+ *
+ *	@return The initialized user object. Must be freed by calling
+ *			nm_deinitialize_user
+ */
+NMUser *nm_initialize_user(const char *name, const char *server, int port,
+						   gpointer data, nm_event_cb event_callback);
+
+
+/** 
+ *	Free up resources associated with the user object.
+ *
+ *  @param	user	The user to deinitialize
+ */
+void nm_deinitialize_user(NMUser * user);
+
+/** 
+ *	Send a login request to the server.
+ *
+ *	The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The User to login -- must be initialized
+ *	@param	pwd			The password of the user
+ *  @param  my_addr		The address of the client machine
+ *  @param	user_agent	String describing the client (eg. "Gaim/0.76 (Linux; 2.4.20)")
+ *	@param	callback	Function to call when we get the response from the server
+ *  @param 	data		User defined data to be passed to the callback function
+ * 
+ *
+ *	@return	NM_OK if login is sent successfully, error otherwise.
+ */
+NMERR_T nm_send_login(NMUser * user, const char *pwd, const char *my_addr,
+					  const char *user_agent, nm_response_cb callback,
+					  gpointer data);
+
+/** 
+ *	Send a set status request to the server.
+ *
+ *	The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	dn			The DN of the user (if known, or NULL if not known)
+ *	@param	address		IP Address of server
+ *	@param	callback	Function to call when we get the response from the server
+ *
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_set_status(NMUser * user, int status, const char *text,
+						   const char *auto_resp, nm_response_cb callback,
+						   gpointer data);
+
+/** 
+ *	Send a create conference to the server.
+ *
+ *	The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	conference	Conference to create
+ *	@param	callback	Function to call when we get the response from the server
+ *	@param	data		User defined data to be passed to the callback function
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_create_conference(NMUser * user, NMConference * conference,
+								  nm_response_cb callback, gpointer data);
+
+/** 
+ *	Tell server we have left the conference.
+ * 
+ *	The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	conference	Conference the user is leaving
+ *	@param	callback	Function to call when we get the response from the server
+ *	@param	data		User defined data to be passed to the callback function
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_leave_conference(NMUser * user, NMConference * conference,
+								 nm_response_cb callback, gpointer data);
+
+/** 
+ *	Send a join conference request to the server.
+ *
+ *	The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	conference	Conference the user is joining
+ *	@param	callback	Function to call when we get the response from the server
+ *	@param	data		User defined data to be passed to the callback function
+ *
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_join_conference(NMUser * user, NMConference * conference,
+								nm_response_cb callback, gpointer data);
+
+/** 
+ *	Send a conference reject request to the server.
+ *
+ *	The response data sent to the callback will be NULL. 
+ *
+ *  @param	user		The logged in User
+ *	@param	conference	Conference the user is rejecting
+ *	@param	callback	Function to call when we get the response from the server
+ *	@param	data		User defined data to be passed to the callback function
+ *
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_reject_conference(NMUser * user, NMConference * conference,
+								  nm_response_cb callback, gpointer data);
+
+/** 
+ *	Get details for a user from the server.
+ * 
+ *	The response data sent to the callback will be an NMUserRecord which should be
+ *  freed with nm_release_user_record
+ *
+ *  @param	user		The logged in User
+ *	@param	name		Userid or DN of the user to look up
+ *	@param	callback	Function to call when we get the response from the server
+ *	@param	data		User defined data to be passed to the callback function
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_get_details(NMUser * user, const char *name,
+							nm_response_cb callback, gpointer data);
+
+/** 
+ *	Get details for multiple users from the server.
+ * 
+ *	The response data to the callback will be a list of NMUserRecord, which should be
+ *	freed (each user record should be released with nm_release_user_record and the 
+ *  list should be freed)
+ *
+ *  @param	user		The logged in User
+ *	@param	name		Userid or DN of the user to look up
+ *	@param	callback	Function to call when we get the response from the server
+ *	@param	data		User defined data to be passed to the callback function
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_multiple_get_details(NMUser *user, GSList *names,
+									 nm_response_cb callback, gpointer data);
+
+/** 
+ *	Send a message.
+ *
+ *  The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	message		The message to send.
+ *	@param	callback	Function to call when we get the response from the server
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_message(NMUser * user, NMMessage * message,
+						nm_response_cb callback);
+
+/** 
+ *	Sends a typing event to the server.
+ *
+ *  The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	conf		The conference that corresponds to the typing event
+ *	@param	typing		TRUE if the user is typing
+ *						FALSE if the user has stopped typing
+ *	@param	callback	Function to call when we get the response from the server
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_typing(NMUser * user, NMConference * conf,
+					   gboolean typing, nm_response_cb callback);
+
+/** 
+ *	Send a create contact request to the server.
+ *
+ *  The given folder should already exist on the server. If not,
+ *  the call will fail.
+ *
+ *  The response data sent to the callback will be a NMContact which should
+ *  be released with nm_release_contact
+ *
+ *  @param	user		The logged in User
+ *	@param	folder		The folder that the contact should be created in
+ *	@param	contact		The contact to add
+ *	@param	callback	Function to call when we get the response from the server
+ *	@param	data		User defined data
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_create_contact(NMUser * user, NMFolder * folder,
+							   NMContact * contact, nm_response_cb callback,
+							   gpointer data);
+
+/** 
+ *	Send a remove contact request to the server.
+ *
+ *  The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	folder		The folder to remove contact from
+ *	@param	contact		The contact to remove
+ *	@param	callback	Function to call when we get the response from the server
+ *  @param	data		User defined data
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_remove_contact(NMUser * user, NMFolder * folder,
+							   NMContact * contact, nm_response_cb callback,
+							   gpointer data);
+
+/** 
+ *	Send a create folder request to the server.
+ *
+ *  The response data sent to the callback will be a NMFolder which should be
+ *  released with nm_release_folder
+ *
+ *  @param	user		The logged in User
+ *	@param	name		The name of the folder to create
+ *	@param	callback	Function to call when we get the response from the server
+ *  @param	data		User defined data
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_create_folder(NMUser * user, const char *name,
+							  nm_response_cb callback, gpointer data);
+
+/** 
+ *	Send a delete folder request to the server.
+ *
+ *  The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	folder		The name of the folder to remove
+ *	@param	callback	Function to call when we get the response from the server
+ *  @param	data		User defined data
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_remove_folder(NMUser * user, NMFolder * folder,
+							  nm_response_cb callback, gpointer data);
+
+/** 
+ *	Send a rename contact request to the server.
+ *
+ *	The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	contact		The contact to rename
+ *  @param	new_name	The new display name for the contact
+ *	@param	callback	Function to call when we get the response from the server
+ *  @param	data		User defined data
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_rename_contact(NMUser * user, NMContact * contact,
+							   const char *new_name, nm_response_cb callback,
+							   gpointer data);
+
+/** 
+ *	Send a rename folder request to the server.
+ *
+ *	The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	folder		The folder to rename
+ *  @param	new_name	The new name of the folder
+ *	@param	callback	Function to call when we get the response from the server
+ *  @param	data		User defined data
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_rename_folder(NMUser * user, NMFolder * folder,
+							  const char *new_name, nm_response_cb callback,
+							  gpointer data);
+
+/** 
+ *	Send a move contact request to the server.
+ *
+ *	The response data sent to the callback will be NULL.
+ *
+ *  @param	user		The logged in User
+ *	@param	contact		The contact to move
+ *  @param	folder	    The folder to move the contact to
+ *	@param	callback	Function to call when we get the response from the server
+ *  @param	data		User defined data
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_move_contact(NMUser * user, NMContact * contact,
+							 NMFolder * folder, nm_response_cb callback,
+							 gpointer data);
+
+/** 
+ *	Send a get status request to the server.
+ *
+ * 	The response data sent to the callback will be a NMUserRecord.
+ *
+ *  @param	user		The logged in User
+ *	@param	contact		The contact to move
+ *  @param	folder	    The folder to move the contact to
+ *	@param	callback	Function to call when we get the response from the server
+ *  @param	data		User defined data
+ *
+ *	@return	NM_OK if successfully sent, error otherwise
+ */
+NMERR_T nm_send_get_status(NMUser * user, NMUserRecord * user_record,
+						   nm_response_cb callback, gpointer data);
+
+/** 
+ *	Reads a response/event from the server and processes it.
+ *
+ *  @param	user	The logged in User
+ */
+NMERR_T nm_process_new_data(NMUser * user);
+
+/** 
+ *	Return the root folder of the contact list
+ *
+ *  @param	user	The logged in User
+ *
+ *	@return	Root folder
+ */
+NMFolder *nm_get_root_folder(NMUser * user);
+
+/** 
+ *	Create the contact list based on the login fields
+ *
+ *  @param	user	The logged in User
+ *
+ */
+NMERR_T nm_create_contact_list(NMUser * user);
+
+void nm_destroy_contact_list(NMUser * user);
+
+void nm_user_add_contact(NMUser * user, NMContact * contact);
+
+void nm_user_add_user_record(NMUser * user, NMUserRecord * user_record);
+
+NMContact *nm_find_contact(NMUser * user, const char *dn);
+
+GList *nm_find_contacts(NMUser * user, const char *dn);
+
+NMUserRecord *nm_find_user_record(NMUser * user, const char *dn);
+
+NMFolder *nm_find_folder(NMUser * user, const char *name);
+
+NMFolder *nm_find_folder_by_id(NMUser * user, int object_id);
+
+NMConference *nm_find_conversation(NMUser * user, const char *who);
+
+void nm_conference_list_add(NMUser * user, NMConference * conf);
+
+void nm_conference_list_remove(NMUser * user, NMConference * conf);
+
+void nm_conference_list_free(NMUser * user);
+
+NMConference *nm_conference_list_find(NMUser * user, const char *guid);
+
+const char *nm_lookup_dn(NMUser * user, const char *display_id);
+
+nm_event_cb nm_user_get_event_callback(NMUser * user);
+
+NMConn *nm_user_get_conn(NMUser * user);
+
+/** Some utility functions **/
+
+/**
+ * Check to see if the conference GUIDs are equivalent.	
+ *
+ * @param guid1	First guid to compare
+ * @param guid2 Second guid to compare
+ *
+ * @return 		TRUE if conference GUIDs are equivalent, FALSE otherwise.
+ *
+ */
+gboolean nm_are_guids_equal(const char *guid1, const char *guid2);
+
+
+/**
+ * Case insensitive compare for utf8 strings
+ *
+ * @param guid1	First string to compare
+ * @param guid2 Second string to compare
+ *
+ * @return 		-1 if str1 < str2, 0 if str1 = str2, 1 if str1 > str2
+ *
+ */
+gint nm_utf8_strcasecmp(gconstpointer str1, gconstpointer str2);
+
+/**
+ * Compare UTF8 strings for equality only (case insensitive)
+ *
+ * @param guid1	First string to compare
+ * @param guid2 Second string to compare
+ *
+ * @return 		TRUE if strings are equal, FALSE otherwise
+ *
+ */
+gboolean nm_utf8_str_equal(gconstpointer str1, gconstpointer str2);
+
+/**
+ * Convert a fully typed LDAP DN to dotted, untype notation
+ * e.g. cn=mike,o=novell -> mike.novell
+ *
+ * @param typed	Fully typed dn
+ *
+ * @return 		Dotted equivalent of typed (must be freed).
+ *
+ */
+char *nm_typed_to_dotted(const char *typed);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmuserrecord.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,563 @@
+/*
+ * nmuserrecord.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include <glib.h>
+#include <string.h>
+#include "nmuserrecord.h"
+#include "nmfield.h"
+#include "nmuser.h"
+
+struct _NMUserRecord
+{
+	NMSTATUS_T status;
+	char *status_text;
+	char *dn;
+	char *cn;
+	char *display_id;
+	char *fname;
+	char *lname;
+	char *full_name;
+	NMField *fields;
+	gboolean auth_attr;
+	gpointer data;
+	int ref_count;
+};
+
+struct _NMProperty
+{
+	char *tag;
+	char *value;
+};
+
+static int count = 0;
+
+/* API functions */
+
+NMUserRecord *
+nm_create_user_record()
+{
+	NMUserRecord *user_record = g_new0(NMUserRecord, 1);
+
+	user_record->ref_count = 1;
+
+	gaim_debug(GAIM_DEBUG_INFO, "novell", "Creating user_record, total=%d\n",
+			   count++);
+
+	return user_record;
+}
+
+static char *
+_get_attribute_value(NMField *field)
+{
+	char *value = NULL;
+
+	if (field->value == 0)
+		return NULL;
+
+	if (field->type == NMFIELD_TYPE_UTF8 || field->type == NMFIELD_TYPE_DN) {
+
+		value = (char *)field->value;
+
+	} else if (field->type == NMFIELD_TYPE_MV) {
+
+		/* Need to handle multi-valued returns, for now
+		 * just pick the first value and return it
+		 */
+		NMField *tmp = (NMField *)field->value;
+		if ((tmp != NULL) && 
+			((tmp->type == NMFIELD_TYPE_UTF8) ||
+			(tmp->type == NMFIELD_TYPE_DN))) {
+
+			value = (char *)tmp->value;
+
+		} else {
+			return NULL;
+		}
+
+	} else {
+		return NULL;
+	}
+	
+	return g_strdup(value);
+}
+/*
+ * This creates a user_record for the reference list the 
+ * field array that is passed in should be a 
+ * NM_A_FA_USER_DETAILS array.
+ */
+NMUserRecord *
+nm_create_user_record_from_fields(NMField * details)
+{
+	NMUserRecord *user_record;
+	NMField *field, *fields = details;
+
+	if (details == NULL) {
+		return NULL;
+	}
+
+	if (details->type == NMFIELD_TYPE_ARRAY) {
+		if (details->value == 0)
+			return NULL;
+		fields = (NMField *) details->value;
+	}
+
+	user_record = nm_create_user_record();
+
+	if ((field = nm_locate_field(NM_A_SZ_AUTH_ATTRIBUTE, fields))) {
+		
+		if (field->value) {
+			user_record->display_id = _get_attribute_value(field);
+			user_record->auth_attr = TRUE;
+		}
+	}
+
+	if ((field = nm_locate_field(NM_A_SZ_DN, fields))) {
+		
+		if (field->value) {
+			user_record->dn = _get_attribute_value(field);
+		}
+	}
+
+	if ((field = nm_locate_field("CN", fields))) {
+
+		if (field->value) {
+			user_record->cn = _get_attribute_value(field);
+		}
+	}
+
+	if ((field = nm_locate_field("Given Name", fields))) {
+
+		if (field->value) {
+			user_record->fname = _get_attribute_value(field);
+		}
+	}
+
+	if ((field = nm_locate_field("Surname", fields))) {
+		
+		if (field->value) {
+			user_record->lname = _get_attribute_value(field);
+		}
+	}
+
+	if ((field = nm_locate_field("Full Name", fields))) {
+
+		if (field->value) {
+			user_record->full_name = _get_attribute_value(field);
+		}
+	}
+
+	if ((field = nm_locate_field(NM_A_SZ_STATUS, fields))) {
+
+		if (field->value)
+			user_record->status = atoi((char *) field->value);
+
+	}
+
+	if ((field = nm_locate_field(NM_A_SZ_MESSAGE_BODY, fields))) {
+
+		if (field->value)
+			user_record->status_text = g_strdup((char *) field->value);
+
+	}
+
+	user_record->fields = nm_copy_field_array(fields);
+
+	return user_record;
+}
+
+void
+nm_user_record_copy(NMUserRecord * dest, NMUserRecord * src)
+{
+	if (dest == NULL || src == NULL)
+		return;
+
+	dest->status = src->status;
+
+	/* Copy status text */
+	if (dest->status_text) {
+		g_free(dest->status_text);
+		dest->status_text = NULL;
+	}
+
+	if (src->status_text)
+		dest->status_text = g_strdup(src->status_text);
+
+	/* Copy DN */
+	if (dest->dn) {
+		g_free(dest->dn);
+		dest->dn = NULL;
+	}
+
+	if (src->dn)
+		dest->dn = g_strdup(src->dn);
+
+	/* Copy CN */
+	if (dest->cn) {
+		g_free(dest->cn);
+		dest->cn = NULL;
+	}
+
+	if (src->cn)
+		dest->cn = g_strdup(src->cn);
+
+	/* Copy display id */
+	if (dest->display_id) {
+		g_free(dest->display_id);
+		dest->display_id = NULL;
+	}
+
+	if (src->display_id)
+		dest->display_id = g_strdup(src->display_id);
+
+	/* Copy first name */
+	if (dest->fname) {
+		g_free(dest->fname);
+		dest->fname = NULL;
+	}
+
+	if (src->fname)
+		dest->fname = g_strdup(src->fname);
+
+	/* Copy last name */
+	if (dest->lname) {
+		g_free(dest->lname);
+		dest->lname = NULL;
+	}
+
+	if (src->lname)
+		dest->lname = g_strdup(src->lname);
+
+	/* Copy full name */
+	if (dest->full_name) {
+		g_free(dest->full_name);
+		dest->full_name = NULL;
+	}
+
+	if (src->full_name)
+		dest->full_name = g_strdup(src->full_name);
+
+	/* Copy fields */
+	if (src->fields) {
+		
+		if (dest->fields) {
+			nm_free_fields(&dest->fields);
+		}
+		
+		dest->fields = nm_copy_field_array(src->fields);
+	}
+
+	/* Copy data */
+	dest->data = src->data;
+}
+
+void
+nm_user_record_add_ref(NMUserRecord * user_record)
+{
+	if (user_record)
+		user_record->ref_count++;
+}
+
+void
+nm_release_user_record(NMUserRecord * user_record)
+{
+	if (--(user_record->ref_count) == 0) {
+
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "Releasing user_record, total=%d\n", --count);
+
+		if (user_record->dn) {
+			g_free(user_record->dn);
+		}
+
+		if (user_record->cn) {
+			g_free(user_record->cn);
+		}
+
+		if (user_record->display_id) {
+			g_free(user_record->display_id);
+		}
+
+		if (user_record->fname) {
+			g_free(user_record->fname);
+		}
+
+		if (user_record->lname) {
+			g_free(user_record->lname);
+		}
+
+		if (user_record->full_name) {
+			g_free(user_record->full_name);
+		}
+		
+		if (user_record->status_text) {
+			g_free(user_record->status_text);
+		}
+
+		nm_free_fields(&user_record->fields);
+
+		g_free(user_record);
+	}
+}
+
+/* UserRecord API */
+
+NMSTATUS_T
+nm_user_record_get_status(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return (NMSTATUS_T) - 1;
+
+	return user_record->status;
+
+}
+
+const char *
+nm_user_record_get_status_text(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return NULL;
+
+	return user_record->status_text;
+}
+
+void
+nm_user_record_set_dn(NMUserRecord * user_record, const char *dn)
+{
+	if (user_record != NULL && dn != NULL) {
+		if (user_record->dn)
+			g_free(user_record->dn);
+
+		user_record->dn = g_strdup(dn);
+	}
+}
+
+const char *
+nm_user_record_get_dn(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return NULL;
+
+	return user_record->dn;
+}
+
+void
+nm_user_record_set_userid(NMUserRecord * user_record, const char *userid)
+{
+	if (user_record != NULL && userid != NULL) {
+		if (user_record->cn)
+			g_free(user_record->cn);
+
+		user_record->cn = g_strdup(userid);
+	}
+}
+
+const char *
+nm_user_record_get_userid(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return NULL;
+
+	return user_record->cn;
+}
+
+void
+nm_user_record_set_display_id(NMUserRecord * user_record, const char *display_id)
+{
+	if (user_record != NULL && display_id != NULL) {
+		if (user_record->display_id)
+			g_free(user_record->display_id);
+
+		user_record->display_id = g_strdup(display_id);
+	}
+}
+
+const char *
+nm_user_record_get_display_id(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return NULL;
+
+	if (user_record->display_id == NULL) {
+		user_record->display_id = nm_typed_to_dotted(user_record->dn);
+	}
+
+	return user_record->display_id;
+}
+
+const char *
+nm_user_record_get_full_name(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return NULL;
+
+	if (user_record->full_name == NULL) {
+		if (user_record->fname && user_record->lname) {
+			user_record->full_name = g_strdup_printf("%s %s",
+													 user_record->fname,
+													 user_record->lname);
+
+		}
+	}
+
+	return user_record->full_name;
+}
+
+const char *
+nm_user_record_get_first_name(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return NULL;
+
+	return user_record->fname;
+
+}
+
+const char *
+nm_user_record_get_last_name(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return NULL;
+
+	return user_record->lname;
+}
+
+gpointer
+nm_user_record_get_data(NMUserRecord * user_record)
+{
+	if (user_record == NULL)
+		return NULL;
+
+	return user_record->data;
+}
+
+void
+nm_user_record_set_data(NMUserRecord * user_record, gpointer data)
+{
+	if (user_record == NULL)
+		return;
+
+	user_record->data = data;
+}
+
+void
+nm_user_record_set_status(NMUserRecord * user_record,
+						  int status, const char *text)
+{
+	if (user_record == NULL)
+		return;
+
+	user_record->status = status;
+
+	if (user_record->status_text) {
+		g_free(user_record->status_text);
+		user_record->status_text = NULL;
+	}
+	
+	if (text)
+		user_record->status_text = g_strdup(text);
+}
+
+gboolean
+nm_user_record_get_auth_attr(NMUserRecord *user_record)
+{
+	if (user_record == NULL)
+		return FALSE;
+
+	return user_record->auth_attr;
+}
+
+int
+nm_user_record_get_property_count(NMUserRecord * user_record)
+{
+	NMField *locate, *fields;
+
+	int count = 0;
+
+	if (user_record && user_record->fields) {
+		locate = nm_locate_field(NM_A_FA_INFO_DISPLAY_ARRAY,
+								 (NMField *) user_record->fields);
+		if (locate && (fields = (NMField *) (locate->value))) {
+			count = (int) nm_count_fields(fields);
+		}
+	}
+	return count;
+}
+
+NMProperty *
+nm_user_record_get_property(NMUserRecord * user_record, int index)
+{
+	NMProperty *property = NULL;
+	NMField *field = NULL, *fields, *locate;
+
+	if (user_record && user_record->fields) {
+		locate = nm_locate_field(NM_A_FA_INFO_DISPLAY_ARRAY,
+								 (NMField *) user_record->fields);
+		if (locate && (fields = (NMField *) (locate->value))) {
+			int max = nm_count_fields(fields);
+
+			if (index < max) {
+				if (user_record) {
+					field = &fields[index];
+					if (field && field->tag && field->value) {
+						property = g_new0(NMProperty, 1);
+						property->tag = g_strdup(field->tag);
+						property->value = _get_attribute_value(field);
+					}
+				}
+			}
+		}
+	}
+
+	return property;
+}
+
+void
+nm_release_property(NMProperty * property)
+{
+	if (property) {
+		if (property->tag)
+			g_free(property->tag);
+
+		if (property->value)
+			g_free(property->value);
+
+		g_free(property);
+	}
+}
+
+const char *
+nm_property_get_tag(NMProperty * property)
+{
+	if (property)
+		return property->tag;
+	else
+		return NULL;
+}
+
+const char *
+nm_property_get_value(NMProperty * property)
+{
+	if (property)
+		return property->value;
+	else
+		return NULL;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/nmuserrecord.h	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,275 @@
+/*
+ * nmuserrecord.h
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#ifndef __NM_USER_RECORD_H__
+#define __NM_USER_RECORD_H__
+
+#include <glib.h>
+
+typedef struct _NMUserRecord NMUserRecord;
+typedef struct _NMProperty NMProperty;
+
+#include "nmfield.h"
+#include "nmuser.h"
+
+/**
+ * Creates an NMUserRecord
+ *
+ * The NMUserRecord should be released by calling
+ * nm_release_user_record
+ *
+ * @return 			The new user record
+ *
+ */
+NMUserRecord *nm_create_user_record();
+
+/**
+ * Creates an NMUserRecord
+ *
+ * The NMUserRecord should be released by calling
+ * nm_release_user_record 
+ *
+ * @param	details	Should be a NM_A_FA_USER_DETAILS
+ *
+ *
+ * @return 			The new user record
+ *
+ */
+NMUserRecord *nm_create_user_record_from_fields(NMField * details);
+
+/**
+ * Add a reference to an existing user_record
+ *
+ * The reference should be released by calling
+ * nm_release_user_record 
+ *
+ * @param	user_record	The contact to addref
+ *
+ */
+void nm_user_record_add_ref(NMUserRecord * user_record);
+
+/**
+ * Release a reference to the user record
+ *
+ * @param	user_record		The user record
+ *
+ */
+void nm_release_user_record(NMUserRecord * user_record);
+
+/**
+ * Set the status for the user record
+ *
+ * @param	user_record		The user record
+ * @param 	status			The status for the user
+ * @param	text			The status text for the user
+ *
+ */
+void nm_user_record_set_status(NMUserRecord * user_record, NMSTATUS_T status,
+							   const char *text);
+
+/**
+ * Get the status for the user record
+ *
+ * @param	user_record 	The user record
+ *
+ * @return	The status for the user record
+ */
+NMSTATUS_T nm_user_record_get_status(NMUserRecord * user_record);
+
+/**
+ * Get the status text for the user record
+ *
+ * @param	user_record		The user record
+ *
+ * @return	The status text if there is any, NULL otherwise
+ *
+ */
+const char *nm_user_record_get_status_text(NMUserRecord * user_record);
+
+/**
+ * Set the DN for the user record
+ *
+ * @param	user_record		The user record
+ * @param	dn				The new DN for the user record
+ *
+ */
+void nm_user_record_set_dn(NMUserRecord * user_record, const char *dn);
+
+/**
+ * Get the DN for the user record
+ *
+ * @param	user_record		The user record
+ *
+ * @return	The DN for the user record
+ */
+const char *nm_user_record_get_dn(NMUserRecord * user_record);
+
+/**
+ * Set the user id for the 
+ *
+ * @param	user_record		The user record
+ * @param	userid			The userid (CN) for the user record
+ *
+ */
+void nm_user_record_set_userid(NMUserRecord * user_record, const char *userid);
+
+/**
+ * Get the user id for the user record
+ *
+ * @param	user_record	The user record
+ *
+ * @return	The user id for the user record
+ */
+const char *nm_user_record_get_userid(NMUserRecord * user_record);
+
+/**
+ * Set the display id for the user record
+ *
+ * @param	user_record		The user record
+ * @param	display_id		The new display id for the user
+ *
+ */
+void nm_user_record_set_display_id(NMUserRecord * user_record,
+								   const char *display_id);
+
+/**
+ * Get the display id for the user record
+ *
+ * @param	user_record		The user record
+ *
+ * @return	The display id for the user record
+ */
+const char *nm_user_record_get_display_id(NMUserRecord * user_record);
+
+/**
+ * Return whether or not the display id is an auth attribute or not.
+ *
+ * @param	user_record		The user record
+ *
+ * @return	TRUE if display_id is an auth attribute, FALSE otherwise.
+ */
+gboolean
+nm_user_record_get_auth_attr(NMUserRecord *user_record);
+
+/**
+ * Get the full name for the user record
+ *
+ * @param	user_record		The user record
+ *
+ * @return	The full name for the user
+ */
+const char *nm_user_record_get_full_name(NMUserRecord * user_record);
+
+/**
+ * Get the first name for the user record
+ *
+ * @param	user_record		The user record
+ *
+ * @return	The first name for the user
+ */
+const char *nm_user_record_get_first_name(NMUserRecord * user_record);
+
+/**
+ * Get the last name for the user record
+ *
+ * @param	user_record		The user record
+ * 
+ * @return	The last name for the user
+ */
+const char *nm_user_record_get_last_name(NMUserRecord * user_record);
+
+/**
+ * Set the user defined data for the user record
+ *
+ * @param	user_record		The user record
+ * @param	data			The user defined data for the user record
+ * 
+ */
+void nm_user_record_set_data(NMUserRecord * user_record, gpointer data);
+
+/**
+ * Get the user defined data for the user record
+ *
+ * @param	user_record		The user record
+ *
+ * @return	The user defined data for the user record
+ */
+gpointer nm_user_record_get_data(NMUserRecord * user_record);
+
+/**
+ * Get the property count for the user record
+ *
+ * @param	user_record		The user record
+ *
+ * @return	The number of information properties for the user record
+ *
+ */
+int nm_user_record_get_property_count(NMUserRecord * user_record);
+
+/**
+ * Get an info property for the user record. The property must be released
+ * by calling nm_release_property()
+ *
+ * @param	user_record		The user record
+ * @param	index			The index of the property to get (zero based)
+ *
+ * @return	The property
+ */
+NMProperty *nm_user_record_get_property(NMUserRecord * user_record, int index);
+
+/**
+ * Release a property object
+ *
+ * @param	property	The property
+ *
+ */
+void nm_release_property(NMProperty * property);
+
+/**
+ * Get the tag for the property
+ *
+ * @param 	property	The property
+ *
+ * @return 	The tag of the property (i.e. "Email Address")
+ */
+const char *nm_property_get_tag(NMProperty * property);
+
+/**
+ * Get the value for the property
+ *
+ * @param	property	The property
+ *
+ * @return	The value of the property (i.e. "[e-mail]")
+ */
+const char *nm_property_get_value(NMProperty * property);
+
+/**
+ * Copy a user record (deep copy). The dest user record must have already been
+ * created (nm_create_user_record)
+ *
+ * @param	dest	The destination of the copy
+ * @param	src		The source of the copy
+ *
+ */
+void nm_user_record_copy(NMUserRecord * dest, NMUserRecord * src);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/novell/novell.c	Sat Apr 17 13:55:28 2004 +0000
@@ -0,0 +1,2436 @@
+/*
+ * novell.c
+ *
+ * Copyright © 2004 Unpublished Work of Novell, Inc. All Rights Reserved.
+ *
+ * THIS WORK IS AN UNPUBLISHED WORK OF NOVELL, INC. NO PART OF THIS WORK MAY BE
+ * USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED, MODIFIED,
+ * TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED, COMPILED, LINKED,
+ * RECAST, TRANSFORMED OR ADAPTED WITHOUT THE PRIOR WRITTEN CONSENT OF NOVELL,
+ * INC. ANY USE OR EXPLOITATION OF THIS WORK WITHOUT AUTHORIZATION COULD SUBJECT
+ * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
+ * 
+ * AS BETWEEN [GAIM] AND NOVELL, NOVELL GRANTS [GAIM] THE RIGHT TO REPUBLISH
+ * THIS WORK UNDER THE GPL (GNU GENERAL PUBLIC LICENSE) WITH ALL RIGHTS AND
+ * LICENSES THEREUNDER.  IF YOU HAVE RECEIVED THIS WORK DIRECTLY OR INDIRECTLY
+ * FROM [GAIM] AS PART OF SUCH A REPUBLICATION, YOU HAVE ALL RIGHTS AND LICENSES
+ * GRANTED BY [GAIM] UNDER THE GPL.  IN CONNECTION WITH SUCH A REPUBLICATION, IF
+ * ANYTHING IN THIS NOTICE CONFLICTS WITH THE TERMS OF THE GPL, SUCH TERMS
+ * PREVAIL.
+ *
+ */
+
+#include "internal.h"
+#include "accountopt.h"
+#include "debug.h"
+#include "prpl.h"
+#include "server.h"
+#include "nmuser.h"
+#include "notify.h"
+#include "util.h"
+#include "sslconn.h"
+#include "request.h"
+#include "network.h"
+
+#define DEFAULT_PORT			8300
+#define NOVELL_CONNECT_STEPS	4
+
+static GaimPlugin *my_protocol = NULL;
+
+static gboolean
+_is_disconnect_error(NMERR_T err);
+
+static gboolean
+_check_for_disconnect(NMUser * user, NMERR_T err);
+
+static void
+_send_message(NMUser * user, NMMessage * message);
+
+static void
+_update_buddy_status(GaimBuddy * buddy, int status, int gmt);
+
+static void
+_remove_gaim_buddies(NMUser * user);
+
+static void
+_add_contacts_to_gaim_blist(NMUser * user, NMFolder * folder);
+
+static void
+_add_gaim_buddies(NMUser * user);
+
+static void
+_show_info(GaimConnection * gc, NMUserRecord * user_record);
+
+/*******************************************************************************
+ * Response callbacks
+ *******************************************************************************/
+
+/* Handle login response */
+static void
+_login_resp_cb(NMUser * user, NMERR_T ret_code,
+			   gpointer resp_data, gpointer user_data)
+{
+	GaimConnection *gc;
+	const char *alias;
+	NMERR_T rc;
+
+	if (user == NULL)
+		return;
+
+	gc = gaim_account_get_connection(user->client_data);
+	if (gc == NULL)
+		return;
+
+	if (ret_code == NM_OK) {
+
+		/* Set alias for user if not set (use Full Name) */
+		alias = gaim_account_get_alias(user->client_data);
+		if (alias == NULL || *alias == '\0') {
+			alias = nm_user_record_get_full_name(user->user_record);
+
+			if (alias)
+				gaim_account_set_alias(user->client_data, alias);
+		}
+
+		/* Tell Gaim that we are connected */
+		gaim_connection_set_state(gc, GAIM_CONNECTED);
+		serv_finish_login(gc);
+
+		/* Sync the contact list. This is pretty simplistic right now,
+		 * we just remove all of the GaimBuddy from the client side list
+		 * for this account and then add in all of the contacts from the
+		 * server side list.
+		 */
+		_remove_gaim_buddies(user);
+		_add_gaim_buddies(user);
+
+		rc = nm_send_set_status(user, NM_STATUS_AVAILABLE, NULL, NULL, NULL,
+								NULL);
+		_check_for_disconnect(user, rc);
+
+	} else {
+
+		char *err = g_strdup_printf(_("Login failed (0x%X)."), ret_code);
+
+		gaim_connection_error(gc, err);
+		g_free(err);
+
+	}
+}
+
+/* Handle getstatus response*/
+static void
+_get_status_resp_cb(NMUser * user, NMERR_T ret_code,
+					gpointer resp_data, gpointer user_data)
+{
+	GaimBuddy *buddy;
+	GSList *buddies;
+	GSList *bnode;
+	NMUserRecord *user_record = (NMUserRecord *) resp_data;
+	int status;
+
+	if (user == NULL || user_record == NULL)
+		return;
+
+	if (ret_code == NM_OK) {
+
+		/* Find all Gaim buddies and update their statuses */
+		const char *name = nm_user_record_get_display_id(user_record);
+
+		if (name) {
+			buddies = gaim_find_buddies((GaimAccount *) user->client_data, name);
+			for (bnode = buddies; bnode; bnode = bnode->next) {
+				buddy = (GaimBuddy *) bnode->data;
+				if (buddy) {
+					status = nm_user_record_get_status(user_record);
+					_update_buddy_status(buddy, status, time(0));
+				}
+			}
+		}
+
+	} else {
+
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "_get_status_resp_cb(): rc = 0x%X\n", ret_code);
+
+	}
+}
+
+/* Show an error if the rename failed */
+static void
+_rename_contact_resp_cb(NMUser * user, NMERR_T ret_code,
+						gpointer resp_data, gpointer user_data)
+{
+	if (ret_code != NM_OK) {
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "_rename_contact_resp_cb(): rc = 0x%X\n", ret_code);
+	}
+}
+
+/* Handle the getdetails response and send the message */
+static void
+_get_details_resp_send_msg(NMUser * user, NMERR_T ret_code,
+						   gpointer resp_data, gpointer user_data)
+{
+	GaimConversation *gconv;
+	GaimConnection *gc;
+	NMUserRecord *user_record = NULL;
+	NMContact *cntct = NULL;
+	NMConference *conf;
+	NMMessage *msg = user_data;
+	const char *dn = NULL;
+	const char *name;
+
+	if (user == NULL || msg == NULL)
+		return;
+
+	if (ret_code == NM_OK) {
+		user_record = (NMUserRecord *) resp_data;
+		if (user_record) {
+
+			/* Set the title for the conversation */
+			gconv =	gaim_find_conversation_with_account(nm_user_record_get_display_id(user_record),
+														(GaimAccount *) user->client_data);
+			if (gconv) {
+
+				dn = nm_user_record_get_dn(user_record);
+				if (dn) {
+					cntct = nm_find_contact(user, dn);
+				}
+
+				if (cntct) {
+					gaim_conversation_set_title(gconv,
+												nm_contact_get_display_name(cntct));
+				} else {
+
+					/* Not in the contact list, try to user full name */
+					name = (char *) nm_user_record_get_full_name(user_record);
+					if (name)
+						gaim_conversation_set_title(gconv, name);
+				}
+			}
+
+			/* Add the user record to particpant list */
+			conf = nm_message_get_conference(msg);
+			if (conf) {
+				nm_conference_add_participant(conf, user_record);
+				_send_message(user, msg);
+			}
+		}
+
+	} else {
+		
+		gc = gaim_account_get_connection(user->client_data);
+		if (gc != NULL) {
+			char *err = g_strdup_printf(_("Unable to send message."
+										  " Could not get details for user (0x%X)."),
+										ret_code);
+
+			gaim_notify_error(gc, NULL, err, NULL);
+			g_free(err);
+		}
+
+		if (msg)
+			nm_release_message(msg);
+	}
+}
+
+/* Set up the new GaimBuddy based on the response from getdetails */
+static void
+_get_details_resp_setup_buddy(NMUser * user, NMERR_T ret_code,
+							  gpointer resp_data, gpointer user_data)
+{
+	NMUserRecord *user_record;
+	NMContact *contact;
+	GaimBuddy *buddy;
+	const char *alias;
+	NMERR_T rc = NM_OK;
+
+	if (user == NULL || resp_data == NULL || user_data == NULL)
+		return;
+
+	contact = user_data;
+
+	if (ret_code == NM_OK) {
+		user_record = resp_data;
+
+		buddy = nm_contact_get_data(contact);
+
+		nm_contact_set_user_record(contact, user_record);
+
+		/* Set the display id */
+		gaim_blist_rename_buddy(buddy,
+								nm_user_record_get_display_id(user_record));
+
+		alias = gaim_get_buddy_alias(buddy);
+		if (alias == NULL || (strcmp(alias, buddy->name) == 0)) {
+			gaim_blist_alias_buddy(buddy,
+								   nm_user_record_get_full_name(user_record));
+
+			/* Tell the server about the new display name */
+			rc = nm_send_rename_contact(user, contact,
+										nm_user_record_get_full_name(user_record),
+										NULL, NULL);
+			_check_for_disconnect(user, rc);
+
+		}
+
+
+		/* Get initial status for the buddy */
+		rc = nm_send_get_status(user, resp_data, _get_status_resp_cb, NULL);
+		_check_for_disconnect(user, rc);
+
+/*		nm_release_contact(contact);*/
+
+	}
+
+	if (contact)
+		nm_release_contact(contact);
+}
+
+/* Add the new contact into the GaimBuddy list */
+static void
+_create_contact_resp_cb(NMUser * user, NMERR_T ret_code,
+						gpointer resp_data, gpointer user_data)
+{
+	NMContact *tmp_contact = (NMContact *) user_data;
+	NMContact *new_contact = NULL;
+	NMFolder *folder = NULL;
+	GaimGroup *group;
+	GaimBuddy *buddy;
+	const char *folder_name = NULL;
+	NMERR_T rc = NM_OK;
+
+	if (user == NULL)
+		return;
+
+	if (ret_code == NM_OK) {
+
+		new_contact = (NMContact *) resp_data;
+		if (new_contact == NULL || tmp_contact == NULL)
+			return;
+
+		/* Get the userid and folder name for the new contact */
+		folder = nm_find_folder_by_id(user,
+									  nm_contact_get_parent_id(new_contact));
+		if (folder) {
+			folder_name = nm_folder_get_name(folder);
+		}
+
+		/* Re-add the buddy now that we got the okay from the server */
+		if (folder_name && (group = gaim_find_group(folder_name))) {
+
+			const char *alias = nm_contact_get_display_name(tmp_contact);
+			const char *display_id = nm_contact_get_display_id(new_contact);
+
+			if (display_id == NULL)
+				display_id = nm_contact_get_dn(new_contact);
+
+			if (alias && strcmp(alias, display_id)) {
+
+				/* The user requested an alias, tell the server about it. */
+				rc = nm_send_rename_contact(user, new_contact, alias,
+											_rename_contact_resp_cb, NULL);
+				_check_for_disconnect(user, rc);
+
+			} else {
+
+				alias = "";
+
+			}
+
+			/* Add it to the gaim buddy list if it is not there */
+			buddy = gaim_find_buddy_in_group(user->client_data, display_id, group);
+			if (buddy == NULL) {
+				buddy = gaim_buddy_new(user->client_data, display_id, alias);
+				gaim_blist_add_buddy(buddy, NULL, group, NULL);
+			}
+
+			/* Save the new buddy as part of the contact object */
+			nm_contact_set_data(new_contact, (gpointer) buddy);
+
+			/* We need details for the user before we can setup the 
+			 * new Gaim buddy. We always call this because the
+			 * 'createcontact' response fields do not always contain
+			 * everything that we need.
+			 */
+			nm_contact_add_ref(new_contact);
+
+			rc = nm_send_get_details(user, nm_contact_get_dn(new_contact),
+									 _get_details_resp_setup_buddy, new_contact);
+			_check_for_disconnect(user, rc);
+
+		}
+
+	} else {
+		GaimConnection *gc = gaim_account_get_connection(user->client_data);
+		const char *name = nm_contact_get_dn(tmp_contact);
+		char *err;
+
+		err =
+			g_strdup_printf(_("Unable to add %s to your buddy list (0x%X)."),
+							name, ret_code);
+		gaim_notify_error(gc, NULL, err, NULL);
+		g_free(err);
+
+	}
+
+	if (tmp_contact)
+		nm_release_contact(tmp_contact);
+}
+
+/* Show an error if we failed to send the message */
+static void
+_send_message_resp_cb(NMUser * user, NMERR_T ret_code,
+					  gpointer resp_data, gpointer user_data)
+{
+	GaimConnection *gc;
+	char *err = NULL;
+
+	if (user == NULL)
+		return;
+
+	if (ret_code != NM_OK) {
+		gc = gaim_account_get_connection(user->client_data);
+
+		/* TODO: Improve this! message to who or for what conference? */
+		err = g_strdup_printf(_("Unable to send message (0x%X)."),
+							  ret_code);
+		gaim_notify_error(gc, NULL, err, NULL);
+		g_free(err);
+	}
+}
+
+/* Show an error if the remove failed */
+static void
+_remove_contact_resp_cb(NMUser * user, NMERR_T ret_code,
+						gpointer resp_data, gpointer user_data)
+{
+	if (ret_code != NM_OK) {
+		/* TODO: Display an error? */
+
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "_remove_contact_resp_cb(): rc = 0x%x\n", ret_code);
+	}
+}
+
+/* Show an error if the remove failed */
+static void
+_remove_folder_resp_cb(NMUser * user, NMERR_T ret_code,
+					   gpointer resp_data, gpointer user_data)
+{
+	if (ret_code != NM_OK) {
+		/* TODO: Display an error? */
+
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "_remove_folder_resp_cb(): rc = 0x%x\n", ret_code);
+	}
+}
+
+/* Show an error if the move failed */
+static void
+_move_contact_resp_cb(NMUser * user, NMERR_T ret_code,
+					  gpointer resp_data, gpointer user_data)
+{
+	if (ret_code != NM_OK) {
+		/* TODO: Display an error? */
+
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "_move_contact_resp_cb(): rc = 0x%x\n", ret_code);
+	}
+}
+
+/* Show an error if the rename failed */
+static void
+_rename_folder_resp_cb(NMUser * user, NMERR_T ret_code,
+					   gpointer resp_data, gpointer user_data)
+{
+	if (ret_code != NM_OK) {
+		/* TODO: Display an error? */
+
+		gaim_debug(GAIM_DEBUG_INFO, "novell",
+				   "_rename_folder_resp_cb(): rc = 0x%x\n", ret_code);
+	}
+}
+
+/* If the createconf was successful attempt to send the message,
+ * otherwise display an error message to the user.
+ */
+static void
+_createconf_resp_send_msg(NMUser * user, NMERR_T ret_code,
+						  gpointer resp_data, gpointer user_data)
+{
+	NMConference *conf;
+	NMMessage *msg = user_data;
+
+	if (user == NULL || msg == NULL)
+		return;
+
+	if (ret_code == NM_OK) {
+		_send_message(user, msg);
+	} else {
+
+		if ((conf = nm_message_get_conference(msg))) {
+
+			GaimConnection *gc = gaim_account_get_connection(user->client_data);
+			const char *name = NULL;
+			char *err;
+			NMUserRecord *ur;
+
+			ur = nm_conference_get_participant(conf, 0);
+			if (ur)
+				name = nm_user_record_get_userid(ur);
+
+			if (name)
+				err = g_strdup_printf(_("Unable to send message to %s."
+										" Could not create the conference (0x%X)."),
+									  name, ret_code);
+			else
+				err = g_strdup_printf(_("Unable to send message."
+										" Could not create the conference (0x%X)."),
+									  ret_code);
+
+			gaim_notify_error(gc, NULL, err, NULL);
+			g_free(err);
+		}
+
+		if (msg)
+			nm_release_message(msg);
+	}
+}
+
+/* Move contact to newly created folder */
+static void
+_create_folder_resp_move_contact(NMUser * user, NMERR_T ret_code,
+								 gpointer resp_data, gpointer user_data)
+{
+	NMContact *contact = user_data;
+	NMFolder *new_folder;
+	char *folder_name = resp_data;
+	NMERR_T rc = NM_OK;
+
+	if (user == NULL || folder_name == NULL || contact == NULL) {
+
+		if (folder_name)
+			g_free(folder_name);
+
+		return;
+	}
+
+	if (ret_code == NM_OK || ret_code == 0xD126) {
+		new_folder = nm_find_folder(user, folder_name);
+		if (new_folder) {
+
+			/* Tell the server to move the contact to the new folder */
+/*			rc = nm_send_move_contact(user, contact, new_folder,
+			_move_contact_resp_cb, NULL); */
+	
+			rc = nm_send_create_contact(user, new_folder, contact,
+										NULL, NULL);
+
+			_check_for_disconnect(user, rc);
+
+		}
+	} else {
+		GaimConnection *gc = gaim_account_get_connection(user->client_data);
+		char *err = g_strdup_printf(_("Unable to move user %s"
+									  " to folder %s in the server side list."
+									  " Error while creating folder (0x%X)."),
+									nm_contact_get_dn(contact),
+									folder_name,
+									ret_code);
+
+		gaim_notify_error(gc, NULL, err, NULL);
+		g_free(err);
+	}
+
+	if (folder_name)
+		g_free(folder_name);
+}
+
+/* Add contact to newly create folder */
+static void
+_create_folder_resp_add_contact(NMUser * user, NMERR_T ret_code,
+								gpointer resp_data, gpointer user_data)
+{
+	NMContact *contact = (NMContact *) user_data;
+	NMFolder *folder;
+	char *folder_name = (char *) resp_data;
+	NMERR_T rc = NM_OK;
+
+	if (user == NULL || folder_name == NULL || contact == NULL) {
+
+		if (contact)
+			nm_release_contact(contact);
+
+		if (folder_name)
+			g_free(folder_name);
+
+		return;
+	}
+
+	if (ret_code == NM_OK || ret_code == 0xD126) {
+		folder = nm_find_folder(user, folder_name);
+		if (folder) {
+
+			rc = nm_send_create_contact(user, folder, contact,
+										_create_contact_resp_cb, contact);
+			_check_for_disconnect(user, rc);
+		}
+	} else {
+		GaimConnection *gc = gaim_account_get_connection(user->client_data);
+		const char *name = nm_contact_get_dn(contact);
+		char *err =
+			g_strdup_printf(_("Unable to add %s to your buddy list."
+							 " Error creating folder in server side list (0x%X)."),
+							name, ret_code);
+
+		gaim_notify_error(gc, NULL, err, NULL);
+
+		nm_release_contact(contact);
+		g_free(err);
+	}
+
+	g_free(folder_name);
+}
+
+static void
+_join_conf_resp_cb(NMUser * user, NMERR_T ret_code,
+				   gpointer resp_data, gpointer user_data)
+{
+	GaimConversation *chat;
+	GaimConnection *gc;
+	NMUserRecord *ur;
+	NMConference *conference = user_data;
+	const char *name;
+	char *conf_name;
+	int i, count;
+
+	if (user == NULL || conference == NULL)
+		return;
+
+	gc = gaim_account_get_connection(user->client_data);
+
+	if (ret_code == NM_OK) {
+		conf_name = g_strdup_printf(_("GroupWise Conference %d"),
+									++user->conference_count);
+		chat = serv_got_joined_chat(gc, user->conference_count, conf_name);
+		if (chat) {
+
+			nm_conference_set_data(conference, (gpointer) chat);
+
+			count = nm_conference_get_participant_count(conference);
+			for (i = 0; i < count; i++) {
+				ur = nm_conference_get_participant(conference, i);
+				if (ur) {
+					name = nm_user_record_get_display_id(ur);
+					gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL);
+				}
+			}
+		}
+		g_free(conf_name);
+	}
+}
+
+/* Show info returned by getdetails */
+static void
+_get_details_resp_show_info(NMUser * user, NMERR_T ret_code,
+							gpointer resp_data, gpointer user_data)
+{
+	GaimConnection *gc;
+	NMUserRecord *user_record;
+	char *name;
+	char *err;
+
+	if (user == NULL)
+		return;
+
+	name = user_data;
+
+	if (ret_code == NM_OK) {
+		user_record = (NMUserRecord *) resp_data;
+		if (user_record) {
+			_show_info(gaim_account_get_connection(user->client_data),
+					   user_record);
+		}
+	} else {
+		gc = gaim_account_get_connection(user->client_data);
+		err =
+			g_strdup_printf(_("Could not get details for user %s (0x%X)."), name,
+							ret_code);
+		gaim_notify_error(gc, NULL, err, NULL);
+		g_free(err);
+	}
+
+	if (name)
+		g_free(name);
+}
+
+/*******************************************************************************
+ * Helper functions
+ ******************************************************************************/
+
+static char *
+_user_agent_string()
+{
+
+#if !defined(_WIN32)
+
+	const char *sysname = "";
+	const char *release = "";
+	const char *template = "Gaim/%s (%s; %s)";
+	struct utsname u;
+	
+	if (uname(&u) == 0) {
+		sysname = u.sysname;
+		release = u.release;
+	} else {
+		sysname = "Linux";
+		release = "Unknown";
+	}
+
+	return g_strdup_printf(template, VERSION, sysname, release);
+
+#else
+
+	const char *sysname = "";
+	const char *template = "Gaim/%s (%s; %d.%d)";
+	OSVERSIONINFO os_info;
+	SYSTEM_INFO sys_info;
+	
+	os_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+	GetVersionEx(&os_info);
+	GetSystemInfo(&sys_info);
+	
+	if (os_info.dwPlatformId == VER_PLATFORM_WIN32_NT)  {
+		switch (os_info.dwMajorVersion) {
+			case 3:
+			case 4:			
+				sysname = "Windows NT";
+				break;
+			case 5:			  
+				switch (os_info.dwMinorVersion) {
+					case 0:
+						sysname = "Windows 2000";
+						break;
+					case 1:
+						sysname = "Windows XP";
+						break;
+					case 2:
+						sysname = "Windows Server 2003";
+						break;
+					default:
+						sysname = "Windows";
+						break;
+				}
+				break;
+			default:
+				sysname = "Windows";
+				break;
+		}
+		
+	}	else if (os_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
+		switch (os_info.dwMinorVersion) {
+			case 0:
+				sysname = "Windows 95";
+				break;
+			case 10:
+				sysname = "Windows 98";
+				break;
+			case 90:
+				sysname = "Windows ME";
+				break;
+			default:
+				sysname = "Windows";
+				break;
+		}
+	} else {
+		sysname = "Windows";
+	}
+	
+	return g_strdup_printf(template, VERSION, sysname,
+						   os_info.dwMajorVersion, os_info.dwMinorVersion);
+	
+#endif
+	
+	
+}
+
+static gboolean
+_is_disconnect_error(NMERR_T err)
+{
+	return (err == NMERR_TCP_WRITE ||
+			err == NMERR_TCP_READ || err == NMERR_PROTOCOL);
+}
+
+static gboolean
+_check_for_disconnect(NMUser * user, NMERR_T err)
+{
+	GaimConnection *gc = gaim_account_get_connection(user->client_data);
+
+	if (_is_disconnect_error(err)) {
+
+		gaim_connection_error(gc, _("Error communicating with server."
+									" Closing connection."));
+		return TRUE;
+
+	}
+
+	return FALSE;
+}
+
+/* Check to see if the conference is instantiated, if so send the message.
+ * If not send the create conference -- the response handler for the createconf
+ * will call this function again.
+ */
+static void
+_send_message(NMUser * user, NMMessage * message)
+{
+	NMConference *conf;
+	NMERR_T rc = NM_OK;
+
+	conf = nm_message_get_conference(message);
+	if (conf) {
+		/* We have a conference make sure that the 
+		   server knows about it already. */
+		if (nm_conference_is_instantiated(conf)) {
+
+			/* We have everything that we need...finally! */
+			rc = nm_send_message(user, message, _send_message_resp_cb);
+			_check_for_disconnect(user, rc);
+
+			nm_release_message(message);
+
+		} else {
+			rc = nm_send_create_conference(user, conf,
+										   _createconf_resp_send_msg, message);
+			_check_for_disconnect(user, rc);
+		}
+	}
+}
+
+/* Update the status of the given buddy in the Gaim buddy list */
+static void
+_update_buddy_status(GaimBuddy * buddy, int status, int gmt)
+{
+	GaimConnection *gc = gaim_account_get_connection(buddy->account);
+	int gstatus = status << 1;
+	int idle = 0;
+	int loggedin = 1;
+
+	switch (status) {
+		case NM_STATUS_AVAILABLE:
+			/*nothing to do */
+			break;
+		case NM_STATUS_AWAY:
+		case NM_STATUS_BUSY:
+			gstatus |= UC_UNAVAILABLE;
+			break;
+		case NM_STATUS_OFFLINE:
+			loggedin = 0;
+			gstatus |= UC_UNAVAILABLE;
+			break;
+		case NM_STATUS_AWAY_IDLE:
+			idle = gmt;
+			gstatus |= UC_UNAVAILABLE;
+			break;
+		default:
+			gstatus |= UC_UNAVAILABLE;
+			loggedin = 0;
+			break;
+	}
+
+	serv_got_update(gc, buddy->name, loggedin, 0, 0, idle, gstatus);
+}
+
+/* Iterate through the cached Gaim buddy list and remove all buddies
+ * for this account.
+ */
+static void
+_remove_gaim_buddies(NMUser * user)
+{
+	GaimBlistNode *gnode;
+	GaimBlistNode *cnode;
+	GaimBlistNode *bnode;
+	GaimGroup *group;
+	GaimBuddy *buddy;
+	GaimBuddyList *blist;
+	GSList *rem_list = NULL;
+	GSList *l;
+
+	if ((blist = gaim_get_blist())) {
+		for (gnode = blist->root; gnode; gnode = gnode->next) {
+			if (!GAIM_BLIST_NODE_IS_GROUP(gnode))
+				continue;
+			group = (GaimGroup *) gnode;
+			for (cnode = gnode->child; cnode; cnode = cnode->next) {
+				if (!GAIM_BLIST_NODE_IS_CONTACT(cnode))
+					continue;
+				for (bnode = cnode->child; bnode; bnode = bnode->next) {
+					if (!GAIM_BLIST_NODE_IS_BUDDY(bnode))
+						continue;
+					buddy = (GaimBuddy *) bnode;
+					if (buddy->account == user->client_data) {
+						rem_list = g_slist_append(rem_list, buddy);
+					}
+				}
+			}
+		}
+
+		if (rem_list) {
+			for (l = rem_list; l; l = l->next) {
+				gaim_blist_remove_buddy(l->data);
+			}
+			g_slist_free(rem_list);
+		}
+	}
+}
+
+/* Add all of the contacts in the given folder to the Gaim buddy list */
+static void
+_add_contacts_to_gaim_blist(NMUser * user, NMFolder * folder)
+{
+	NMUserRecord *user_record = NULL;
+	NMContact *contact = NULL;
+	GaimBuddy *buddy = NULL;
+	NMERR_T cnt = 0, i;
+	const char *text = NULL;
+	const char *name = NULL;
+	int status = 0;
+
+	/* Get each contact for this folder */
+	cnt = nm_folder_get_contact_count(folder);
+	for (i = 0; i < cnt; i++) {
+		contact = nm_folder_get_contact(folder, i);
+		if (contact) {
+
+			name = nm_contact_get_display_id(contact);
+			if (name) {
+				/* Add it to the gaim buddy list */
+				buddy = gaim_buddy_new(user->client_data,
+									   name,
+									   nm_contact_get_display_name(contact));
+
+				/* Does the Gaim group exist already? */
+				GaimGroup *group = gaim_find_group(nm_folder_get_name(folder));
+
+				if (group == NULL) {
+					group = gaim_group_new(nm_folder_get_name(folder));
+					gaim_blist_add_group(group, NULL);
+				}
+
+				/* Set the initial status for the buddy */
+				user_record = nm_contact_get_user_record(contact);
+				if (user_record) {
+					status = nm_user_record_get_status(user_record);
+					text = nm_user_record_get_status_text(user_record);
+				}
+
+				gaim_blist_add_buddy(buddy, NULL, group, NULL);
+				_update_buddy_status(buddy, status, time(0));
+
+				/* Save the new buddy as part of the contact object */
+				nm_contact_set_data(contact, (gpointer) buddy);
+			}
+
+		} else {
+			/* NULL contact. This should not happen, but
+			 * let's break out of the loop. 
+			 */
+			break;
+		}
+	}
+
+}
+
+/* Add all of the server side contacts to the Gaim buddy list. */
+static void
+_add_gaim_buddies(NMUser * user)
+{
+	NMERR_T cnt = 0, i;
+	NMFolder *root_folder = NULL;
+	NMFolder *folder = NULL;
+
+	root_folder = nm_get_root_folder(user);
+	if (root_folder) {
+
+		/* Add contacts for the sub folders */
+		cnt = nm_folder_get_subfolder_count(root_folder);
+		for (i = 0; i < cnt; i++) {
+			folder = nm_folder_get_subfolder(root_folder, i);
+			if (folder) {
+				_add_contacts_to_gaim_blist(user, folder);
+			}
+		}
+
+		/* Add contacts for the root folder */
+		_add_contacts_to_gaim_blist(user, root_folder);
+	}
+}
+
+/* Display a dialog box showing the properties for the given user record */
+static void
+_show_info(GaimConnection * gc, NMUserRecord * user_record)
+{
+	GString *info_text;
+	int count, i;
+	NMProperty *property;
+	const char *tag, *value;
+
+	info_text = g_string_new("");
+
+	tag = _("Userid");
+	value = nm_user_record_get_userid(user_record);
+	if (value) {
+		g_string_append_printf(info_text, "<b>%s:</b> %s<br/>\n", tag, value);
+	}
+
+/*	tag = _("DN");
+	value = nm_user_record_get_dn(user_record);
+	if (value) {
+	g_string_append_printf(info_text, "<b>%s:</b> %s<br/>\n",
+	tag, value);
+	}
+*/
+
+	tag = _("Full name");
+	value = nm_user_record_get_full_name(user_record);
+	if (value) {
+		g_string_append_printf(info_text, "<b>%s:</b> %s<br/>\n", tag, value);
+	}
+
+	count = nm_user_record_get_property_count(user_record);
+	for (i = 0; i < count; i++) {
+		property = nm_user_record_get_property(user_record, i);
+		if (property) {
+			tag = nm_property_get_tag(property);
+			value = nm_property_get_value(property);
+			if (tag && value) {
+				g_string_append_printf(info_text, "<b>%s:</b> %s<br/>\n",
+									   tag, value);
+			}
+			nm_release_property(property);
+		}
+	}
+
+	gaim_notify_formatted(NULL, "Title", _("User Properties"),
+						  NULL, info_text->str, NULL, NULL);
+
+	g_string_free(info_text, TRUE);
+}
+
+/* Send a join conference, the first item in the parms list is the
+ * NMUser object and the second item is the conference to join.
+ * This callback is passed to gaim_request_action when we ask the
+ * user if they want to join the conference.
+ */
+static void
+_join_conference_cb(GSList * parms)
+{
+	NMUser *user;
+	NMConference *conference;
+	NMERR_T rc = NM_OK;
+
+	if (parms == NULL || g_slist_length(parms) != 2)
+		return;
+
+	user = g_slist_nth_data(parms, 0);
+	conference = g_slist_nth_data(parms, 1);
+
+	if (user && conference) {
+		rc = nm_send_join_conference(user, conference,
+									 _join_conf_resp_cb, conference);
+		_check_for_disconnect(user, rc);
+	}
+
+	g_slist_free(parms);
+}
+
+/* Send a reject conference, the first item in the parms list is the
+ * NMUser object and the second item is the conference to reject.
+ * This callback is passed to gaim_request_action when we ask the
+ * user if they want to joing the conference.
+ */
+static void
+_reject_conference_cb(GSList * parms)
+{
+	NMUser *user;
+	NMConference *conference;
+	NMERR_T rc = NM_OK;
+
+	if (parms == NULL || g_slist_length(parms) != 2)
+		return;
+
+	user = g_slist_nth_data(parms, 0);
+	conference = g_slist_nth_data(parms, 1);
+
+	if (user && conference) {
+		rc = nm_send_reject_conference(user, conference, NULL, NULL);
+		_check_for_disconnect(user, rc);
+	}
+
+	g_slist_free(parms);
+}
+
+/*******************************************************************************
+ * Connect and recv callbacks
+ ******************************************************************************/
+
+static void
+novell_ssl_connect_error(GaimSslConnection * gsc,
+						 GaimSslErrorType error, gpointer data)
+{
+	gaim_connection_error((GaimConnection *)data,
+						  _("Unable to make SSL connection to server."));
+}
+
+static void
+novell_ssl_recv_cb(gpointer data, GaimSslConnection * gsc,
+				   GaimInputCondition condition)
+{
+	GaimConnection *gc = data;
+	NMUser *user;
+	NMERR_T rc;
+
+	if (gc == NULL)
+		return;
+
+	user = gc->proto_data;
+	if (user == NULL)
+		return;
+
+	rc = nm_process_new_data(user);
+	if (rc != NM_OK) {
+
+		if (_is_disconnect_error(rc)) {
+			gaim_connection_error(gc,
+								  _("Error communicating with server."
+									" Closing connection."));
+		} else {
+
+			char *error;
+
+			error = g_strdup_printf(_("Error processing event or response."
+									  " (0x%X)"), rc);
+			gaim_notify_error(gc, NULL, error, NULL);
+			g_free(error);
+
+		}
+
+	}
+}
+
+static void
+novell_ssl_connected_cb(gpointer data, GaimSslConnection * gsc,
+						GaimInputCondition cond)
+{
+	GaimConnection *gc = data;
+	NMUser *user;
+	NMConn *conn;
+	NMERR_T rc = 0;
+	const char *pwd = NULL;
+	const char *my_addr = NULL;
+	char *ua = NULL;
+
+	if (gc == NULL || gsc == NULL)
+		return;
+
+	user = gc->proto_data;
+	if ((user == NULL) || (conn = user->conn) == NULL)
+		return;
+
+	conn->ssl_conn = g_new0(NMSSLConn, 1);
+	conn->ssl_conn->data = gsc;
+	conn->ssl_conn->read = (nm_ssl_read_cb) gaim_ssl_read;
+	conn->ssl_conn->write = (nm_ssl_write_cb) gaim_ssl_write;
+
+	gaim_connection_update_progress(gc, _("Authenticating..."),
+									2, NOVELL_CONNECT_STEPS);
+
+	my_addr = gaim_network_get_ip_for_account(user->client_data, gsc->fd);
+	pwd = gaim_account_get_password(user->client_data);
+	ua = _user_agent_string();
+
+	rc = nm_send_login(user, pwd, my_addr, ua, _login_resp_cb, NULL);
+	if (rc == NM_OK) {
+		conn->connected = TRUE;
+		gaim_ssl_input_add(gsc, novell_ssl_recv_cb, gc);
+	} else {
+		gaim_connection_error(gc, _("Unable to connect to server."));
+	}
+	
+	gaim_connection_update_progress(gc, _("Waiting for response..."),
+									3, NOVELL_CONNECT_STEPS);
+
+	g_free(ua);
+}
+
+/*******************************************************************************
+ * Event callback and event handlers
+ ******************************************************************************/
+
+static void
+_evt_receive_message(NMUser * user, NMEvent * event)
+{
+	NMUserRecord *user_record = NULL;
+	NMContact *contact = NULL;
+	GaimConversation *gconv;
+	NMConference *conference;
+	GaimConvImFlags imflags;
+
+	conference = nm_event_get_conference(event);
+	if (conference) {
+
+		GaimConversation *chat = nm_conference_get_data(conference);
+
+		/* Is this a single person 'conversation' or a conference? */
+		if (chat == NULL && nm_conference_get_participant_count(conference) == 1) {
+
+			user_record = nm_find_user_record(user, nm_event_get_source(event));
+			if (user_record) {
+
+				imflags = 0;
+				if (nm_event_get_type(event) == NMEVT_RECEIVE_AUTOREPLY)
+					imflags |= GAIM_CONV_IM_AUTO_RESP;
+
+				serv_got_im(gaim_account_get_connection(user->client_data),
+							nm_user_record_get_display_id(user_record),
+							nm_event_get_text(event), imflags,
+							nm_event_get_gmt(event));
+
+				gconv =	gaim_find_conversation_with_account(
+					nm_user_record_get_display_id(user_record),
+					(GaimAccount *) user->client_data);
+				if (gconv) {
+
+					contact = nm_find_contact(user, nm_event_get_source(event));
+					if (contact) {
+
+						gaim_conversation_set_title(
+							gconv,
+							nm_contact_get_display_name(contact));
+
+
+					} else {
+
+						const char *name =
+							nm_user_record_get_full_name(user_record);
+
+						if (name == NULL)
+							name = nm_user_record_get_userid(user_record);
+
+						gaim_conversation_set_title(gconv, name);
+					}
+
+				}
+
+			} else {
+				/* this should not happen, see the event code.
+				 * the event code will get the contact details from
+				 * the server if it does not have them before calling
+				 * the event callback.
+				 */
+			}
+
+		} else if (chat) {
+
+			/* get the contact for send if we have one */
+			NMContact *contact = nm_find_contact(user,
+												 nm_event_get_source(event));
+
+			/* get the user record for the sender */
+			user_record = nm_find_user_record(user, nm_event_get_source(event));
+			if (user_record) {
+				const char *name = nm_contact_get_display_name(contact);
+
+				if (name == NULL) {
+					name = nm_user_record_get_full_name(user_record);
+					if (name == NULL)
+						name = nm_user_record_get_display_id(user_record);
+				}
+
+				serv_got_chat_in(gaim_account_get_connection(user->client_data),
+								 gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)),
+								 name,
+								 0, nm_event_get_text(event),
+								 nm_event_get_gmt(event));
+			}
+		}
+	}
+}
+
+static void
+_evt_conference_left(NMUser * user, NMEvent * event)
+{
+	GaimConversation *chat;
+	NMConference *conference;
+
+	conference = nm_event_get_conference(event);
+	if (conference) {
+		chat = nm_conference_get_data(conference);
+		if (chat) {
+			NMUserRecord *ur = nm_find_user_record(user,
+												   nm_event_get_source(event));
+
+			if (ur)
+				gaim_conv_chat_remove_user(GAIM_CONV_CHAT(chat),
+										   nm_user_record_get_display_id(ur),
+										   NULL);
+		}
+	}
+}
+
+static void
+_evt_conference_invite(NMUser * user, NMEvent * event)
+{
+	NMUserRecord *ur;
+	GSList *parms = NULL;
+	const char *title = NULL;
+	const char *secondary = NULL;
+	const char *name = NULL;
+	char *primary = NULL;
+	time_t gmt;
+
+	ur = nm_find_user_record(user, nm_event_get_source(event));
+	if (ur)
+		name = nm_user_record_get_full_name(ur);
+
+	if (name == NULL)
+		name = nm_event_get_source(event);
+
+	gmt = nm_event_get_gmt(event);
+	title = _("Invitation to Conversation");
+	primary = g_strdup_printf(_("Invitation from: %s\n\nSent: %s"),
+							  name, asctime(localtime(&gmt)));
+	secondary = _("Would you like to join the conversation?");
+
+	/* Set up parms list for the callbacks
+	 * We need to send the NMUser object and
+	 * the NMConference object to the callbacks
+	 */
+	parms = NULL;
+	parms = g_slist_append(parms, user);
+	parms = g_slist_append(parms, nm_event_get_conference(event));
+
+	/* Prompt the user */
+	gaim_request_action(NULL, title, primary, secondary, -1, parms, 2,
+						_("Yes"), G_CALLBACK(_join_conference_cb),
+						_("No"), G_CALLBACK(_reject_conference_cb));
+
+	g_free(primary);
+}
+
+
+static void
+_evt_conference_joined(NMUser * user, NMEvent * event)
+{
+	GaimConversation *chat = NULL;
+	GaimConnection *gc;
+	NMConference *conference = NULL;
+	NMUserRecord *ur = NULL;
+	const char *name;
+	char *conf_name;
+
+	gc = gaim_account_get_connection(user->client_data);
+	if (gc == NULL)
+		return;
+
+	conference = nm_event_get_conference(event);
+	if (conference) {
+		chat = nm_conference_get_data(conference);
+		if (nm_conference_get_participant_count(conference) == 2 && chat == NULL) {
+			ur = nm_conference_get_participant(conference, 0);
+			if (ur) {
+				conf_name = g_strdup_printf(_("GroupWise Conference %d"),
+											++user->conference_count);
+				chat =
+					serv_got_joined_chat(gc, user->conference_count, conf_name);
+				g_free(conf_name);
+				if (chat) {
+
+					nm_conference_set_data(conference, (gpointer) chat);
+
+					name = nm_user_record_get_display_id(ur);
+					gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL);
+
+				}
+			}
+		}
+
+		if (chat != NULL) {
+			ur = nm_find_user_record(user, nm_event_get_source(event));
+			if (ur) {
+				name = nm_user_record_get_display_id(ur);
+				gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL);
+			}
+		}
+	}
+}
+
+static void
+_evt_status_change(NMUser * user, NMEvent * event)
+{
+	GaimBuddy *buddy = NULL;
+	GSList *buddies;
+	GSList *bnode;
+	NMUserRecord *user_record;
+	const char *display_id;
+	int status;
+
+	user_record = nm_event_get_user_record(event);
+	if (user_record) {
+
+		/* Retrieve new status */
+		status = nm_user_record_get_status(user_record);
+
+		/* Update status for buddy in all folders */
+		display_id = nm_user_record_get_display_id(user_record);
+		buddies = gaim_find_buddies(user->client_data, display_id);
+		for (bnode = buddies; bnode; bnode = bnode->next) {
+			buddy = (GaimBuddy *) bnode->data;
+			if (buddy) {
+				_update_buddy_status(buddy, status, nm_event_get_gmt(event));
+			}
+		}
+
+		g_slist_free(buddies);
+
+	}
+}
+
+static void
+_evt_user_disconnect(NMUser * user, NMEvent * event)
+{
+	GaimConnection *gc;
+
+	gc = gaim_account_get_connection((GaimAccount *) user->client_data);
+	if (gc)
+		gaim_connection_error(gc, _("You have been logged out because you"
+									" logged in at another workstation."));
+}
+
+static void
+_evt_user_typing(NMUser * user, NMEvent * event)
+{
+	GaimConnection *gc;
+	NMUserRecord *user_record = NULL;
+
+	gc = gaim_account_get_connection((GaimAccount *) user->client_data);
+	if (gc) {
+		user_record = nm_find_user_record(user, nm_event_get_source(event));
+		if (user_record) {
+			serv_got_typing(gc, nm_user_record_get_display_id(user_record),
+							30, GAIM_TYPING);
+		}
+	}
+}
+
+static void
+_evt_user_not_typing(NMUser * user, NMEvent * event)
+{
+	GaimConnection *gc;
+	NMUserRecord *user_record;
+
+	gc = gaim_account_get_connection((GaimAccount *) user->client_data);
+	if (gc) {
+		user_record = nm_find_user_record(user, nm_event_get_source(event));
+		if (user_record) {
+			serv_got_typing_stopped(gc,
+									nm_user_record_get_display_id(user_record));
+		}
+	}
+}
+
+static void
+_evt_undeliverable_status(NMUser * user, NMEvent * event)
+{
+	NMUserRecord *ur;
+	GaimConversation *gconv;
+	char *str;
+
+	ur = nm_find_user_record(user, nm_event_get_source(event));
+	if (ur) {
+		gconv =
+			gaim_find_conversation_with_account(nm_user_record_get_display_id(ur),
+												user->client_data);
+		if (gconv) {
+			const char *name = nm_user_record_get_full_name(ur);
+
+			if (name == NULL) {
+				name = nm_user_record_get_display_id(ur);
+			}
+			str = g_strdup_printf(_("%s appears to be offline and did not receive"
+									" the message that you just sent."), name);
+			gaim_conversation_write(gconv, NULL, str,
+									GAIM_MESSAGE_SYSTEM, time(NULL));
+			g_free(str);
+		}
+	}
+}
+
+static void
+_event_callback(NMUser * user, NMEvent * event)
+{
+	if (user == NULL || event == NULL)
+		return;
+
+	switch (nm_event_get_type(event)) {
+		case NMEVT_STATUS_CHANGE:
+			_evt_status_change(user, event);
+			break;
+		case NMEVT_RECEIVE_AUTOREPLY:
+		case NMEVT_RECEIVE_MESSAGE:
+			_evt_receive_message(user, event);
+			break;
+		case NMEVT_USER_DISCONNECT:
+			_evt_user_disconnect(user, event);
+			break;
+		case NMEVT_USER_TYPING:
+			_evt_user_typing(user, event);
+			break;
+		case NMEVT_USER_NOT_TYPING:
+			_evt_user_not_typing(user, event);
+			break;
+		case NMEVT_SERVER_DISCONNECT:
+			/* Nothing to do? */
+			break;
+		case NMEVT_INVALID_RECIPIENT:
+			break;
+		case NMEVT_UNDELIVERABLE_STATUS:
+			_evt_undeliverable_status(user, event);
+			break;
+		case NMEVT_CONFERENCE_INVITE_NOTIFY:
+			/* Someone else has been invited to join a
+			 * conference that we are currently a part of 
+			 */
+			/* TODO: show the invite notify in chat window */
+			break;
+		case NMEVT_CONFERENCE_INVITE:
+			/* We have been invited to join a conference */
+			_evt_conference_invite(user, event);
+			break;
+		case NMEVT_CONFERENCE_JOINED:
+			/* Some one has joined a conference that we
+			 * are a part of
+			 */
+			_evt_conference_joined(user, event);
+			break;
+		case NMEVT_CONFERENCE_LEFT:
+			/* Someone else has left a conference that we
+			 * are currently a part of 
+			 */
+			_evt_conference_left(user, event);
+			break;
+		default:
+			gaim_debug(GAIM_DEBUG_INFO, "novell",
+					   "_event_callback(): unhandled event, %d\n",
+					   nm_event_get_type(event));
+			break;	
+	}
+}
+
+/*******************************************************************************
+ * Prpl Ops
+ ******************************************************************************/
+
+static void
+novell_login(GaimAccount * account)
+{
+	GaimConnection *gc;
+	NMUser *user = NULL;
+	const char *server;
+	const char *name;
+	int port;
+
+	if (account == NULL)
+		return;
+
+	gc = gaim_account_get_connection(account);
+	if (gc == NULL)
+		return;
+
+	server = gaim_account_get_string(account, "server", NULL);
+	if (server == NULL || *server == '\0') {
+
+		/* TODO: Would be nice to prompt if not set!      
+		 *  gaim_request_fields(gc, _("Server Address"),...);
+		 */
+
+		/* ...but for now just error out with a nice message. */
+		gaim_connection_error(gc, _("Unable to connect to server."
+									" Please enter the address of the server"
+									" you wish to connect to."));
+		return;
+	}
+
+	port = gaim_account_get_int(account, "port", DEFAULT_PORT);
+	name = gaim_account_get_username(account);
+
+	user = nm_initialize_user(name, server, port, account, _event_callback);
+	if (user) {
+		/* save user */
+		gc->proto_data = user;
+
+		/* connect to the server */
+		gaim_connection_update_progress(gc, _("Connecting"),
+										1, NOVELL_CONNECT_STEPS);
+
+		user->conn->use_ssl = TRUE;
+		if (gaim_ssl_connect(user->client_data, user->conn->addr,
+							 user->conn->port, novell_ssl_connected_cb,
+							 novell_ssl_connect_error, gc) == NULL) {
+			gaim_connection_error(gc, _("Error."
+										" SSL support is not installed."));
+		}
+	}	
+}
+
+static void
+novell_close(GaimConnection * gc)
+{
+	NMUser *user;
+	NMConn *conn;
+
+	if (gc == NULL)
+		return;
+
+	user = gc->proto_data;
+	if (user) {
+		conn = user->conn;
+		if (conn) {
+			if (conn->use_ssl && user->conn->ssl_conn) {
+				gaim_ssl_close(user->conn->ssl_conn->data);
+			} else {
+				gaim_input_remove(gc->inpa);
+				close(conn->fd);
+			}
+		}
+		nm_deinitialize_user(user);
+	}
+	gc->proto_data = NULL;
+}
+
+static int
+novell_send_im(GaimConnection * gc, const char *name,
+			   const char *message_body, GaimConvImFlags flags)
+{
+	NMUserRecord *user_record = NULL;
+	NMConference *conf = NULL;
+	NMMessage *message;
+	NMUser *user;
+	const char *dn = NULL;
+	gboolean done = TRUE, created_conf = FALSE;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL || name == NULL ||
+		message_body == NULL || *message_body == '\0')
+		return 0;
+
+	user = gc->proto_data;
+	if (user == NULL)
+		return 0;
+
+	/* Create a new message */
+	message = nm_create_message(gaim_markup_strip_html(message_body));
+
+	/* Need to get the DN for the buddy so we can look up the convo */
+	dn = nm_lookup_dn(user, name);
+
+	/* Do we already know about the sender? */
+	user_record = nm_find_user_record(user, dn);
+	if (user_record) {
+
+		/* Do we already have an instantiated conference? */
+		conf = nm_find_conversation(user, dn);
+		if (conf == NULL) {
+
+			/* If not, create a blank conference */
+			conf = nm_create_conference(NULL);
+			created_conf = TRUE;
+
+			nm_conference_add_participant(conf, user_record);
+		}
+
+		nm_message_set_conference(message, conf);
+
+		/* Make sure conference is instatiated */
+		if (!nm_conference_is_instantiated(conf)) {
+
+			/* It is not, so send the createconf. We will
+			 * have to finish sending the message when we
+			 * get the response with the new conference guid.
+			 */
+			rc = nm_send_create_conference(user, conf,
+										   _createconf_resp_send_msg, message);
+			_check_for_disconnect(user, rc);
+
+			done = FALSE;
+		}
+
+	} else {
+
+		/* If we don't have details for the user, then we don't have
+		 * a conference yet. So create one and send the getdetails
+		 * to the server. We will have to finish sending the message
+		 * when we get the response from the server.
+		 */
+		conf = nm_create_conference(NULL);
+		created_conf = TRUE;
+
+		nm_message_set_conference(message, conf);
+		
+		rc = nm_send_get_details(user, name, _get_details_resp_send_msg, message);
+		_check_for_disconnect(user, rc);
+
+		done = FALSE;
+	}
+
+	if (done) {
+
+		/* Did we find everything we needed? */
+		rc = nm_send_message(user, message, _send_message_resp_cb);
+		_check_for_disconnect(user, rc);
+
+		nm_release_message(message);
+	}
+
+	if (created_conf && conf)
+		nm_release_conference(conf);
+
+	return 1;
+}
+
+static int
+novell_send_typing(GaimConnection * gc, const char *name, int typing)
+{
+	NMConference *conf = NULL;
+	NMUser *user;
+	const char *dn = NULL;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL || name == NULL)
+		return -1;
+
+	user = gc->proto_data;
+	if (user == NULL)
+		return -1;
+
+	/* Need to get the DN for the buddy so we can look up the convo */
+	dn = nm_lookup_dn(user, name);
+	if (dn) {
+
+		/* Now find the conference in our list */
+		conf = nm_find_conversation(user, dn);
+		if (conf) {
+
+			rc = nm_send_typing(user, conf,
+								((typing == GAIM_TYPING) ? TRUE : FALSE), NULL);
+			_check_for_disconnect(user, rc);
+
+		}
+
+	}
+
+	return 0;
+}
+
+static void
+novell_convo_closed(GaimConnection * gc, const char *who)
+{
+	NMUser *user;
+	NMConference *conf;
+	const char *dn;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL || who == NULL)
+		return;
+
+	user = gc->proto_data;
+	if (user && (dn = nm_lookup_dn(user, who))) {
+		conf = nm_find_conversation(user, dn);
+		if (conf) {
+			rc = nm_send_leave_conference(user, conf, NULL, NULL);
+			_check_for_disconnect(user, rc);
+		}
+	}
+}
+
+static void
+novell_chat_leave(GaimConnection * gc, int id)
+{
+	NMConference *conference;
+	NMUser *user;
+	GaimConversation *chat;
+	GSList *cnode;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL)
+		return;
+
+	user = gc->proto_data;
+	if (user == NULL)
+		return;
+
+	for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) {
+		conference = cnode->data;
+		if (conference && (chat = nm_conference_get_data(conference))) {
+			if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) {
+				rc = nm_send_leave_conference(user, conference, NULL, NULL);
+				_check_for_disconnect(user, rc);
+				break;
+			}
+		}
+	}
+
+	serv_got_chat_left(gc, id);
+}
+
+static int
+novell_chat_send(GaimConnection * gc, int id, const char *text)
+{
+	NMConference *conference;
+	GaimConversation *chat;
+	GSList *cnode;
+	NMMessage *message;
+	NMUser *user;
+	NMERR_T rc = NM_OK;
+	const char *name;
+	char *str;
+
+	if (gc == NULL || text == NULL)
+		return -1;
+
+	user = gc->proto_data;
+	if (user == NULL)
+		return -1;
+
+	message = nm_create_message(gaim_markup_strip_html(text));
+
+	for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) {
+		conference = cnode->data;
+		if (conference && (chat = nm_conference_get_data(conference))) {
+			if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) {
+
+				nm_message_set_conference(message, conference);
+
+				rc = nm_send_message(user, message, _send_message_resp_cb);
+				nm_release_message(message);
+
+				if (!_check_for_disconnect(user, rc)) {
+
+					/* Use the account alias if it is set */
+					name = gaim_account_get_alias(user->client_data);
+					if (name == NULL || *name == '\0') {
+
+						/* If there is no account alias, try full name */
+						name = nm_user_record_get_full_name(user->user_record);
+						if (name == NULL || *name == '\0') {
+
+							/* Fall back to the username that we are signed in with */
+							name = gaim_account_get_username(user->client_data);
+						}
+					}
+
+					serv_got_chat_in(gc, id, name, 0, text, time(NULL));
+					return 0;
+				} else
+					return -1;
+
+			}
+		}
+	}
+
+	/* The conference was not found, must be closed */
+	chat = gaim_find_chat(gc, id);
+	if (chat) {
+		str = g_strdup_printf(_("This conference has been closed."
+								" No more messages can be sent."));
+		gaim_conversation_write(chat, NULL, str, GAIM_MESSAGE_SYSTEM, time(NULL));
+		g_free(str);
+	}
+
+	return -1;
+}
+
+static void
+novell_add_buddy(GaimConnection * gc, const char *name, GaimGroup * group)
+{
+	GaimBuddy *buddy;
+	NMFolder *folder = NULL;
+	NMContact *contact;
+	NMUser *user;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL || name == NULL || group == NULL)
+		return;
+
+	user = (NMUser *) gc->proto_data;
+	if (user == NULL)
+		return;
+
+	contact = nm_create_contact();
+	nm_contact_set_dn(contact, name);
+
+	/* Remove the GaimBuddy (we will add it back after adding it 
+	 * to the server side list). Save the alias if there is one.
+	 */
+	buddy = gaim_find_buddy_in_group(user->client_data, name, group);
+	if (buddy) {
+		const char *alias = gaim_get_buddy_alias(buddy);
+
+		if (alias && strcmp(alias, name))
+			nm_contact_set_display_name(contact, gaim_get_buddy_alias(buddy));
+		gaim_blist_remove_buddy(buddy);
+		buddy = NULL;
+	}
+
+
+	folder = nm_find_folder(user, group->name);
+	if (folder) {
+
+		/* We have everything that we need, so send the createcontact */
+		rc = nm_send_create_contact(user, folder, contact,
+									_create_contact_resp_cb, contact);
+
+	} else {
+
+		/* Need to create the folder before we can add the contact */
+		rc = nm_send_create_folder(user, group->name,
+								   _create_folder_resp_add_contact, contact);
+	}
+
+	_check_for_disconnect(user, rc);
+
+}
+
+static void
+novell_remove_buddy(GaimConnection * gc, const char *name, const char *group_name)
+{
+	NMContact *contact;
+	NMFolder *folder;
+	NMUser *user;
+	const char *dn;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL || name == NULL || group_name == NULL)
+		return;
+
+	user = (NMUser *) gc->proto_data;
+	if (user && (dn = nm_lookup_dn(user, name))) {
+
+		folder = nm_find_folder(user, group_name);
+		if (folder) {
+			contact = nm_folder_find_contact(folder, dn);
+			if (contact) {
+
+				/* Remove the buddy from the contact */
+				nm_contact_set_data(contact, NULL);
+
+				/* Tell the server to remove the contact */
+				rc = nm_send_remove_contact(user, folder, contact,
+											_remove_contact_resp_cb, NULL);
+				_check_for_disconnect(user, rc);
+			}
+		}
+	}
+}
+
+static void
+novell_remove_group(GaimConnection * gc, const char *name)
+{
+	NMUser *user;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL || name == NULL)
+		return;
+
+	user = (NMUser *) gc->proto_data;
+	if (user) {
+		NMFolder *folder = nm_find_folder(user, name);
+
+		if (folder) {
+			rc = nm_send_remove_folder(user, folder,
+									   _remove_folder_resp_cb, NULL);
+			_check_for_disconnect(user, rc);
+		}
+	}
+}
+
+static void
+novell_alias_buddy(GaimConnection * gc, const char *name, const char *alias)
+{
+	NMContact *contact;
+	NMUser *user;
+	GList *contacts = NULL;
+	GList *cnode = NULL;
+	const char *dn = NULL;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL || name == NULL || alias == NULL)
+		return;
+
+	user = (NMUser *) gc->proto_data;
+	if (user && (dn = nm_lookup_dn(user, name))) {
+
+		/* Alias all of instances of the contact */
+		contacts = nm_find_contacts(user, dn);
+		for (cnode = contacts; cnode != NULL; cnode = cnode->next) {
+			contact = (NMContact *) cnode->data;
+			if (contact) {
+				GaimGroup *group;
+				GaimBuddy *buddy;
+				NMFolder *folder;
+
+				/* Alias the Gaim buddy? */
+				folder = nm_find_folder_by_id(user,
+											  nm_contact_get_parent_id(contact));
+				if (folder &&
+					(group = gaim_find_group(nm_folder_get_name(folder)))) {
+					buddy = gaim_find_buddy_in_group(user->client_data,
+													 name, group);
+					if (buddy && strcmp(buddy->alias, alias))
+						gaim_blist_alias_buddy(buddy, alias);
+
+				}
+				/* Tell the server to alias the contact */
+				rc = nm_send_rename_contact(user, contact, alias,
+											_rename_contact_resp_cb, NULL);
+				_check_for_disconnect(user, rc);
+			}
+		}
+		if (contacts)
+			g_list_free(contacts);
+	}
+}
+
+static void
+novell_group_buddy(GaimConnection * gc,
+				   const char *name, const char *old_group_name,
+				   const char *new_group_name)
+{
+	NMFolder *old_folder;
+	NMFolder *new_folder;
+	NMContact *contact;
+	NMUser *user;
+	const char *dn;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL || name == NULL ||
+		old_group_name == NULL || new_group_name == NULL)
+		return;
+
+	user = (NMUser *) gc->proto_data;
+	if (user && (dn = nm_lookup_dn(user, name))) {
+
+		/* Find the old folder */
+		old_folder = nm_find_folder(user, old_group_name);
+		if (old_folder && (contact = nm_folder_find_contact(old_folder, dn))) {
+
+			/* Find the new folder */
+			new_folder = nm_find_folder(user, new_group_name);
+			if (new_folder) {
+
+				/* Tell the server to move the contact to the new folder */
+				rc = nm_send_move_contact(user, contact, new_folder,
+										  _move_contact_resp_cb, NULL);
+
+			} else {
+
+				nm_contact_add_ref(contact);
+
+				/* Remove the old contact first */
+				nm_send_remove_contact(user, old_folder, contact,
+									   _remove_contact_resp_cb, NULL);
+
+				/* New folder does not exist yet, so create it  */
+				rc = nm_send_create_folder(user, new_group_name,
+										   _create_folder_resp_move_contact,
+										   contact);
+			}
+
+			_check_for_disconnect(user, rc);
+		}
+	}
+}
+
+static void
+novell_rename_group(GaimConnection * gc, const char *old_name,
+					const char *new_name, GList * tobemoved)
+{
+	NMERR_T rc = NM_OK;
+	NMUser *user;
+
+	if (gc == NULL || old_name == NULL || new_name == NULL || tobemoved == NULL) {
+		return;
+	}
+
+	user = gc->proto_data;
+	if (user) {
+		/* Does new folder exist already? */
+		if (nm_find_folder(user, new_name)) {
+			/* Gaim currently calls novell_group_buddy() for
+			 * for all buddies in the group, so we don't
+			 * need to worry about this situation.
+			 */
+			return;
+		}
+
+		NMFolder *folder = nm_find_folder(user, old_name);
+
+		if (folder) {
+			rc = nm_send_rename_folder(user, folder, new_name,
+									   _rename_folder_resp_cb, NULL);
+			_check_for_disconnect(user, rc);
+		}
+	}
+}
+
+static void
+novell_list_emblems(GaimBuddy * buddy, char **se, char **sw, char **nw, char **ne)
+{
+	int status = buddy->uc >> 1;
+
+	switch (status) {
+		case NM_STATUS_AVAILABLE:
+			*se = "";
+			break;
+		case NM_STATUS_AWAY:
+			*se = "away";
+			break;
+		case NM_STATUS_BUSY:
+			*se = "occupied";
+			break;
+		case NM_STATUS_UNKNOWN:
+			*se = "error";
+			break;
+	}
+}
+
+static const char *
+novell_list_icon(GaimAccount * account, GaimBuddy * buddy)
+{
+	return "novell";
+}
+
+static char *
+novell_tooltip_text(GaimBuddy * buddy)
+{
+	NMUserRecord *user_record = NULL;
+	GaimConnection *gc;
+	NMUser *user;
+	int status = 0;
+	char *ret_text = NULL;
+	const char *status_str = NULL;
+	const char *text = NULL;
+
+	if (buddy == NULL)
+		return "";
+
+	gc = gaim_account_get_connection(buddy->account);
+	if (gc == NULL || (user = gc->proto_data) == NULL)
+		return "";
+
+	if (GAIM_BUDDY_IS_ONLINE(buddy)) {
+		user_record = nm_find_user_record(user, buddy->name);
+		if (user_record) {
+			status = nm_user_record_get_status(user_record);
+			text = nm_user_record_get_status_text(user_record);
+			/* No custom text, so default it ... */
+			switch (status) {
+				case NM_STATUS_AVAILABLE:
+					status_str = _("Available");
+					break;
+				case NM_STATUS_AWAY:
+					status_str = _("Away");
+					break;
+				case NM_STATUS_BUSY:
+					status_str = _("Busy");
+					break;
+				case NM_STATUS_AWAY_IDLE:
+					status_str = _("Idle");
+					break;
+				case NM_STATUS_OFFLINE:
+					status_str = _("Offline");
+					break;
+				default:
+					status_str = _("Unknown");
+					break;
+			}
+
+			if (text)
+				ret_text = g_strdup_printf(_("<b>Status:</b> %s\n"
+											 "<b>Message:</b> %s"),
+										   status_str, text);
+			else
+				ret_text = g_strdup_printf(_("<b>Status:</b> %s"), status_str);
+		}
+	}
+
+	return ret_text;
+}
+
+static void
+novell_set_idle(GaimConnection * gc, int time)
+{
+	NMUser *user;
+	NMERR_T rc = NM_OK;
+
+	if (gc == NULL)
+		return;
+
+	user = gc->proto_data;
+	if (user == NULL)
+		return;
+
+	if (time > 0)
+		rc = nm_send_set_status(user, NM_STATUS_AWAY_IDLE, NULL, NULL, NULL,
+								NULL);
+	else
+		rc = nm_send_set_status(user, NM_STATUS_AVAILABLE, NULL, NULL, NULL,
+								NULL);
+
+	_check_for_disconnect(user, rc);
+}
+
+static void
+novell_get_info(GaimConnection * gc, const char *name)
+{
+	NMUserRecord *user_record;
+	NMUser *user;
+	NMERR_T rc;
+
+	if (gc == NULL || name == NULL)
+		return;
+
+	user = (NMUser *) gc->proto_data;
+	if (user) {
+
+		user_record = nm_find_user_record(user, name);
+		if (user_record) {
+
+			_show_info(gc, user_record);
+
+		} else {
+
+			rc = nm_send_get_details(user, name,
+									 _get_details_resp_show_info, g_strdup(name));
+
+			_check_for_disconnect(user, rc);
+
+		}
+
+	}
+}
+
+static char *
+novell_status_text(GaimBuddy * buddy)
+{
+	const char *text = NULL;
+	const char *dn = NULL;
+
+	if (buddy && buddy->account) {
+		GaimConnection *gc = gaim_account_get_connection(buddy->account);
+
+		if (gc && gc->proto_data) {
+			NMUser *user = gc->proto_data;
+
+			dn = nm_lookup_dn(user, buddy->name);
+			if (dn) {
+				NMUserRecord *user_record = nm_find_user_record(user, dn);
+
+				if (user_record) {
+					text = nm_user_record_get_status_text(user_record);
+					if (text)
+						return g_strdup(text);
+				}
+			}
+		}
+	}
+
+	return NULL;
+}
+
+static GList *
+novell_away_states(GaimConnection * gc)
+{
+	GList *m = NULL;
+
+	m = g_list_append(m, _("Available"));
+	m = g_list_append(m, _("Away"));
+	m = g_list_append(m, _("Busy"));
+	m = g_list_append(m, _("Appear Offline"));
+	m = g_list_append(m, GAIM_AWAY_CUSTOM);
+
+	return m;
+}
+
+static void
+novell_set_away(GaimConnection * gc, const char *state, const char *msg)
+{
+	NMUser *user;
+	NMSTATUS_T status = NM_STATUS_AVAILABLE;
+	NMERR_T rc = NM_OK;
+	char *text = NULL;
+	char *tmp = NULL;
+	char *p = NULL;
+
+	if (gc == NULL)
+		return;
+
+	user = gc->proto_data;
+	if (user == NULL)
+		return;
+
+	if (gc->away) {
+		g_free(gc->away);
+		gc->away = NULL;
+	}
+
+	if (msg != NULL) {
+		status = NM_STATUS_AWAY;
+		gc->away = g_strdup("");
+
+		/* Don't want newlines in status text */
+		tmp = g_strdup(msg);
+		if ((p = strchr(tmp, '\n'))) {
+			*p = '\0';
+		}
+
+		/* Truncate the status text if necessary */
+		text = g_strdup(tmp);
+		if (g_utf8_strlen(tmp, -1) > 60) {
+			g_utf8_strncpy(text, tmp, 60);
+			strcat(text, "...");
+		}
+
+		g_free(tmp);
+
+	} else if (state) {
+		if (!strcmp(state, _("Available"))) {
+			status = NM_STATUS_AVAILABLE;
+		} else if (!strcmp(state, _("Away"))) {
+			status = NM_STATUS_AWAY;
+			gc->away = g_strdup("");
+		} else if (!strcmp(state, _("Busy"))) {
+			status = NM_STATUS_BUSY;
+			gc->away = g_strdup("");
+		} else if (!strcmp(state, _("Appear Offline"))) {
+			status = NM_STATUS_OFFLINE;
+			gc->away = g_strdup("");
+		} else {
+			status = NM_STATUS_AVAILABLE;
+			g_free(gc->away);
+			gc->away = NULL;
+		}
+	} else if (gc->is_idle) {
+		status = NM_STATUS_AWAY_IDLE;
+	} else {
+		status = NM_STATUS_AVAILABLE;
+	}
+
+	rc = nm_send_set_status(user, status, text, msg, NULL, NULL);
+	_check_for_disconnect(user, rc);
+
+	if (text)
+		g_free(text);
+}
+
+static GaimPluginProtocolInfo prpl_info = {
+	0,
+	NULL,
+	NULL,
+	NULL,
+	novell_list_icon,
+	novell_list_emblems,
+	novell_status_text,
+	novell_tooltip_text,
+	novell_away_states,
+	NULL,						/* prpl_actions */
+	NULL,						/* buddy_menu */
+	NULL,						/* chat_info */
+	novell_login,
+	novell_close,
+	novell_send_im,
+	NULL,						/* set_info */
+	novell_send_typing,
+	novell_get_info,
+	novell_set_away,
+	NULL,						/* set_dir */
+	NULL,						/* get_dir */
+	NULL,						/* dir_search */
+	novell_set_idle,
+	NULL,						/* change pwd */
+	novell_add_buddy,
+	NULL,						/* add_buddies */
+	novell_remove_buddy,
+	NULL,						/* remove_buddies */
+	NULL,						/* add_permit */
+	NULL,						/* add_deny */
+	NULL,						/* rem_permit */
+	NULL,						/* rem_deny */
+	NULL,						/* set_permit_deny */
+	NULL,						/* warn */
+	NULL,						/* join_chat */
+	NULL,						/* reject_chat ?? */
+	NULL,						/* chat_invite */
+	novell_chat_leave,
+	NULL,						/* chat_whisper */
+	novell_chat_send,
+	NULL,						/* keepalive */
+	NULL,						/* register_user */
+	NULL,						/* get_cb_info */
+	NULL,						/* get_cb_away_msg */
+	novell_alias_buddy,
+	novell_group_buddy,
+	novell_rename_group,
+	NULL,						/* buddy_free */
+	novell_convo_closed,
+	NULL,						/* normalize */
+	NULL,						/* set_buddy_icon */
+	novell_remove_group,
+	NULL
+};
+
+static GaimPluginInfo info = {
+	2,												  /**< api_version    */
+	GAIM_PLUGIN_PROTOCOL,							  /**< type           */
+	NULL,											  /**< ui_requirement */
+	0,												  /**< flags          */
+	NULL,											  /**< dependencies   */
+	GAIM_PRIORITY_DEFAULT,							  /**< priority       */
+
+	"prpl-novell",									  /**< id             */
+	"GroupWise Messenger",								 /**< name           */
+	VERSION,										  /**< version        */
+	/**  summary        */
+	N_("Novell GroupWise Messenger Protocol Plugin"),
+	/**  description    */
+	N_("Novell GroupWise Messenger Protocol Plugin"),
+	NULL,											  /**< author         */
+	GAIM_WEBSITE,									  /**< homepage       */
+
+	NULL,											  /**< load           */
+	NULL,											  /**< unload         */
+	NULL,											  /**< destroy        */
+
+	NULL,											  /**< ui_info        */
+	&prpl_info										  /**< extra_info     */
+};
+
+static void
+init_plugin(GaimPlugin * plugin)
+{
+	GaimAccountOption *option;
+
+	option = gaim_account_option_string_new(_("Server address"), "server", NULL);
+	prpl_info.protocol_options =
+		g_list_append(prpl_info.protocol_options, option);
+
+	option = gaim_account_option_int_new(_("Server port"), "port", DEFAULT_PORT);
+	prpl_info.protocol_options =
+		g_list_append(prpl_info.protocol_options, option);
+
+	my_protocol = plugin;
+}
+
+GAIM_INIT_PLUGIN(novell, init_plugin, info);

--- a/src/prpl.c	Fri Apr 16 23:32:46 2004 +0000
+++ b/src/prpl.c	Sat Apr 17 13:55:28 2004 +0000
@@ -49,6 +49,7 @@
 		case GAIM_PROTO_MOO:      return "prpl-moo";     break;
 		case GAIM_PROTO_TREPIA:   return "prpl-trepia";  break;
 		case GAIM_PROTO_BLOGGER:  return "prpl-blogger"; break;
+		case GAIM_PROTO_NOVELL:  return "prpl-novell"; break;
 
 		default:
 			break;
@@ -75,6 +76,7 @@
 	else if (!strcmp(id, "prpl-moo"))     return GAIM_PROTO_MOO;
 	else if (!strcmp(id, "prpl-trepia"))  return GAIM_PROTO_TREPIA;
 	else if (!strcmp(id, "prpl-blogger")) return GAIM_PROTO_BLOGGER;
+	else if (!strcmp(id, "prpl-novell"))  return GAIM_PROTO_NOVELL;
 
 	return -1;
 }

--- a/src/prpl.h	Fri Apr 16 23:32:46 2004 +0000
+++ b/src/prpl.h	Sat Apr 17 13:55:28 2004 +0000
@@ -66,6 +66,7 @@
 	GAIM_PROTO_BATTLENET,   /**< Battle.NET protocol       */
 	GAIM_PROTO_SSCP,	/**< SSCP (ConfMgr) protocol   */
 	GAIM_PROTO_BLOGGER,	/**< Blogger xml-rpc protocol  */
+	GAIM_PROTO_NOVELL,	/**< GroupWise Messenger protocol  */
 	GAIM_PROTO_UNTAKEN      /**< Untaken protocol number   */
 
 } GaimProtocol;