More Doxygen. API cleanup.

[vcard2ldap.git] / patch / patch-v2l-jabberd-2.1.14.diff

diff -Naurb jabberd-2.1.14.orig/configure.ac jabberd-2.1.14/configure.ac
--- jabberd-2.1.14.orig/configure.ac    2007-08-14 00:35:21.000000000 +0200
+++ jabberd-2.1.14/configure.ac 2007-08-23 03:37:44.000000000 +0200
@@ -733,6 +733,17 @@
 fi
 AM_CONDITIONAL(STORAGE_ANON, [test "x-$want_anon" = "x-yes"])
 
+######################
+# vCard <-> LDAP (Iris)
+AC_ARG_ENABLE(v2l, AC_HELP_STRING([--enable-v2l], 
+    [enable vCard LDAP storage support (no)]),
+    want_v2l=$enableval, want_v2l=no)
+AM_CONDITIONAL(V2L, [test "x-$want_v2l" = "x-yes"])
+
+if test "x-$want_v2l" = "x-yes" ; then
+    AC_MSG_NOTICE(vCard <-> LDAP support activated.)
+fi
+#####################
 
 # Filesystem storage
 AC_ARG_ENABLE(fs, AC_HELP_STRING([--enable-fs], [enable filesystem storage support (no)]),
diff -Naurb jabberd-2.1.14.orig/sm/Makefile.am jabberd-2.1.14/sm/Makefile.am
--- jabberd-2.1.14.orig/sm/Makefile.am  2007-06-17 17:13:17.000000000 +0200
+++ jabberd-2.1.14/sm/Makefile.am       2007-09-08 21:37:16.000000000 +0200
@@ -26,6 +26,10 @@
 
 noinst_HEADERS = sm.h
 
+if V2L
+noinst_HEADERS += v2l_config.h v2l_conn.h v2l_vcard.h xmlnode.h
+endif
+
 sm_SOURCES = aci.c \
              dispatch.c \
              feature.c \
@@ -98,6 +102,12 @@
 mod_iq_vcard_la_LDFLAGS = -module -export-dynamic
 mod_iq_vcard_la_LIBADD = $(top_builddir)/subst/libsubst.la
 
+if V2L
+mod_iq_vcard_la_SOURCES += v2l_config.c v2l_conn.c v2l_vcard.c xmlnode.c 
+mod_iq_vcard_la_LIBADD += -lpthread -lexpat -lresolv -lldap -llber
+mod_iq_vcard_la_CPPFLAGS = -D_V2L_JABBER2 
+endif 
+
 mod_iq_version_la_SOURCES = mod_iq_version.c
 mod_iq_version_la_LDFLAGS = -module -export-dynamic
 mod_iq_version_la_LIBADD = $(top_builddir)/subst/libsubst.la
diff -Naurb jabberd-2.1.14.orig/sm/mod_iq_vcard.c jabberd-2.1.14/sm/mod_iq_vcard.c
--- jabberd-2.1.14.orig/sm/mod_iq_vcard.c       2007-08-29 16:56:58.000000000 +0200
+++ jabberd-2.1.14/sm/mod_iq_vcard.c    2007-09-25 17:45:15.000000000 +0200
@@ -27,6 +27,23 @@
   * $Revision: 1.25 $
   */
 
+#ifdef _V2L_JABBER2
+#include <xmlnode.h>
+#include <v2l_config.h>
+#include <v2l_conn.h>
+#include <v2l_vcard.h>
+
+static v2l_Config *_v2l_get_config(config_t cfg) {
+    static v2l_Config ldap_config = { NULL, NULL, NULL, LDAP_PORT, NULL,
+        NULL, NULL, NULL };
+
+    if(!cfg || ldap_config.master_conn)
+        return &ldap_config;
+
+    return v2l_config_init(&ldap_config, cfg) ? &ldap_config : NULL;
+}
+#endif
+
 #define uri_VCARD    "vcard-temp"
 static int ns_VCARD = 0;
 
@@ -100,8 +117,37 @@
     char ekey[10], cdata[VCARD_MAX_FIELD_SIZE];
     const char *vkey, *dkey, *vskey;
 
+#ifdef _V2L_JABBER2
+    v2l_LdapConn *ldap_conn = NULL;
+    v2l_Config *ldap_config;
+
+    xmlnode vcard, node = NULL;
+    char gtag[10], prev_gtag[10];
+
+    gtag[0] = 0;
+    prev_gtag[0] = 0;
+#endif
+
     log_debug(ZONE, "building object from packet");
 
+#ifdef _V2L_JABBER2
+    vcard = NULL; /* Warning */
+    ldap_config = _v2l_get_config(pkt->sm->config);
+
+    if(!ldap_config) {
+        log_debug(ZONE, "Cannot connect to LDAP/V2L not configured");
+    } else {
+        ldap_conn = v2l_get_conn(ldap_config,
+            (char *) (pkt->source->user->jid->node));
+
+        if(ldap_conn)
+            vcard = xmlnode_new_tag ("vCard");
+        else
+            log_debug(ZONE, "Unable to create connection for \"%s\" user",
+                        pkt->source->user->jid->node);
+    }
+#endif
+
     os = os_new();
     o = os_object_new(os);
     
@@ -115,12 +161,26 @@
         if(vskey == NULL) {
             vskey = vkey;
             elem = 2;
+#ifdef _V2L_JABBER2
+            gtag[0] = 0;
+#endif
         } else {
             sprintf(ekey, "%.*s", vskey - vkey, vkey);
             elem = nad_find_elem(pkt->nad, 2, NAD_ENS(pkt->nad, 2), ekey, 1);
             if(elem < 0)
                 continue;
             vskey++;
+
+#ifdef _V2L_JABBER2
+            if(vcard) {
+                strcpy(gtag, ekey);
+
+                if(strcmp(gtag, prev_gtag)) {
+                    strcpy(prev_gtag, gtag);
+                    node = xmlnode_insert_tag(vcard, gtag);
+                }
+            }
+#endif
         }
 
         elem = nad_find_elem(pkt->nad, elem, NAD_ENS(pkt->nad, 2), vskey, 1);
@@ -131,27 +191,79 @@
 
         snprintf(cdata, sizeof(cdata), "%.*s", NAD_CDATA_L(pkt->nad, elem), NAD_CDATA(pkt->nad, elem));
         cdata[sizeof(cdata)-1] = '\0';
+
+#ifdef _V2L_JABBER2
+        if(vcard) {
+            xmlnode tmp;
+
+            if (!gtag[0])
+                node = vcard;
+
+            tmp = xmlnode_insert_tag(node, vskey);
+            xmlnode_insert_cdata(tmp, cdata, strlen(cdata));
+        }
+#endif
         os_object_put(o, dkey, cdata, os_type_STRING);
     }
 
+#ifdef _V2L_JABBER2
+    if(vcard) {
+        v2l_vcard_set(ldap_config, ldap_conn, vcard);
+        xmlnode_free(vcard);
+    }
+#endif
+
     return os;
 }
 
+#ifndef _V2L_JABBER2
 static pkt_t _iq_vcard_to_pkt(sm_t sm, os_t os) {
+#else
+static pkt_t _iq_vcard_to_pkt(sm_t sm, os_t os, const char *user) {
+#endif
     pkt_t pkt;
     os_object_t o;
     int i = 0, elem;
     char ekey[10], *dval;
     const char *vkey, *dkey, *vskey;
     
+#ifdef _V2L_JABBER2
+    v2l_LdapConn *ldap_conn = NULL;
+    v2l_Config *ldap_config;
+    xmlnode vcard, node = NULL;
+#endif
+
     log_debug(ZONE, "building packet from object");
 
+#ifdef _V2L_JABBER2
+    vcard = NULL; /* WARNING */
+    ldap_config = _v2l_get_config(sm->config);
+
+    if(!ldap_config) {
+        log_debug(ZONE, "Cannot connect to LDAP/V2L not configured");
+    } else {
+        ldap_conn = v2l_get_conn(ldap_config, user);
+
+        if(ldap_conn)
+            vcard = v2l_vcard_get (ldap_config, ldap_conn);
+        else
+            log_debug(ZONE, "Unable to create connection for \"%s\" user",
+                        user);
+    }
+#endif
+
     pkt = pkt_create(sm, "iq", "result", NULL, NULL);
     nad_append_elem(pkt->nad, nad_add_namespace(pkt->nad, uri_VCARD, NULL), "vCard", 2);
 
+#ifdef _V2L_JABBER2
+    if(!vcard) {
+#endif
     if(!os_iter_first(os))
         return pkt;
     o = os_iter_object(os);
+#ifdef _V2L_JABBER2
+    }
+#endif
 
     while(_iq_vcard_map[i] != NULL) {
         vkey = _iq_vcard_map[i];
@@ -159,8 +271,15 @@
 
         i += 2;
 
+#ifdef _V2L_JABBER2
+        if(!vcard) {
+#endif
         if(!os_object_get_str(os, o, dkey, &dval))
             continue;
+#ifdef _V2L_JABBER2
+        } else
+            node = vcard;
+#endif
 
         vskey = strchr(vkey, '/');
         if(vskey == NULL) {
@@ -172,14 +291,30 @@
             if(elem < 0)
                 elem = nad_append_elem(pkt->nad, NAD_ENS(pkt->nad, 2), ekey, 3);
             vskey++;
+#ifdef _V2L_JABBER2
+            if(vcard)
+                node = xmlnode_get_tag(node, ekey);
+#endif
         }
 
+#ifdef _V2L_JABBER2
+        if(vcard) {
+            node = xmlnode_get_tag(node, vskey);
+            dval = node ? xmlnode_get_data(node) : "";
+        }
+#endif
+
         log_debug(ZONE, "extracted dbkey %s val '%s' for vcard key %s", dkey, dval, vkey);
 
         nad_append_elem(pkt->nad, NAD_ENS(pkt->nad, 2), vskey, pkt->nad->elems[elem].depth + 1);
         nad_append_cdata(pkt->nad, dval, strlen(dval), pkt->nad->elems[elem].depth + 2);
     }
 
+#ifdef _V2L_JABBER2
+    if(vcard)
+        xmlnode_free(vcard);
+#endif
+
     return pkt;
 }
 
@@ -212,7 +347,11 @@
                 return mod_HANDLED;
 
             case st_SUCCESS:
+#ifndef _V2L_JABBER2
                 result = _iq_vcard_to_pkt(sess->user->sm, os);
+#else
+                result = _iq_vcard_to_pkt(sess->user->sm, os, sess->jid->node);
+#endif
                 os_free(os);
 
                 nad_set_attr(result->nad, 1, -1, "type", "result", 6);
@@ -283,7 +422,11 @@
             return -stanza_err_SERVICE_UNAVAILABLE;
 
         case st_SUCCESS:
+#ifndef _V2L_JABBER2
             result = _iq_vcard_to_pkt(user->sm, os);
+#else
+            result = _iq_vcard_to_pkt(user->sm, os, user->jid->node);
+#endif
             os_free(os);
 
             result->to = jid_dup(pkt->from);
@@ -315,6 +458,10 @@
 static void _iq_vcard_free(module_t mod) {
     sm_unregister_ns(mod->mm->sm, uri_VCARD);
     feature_unregister(mod->mm->sm, uri_VCARD);
+
+#ifdef _VL2
+    v2l_config_shutdown(_v2l_get_config(NULL));
+#endif
 }
 
 DLLEXPORT int module_init(mod_instance_t mi, char *arg) {
diff -Naurb jabberd-2.1.14.orig/sm/v2l_config.c jabberd-2.1.14/sm/v2l_config.c
--- jabberd-2.1.14.orig/sm/v2l_config.c 1970-01-01 01:00:00.000000000 +0100
+++ jabberd-2.1.14/sm/v2l_config.c      2007-09-26 23:51:26.000000000 +0200
@@ -0,0 +1,176 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*! \file v2l_config.c
+    \brief Config handling functions. Implementation
+*/
+
+#include <stdlib.h>
+#include <strings.h>
+
+#ifndef _V2L_JABBER2
+#include <jabberd.h>
+#else
+#include "../util/util.h"
+
+#define log_warn log_debug
+#define log_error log_debug
+typedef pool_t pool;
+#endif
+
+#include <v2l_config.h>
+#include <v2l_conn.h>
+
+/*! \brief Gets value for tag from config
+    Generic (preprocessor) function for handling Jabberd14/2 config differences
+*/
+static char *_v2l_config_get_tag (T_CONF conn_base, const char *tag);
+
+int
+v2l_config_init (v2l_Config *self, T_CONF cfgroot)
+{
+  T_CONF conn_base;
+  const char *portstr;
+
+  if (!cfgroot)
+    {
+      log_error(ZONE, "xdb_v2l configuration not present");
+      return 0;
+    }
+
+#ifndef _V2L_JABBER2
+  /* Have a look in the XML configuration data for connection information. */
+  conn_base = xmlnode_get_tag (cfgroot, "connection");
+
+  if (conn_base == NULL)
+    {
+      log_error(ZONE,"<connection> tag is not present");
+      return 0;
+    }
+#else
+  conn_base = cfgroot;
+#endif
+
+  self->host = _v2l_config_get_tag (conn_base, "host");
+
+  if  (self->host == NULL)
+    {
+      log_error (ZONE, "LDAP server is not specified");
+      return 0;
+    }
+
+  portstr = _v2l_config_get_tag (conn_base, "port");
+  self->port = portstr != NULL ? atoi (portstr) : LDAP_PORT;
+
+  self->suffix = _v2l_config_get_tag (conn_base, "suffix");
+
+  if (self->suffix == NULL)
+    {
+      log_error (ZONE, "LDAP suffix is not specified");
+      return 0;
+    }
+
+  self->uniqattr = _v2l_config_get_tag (conn_base, "uniqattr");
+
+  if (self->uniqattr == NULL)
+    {
+      log_error (ZONE, "LDAP unique attribute is not specified");
+      return 0;
+    }
+
+  self->binddn = _v2l_config_get_tag (conn_base, "binddn");
+
+  if (self->binddn == NULL)
+    {
+      log_error (ZONE, "LDAP jabber admin dn is not specified");
+      return 0;
+    }
+
+  self->bindpw = _v2l_config_get_tag (conn_base, "bindpw");
+
+  if (self->bindpw == NULL)
+    {
+      log_error (ZONE,
+          "LDAP jabber admin password is not specified");
+       return 0;
+    }
+
+  self->confpath = _v2l_config_get_tag (conn_base, "tpl");
+
+  if (self->confpath == NULL)
+    {
+      log_error (ZONE,
+          "Path to vCard <->LDAP is not specified");
+       return 0;
+    }
+
+  self->poolref = pool_new ();
+
+  if (self->poolref == NULL)
+    {
+      log_error (ZONE, "Cannot create pool");
+      return 0;
+    }
+
+  /* Get a handle to an LDAP connection. */
+  log_debug (ZONE, "LDAP server: %s / port : %d", self->host, self->port);
+
+  self->master_conn = v2l_get_master_conn (self);
+
+  if (self->master_conn == NULL)
+    {
+      log_error (ZONE,
+        "Unable to create the LDAP main connection");
+      return 0;
+    }
+
+  return 1;
+}
+
+void
+v2l_config_shutdown (v2l_Config *self)
+{
+  if (self != NULL && self->master_conn != NULL)
+    {
+      v2l_free_allconn ();
+      ldap_unbind_s (self->master_conn->ld);
+      pool_free (self->master_conn->poolref);
+      pool_free (self->poolref);
+    }
+}
+
+/* public api ends here */
+
+static char *
+_v2l_config_get_tag (T_CONF conn_base, const char *tag)
+{
+#ifndef _V2L_JABBER2
+  xmlnode tmp;
+
+  tmp = xmlnode_get_tag (conn_base, tag);
+
+  if (tmp == NULL)
+    {
+      return NULL;
+    }
+
+  return (char *) xmlnode_get_data (xmlnode_get_firstchild (tmp));
+#else
+  char str[32] = "v2l.";
+
+  return config_get_one (conn_base, strncat (str, tag, 27), 0);
+#endif
+}
diff -Naurb jabberd-2.1.14.orig/sm/v2l_config.h jabberd-2.1.14/sm/v2l_config.h
--- jabberd-2.1.14.orig/sm/v2l_config.h 1970-01-01 01:00:00.000000000 +0100
+++ jabberd-2.1.14/sm/v2l_config.h      2007-09-27 01:05:30.000000000 +0200
@@ -0,0 +1,73 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*! \file v2l_config.h
+    \brief Config handling functions.
+*/
+
+#ifndef __V2L_CONFIG_H
+#define __V2L_CONFIG_H
+
+/*! Forward declaration */
+typedef struct v2l_LdapConn* v2l_LdapConnPtr;
+
+/*! The username associated with the master connection */
+#define V2L_ADMIN "jabberadmin"
+
+/*! \brief Type of the jabberd global config.
+    'xmlnode' for jabberd14, 'config_t' por jabberd2
+*/
+#ifdef _V2L_JABBER2
+#define T_CONF config_t
+#else
+#define T_CONF xmlnode
+#endif
+
+/*! \brief VCard2LDAP configuration.
+    Shared config for the module API.
+*/
+typedef struct v2l_Config
+{
+#ifndef _V2L_JABBER2
+  xmlnode config;      /*! reference to config file (jabber14) */
+#endif
+  pool poolref;
+  v2l_LdapConnPtr master_conn;  /*! root connection to LDAP */
+  char *host;          /*!< LDAP hostname */
+  int port;            /*!< LDAP port */
+  char *suffix;        /*!< LDAP root dn */
+  char *uniqattr;      /*!< unique attr used to retrieve/set objects */
+  char *binddn;        /*!< dn used for "master" connections */
+  char *bindpw;        /*!< pw used for "master" connections */
+  char *confpath;      /*!< path to the translation template */
+} v2l_Config;
+
+/*! \brief Reads global config and initialize module config.
+    \pre jabberd config exists and it's valid.
+    \post all fields of self are set.
+    \param self Module config.
+    \param cfgroot Global config. T_CONF type.
+    \return 1 if no error, otherwise returns 0.
+*/
+extern int v2l_config_init (v2l_Config *self, T_CONF cfgroot);
+
+/*! \brief Shutdown function, closes all connections and frees mempools.
+    \pre self != NULL and self->master_conn is open.
+    \post self->master_conn closed, all pools freeds.
+    \param self Module config.
+*/
+extern void v2l_config_shutdown (v2l_Config *self);
+#endif
diff -Naurb jabberd-2.1.14.orig/sm/v2l_conn.c jabberd-2.1.14/sm/v2l_conn.c
--- jabberd-2.1.14.orig/sm/v2l_conn.c   1970-01-01 01:00:00.000000000 +0100
+++ jabberd-2.1.14/sm/v2l_conn.c        2007-09-27 01:47:13.000000000 +0200
@@ -0,0 +1,875 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*! \file v2l_conn.c
+    \brief Handling the LDAP directory. Implementation
+*/
+
+#include <stdlib.h>
+
+#ifndef _V2L_JABBER2
+#include <jabberd.h>
+#else
+#include <pthread.h>
+#include "../util/util.h"
+
+#define log_warn log_debug
+#define log_error log_debug
+typedef pool_t pool;
+#endif
+
+#include <v2l_conn.h>
+
+/*! \brief Lifetime of an ephemeral connection, in seconds
+    The recall connections thread period.
+*/
+#define V2L_CONN_LIFETIME 30
+
+/*! How often thread checks for LDAP results, in seconds */
+#define V2L_POLL_INTERVAL 1
+
+#define LOG_ERROR_MEM log_error(ZONE, "Unable to allocate memory")
+
+/*! Global hashtable of all currently active LDAP connections */
+static xht V2L_CONN_LIST = NULL;
+
+/*! \brief Creates new LDAP connection
+    \param host LDAP hostname.
+    \param port LDAP port.
+    \param binddn Bind DN.
+    \param user User name.
+    \param passwd User password.
+    \param expire Boolean, ephemeral connection?
+    \return LDAP connectior or NULL if error.
+*/
+static v2l_LdapConn *_v2l_create_conn (char *host, int port, const char *binddn,
+  const char *user, const char *passwd, int expire);
+
+/*! \brief Gets user password
+    Retrieves user password from LDAP directory using master connection.
+    \note Allocated memory must be freed by the caller.
+    \param self Module config.
+    \param user User name.
+    \pre self is valid, user is not NULL
+    \return user password string or NULL if doesn't exist or error.
+*/
+static char *_v2l_ldap_get_passwd (v2l_Config *self, const char *user);
+
+/*! \brief Closes and frees a connection.
+    Utility function, common code for two hash walker functions.
+    \param h Jabberd hash. Hash table "username"->connection.
+    \param user User name.
+    \param val deference pointer to connection.
+    \sa _v2l_free_walker
+    \sa _v2l_free_expired_walker
+*/
+static void _v2l_free_conn (xht h, const char *user, void *val);
+
+/*! \brief Gets the number or attributes in a LDAP request.
+    \param[in,out] req The SLL of LDAP requests.
+    \return number of attributes, 0 if req is NULL.
+*/
+static int _v2l_count_attrs (v2l_LdapRequest *req);
+
+/*! \brief Modifies an entry in the LDAP directory
+    Utility function.
+    \param dn Entry bind DN
+    \param attrs List of attributes changed.
+    \param[in,out] evt_res Control and info parameter.
+    \return LDAP error code.
+*/
+static int _v2l_ldap_modify (char *dn, LDAPMod **attrs, v2l_LdapEvt *evt_res);
+
+/*! \brief Searchs and retrieves an entry from the LDAP directory
+    Utility function.
+    \param dn Entry bind DN.
+    \param suffix LDAP suffix
+    \param[out] attrs Entry attributes.
+    \param subtree boolean. Search in a one level or in entire subtree?
+    \param[in,out] evt_res Control and info parameter.
+    \return LDAP error code.
+*/
+static int _v2l_ldap_search (char *dn, char *suffix, char **attrs, int subtree,
+  v2l_LdapEvt *evt_res);
+
+/*! \brief Waits for LDAP results
+    Operations on the directory are asynchronous. This is a sync wait function.
+    \param \param[in,out] evt_res Control and info parameter.
+*/
+static void _v2l_ldap_sync (v2l_LdapEvt *evt_res);
+
+/*! \brief Adds LDAP attr to request.
+    Utility function, hides OpenLDAP API to upper level.
+    \param[in,out] req The SLL of LDAP requests.
+    \param attr The attr, LDAPMod pointer.
+    \return The list of requests + the last added. The list of request if error.
+*/
+static v2l_LdapRequest *_v2l_add_attr (v2l_LdapRequest *req, LDAPMod *attr);
+
+/*! \brief Adds a conn to the global list.
+    If list is empty, initializes it and starts the thread who recalls expired
+    connections.
+    \param ldap_conn New connection.
+*/
+static void _v2l_add_conn (v2l_LdapConn *ldap_conn);
+
+/*! \brief Frees connection unconditionally.
+    Utility function. Hash walker function.
+    See jabberd API for details.
+*/
+static void _v2l_free_walker (xht h, const char *key, void *val,
+  void *arg);
+
+/*! \brief Frees connections when its slice time expired (periodic thread)
+  \dot
+  digraph G {
+    rankdir = LR
+    node [shape = ellipse, fontname = Helvetica fontsize = 12]
+    {node[style = filled, fontsize = 16, bgcolor = grey] sleep}
+    {node[shape = circle, label = delete] free}
+    {node[label = "expired?" ] is_expired}
+    {node[label = "conn left?" ] any_conn}
+    sleep -> sleep
+    sleep -> any_conn [label = "    "]
+    any_conn -> sleep [label = no]
+    any_conn -> is_expired [label = yes]
+    is_expired -> free [label = yes]
+    is_expired -> any_conn [label = no]
+    free -> any_conn
+  }
+  \enddot
+  \param arg Unused.
+*/
+static void *_v2l_purge_conn_callback (void *arg);
+
+/*! \brief Frees expired connections.
+    Utility function. Hash walker function.
+    See jabberd API for details.
+*/
+static void _v2l_free_expired_walker (xht h, const char *key, void *val,
+  void *arg);
+
+/*! A thread for active wait for LDAP results */
+static int _v2l_ldap_wait_callback(void *arg);
+
+#ifdef _V2L_JABBER2
+static void *_v2l_ldap_wait_callback_g (void *arg);
+#endif
+
+/* public api */
+
+v2l_LdapConn *
+v2l_get_conn (v2l_Config *self, const char *user)
+{
+  v2l_LdapConn *user_conn;
+
+  user_conn = (v2l_LdapConn *) xhash_get (V2L_CONN_LIST, user);
+
+  if(user_conn == NULL)
+    {
+      char *passwd, *binddn;
+
+      /* Get the user password for connecting him to LDAP server */
+      passwd = _v2l_ldap_get_passwd (self, user);
+
+      /* user exists? */
+      if (passwd == NULL)
+        {
+          log_error (ZONE, "User \"%s\" not found in the directory", user);
+          return NULL;
+        }
+
+      binddn = (char *) malloc (sizeof(char) * (strlen (self->suffix) +
+        strlen (self->uniqattr) + strlen (user) + 3));
+
+      if (binddn == NULL)
+        {
+          LOG_ERROR_MEM;
+          free (passwd);
+          return NULL;
+        }
+
+      sprintf (binddn, "%s=%s,%s", self->uniqattr, user, self->suffix);
+
+      log_debug (ZONE, "Attempting to connect with DN: %s", binddn);
+
+      user_conn = _v2l_create_conn (self->host, self->port, binddn, user,
+        passwd, 1);
+
+      free (passwd);
+      free (binddn);
+
+    } /* user_conn == NULL */
+
+  return user_conn;
+}
+
+v2l_LdapConn *
+v2l_get_master_conn (v2l_Config *self)
+{
+  return _v2l_create_conn (self->host, self->port, self->binddn, V2L_ADMIN,
+    self->bindpw, 0);
+}
+
+void
+v2l_free_allconn ()
+{
+  xhash_walk (V2L_CONN_LIST, _v2l_free_walker, NULL);
+  xhash_free (V2L_CONN_LIST);
+}
+
+v2l_LdapEvt *
+v2l_ldap_get_entry (v2l_Config *self, v2l_LdapConn *curr_conn)
+{
+  v2l_LdapEvt *evt_res;
+  int rc;
+
+  evt_res = (v2l_LdapEvt *) malloc (sizeof (v2l_LdapEvt));
+
+  if (evt_res == NULL)
+    {
+      LOG_ERROR_MEM;
+      return NULL;
+    }
+
+  evt_res->ld = curr_conn->ld;
+
+  rc = _v2l_ldap_search (curr_conn->entry, self->suffix, NULL, 1, evt_res);
+
+  if (rc != LDAP_SUCCESS)
+    {
+      log_error (ZONE, "LDAP error attempting to retrieve user info: %s",
+        ldap_err2string (rc));
+      free (evt_res);
+      return NULL;
+    }
+
+  _v2l_ldap_sync(evt_res);
+
+  if (ldap_count_entries (evt_res->ld, evt_res->result) != 1)
+    {
+      log_warn (ZONE, "Multiple users with the same dn?");
+      free (evt_res);
+      return NULL;
+    }
+
+  return evt_res;
+}
+
+int
+v2l_request_record (v2l_Config *self, v2l_LdapConn *curr_conn,
+  v2l_LdapRequest *req)
+{
+  LDAPMod **attrs;
+  int i, nbmod, ret;
+  v2l_LdapRequest *cur_req, *cur_temp;
+  v2l_LdapEvt *evt_res;
+
+  if (req == NULL)
+    {
+      log_warn (ZONE, "LDAP request is NULL? I cannot record anything");
+      return 1;
+    }
+
+  nbmod = _v2l_count_attrs (req);
+
+  attrs = (LDAPMod **) malloc ((nbmod + 1) * sizeof (LDAPMod *));
+
+  if (attrs == NULL)
+    {
+      LOG_ERROR_MEM;
+      return 0;
+    }
+
+  /* to wait for the results */
+  evt_res = (v2l_LdapEvt *) malloc (sizeof (v2l_LdapEvt));
+
+  if (evt_res == NULL)
+    {
+      LOG_ERROR_MEM;
+      free (attrs);
+      return 0;
+    }
+
+  for (i = 0; i < nbmod; i++)
+    {
+      attrs[i] = (LDAPMod *) malloc (sizeof (LDAPMod));
+
+      if (attrs[i] == NULL)
+        {
+          while (--i >= 0)
+            {
+              free (attrs[i]);
+            }
+
+          LOG_ERROR_MEM;
+          free (attrs);
+          free (evt_res);
+          return 0;
+        }
+    }
+
+  for (cur_req = req, i = 0; i < nbmod; cur_req = cur_req->next, i++)
+    {
+      memcpy (attrs[i], cur_req->attr, sizeof (LDAPMod));
+      log_debug (ZONE, "Element \"%s\" (%d) in the LDAP request: %s",
+      attrs[i]->mod_type, i, attrs[i]->mod_values[0]);
+    }
+
+  attrs[nbmod] = NULL;
+
+  log_debug (ZONE, "LDAP attempting to modify \"%s\" with dn \"%s\"",
+  curr_conn->user, curr_conn->binddn);
+
+  evt_res->ld = curr_conn->ld;
+  evt_res->rc = _v2l_ldap_modify (curr_conn->binddn, attrs, evt_res);
+  ret = evt_res->rc == LDAP_SUCCESS;
+
+  if (!ret)
+    {
+      log_error (ZONE, "LDAP error attempting to modify user info: %s",
+        ldap_err2string (evt_res->rc));
+    }
+  else
+    {
+      _v2l_ldap_sync (evt_res);
+    }
+
+  ldap_msgfree (evt_res->result);
+  free (evt_res);
+
+  for (cur_req = req, i = 0; i < nbmod; i++)
+    {
+      cur_temp = cur_req;
+      cur_req = cur_req->next;
+
+      free (attrs[i]);
+      free (cur_temp->attr->mod_values[0]);
+      free (cur_temp->attr->mod_values);
+      free (cur_temp->attr);
+      free (cur_temp);
+    }
+
+  free (attrs);
+
+  return ret;
+}
+
+v2l_LdapRequest *
+v2l_add_attr_str (v2l_LdapRequest *req, const char *attr, const char *str)
+{
+  LDAPMod *mod;
+
+  mod = (LDAPMod *) malloc (sizeof (LDAPMod));
+
+  if (mod == NULL)
+    {
+      return NULL;
+    }
+
+  mod->mod_op = LDAP_MOD_REPLACE;
+  mod->mod_type = (char *) attr;
+
+  mod->mod_values = (char **) malloc (2 * sizeof (char *));
+
+  if (mod->mod_values == NULL)
+    {
+      free (mod);
+      return NULL;
+    }
+
+  mod->mod_values[0] = (char *) malloc (strlen (str) + 1);
+
+  if (mod->mod_values[0] == NULL)
+    {
+      free (mod->mod_values);
+      free (mod);
+      return NULL;
+    }
+
+  memcpy (mod->mod_values[0], str, strlen (str) + 1);
+  mod->mod_values[1] = NULL;
+
+  return _v2l_add_attr (req, mod);
+}
+
+/* public api ends here */
+
+static v2l_LdapConn *
+_v2l_create_conn (char *host, int port, const char *binddn, const char *user,
+  const char *passwd, int expire)
+{
+  LDAP *ld;
+  v2l_LdapConn *ldap_conn;
+  int version;      /* LDAP protocol version */
+  int rc;
+  pool poolref;
+
+  ld = ldap_init (host, port);
+
+  if (ld == NULL)
+    {
+      log_error (ZONE, "Unable to init LDAP");
+      return NULL;
+    }
+
+  /* XXX */
+  version = LDAP_VERSION3;
+  /***/
+
+  ldap_set_option (ld, LDAP_OPT_PROTOCOL_VERSION, &version);
+  rc = ldap_simple_bind_s (ld, binddn, passwd);
+
+  if (rc != LDAP_SUCCESS)
+    {
+      log_error (ZONE,
+         "LDAP simple bind error : %s", ldap_err2string (rc));
+      return NULL;
+    }
+
+  poolref = pool_new ();
+
+  if (poolref == NULL)
+    {
+      LOG_ERROR_MEM;
+      ldap_unbind_s (ld);
+      return NULL;
+    }
+
+  ldap_conn = (v2l_LdapConn *) pmalloc (poolref, sizeof (v2l_LdapConn));
+
+  if (ldap_conn == NULL)
+   {
+      LOG_ERROR_MEM;
+      ldap_unbind_s (ld);
+      pool_free(poolref);
+      return NULL;
+   }
+
+  ldap_conn->poolref = poolref;
+  ldap_conn->ld = ld;
+
+  ldap_conn->binddn = (char *) pmalloc (ldap_conn->poolref,
+    strlen (binddn) + 1);
+
+  if (ldap_conn->binddn == NULL)
+   {
+      LOG_ERROR_MEM;
+      ldap_unbind_s (ld);
+      pool_free(poolref);
+      return NULL;
+   }
+
+  strcpy (ldap_conn->binddn, binddn);
+
+  ldap_conn->entry = (char *) pmalloc (ldap_conn->poolref, strlen (binddn) + 1);
+
+  if (ldap_conn->entry == NULL)
+   {
+      LOG_ERROR_MEM;
+      ldap_unbind_s (ld);
+      pool_free(poolref);
+      return NULL;
+   }
+
+  strcpy (ldap_conn->entry, binddn);
+  strtok (ldap_conn->entry, ", ");
+
+  ldap_conn->user = (char *) pmalloc (ldap_conn->poolref, strlen (user) + 1);
+
+  if (ldap_conn->user == NULL)
+   {
+      LOG_ERROR_MEM;
+      ldap_unbind_s (ld);
+      pool_free(poolref);
+      return NULL;
+   }
+
+  strcpy (ldap_conn->user, user);
+
+  ldap_conn->creation_time = time (NULL); /* timestamp */
+
+  if (expire == 1)   /* Add it to V2L_CONN_LIST */
+    {
+      _v2l_add_conn (ldap_conn);
+    }
+
+  return ldap_conn;
+}
+
+static char *
+_v2l_ldap_get_passwd(v2l_Config *self, const char *user)
+{
+    LDAPMessage *e;
+    v2l_LdapEvt *evt_res;
+    char *data, *filter, **vals, *attrs[2] = {"userPassword", NULL};
+
+    evt_res = (v2l_LdapEvt *) malloc(sizeof(v2l_LdapEvt));
+
+    if (evt_res == NULL)
+      {
+        LOG_ERROR_MEM;
+        return NULL;
+      }
+
+   filter = (char *) malloc (strlen (self->uniqattr) + strlen (user) + 2);
+
+    if (filter == NULL)
+      {
+        LOG_ERROR_MEM;
+        free (evt_res);
+        return NULL;
+      }
+
+    sprintf(filter, "%s=%s", self->uniqattr, user);
+    evt_res->ld = self->master_conn->ld;
+
+    evt_res->rc = _v2l_ldap_search (filter, self->suffix, attrs, 0, evt_res);
+    free (filter);
+
+    if (evt_res->rc != LDAP_SUCCESS)
+      {
+        log_error(ZONE,
+          "LDAP error attempting to retrieve \"%s\"'s password: %s",
+          user, ldap_err2string (evt_res->rc));
+        free (evt_res);
+        return NULL;
+      }
+
+    _v2l_ldap_sync (evt_res);
+    data = NULL;
+
+    if (ldap_count_entries(evt_res->ld, evt_res->result) == 1)
+      {
+        e = ldap_first_entry(evt_res->ld, evt_res->result);
+        vals = ldap_get_values(evt_res->ld, e, "userPassword");
+
+        if (vals == NULL)
+          {
+            log_debug(ZONE, "User has no password!");
+            data = (char *) malloc(sizeof(char));
+
+            if (data == NULL)
+              {
+                LOG_ERROR_MEM;
+                ldap_msgfree(evt_res->result);
+                free(evt_res);
+                return NULL;
+              }
+
+            data[0] = 0;
+          }
+        else
+          {
+            data = (char *) malloc(sizeof(char) * (strlen(vals[0]) + 1));
+
+            if (data != NULL)
+              {
+                strcpy(data, vals[0]);
+              }
+
+            ldap_value_free(vals);
+          }
+
+        ldap_msgfree(evt_res->result);
+      }
+
+    free(evt_res);
+    return data;
+}
+
+static int
+_v2l_ldap_modify (char *dn, LDAPMod **attrs, v2l_LdapEvt *evt_res)
+{
+  return ldap_modify_ext (evt_res->ld, dn, attrs, NULL, NULL,
+    &(evt_res->msgid));
+}
+
+static int
+_v2l_ldap_search (char *dn, char *suffix, char **attrs, int subtree,
+  v2l_LdapEvt *evt_res)
+{
+  int scope;
+
+  scope = subtree ? LDAP_SCOPE_SUBTREE : LDAP_SCOPE_ONELEVEL;
+
+  return ldap_search_ext (evt_res->ld, suffix, scope,
+    dn, attrs, 0, NULL, NULL, NULL, LDAP_NO_LIMIT,
+    &(evt_res->msgid));
+}
+
+static void
+_v2l_ldap_sync (v2l_LdapEvt *evt_res)
+{
+#ifndef _V2L_JABBER2
+  pth_event_t evt;
+
+  evt = pth_event (PTH_EVENT_FUNC, &_v2l_ldap_wait_callback,
+       (void *) evt_res, pth_time (V2L_POLL_INTERVAL, 0));
+  pth_wait (evt);
+#else
+  pthread_t thr;
+  int rc;
+
+  rc = pthread_create(&thr, NULL, _v2l_ldap_wait_callback_g, (void *) evt_res);
+
+  if (rc != 0)
+    {
+      log_error (ZONE, "Thread create failed: %d", rc);
+      return;
+    }
+
+  pthread_join(thr, NULL);
+#endif
+}
+
+/*! Count the number of LDAPMod in the structure */
+static int
+_v2l_count_attrs (v2l_LdapRequest *req)
+{
+  v2l_LdapRequest *ptr;
+  int nbmod;
+
+  for (nbmod = 0, ptr = req; ptr != NULL; ptr = ptr->next, nbmod++);
+
+  return nbmod;
+}
+
+static v2l_LdapRequest *
+_v2l_add_attr (v2l_LdapRequest *req, LDAPMod *attr)
+{
+  if (attr == NULL)
+    {
+      log_warn (ZONE, "LDAP attribute is NULL? I cannot add anything");
+      return NULL;
+    }
+
+  if (req == NULL)
+    {
+      req = (v2l_LdapRequest *) malloc (sizeof (v2l_LdapRequest));
+
+      if (req == NULL)
+        {
+          LOG_ERROR_MEM;
+          return NULL;
+        }
+
+      req->attr = attr;
+      req->next = NULL;
+    }
+  else
+    {
+      v2l_LdapRequest *ptr;
+      v2l_LdapRequest *new_req;
+
+      new_req = (v2l_LdapRequest *) malloc (sizeof (v2l_LdapRequest));
+
+      if (new_req == NULL)
+        {
+          LOG_ERROR_MEM;
+          return NULL;
+        }
+
+      new_req->attr = attr;
+      new_req->next = NULL;
+
+      for (ptr = req; ptr->next != NULL; ptr = ptr->next);
+
+      ptr->next = new_req;
+    }
+
+  return req;
+}
+
+static int
+_v2l_ldap_wait_callback(void *arg)
+{
+    v2l_LdapEvt *evt_res = (v2l_LdapEvt *) arg;
+    LDAPMessage *result;
+    int rc;
+
+    rc = ldap_result (evt_res->ld, evt_res->msgid, 1, NULL, &result);
+
+    if (rc == -1)
+      {
+        log_error(ZONE, "LDAP result error %s",
+            ldap_err2string(rc));
+        evt_res->result = NULL;
+        evt_res->rc = -1;
+        return 1;
+      }
+
+    if ((rc == LDAP_RES_ADD)
+      || (rc == LDAP_RES_MODIFY)
+      || (rc == LDAP_RES_SEARCH_RESULT)
+      || (rc == LDAP_RES_SEARCH_ENTRY)
+      || (rc == LDAP_RES_DELETE))
+      {
+        evt_res->result = result;
+        evt_res->rc = rc;
+        return 1;
+      }
+
+  return 0; /* still waiting */
+}
+
+#ifdef _V2L_JABBER2
+static void *
+_v2l_ldap_wait_callback_g (void *arg)
+{
+  while (!_v2l_ldap_wait_callback (arg))
+    {
+      sleep (V2L_POLL_INTERVAL);
+    }
+
+  return NULL;
+}
+#endif
+
+static void
+_v2l_free_walker (xht h, const char *key, void *val, void *arg)
+{
+  _v2l_free_conn (h, key, val);
+}
+
+static void
+_v2l_free_conn (xht h, const char *user, void *val)
+{
+  v2l_LdapConn *temp_conn = (v2l_LdapConn *) val;
+
+  log_debug (ZONE, "Freeing LDAP connection for user \"%s\"", user);
+
+  xhash_zap (h, user);
+  ldap_unbind_s (temp_conn->ld);
+  pool_free (temp_conn->poolref);
+}
+
+static void
+_v2l_free_expired_walker (xht h, const char *key, void *val, void *arg)
+{
+  v2l_LdapConn *temp_conn = (v2l_LdapConn *) val;
+
+  /* kill connections older than V2L_CONN_LIFETIME */
+  if ((time (NULL) - temp_conn->creation_time) > (time_t) V2L_CONN_LIFETIME)
+    {
+      _v2l_free_conn (h, key, val);
+    }
+}
+
+static void *
+_v2l_purge_conn_callback (void *arg)
+{
+  log_debug (ZONE, "Checking connections lifetime");
+
+  while (1)
+    {
+      /* V2L_CONN_LIST has been freed? */
+      if (V2L_CONN_LIST != NULL)
+        {
+          xhash_walk (V2L_CONN_LIST, _v2l_free_expired_walker, NULL);
+        }
+#ifndef _V2L_JABBER2
+      pth_sleep (V2L_CONN_LIFETIME);
+#else
+      sleep (V2L_CONN_LIFETIME);
+#endif
+    }
+
+    return NULL;
+}
+
+static void
+_v2l_add_conn (v2l_LdapConn *ldap_conn)
+{
+#ifndef _V2L_JABBER2
+  pth_attr_t attr;
+#else
+  pthread_t thr;
+  pthread_attr_t attr;
+  int rc;
+#endif
+
+  if (V2L_CONN_LIST == NULL)
+    {
+
+      log_debug (ZONE, "V2L_CONN_LIST hashtable is not initialized yet");
+
+      V2L_CONN_LIST = xhash_new (509);
+
+      /* spawn the thread which deletes expired connections */
+#ifndef _V2L_JABBER2
+      attr = pth_attr_new ();
+      pth_attr_set (attr, PTH_ATTR_JOINABLE, FALSE);
+      pth_spawn (attr, _v2l_purge_conn_callback, NULL);
+      pth_attr_destroy (attr);
+#else
+      pthread_attr_init(&attr);
+      pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+
+      rc = pthread_create (&thr, &attr, _v2l_purge_conn_callback, NULL);
+      pthread_attr_destroy(&attr);
+
+      if (rc != 0)
+      {
+        log_error (ZONE, "Thread create failed: %d", rc);
+      }
+#endif
+    }
+
+  xhash_put (V2L_CONN_LIST, ldap_conn->user, (void *) ldap_conn);
+}
+
+void
+v2l_ldap_for_all_attrs(v2l_AttrValueFunction value_func,
+  v2l_AttrMatchFunction match_func, void *pointer, v2l_LdapEvt *evt_res)
+{
+  LDAPMessage *current_result;
+  BerElement *ber;
+  char *current_attr, **vals;
+  void *shrdata;
+
+  current_result = ldap_first_entry (evt_res->ld, evt_res->result);
+  current_attr = ldap_first_attribute (evt_res->ld, current_result, &ber);
+
+  /* step through each attribute in objectclass */
+  for (;
+    current_attr != NULL;
+    current_attr = ldap_next_attribute (evt_res->ld, current_result, ber))
+    {
+
+      if (match_func (current_attr, &shrdata))
+        {
+          vals = ldap_get_values (evt_res->ld, current_result, current_attr);
+          value_func (current_attr, (const char **) vals, pointer, shrdata);
+
+          if (vals != NULL)
+            {
+              ldap_value_free (vals);
+            }
+        }
+
+      ldap_memfree (current_attr);
+    } /* attributes loop */
+
+  if (ber != NULL)
+    {
+      ber_free (ber, 0);
+    }
+
+  /* don't forget to free the next attribute */
+  ldap_memfree (current_attr);
+  ldap_msgfree (evt_res->result);
+}
diff -Naurb jabberd-2.1.14.orig/sm/v2l_conn.h jabberd-2.1.14/sm/v2l_conn.h
--- jabberd-2.1.14.orig/sm/v2l_conn.h   1970-01-01 01:00:00.000000000 +0100
+++ jabberd-2.1.14/sm/v2l_conn.h        2007-09-27 01:03:26.000000000 +0200
@@ -0,0 +1,143 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*! \file v2l_conn.h
+    \brief Handling the LDAP directory. Low-level tier.
+*/
+
+#ifndef __V2L_CONN_H
+#define __V2L_CONN_H
+
+#include <ldap.h>
+#include <time.h>
+
+#include <v2l_config.h>
+
+/*! \brief Simple Linked List of connections to LDAP directory */
+typedef struct v2l_LdapConn
+{
+  pool poolref;
+  LDAP *ld;              /*!< LDAP descriptor */
+  time_t creation_time;  /*!< timestamp */
+  char *binddn;          /*!< complete dn */
+  char *entry;           /*!< short dn */
+  char *user;            /*!< username */
+  struct v2l_LdapConn *next;
+} v2l_LdapConn;
+
+/*! \brief Request (SLL) for LDAP directory */
+typedef struct v2l_LdapRequest
+{
+  LDAPMod *attr;
+  struct v2l_LdapRequest *next;
+} v2l_LdapRequest;
+
+/*! \brief LDAP environment.
+    Control struct for perform operations on the LDAP directory and retrieve
+    results.
+*/
+typedef struct v2l_LdapEvt
+{
+  LDAP *ld;   /*!< LDAP descriptor */
+  int msgid;  /*!< LDAP message id (see OpenLDAP API docs) */
+  int rc;     /*!< LDAP error code */
+  LDAPMessage *result; /*!< LDAP result (see OpenLDAP API docs) */
+} v2l_LdapEvt;
+
+/*! \brief Match function type
+    Generic attribute matching routine.
+    \param attr The attribute.
+    \param[out] shrdata Generic deferenced pointer. Shared data with a 'value
+    function'
+    \sa v2l_AttrValueFunction
+    \sa v2l_ldap_for_all_attrs
+    \return true if matching, otherwise false.
+*/
+typedef int (*v2l_AttrMatchFunction) (const char *attr, void **shrdata);
+
+/*! \brief Values read function type
+    Generic values handling routine.
+    \param attr The attribute.
+    \param vals Values of attribute.
+    \param pointer Generic multipurpose pointer.
+    \param shrdata Shared data with 'match function'
+    \sa v2l_MatchValueFunction
+    \sa v2l_ldap_for_all_attrs
+*/
+typedef void (*v2l_AttrValueFunction) (const char *attr, const char **vals,
+  void *pointer, void *shrdata);
+
+/*! \brief Gets a (ephemeral) connection by name. Creates one if doesn't exist.
+    \pre self is valid, user is not null and exists.
+    \post ephermeral connection for user is open.
+    \param self Module config.
+    \param user the username
+    \return the connection if no error, otherwise NULL.
+*/
+extern v2l_LdapConn *v2l_get_conn (v2l_Config *self, const char *user);
+
+/*! \brief Gets a connection master connection. Creates one if doesn't exist.
+    \pre self is valid
+    \post master connection is open.
+    \param self Module config.
+    \return the connection if no error, otherwise NULL.
+*/
+extern v2l_LdapConn *v2l_get_master_conn (v2l_Config *self);
+
+/*! \brief Frees and closes all connections (ephemeral or not)
+    If connections doesn't exist does nothing.
+    \post self->master_conn closed. Connections list empty.
+*/
+extern void v2l_free_allconn ();
+
+/*! \brief Retrieves an user entry from the LDAP directory
+    \note Allocated memory must be freed by the caller.
+    \param self Module config
+    \param curr_conn user connection.
+    \return evt_res LDAP descriptor, control code and result. NULL if error.
+*/
+extern v2l_LdapEvt *v2l_ldap_get_entry (v2l_Config *self,
+  v2l_LdapConn *curr_conn);
+
+/*! \brief Executes a list of changes on the LDAP directory.
+    \pre req is not NULL
+    \param self Module config
+    \param curr_conn The user connection.
+    \param req list of changes.
+    \return 1 if no error, otherwise 0
+*/
+extern int v2l_request_record (v2l_Config *self, v2l_LdapConn *curr_conn,
+  v2l_LdapRequest *req);
+
+/*! \brief Adds a new request to the list
+    \param req The list of requests.
+    \param attr attribute name.
+    \param str attribute value.
+    \return The list of requests + the last added. The list of request if error.
+*/
+extern v2l_LdapRequest *v2l_add_attr_str (v2l_LdapRequest *req,
+  const char *attr, const char *str);
+
+/*! \brief Applies a function to all LDAP object attributes.
+    \pre evt_res should be a valid entry (ie. result of a search in directory)
+    \param value_func Walker function.
+    \param match_func Match function. If returns true we'll call to value_func
+    \param pointer Generic multipurpose pointer. It will be passed to value_func
+    \param evt_res LDAP descriptor, control code and result.
+*/
+extern void v2l_ldap_for_all_attrs (v2l_AttrValueFunction value_func,
+  v2l_AttrMatchFunction match_func, void *pointer, v2l_LdapEvt *evt_res);
+#endif
diff -Naurb jabberd-2.1.14.orig/sm/v2l_vcard.c jabberd-2.1.14/sm/v2l_vcard.c
--- jabberd-2.1.14.orig/sm/v2l_vcard.c  1970-01-01 01:00:00.000000000 +0100
+++ jabberd-2.1.14/sm/v2l_vcard.c       2007-09-26 23:46:59.000000000 +0200
@@ -0,0 +1,588 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*! \file v2l_vcard.c
+    \brief XML vCard's to/from LDAP objects translation functions.
+    Implementation
+*/
+
+#include <stdlib.h>
+
+#ifndef _V2L_JABBER2
+#include <jabberd.h>
+#else
+#include "../util/util.h"
+#include <xmlnode.h>
+
+#define log_warn log_debug
+#define log_error log_debug
+
+#endif
+#include <v2l_vcard.h>
+
+#define LOG_ERROR_MEM log_error(ZONE, "Unable to allocate memory")
+
+/*! \brief vCard template item.
+    SLL. All of relations tag<->LDAP attr read from template
+*/
+typedef struct v2l_vCardItem
+{
+  char *vcard;  /*!< tag name */
+  char *ldap;   /*!< LDAP attribute */
+  char *group;  /*!< XML parent of the tag */
+  struct v2l_vCardItem *next;
+} v2l_vCardItem;
+
+/*! \brief Gets the translation map.
+    If it is not initilized yet, the function reads the template from disk
+    and sets the map.
+    \param self Module config, if map is initialized can be NULL.
+    \return The map, NULL if error.
+*/
+static v2l_vCardItem *_v2l_vcard_map (v2l_Config *self);
+
+/*! \brief Creates the FN tag
+    Creates FN tag from GIVEN and FAMILY tags.
+    \param vcard The vCard.
+    \return 1 if no error, otherwise 0.
+*/
+static int _v2l_create_fn (xmlnode vcard);
+
+/*! \brief Sets sn1 and sn2 from sn
+    Hack. IrisPerson has two surnames: first surname and mother's maiden name.
+    This function splits sn in two. Should be called when the list of request
+    are complete and before program excutes them.
+    \param req The SLL of LDAP requests.
+*/
+static v2l_LdapRequest *_v2l_set_sn12 (v2l_LdapRequest *req);
+
+/*! \brief Map function from LDAP to XML vCard
+    \param item Info about the tag (name, parent group and attribute associated)
+    \param vals array of values for the attribe.
+    \param[in,out] res The vCard, output is appended here.
+    \return res + new tag or res if error.
+*/
+static xmlnode _v2l_ldap2vcard_generic (v2l_vCardItem *item, const char **vals,
+  xmlnode res);
+
+/*! \brief Function for maps PHOTO tag.
+    Hack. InetOrgPerson has a jpegphoto attribute so PHOTO/MIMETYPE tag can be
+    only "image/jpeg"
+    \warning The module doesn't support storing avatars in another format (png)
+*/
+static xmlnode _v2l_ldap2vcard_photo (v2l_vCardItem *item, const char **vals,
+  xmlnode res);
+
+/*! \brief Map function from XML Vcard to LDAP
+    \param item Info about the tag (name, parent group and attribute associated)
+    \param data Thhe vCard.
+    \param[in,out] req List of requests, the new request is appended here.
+    \return req + new request or req if error.
+*/
+static v2l_LdapRequest *_v2l_vcard2ldap_generic (v2l_vCardItem *item,
+  xmlnode data, v2l_LdapRequest *req);
+
+/*! \brief Finds tag linked to attr
+    Parses the translation map since 'item' node.
+    \param item Where the search starts.
+    \param attr The attribute;
+    \return node with tag<->attr association or NULL if error or not found.
+*/
+static v2l_vCardItem *_v2l_vcard_find_attr (v2l_vCardItem *item,
+  const char *attr);
+
+/*! \brief Is LDAP object attribute linked to any tag?
+    Utility function.
+    \param attr The attribute.
+    \param[out] shrdata Contents the address of any map's node. NULL if no match
+    \return true if attr is linked to any tag, otherwise false
+*/
+static int _v2l_vcard_attr_match (const char *attr, void **shrdata);
+
+/*! \brief Function applied to all attrs.
+    Utility function, walker function.
+    \param attr The attribute.
+    \param vals Values of attribute.
+    \param pointer Deferenced pointer to vCard.
+    \param shrdata Data shared with the match function.
+*/
+static void _v2l_vcard_attr_value (const char *attr, const char **vals,
+  void *pointer, void *shrdata);
+
+#if 0
+static v2l_vCardItem *
+  _v2l_vcard_find_tag (v2l_vCardItem *item, char *tag);
+#endif
+
+/*! List of all XML vCard tags supported */
+static const char *_V2L_MAP_VCARD [] = {
+    "FN",
+    "NICKNAME",
+    "URL",
+    "TEL/NUMBER",
+    "EMAIL/USERID",
+    "TITLE",
+    "ROLE",
+    "BDAY",
+    "DESC",
+    "N/FAMILY",
+    "N/GIVEN",
+    "N/MIDDLE",
+    "N/PREFIX",
+    "N/SUFFIX",
+    "ADR/STREET",
+    "ADR/POBOX",
+    "ADR/EXTADD",
+    "ADR/LOCALITY",
+    "ADR/REGION",
+    "ADR/PCODE",
+    "ADR/CTRY",
+    "ORG/ORGNAME",
+    "ORG/ORGUNIT",
+
+    "TZ",
+    "GEO/LAT",
+    "GEO/LON",
+    "AGENT/EXTVAL",
+    "NOTE",
+    "REV",
+    "SORT-STRING",
+
+    "KEY/TYPE",
+    "KEY/CRED",
+
+    "PHOTO/TYPE",
+    "PHOTO/BINVAL",
+    "PHOTO/EXTVAL",
+
+    "LOGO/TYPE",
+    "LOGO/BINVAL",
+    "LOGO/EXTVAL",
+
+    "SOUND/PHONETIC",
+    "SOUND/BINVAL",
+    "SOUND/EXTVAL",
+
+    NULL
+};
+
+/* public api */
+xmlnode
+v2l_vcard_get (v2l_Config *self, v2l_LdapConn *curr_conn)
+{
+  xmlnode vcard;
+  v2l_LdapEvt *evt_res;
+
+  if (_v2l_vcard_map (self) == NULL)
+    {
+      log_error (ZONE, "Unreadable/malformed vCard template!");
+      return NULL;
+    }
+
+  /* get user info from LDAP */
+  evt_res = v2l_ldap_get_entry (self, curr_conn);
+
+  if (evt_res == NULL)
+    {
+      return NULL;
+    }
+
+  /* prepare the XML result */
+  vcard = xmlnode_new_tag ("vCard");
+  xmlnode_put_attrib (vcard, "xmlns", "vcard-temp");
+
+  v2l_ldap_for_all_attrs (_v2l_vcard_attr_value, _v2l_vcard_attr_match, vcard,
+    evt_res);
+
+  free (evt_res);
+  _v2l_create_fn (vcard);
+
+  return vcard;
+}
+
+int
+v2l_vcard_set (v2l_Config *self, v2l_LdapConn *curr_conn, xmlnode data)
+{
+  xmlnode node;
+  v2l_LdapRequest *ldap_req = NULL;
+  v2l_vCardItem *item;
+
+  if (data == NULL)
+    {
+      log_warn (ZONE, "vCard data is NULL?");
+      return 0;
+    }
+
+  item = _v2l_vcard_map (self);
+
+  if (item == NULL)
+    {
+      log_error (ZONE, "Unreadable/Malformed vCard template!");
+      return 0;
+    }
+
+  do
+    {
+      if (strcmp (item->vcard, "FN") == 0) /* FIXME: ugly */
+        {
+          goto is_fn;
+        }
+
+      if (item->group != NULL)
+        {
+          char tag[30];
+
+          sprintf (tag, "%s/%s", item->group, item->vcard);
+          node = xmlnode_get_tag (data, tag);
+        }
+      else
+        {
+          node = xmlnode_get_tag (data, item->vcard);
+        }
+
+      if (node != NULL)
+        {
+          ldap_req = _v2l_vcard2ldap_generic (item, node, ldap_req);
+        }
+is_fn:
+      item = item->next;
+    } while (item != NULL);
+
+  ldap_req = _v2l_set_sn12 (ldap_req);
+
+  return v2l_request_record (self, curr_conn, ldap_req);
+}
+
+/* public api ends here */
+
+static v2l_vCardItem *
+_v2l_vcard_map (v2l_Config *self)
+{
+  static v2l_vCardItem *_V2L_TPL = NULL;
+  xmlnode tpl, tag;
+  char **stag, *tmp, group[10];
+  v2l_vCardItem *item;
+
+  if (_V2L_TPL == NULL && self != NULL && self->confpath != NULL)
+    {
+      tpl = xmlnode_file (self->confpath);
+
+      if (tpl == NULL)
+        {
+          return NULL;
+        }
+
+      for (stag = (char **) _V2L_MAP_VCARD; *stag != NULL; stag++)
+        {
+          tmp = strchr(*stag, '/');
+
+          if (tmp == NULL)
+            {
+              group[0] = 0;
+              tmp = *stag;
+            }
+          else
+            {
+              sprintf(group, "%.*s", tmp - *stag, *stag);
+              tmp++;
+            }
+
+          tag = xmlnode_get_tag (tpl, *stag);
+
+          if (xmlnode_get_data(tag) != NULL)
+            {
+              int ntags = 0;
+              char find_attr[30];
+
+              do
+                {
+                  v2l_vCardItem *ptr;
+
+                  ptr = (v2l_vCardItem *) pmalloc (self->poolref,
+                    sizeof(v2l_vCardItem));
+
+                  ptr->vcard = tmp;
+                  ptr->ldap  = pstrdup (self->poolref, xmlnode_get_data(tag));
+                  ptr->next  = NULL;
+                  ptr->group = group[0] == 0 ? NULL :
+                  pstrdup (self->poolref, group);
+
+                  if (_V2L_TPL == NULL)
+                    {
+                      _V2L_TPL = ptr;
+                      item = ptr;
+                    }
+                  else
+                    {
+                      item->next = ptr;
+                      item = item->next;
+                    }
+
+                  sprintf (find_attr, "%s?v2ln=%d", *stag, ++ntags);
+                  tag = xmlnode_get_tag (tpl, find_attr);
+                } while (tag && xmlnode_get_data (tag) != NULL && ntags < 10);
+            }/* xmlnode_get_data(tag) != NULL */
+        }  /* for loop, all tags in template */
+
+      xmlnode_free (tpl);
+    }
+
+  return _V2L_TPL;
+}
+
+#if 0
+static v2l_vCardItem *
+_v2l_vcard_find_tag (v2l_vCardItem *item, char *tag)
+{
+  v2l_vCardItem *res = NULL;
+
+  while (item != NULL)
+    {
+      if (strcmp (item->vcard, tag) == 0)
+        {
+          res = item;
+          break;
+        }
+
+        item = item->next;
+    }
+
+  return res;
+}
+#endif
+
+static v2l_vCardItem *
+_v2l_vcard_find_attr (v2l_vCardItem *item, const char *attr)
+{
+  v2l_vCardItem *res = NULL;
+
+  while (item != NULL)
+    {
+      if (strcmp (item->ldap, attr) == 0)
+        {
+          res = item;
+          break;
+        }
+
+        item = item->next;
+    }
+
+  return res;
+}
+
+static int
+_v2l_vcard_attr_match (const char *attr, void **shrdata)
+{
+  *shrdata = _v2l_vcard_find_attr (_v2l_vcard_map (NULL), attr);
+
+  return *shrdata != NULL;
+}
+
+static void
+_v2l_vcard_attr_value (const char *attr, const char **vals, void *pointer,
+  void *shrdata)
+{
+  xmlnode vcard;
+  v2l_vCardItem *match;
+
+  vcard = (xmlnode) pointer;
+  match = (v2l_vCardItem *) shrdata;
+
+  if (vals != NULL)
+    {
+      /* FIXME: ugly */
+      if (match->group != NULL && (strcmp (match->group, "PHOTO") == 0))
+        {
+          _v2l_ldap2vcard_photo (match, vals, vcard);
+        }
+      else
+        {
+          _v2l_ldap2vcard_generic (match, vals, vcard);
+        }
+    }
+}
+
+static int
+_v2l_create_fn (xmlnode vcard)
+{
+  xmlnode n, fn;
+  char *family, *given, *fn_str;
+  int len;
+
+  fn = xmlnode_insert_tag (vcard, "FN");
+  n  = xmlnode_get_tag (vcard, "N");
+  family = xmlnode_get_tag_data (n, "FAMILY");
+  given  = xmlnode_get_tag_data (n, "GIVEN");
+
+  len = 0;
+  len += (family != NULL) ? strlen (family) : 0;
+  len += (given  != NULL) ? strlen (given)  : 0;
+
+  if (len == 0)
+    {
+      log_debug (ZONE, "<fn><n>...</n></fn> is empty, returning");
+      return 1;
+    }
+
+  fn_str = (char *) malloc (sizeof (char) * (len + 2));
+
+  if (fn_str == NULL)
+    {
+      LOG_ERROR_MEM;
+      return 0;
+    }
+
+  fn_str[0] = 0;
+
+  if (family != NULL)
+    {
+      sprintf (fn_str, "%s ", family);
+    }
+
+  if (given != NULL)
+    {
+      strcat (fn_str, given);
+    }
+
+  xmlnode_insert_cdata (fn, fn_str, len + 1);
+  free (fn_str);
+
+  return 1;
+}
+
+/* LDAP -> vCard */
+
+static xmlnode
+_v2l_ldap2vcard_generic (v2l_vCardItem *item, const char **vals, xmlnode res)
+{
+  xmlnode node;
+
+  if (item->group != NULL)
+    {
+      node = xmlnode_get_tag (res, item->group);
+
+      if (node == NULL)
+        {
+          node = xmlnode_insert_tag(res, item->group);
+        }
+    }
+  else
+    {
+      node = res;
+    }
+
+  node = xmlnode_insert_tag (node, item->vcard);
+  xmlnode_insert_cdata (node, vals[0], strlen (vals[0]));
+
+  return res;
+}
+
+static xmlnode
+_v2l_ldap2vcard_photo (v2l_vCardItem *item, const char **vals, xmlnode res)
+{
+  xmlnode mimetype, photo;
+
+  res = _v2l_ldap2vcard_generic (item, vals, res);
+
+  /* FIXME: mimetype is hardcoded */
+  photo = xmlnode_get_tag (res, "PHOTO");
+  mimetype = xmlnode_insert_tag (photo, "TYPE");
+  xmlnode_insert_cdata (mimetype, "image/jpeg", sizeof ("image/jpeg"));
+
+  return res;
+}
+
+/*  vCard -> LDAP */
+
+static v2l_LdapRequest *
+_v2l_vcard2ldap_generic (v2l_vCardItem *item, xmlnode data,
+  v2l_LdapRequest *req)
+{
+  const char *str;
+
+  str = xmlnode_get_data (data);
+
+  return str == NULL ? req : v2l_add_attr_str (req, item->ldap, str);
+}
+
+static v2l_LdapRequest *
+_v2l_set_sn12 (v2l_LdapRequest *req)
+{
+  if (req != NULL)
+    {
+      v2l_LdapRequest *ptr;
+      char *sn;
+
+      for (ptr = req, sn = NULL; ptr != NULL; ptr = ptr->next)
+        {
+          if (strcmp (ptr->attr->mod_type, "sn") == 0)
+            {
+              sn = ptr->attr->mod_values[0];
+              break;
+            }
+        }
+
+      if (sn != NULL)
+        {
+          char *sit, *sn1, *sn2;
+
+          for (sit = sn; *sit != ' ' && *sit != 0; sit++);
+
+          sn1 = (char *) malloc (sizeof (char) * (sit - sn + 1));
+
+          if (sn1 == NULL)
+            {
+              return req;
+            }
+
+          strncpy (sn1, sn, sizeof (char) * (sit - sn));
+          sn1[sit - sn] = 0;
+          ptr = v2l_add_attr_str (req, "sn1", sn1);
+          free (sn1);
+
+          if (ptr == NULL)
+            {
+              return req;
+            }
+
+          req = ptr;
+
+          if (sit - sn != strlen (sn))
+            {
+              sn2 = (char *) malloc (strlen (sit) + 1);
+
+              if (sn2 == NULL)
+                {
+                  LOG_ERROR_MEM;
+                  return req;
+                }
+
+              strcpy (sn2, sit);
+              ptr = v2l_add_attr_str (req, "sn2", sn2);
+              free (sn2);
+
+              if (ptr == NULL)
+                {
+                  return req;
+                }
+
+              req = ptr;
+            }
+        }  /* sn != NULL */
+    }  /* req != NULL */
+
+  return req;
+}
diff -Naurb jabberd-2.1.14.orig/sm/v2l_vcard.h jabberd-2.1.14/sm/v2l_vcard.h
--- jabberd-2.1.14.orig/sm/v2l_vcard.h  1970-01-01 01:00:00.000000000 +0100
+++ jabberd-2.1.14/sm/v2l_vcard.h       2007-09-26 23:52:13.000000000 +0200
@@ -0,0 +1,41 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*! \file v2l_vcard.h
+    \brief XML vCard's to/from LDAP objects translation functions.
+*/
+
+#ifndef __V2L_VCARD_H
+#define __V2L_VCARD_H
+
+#include <v2l_conn.h>
+
+/*! \brief Gets user vCard in xml format
+    \param self Module config
+    \param curr_conn user connection.
+    \return vCard main node, NULL if error.
+*/
+extern xmlnode v2l_vcard_get (v2l_Config *self, v2l_LdapConn *curr_conn);
+
+/*! \brief Writes vCard to user LDAP directory entry.
+    \param self Module config
+    \param curr_conn user connection.
+    \param data the vCard
+    \return 1 if no error, otherwise 0
+*/
+extern int v2l_vcard_set (v2l_Config *self, v2l_LdapConn *curr_conn,
+  xmlnode data);
+#endif
diff -Naurb jabberd-2.1.14.orig/sm/xmlnode.c jabberd-2.1.14/sm/xmlnode.c
--- jabberd-2.1.14.orig/sm/xmlnode.c    1970-01-01 01:00:00.000000000 +0100
+++ jabberd-2.1.14/sm/xmlnode.c 2007-09-25 17:45:15.000000000 +0200
@@ -0,0 +1,1029 @@
+/* --------------------------------------------------------------------------
+ *
+ * License
+ *
+ * The contents of this file are subject to the Jabber Open Source License
+ * Version 1.0 (the "JOSL").  You may not copy or use this file, in either
+ * source code or executable form, except in compliance with the JOSL. You
+ * may obtain a copy of the JOSL at http://www.jabber.org/ or at
+ * http://www.opensource.org/.
+ *
+ * Software distributed under the JOSL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the JOSL
+ * for the specific language governing rights and limitations under the
+ * JOSL.
+ *
+ * Copyrights
+ *
+ * Portions created by or assigned to Jabber.com, Inc. are
+ * Copyright (c) 1999-2002 Jabber.com, Inc.  All Rights Reserved.  Contact
+ * information for Jabber.com, Inc. is available at http://www.jabber.com/.
+ *
+ * Portions Copyright (c) 1998-1999 Jeremie Miller.
+ *
+ * Acknowledgements
+ *
+ * Special thanks to the Jabber Open Source Contributors for their
+ * suggestions and support of Jabber.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * GNU General Public License Version 2 or later (the "GPL"), in which case
+ * the provisions of the GPL are applicable instead of those above.  If you
+ * wish to allow use of your version of this file only under the terms of the
+ * GPL and not to allow others to use your version of this file under the JOSL,
+ * indicate your decision by deleting the provisions above and replace them
+ * with the notice and other provisions required by the GPL.  If you do not
+ * delete the provisions above, a recipient may use your version of this file
+ * under either the JOSL or the GPL.
+ *
+ *
+ * --------------------------------------------------------------------------*/
+
+#include "../util/util.h"
+#include "xmlnode.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+/* Internal routines */
+xmlnode _xmlnode_new(pool p, const char* name, unsigned int type)
+{
+    xmlnode result = NULL;
+    if (type > NTYPE_LAST)
+        return NULL;
+
+    if (type != NTYPE_CDATA && name == NULL)
+        return NULL;
+
+    if (p == NULL)
+    {
+        p = pool_heap(1*1024);
+    }
+
+    /* Allocate & zero memory */
+    result = (xmlnode)pmalloco(p, sizeof(_xmlnode));
+
+    /* Initialize fields */
+    if (type != NTYPE_CDATA)
+        result->name = pstrdup(p,name);
+    result->type = type;
+    result->p = p;
+    return result;
+}
+
+static xmlnode _xmlnode_append_sibling(xmlnode lastsibling, const char* name, unsigned int type)
+{
+    xmlnode result;
+
+    result = _xmlnode_new(xmlnode_pool(lastsibling), name, type);
+    if (result != NULL)
+    {
+        /* Setup sibling pointers */
+        result->prev = lastsibling;
+        lastsibling->next = result;
+    }
+    return result;
+}
+
+static xmlnode _xmlnode_insert(xmlnode parent, const char* name, unsigned int type)
+{
+    xmlnode result;
+
+    if(parent == NULL || (type != NTYPE_CDATA && name == NULL)) return NULL;
+
+    /* If parent->firstchild is NULL, simply create a new node for the first child */
+    if (parent->firstchild == NULL)
+    {
+        result = _xmlnode_new(parent->p, name, type);
+        parent->firstchild = result;
+    }
+    /* Otherwise, append this to the lastchild */
+    else
+    {
+        result= _xmlnode_append_sibling(parent->lastchild, name, type);
+    }
+    result->parent = parent;
+    parent->lastchild = result;
+    return result;
+
+}
+
+static xmlnode _xmlnode_search(xmlnode firstsibling, const char* name, unsigned int type)
+{
+    xmlnode current;
+
+    /* Walk the sibling list, looking for a NTYPE_TAG xmlnode with
+    the specified name */
+    current = firstsibling;
+    while (current != NULL)
+    {
+        if ((current->type == type) && (j_strcmp(current->name, name) == 0))
+            return current;
+        else
+            current = current->next;
+    }
+    return NULL;
+}
+
+void _xmlnode_merge(xmlnode data)
+{
+    xmlnode cur;
+    char *merge, *scur;
+    int imerge;
+
+    /* get total size of all merged cdata */
+    imerge = 0;
+    for(cur = data; cur != NULL && cur->type == NTYPE_CDATA; cur = cur->next)
+        imerge += cur->data_sz;
+
+    /* copy in current data and then spin through all of them and merge */
+    scur = merge = pmalloc(data->p,imerge + 1);
+    for(cur = data; cur != NULL && cur->type == NTYPE_CDATA; cur = cur->next)
+    {
+        memcpy(scur,cur->data,cur->data_sz);
+        scur += cur->data_sz;
+    }
+    *scur = '\0';
+
+    /* this effectively hides all of the merged-in chunks */
+    data->next = cur;
+    if(cur == NULL)
+        data->parent->lastchild = data;
+    else
+        cur->prev = data;
+
+    /* reset data */
+    data->data = merge;
+    data->data_sz = imerge;
+
+}
+
+static void _xmlnode_hide_sibling(xmlnode child)
+{
+    if(child == NULL)
+        return;
+
+    if(child->prev != NULL)
+        child->prev->next = child->next;
+    if(child->next != NULL)
+        child->next->prev = child->prev;
+}
+
+void _xmlnode_tag2str(spool s, xmlnode node, int flag)
+{
+    xmlnode tmp;
+
+    if(flag==0 || flag==1)
+    {
+        spooler(s,"<",xmlnode_get_name(node),s);
+        tmp = xmlnode_get_firstattrib(node);
+        while(tmp) {
+            spooler(s," ",xmlnode_get_name(tmp),"='",strescape(xmlnode_pool(node),xmlnode_get_data(tmp), strlen(xmlnode_get_data(tmp))),"'",s);
+            tmp = xmlnode_get_nextsibling(tmp);
+        }
+        if(flag==0)
+            spool_add(s,"/>");
+        else
+            spool_add(s,">");
+    }
+    else
+    {
+        spooler(s,"</",xmlnode_get_name(node),">",s);
+    }
+}
+
+spool _xmlnode2spool(xmlnode node)
+{
+    spool s;
+    int level=0,dir=0;
+    xmlnode tmp;
+
+    if(!node || xmlnode_get_type(node)!=NTYPE_TAG)
+        return NULL;
+
+    s = spool_new(xmlnode_pool(node));
+    if(!s) return(NULL);
+
+    while(1)
+    {
+        if(dir==0)
+        {
+            if(xmlnode_get_type(node) == NTYPE_TAG)
+            {
+                if(xmlnode_has_children(node))
+                {
+                    _xmlnode_tag2str(s,node,1);
+                    node = xmlnode_get_firstchild(node);
+                    level++;
+                    continue;
+                }else{
+                    _xmlnode_tag2str(s,node,0);
+                }
+            }else{
+                spool_add(s,strescape(xmlnode_pool(node),xmlnode_get_data(node),strlen(xmlnode_get_data(node))));
+            }
+        }
+
+        tmp = xmlnode_get_nextsibling(node);
+        if(!tmp)
+        {
+            node = xmlnode_get_parent(node);
+            level--;
+            if(level>=0) _xmlnode_tag2str(s,node,2);
+            if(level<1) break;
+            dir = 1;
+        }else{
+            node = tmp;
+            dir = 0;
+        }
+    }
+
+    return s;
+}
+
+
+/* External routines */
+
+
+/*
+ *  xmlnode_new_tag -- create a tag node
+ *  Automatically creates a memory pool for the node.
+ *
+ *  parameters
+ *      name -- name of the tag
+ *
+ *  returns
+ *      a pointer to the tag node
+ *      or NULL if it was unsuccessfull
+ */
+xmlnode xmlnode_new_tag(const char* name)
+{
+    return _xmlnode_new(NULL, name, NTYPE_TAG);
+}
+
+
+/*
+ *  xmlnode_new_tag_pool -- create a tag node within given pool
+ *
+ *  parameters
+ *      p -- previously created memory pool
+ *      name -- name of the tag
+ *
+ *  returns
+ *      a pointer to the tag node
+ *      or NULL if it was unsuccessfull
+ */
+xmlnode xmlnode_new_tag_pool(pool p, const char* name)
+{
+    return _xmlnode_new(p, name, NTYPE_TAG);
+}
+
+
+/*
+ *  xmlnode_insert_tag -- append a child tag to a tag
+ *
+ *  parameters
+ *      parent -- pointer to the parent tag
+ *      name -- name of the child tag
+ *
+ *  returns
+ *      a pointer to the child tag node
+ *      or NULL if it was unsuccessfull
+ */
+xmlnode xmlnode_insert_tag(xmlnode parent, const char* name)
+{
+    return _xmlnode_insert(parent, name, NTYPE_TAG);
+}
+
+
+/*
+ *  xmlnode_insert_cdata -- append character data to a tag
+ *
+ *  parameters
+ *      parent -- parent tag
+ *      CDATA -- character data
+ *      size -- size of CDATA
+ *              or -1 for null-terminated CDATA strings
+ *
+ *  returns
+ *      a pointer to the child CDATA node
+ *      or NULL if it was unsuccessfull
+ */
+xmlnode xmlnode_insert_cdata(xmlnode parent, const char* CDATA, unsigned int size)
+{
+    xmlnode result;
+
+    if(CDATA == NULL || parent == NULL)
+        return NULL;
+
+    if(size == -1)
+        size = strlen(CDATA);
+
+    result = _xmlnode_insert(parent, NULL, NTYPE_CDATA);
+    if (result != NULL)
+    {
+        result->data = (char*)pmalloc(result->p, size + 1);
+        memcpy(result->data, CDATA, size);
+        result->data[size] = '\0';
+        result->data_sz = size;
+    }
+
+    return result;
+}
+
+
+/*
+ *  xmlnode_get_tag -- find given tag in an xmlnode tree
+ *
+ *  parameters
+ *      parent -- pointer to the parent tag
+ *      name -- "name" for the child tag of that name
+ *              "name/name" for a sub child (recurses)
+ *              "?attrib" to match the first tag with that attrib defined
+ *              "?attrib=value" to match the first tag with that attrib and value
+ *              "=cdata" to match the cdata contents of the child
+ *              or any combination: "name/name/?attrib", "name=cdata", etc
+ *
+ *  results
+ *      a pointer to the tag matching search criteria
+ *      or NULL if search was unsuccessfull
+ */
+xmlnode xmlnode_get_tag(xmlnode parent, const char* name)
+{
+    char *str, *slash, *qmark, *equals;
+    xmlnode step, ret;
+
+
+    if(parent == NULL || parent->firstchild == NULL || name == NULL || name == '\0') return NULL;
+
+    if(strstr(name, "/") == NULL && strstr(name,"?") == NULL && strstr(name, "=") == NULL)
+        return _xmlnode_search(parent->firstchild, name, NTYPE_TAG);
+
+    str = strdup(name);
+    slash = strstr(str, "/");
+    qmark = strstr(str, "?");
+    equals = strstr(str, "=");
+
+    if(equals != NULL && (slash == NULL || equals < slash) && (qmark == NULL || equals < qmark))
+    { /* of type =cdata */
+
+        *equals = '\0';
+        equals++;
+
+        for(step = parent->firstchild; step != NULL; step = xmlnode_get_nextsibling(step))
+        {
+            if(xmlnode_get_type(step) != NTYPE_TAG)
+                continue;
+
+            if(*str != '\0')
+                if(j_strcmp(xmlnode_get_name(step),str) != 0)
+                    continue;
+
+            if(j_strcmp(xmlnode_get_data(step),equals) != 0)
+                continue;
+
+            break;
+        }
+
+        free(str);
+        return step;
+    }
+
+
+    if(qmark != NULL && (slash == NULL || qmark < slash))
+    { /* of type ?attrib */
+
+        *qmark = '\0';
+        qmark++;
+        if(equals != NULL)
+        {
+            *equals = '\0';
+            equals++;
+        }
+
+        for(step = parent->firstchild; step != NULL; step = xmlnode_get_nextsibling(step))
+        {
+            if(xmlnode_get_type(step) != NTYPE_TAG)
+                continue;
+
+            if(*str != '\0')
+                if(j_strcmp(xmlnode_get_name(step),str) != 0)
+                    continue;
+
+            if(xmlnode_get_attrib(step,qmark) == NULL)
+                continue;
+
+            if(equals != NULL && j_strcmp(xmlnode_get_attrib(step,qmark),equals) != 0)
+                continue;
+
+            break;
+        }
+
+        free(str);
+        return step;
+    }
+
+
+    *slash = '\0';
+    ++slash;
+
+    for(step = parent->firstchild; step != NULL; step = xmlnode_get_nextsibling(step))
+    {
+        if(xmlnode_get_type(step) != NTYPE_TAG) continue;
+
+        if(j_strcmp(xmlnode_get_name(step),str) != 0)
+            continue;
+
+        ret = xmlnode_get_tag(step, slash);
+        if(ret != NULL)
+        {
+            free(str);
+            return ret;
+        }
+    }
+
+    free(str);
+    return NULL;
+}
+
+
+/* return the cdata from any tag */
+char *xmlnode_get_tag_data(xmlnode parent, const char *name)
+{
+    xmlnode tag;
+
+    tag = xmlnode_get_tag(parent, name);
+    if(tag == NULL) return NULL;
+
+    return xmlnode_get_data(tag);
+}
+
+
+void xmlnode_put_attrib(xmlnode owner, const char* name, const char* value)
+{
+    xmlnode attrib;
+
+    if(owner == NULL || name == NULL || value == NULL) return;
+
+    /* If there are no existing attributs, allocate a new one to start
+    the list */
+    if (owner->firstattrib == NULL)
+    {
+        attrib = _xmlnode_new(owner->p, name, NTYPE_ATTRIB);
+        owner->firstattrib = attrib;
+        owner->lastattrib  = attrib;
+    }
+    else
+    {
+        attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
+        if(attrib == NULL)
+        {
+            attrib = _xmlnode_append_sibling(owner->lastattrib, name, NTYPE_ATTRIB);
+            owner->lastattrib = attrib;
+        }
+    }
+    /* Update the value of the attribute */
+    attrib->data_sz = strlen(value);
+    attrib->data    = pstrdup(owner->p, value);
+
+}
+
+char* xmlnode_get_attrib(xmlnode owner, const char* name)
+{
+    xmlnode attrib;
+
+    if (owner != NULL && owner->firstattrib != NULL)
+    {
+        attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
+        if (attrib != NULL)
+            return (char*)attrib->data;
+    }
+    return NULL;
+}
+
+void xmlnode_put_vattrib(xmlnode owner, const char* name, void *value)
+{
+    xmlnode attrib;
+
+    if (owner != NULL)
+    {
+        attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
+        if (attrib == NULL)
+        {
+            xmlnode_put_attrib(owner, name, "");
+            attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
+        }
+        if (attrib != NULL)
+            attrib->firstchild = (xmlnode)value;
+    }
+}
+
+void* xmlnode_get_vattrib(xmlnode owner, const char* name)
+{
+    xmlnode attrib;
+
+    if (owner != NULL && owner->firstattrib != NULL)
+    {
+        attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
+        if (attrib != NULL)
+            return (void*)attrib->firstchild;
+    }
+    return NULL;
+}
+
+xmlnode xmlnode_get_firstattrib(xmlnode parent)
+{
+    if (parent != NULL)
+        return parent->firstattrib;
+    return NULL;
+}
+
+xmlnode xmlnode_get_firstchild(xmlnode parent)
+{
+    if (parent != NULL)
+        return parent->firstchild;
+    return NULL;
+}
+
+xmlnode xmlnode_get_lastchild(xmlnode parent)
+{
+    if (parent != NULL)
+        return parent->lastchild;
+    return NULL;
+}
+
+xmlnode xmlnode_get_nextsibling(xmlnode sibling)
+{
+    if (sibling != NULL)
+        return sibling->next;
+    return NULL;
+}
+
+xmlnode xmlnode_get_prevsibling(xmlnode sibling)
+{
+    if (sibling != NULL)
+        return sibling->prev;
+    return NULL;
+}
+
+xmlnode xmlnode_get_parent(xmlnode node)
+{
+    if (node != NULL)
+        return node->parent;
+    return NULL;
+}
+
+char* xmlnode_get_name(xmlnode node)
+{
+    if (node != NULL)
+        return node->name;
+    return NULL;
+}
+
+char* xmlnode_get_data(xmlnode node)
+{
+    if(xmlnode_get_type(node) == NTYPE_TAG) /* loop till we find a CDATA in the children */
+        for(node = xmlnode_get_firstchild(node); node != NULL; node = xmlnode_get_nextsibling(node))
+            if(xmlnode_get_type(node) == NTYPE_CDATA) break;
+
+    if(node == NULL) return NULL;
+
+    /* check for a dirty node w/ unassembled cdata chunks */
+    if(xmlnode_get_type(node->next) == NTYPE_CDATA)
+        _xmlnode_merge(node);
+
+    return node->data;
+}
+
+int xmlnode_get_datasz(xmlnode node)
+{
+    if(xmlnode_get_type(node) != NTYPE_CDATA) return 0;
+
+    /* check for a dirty node w/ unassembled cdata chunks */
+    if(xmlnode_get_type(node->next) == NTYPE_CDATA)
+        _xmlnode_merge(node);
+    return node->data_sz;
+}
+
+int xmlnode_get_type(xmlnode node)
+{
+    if (node != NULL)
+        return node->type;
+    return NTYPE_UNDEF;
+}
+
+int xmlnode_has_children(xmlnode node)
+{
+    if ((node != NULL) && (node->firstchild != NULL))
+        return 1;
+    return 0;
+}
+
+int xmlnode_has_attribs(xmlnode node)
+{
+    if ((node != NULL) && (node->firstattrib != NULL))
+        return 1;
+    return 0;
+}
+
+pool xmlnode_pool(xmlnode node)
+{
+    if (node != NULL)
+        return node->p;
+    return (pool)NULL;
+}
+
+void xmlnode_hide(xmlnode child)
+{
+    xmlnode parent;
+
+    if(child == NULL || child->parent == NULL)
+        return;
+
+    parent = child->parent;
+
+    /* first fix up at the child level */
+    _xmlnode_hide_sibling(child);
+
+    /* next fix up at the parent level */
+    if(parent->firstchild == child)
+        parent->firstchild = child->next;
+    if(parent->lastchild == child)
+        parent->lastchild = child->prev;
+}
+
+void xmlnode_hide_attrib(xmlnode parent, const char *name)
+{
+    xmlnode attrib;
+
+    if(parent == NULL || parent->firstattrib == NULL || name == NULL)
+        return;
+
+    attrib = _xmlnode_search(parent->firstattrib, name, NTYPE_ATTRIB);
+    if(attrib == NULL)
+        return;
+
+    /* first fix up at the child level */
+    _xmlnode_hide_sibling(attrib);
+
+    /* next fix up at the parent level */
+    if(parent->firstattrib == attrib)
+        parent->firstattrib = attrib->next;
+    if(parent->lastattrib == attrib)
+        parent->lastattrib = attrib->prev;
+}
+
+
+
+/*
+ *  xmlnode2str -- convert given xmlnode tree into a string
+ *
+ *  parameters
+ *      node -- pointer to the xmlnode structure
+ *
+ *  results
+ *      a pointer to the created string
+ *      or NULL if it was unsuccessfull
+ */
+char *xmlnode2str(xmlnode node)
+{
+     return spool_print(_xmlnode2spool(node));
+}
+
+/*
+ *  xmlnode2tstr -- convert given xmlnode tree into a newline terminated string
+ *
+ *  parameters
+ *      node -- pointer to the xmlnode structure
+ *
+ *  results
+ *      a pointer to the created string
+ *      or NULL if it was unsuccessfull
+ */
+char*    xmlnode2tstr(xmlnode node)
+{
+     spool s = _xmlnode2spool(node);
+     if (s != NULL)
+      spool_add(s, "\n");
+    return spool_print(s);
+}
+
+
+/* loop through both a and b comparing everything, attribs, cdata, children, etc */
+int xmlnode_cmp(xmlnode a, xmlnode b)
+{
+    int ret = 0;
+
+    while(1)
+    {
+        if(a == NULL && b == NULL)
+            return 0;
+
+        if(a == NULL || b == NULL)
+            return -1;
+
+        if(xmlnode_get_type(a) != xmlnode_get_type(b))
+            return -1;
+
+        switch(xmlnode_get_type(a))
+        {
+        case NTYPE_ATTRIB:
+            ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b));
+            if(ret != 0)
+                return -1;
+            ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b));
+            if(ret != 0)
+                return -1;
+            break;
+        case NTYPE_TAG:
+            ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b));
+            if(ret != 0)
+                return -1;
+            ret = xmlnode_cmp(xmlnode_get_firstattrib(a), xmlnode_get_firstattrib(b));
+            if(ret != 0)
+                return -1;
+            ret = xmlnode_cmp(xmlnode_get_firstchild(a), xmlnode_get_firstchild(b));
+            if(ret != 0)
+                return -1;
+            break;
+        case NTYPE_CDATA:
+            ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b));
+            if(ret != 0)
+                return -1;
+        }
+        a = xmlnode_get_nextsibling(a);
+        b = xmlnode_get_nextsibling(b);
+    }
+}
+
+
+xmlnode xmlnode_insert_tag_node(xmlnode parent, xmlnode node)
+{
+    xmlnode child;
+
+    child = xmlnode_insert_tag(parent, xmlnode_get_name(node));
+    if (xmlnode_has_attribs(node))
+        xmlnode_insert_node(child, xmlnode_get_firstattrib(node));
+    if (xmlnode_has_children(node))
+        xmlnode_insert_node(child, xmlnode_get_firstchild(node));
+
+    return child;
+}
+
+/* places copy of node and node's siblings in parent */
+void xmlnode_insert_node(xmlnode parent, xmlnode node)
+{
+    if(node == NULL || parent == NULL)
+        return;
+
+    while(node != NULL)
+    {
+        switch(xmlnode_get_type(node))
+        {
+        case NTYPE_ATTRIB:
+            xmlnode_put_attrib(parent, xmlnode_get_name(node), xmlnode_get_data(node));
+            break;
+        case NTYPE_TAG:
+            xmlnode_insert_tag_node(parent, node);
+            break;
+        case NTYPE_CDATA:
+            xmlnode_insert_cdata(parent, xmlnode_get_data(node), xmlnode_get_datasz(node));
+        }
+        node = xmlnode_get_nextsibling(node);
+    }
+}
+
+
+/* produce full duplicate of x with a new pool, x must be a tag! */
+xmlnode xmlnode_dup(xmlnode x)
+{
+    xmlnode x2;
+
+    if(x == NULL)
+        return NULL;
+
+    x2 = xmlnode_new_tag(xmlnode_get_name(x));
+
+    if (xmlnode_has_attribs(x))
+        xmlnode_insert_node(x2, xmlnode_get_firstattrib(x));
+    if (xmlnode_has_children(x))
+        xmlnode_insert_node(x2, xmlnode_get_firstchild(x));
+
+    return x2;
+}
+
+xmlnode xmlnode_dup_pool(pool p, xmlnode x)
+{
+    xmlnode x2;
+
+    if(x == NULL)
+        return NULL;
+
+    x2 = xmlnode_new_tag_pool(p, xmlnode_get_name(x));
+
+    if (xmlnode_has_attribs(x))
+        xmlnode_insert_node(x2, xmlnode_get_firstattrib(x));
+    if (xmlnode_has_children(x))
+        xmlnode_insert_node(x2, xmlnode_get_firstchild(x));
+
+    return x2;
+}
+
+xmlnode xmlnode_wrap(xmlnode x,const char *wrapper)
+{
+    xmlnode wrap;
+    if(x==NULL||wrapper==NULL) return NULL;
+    wrap=xmlnode_new_tag_pool(xmlnode_pool(x),wrapper);
+    if(wrap==NULL) return NULL;
+    wrap->firstchild=x;
+    wrap->lastchild=x;
+    x->parent=wrap;
+    return wrap;
+}
+
+void xmlnode_free(xmlnode node)
+{
+    if(node == NULL)
+        return;
+
+    pool_free(node->p);
+}
+
+/***/
+void expat_startElement(void* userdata, const char* name, const char** atts)
+{
+    /* get the xmlnode pointed to by the userdata */
+    xmlnode *x = userdata;
+    xmlnode current = *x;
+
+    if (current == NULL)
+    {
+        /* allocate a base node */
+        current = xmlnode_new_tag(name);
+        xmlnode_put_expat_attribs(current, atts);
+        *x = current;
+    }
+    else
+    {
+        *x = xmlnode_insert_tag(current, name);
+        xmlnode_put_expat_attribs(*x, atts);
+    }
+}
+
+void expat_endElement(void* userdata, const char* name)
+{
+    xmlnode *x = userdata;
+    xmlnode current = *x;
+
+    current->complete = 1;
+    current = xmlnode_get_parent(current);
+
+    /* if it's NULL we've hit the top folks, otherwise back up a level */
+    if(current != NULL)
+        *x = current;
+}
+
+void expat_charData(void* userdata, const char* s, int len)
+{
+    xmlnode *x = userdata;
+    xmlnode current = *x;
+
+    xmlnode_insert_cdata(current, s, len);
+}
+
+
+xmlnode xmlnode_str(char *str, int len)
+{
+    XML_Parser p;
+    xmlnode *x, node; /* pointer to an xmlnode */
+
+    if(NULL == str)
+        return NULL;
+
+    x = malloc(sizeof(void *));
+
+    *x = NULL; /* pointer to NULL */
+    p = XML_ParserCreate(NULL);
+    XML_SetUserData(p, x);
+    XML_SetElementHandler(p, expat_startElement, expat_endElement);
+    XML_SetCharacterDataHandler(p, expat_charData);
+    if(!XML_Parse(p, str, len, 1))
+    {
+        /*        jdebug(ZONE,"xmlnode_str_error: %s",(char *)XML_ErrorString(XML_GetErrorCode(p)));*/
+        xmlnode_free(*x);
+        *x = NULL;
+    }
+    node = *x;
+    free(x);
+    XML_ParserFree(p);
+    return node; /* return the xmlnode x points to */
+}
+
+xmlnode xmlnode_file(char *file)
+{
+    XML_Parser p;
+    xmlnode *x, node; /* pointer to an xmlnode */
+    char buf[BUFSIZ];
+    int done, fd, len;
+
+    if(NULL == file)
+        return NULL;
+
+    fd = open(file,O_RDONLY);
+    if(fd < 0)
+        return NULL;
+
+    x = malloc(sizeof(void *));
+
+    *x = NULL; /* pointer to NULL */
+    p = XML_ParserCreate(NULL);
+    XML_SetUserData(p, x);
+    XML_SetElementHandler(p, expat_startElement, expat_endElement);
+    XML_SetCharacterDataHandler(p, expat_charData);
+    do{
+        len = read(fd, buf, BUFSIZ);
+        done = len < BUFSIZ;
+        if(!XML_Parse(p, buf, len, done))
+        {
+            /*            jdebug(ZONE,"xmlnode_file_parseerror: %s",(char *)XML_ErrorString(XML_GetErrorCode(p)));*/
+            xmlnode_free(*x);
+            *x = NULL;
+            done = 1;
+        }
+    }while(!done);
+
+    node = *x;
+    XML_ParserFree(p);
+    free(x);
+    close(fd);
+    return node; /* return the xmlnode x points to */
+}
+
+char* xmlnode_file_borked(char *file)
+{
+    XML_Parser p;
+    char buf[BUFSIZ];
+    static char err[1024];
+    int fd, len, done;
+
+    if(NULL == file)
+        return "no file specified";
+
+    fd = open(file,O_RDONLY);
+    if(fd < 0)
+        return "unable to open file";
+
+    p = XML_ParserCreate(NULL);
+    while(1)
+    {
+        len = read(fd, buf, BUFSIZ);
+        done = len < BUFSIZ;
+        if(!XML_Parse(p, buf, len, done))
+        {
+            snprintf(err,1023,"%s at line %d and column %d",XML_ErrorString(XML_GetErrorCode(p)),XML_GetErrorLineNumber(p),XML_GetErrorColumnNumber(p));
+            XML_ParserFree(p);
+            close(fd);
+            return err;
+        }
+    }
+}
+
+int xmlnode2file(char *file, xmlnode node)
+{
+    char *doc, *ftmp;
+    int fd, i;
+
+    if(file == NULL || node == NULL)
+        return -1;
+
+    ftmp = spools(xmlnode_pool(node),file,".t.m.p",xmlnode_pool(node));
+    fd = open(ftmp, O_CREAT | O_WRONLY | O_TRUNC, 0600);
+    if(fd < 0)
+        return -1;
+
+    doc = xmlnode2str(node);
+    i = write(fd,doc,strlen(doc));
+    if(i < 0)
+        return -1;
+
+    close(fd);
+
+    if(rename(ftmp,file) < 0)
+    {
+        unlink(ftmp);
+        return -1;
+    }
+    return 1;
+}
+
+void xmlnode_put_expat_attribs(xmlnode owner, const char** atts)
+{
+    int i = 0;
+    if (atts == NULL) return;
+    while (atts[i] != '\0')
+    {
+        xmlnode_put_attrib(owner, atts[i], atts[i+1]);
+        i += 2;
+    }
+}
diff -Naurb jabberd-2.1.14.orig/sm/xmlnode.h jabberd-2.1.14/sm/xmlnode.h
--- jabberd-2.1.14.orig/sm/xmlnode.h    1970-01-01 01:00:00.000000000 +0100
+++ jabberd-2.1.14/sm/xmlnode.h 2007-08-29 15:54:24.000000000 +0200
@@ -0,0 +1,128 @@
+#ifndef __XMLNODE_H
+#define __XMLNODE_H
+
+#include "../util/util.h"
+typedef pool_t pool;
+
+/* --------------------------------------------------------- */
+/*                                                           */
+/* xmlnodes - Document Object Model                          */
+/*                                                           */
+/* --------------------------------------------------------- */
+#define NTYPE_TAG    0
+#define NTYPE_ATTRIB 1
+#define NTYPE_CDATA  2
+
+#define NTYPE_LAST   2
+#define NTYPE_UNDEF  -1
+
+/* --------------------------------------------------------------------------
+ *    Node structure. Do not use directly! Always use accessor macros
+ *       and methods!
+ *          -------------------------------------------------------------------------- */
+typedef struct xmlnode_t
+{
+     char*               name;
+     unsigned short      type;
+     char*               data;
+     int                 data_sz;
+     int                 complete;
+     pool               p;
+     struct xmlnode_t*  parent;
+     struct xmlnode_t*  firstchild;
+     struct xmlnode_t*  lastchild;
+     struct xmlnode_t*  prev;
+     struct xmlnode_t*  next;
+     struct xmlnode_t*  firstattrib;
+     struct xmlnode_t*  lastattrib;
+} _xmlnode, *xmlnode;
+
+/* Node creation routines */
+xmlnode  xmlnode_wrap(xmlnode x,const char* wrapper);
+xmlnode  xmlnode_new_tag(const char* name);
+xmlnode  xmlnode_new_tag_pool(pool p, const char* name);
+xmlnode  xmlnode_insert_cdata(xmlnode parent, const char* CDATA, unsigned int size);
+xmlnode  xmlnode_insert_tag(xmlnode parent, const char* name);
+xmlnode  xmlnode_insert_tag_node(xmlnode parent, xmlnode node);
+void     xmlnode_insert_node(xmlnode parent, xmlnode node);
+xmlnode  xmlnode_str(char *str, int len);
+xmlnode  xmlnode_file(char *file);
+char*    xmlnode_file_borked(char *file); /* same as _file but returns the parsing error */
+xmlnode  xmlnode_dup(xmlnode x); /* duplicate x */
+xmlnode  xmlnode_dup_pool(pool p, xmlnode x);
+
+/* Node Memory Pool */
+pool xmlnode_pool(xmlnode node);
+xmlnode _xmlnode_new(pool p, const char *name, unsigned int type);
+
+/* Node editing */
+void xmlnode_hide(xmlnode child);
+void xmlnode_hide_attrib(xmlnode parent, const char *name);
+
+/* Node deletion routine, also frees the node pool! */
+void xmlnode_free(xmlnode node);xmlnode  xmlnode_insert_cdata(xmlnode parent, const char* CDATA, unsigned int size);
+xmlnode  xmlnode_insert_tag_node(xmlnode parent, xmlnode node);
+void     xmlnode_insert_node(xmlnode parent, xmlnode node);
+xmlnode  xmlnode_str(char *str, int len);
+xmlnode  xmlnode_file(char *file);
+char*    xmlnode_file_borked(char *file); /* same as _file but returns the parsing error */
+xmlnode  xmlnode_dup(xmlnode x); /* duplicate x */
+xmlnode  xmlnode_dup_pool(pool p, xmlnode x);
+
+/* Node Memory Pool */
+pool xmlnode_pool(xmlnode node);
+xmlnode _xmlnode_new(pool p, const char *name, unsigned int type);
+
+/* Node editing */
+void xmlnode_hide(xmlnode child);
+void xmlnode_hide_attrib(xmlnode parent, const char *name);
+
+/* Node deletion routine, also frees the node pool! */
+void xmlnode_free(xmlnode node);
+
+/* Locates a child tag by name and returns it */
+xmlnode  xmlnode_get_tag(xmlnode parent, const char* name);
+char* xmlnode_get_tag_data(xmlnode parent, const char* name);
+
+/* Attribute accessors */
+void     xmlnode_put_attrib(xmlnode owner, const char* name, const char* value);
+char*    xmlnode_get_attrib(xmlnode owner, const char* name);
+void     xmlnode_put_expat_attribs(xmlnode owner, const char** atts);
+
+/* Bastard am I, but these are fun for internal use ;-) */
+void     xmlnode_put_vattrib(xmlnode owner, const char* name, void *value);
+void*    xmlnode_get_vattrib(xmlnode owner, const char* name);
+
+/* Node traversal routines */
+xmlnode  xmlnode_get_firstattrib(xmlnode parent);
+xmlnode  xmlnode_get_firstchild(xmlnode parent);
+xmlnode  xmlnode_get_lastchild(xmlnode parent);
+xmlnode  xmlnode_get_nextsibling(xmlnode sibling);
+xmlnode  xmlnode_get_prevsibling(xmlnode sibling);
+xmlnode  xmlnode_get_parent(xmlnode node);
+
+/* Node information routines */
+char*    xmlnode_get_name(xmlnode node);
+char*    xmlnode_get_data(xmlnode node);
+int      xmlnode_get_datasz(xmlnode node);
+int      xmlnode_get_type(xmlnode node);
+
+int      xmlnode_has_children(xmlnode node);
+int      xmlnode_has_attribs(xmlnode node);
+
+/* Node-to-string translation */
+char*    xmlnode2str(xmlnode node);
+
+/* Node-to-terminated-string translation
+ *    -- useful for interfacing w/ scripting langs */
+char*    xmlnode2tstr(xmlnode node);
+
+int      xmlnode_cmp(xmlnode a, xmlnode b); /* compares a and b for equality */
+
+int      xmlnode2file(char *file, xmlnode node); /* writes node to file */
+
+/* Expat callbacks */
+void expat_startElement(void* userdata, const char* name, const char** atts);
+void expat_endElement(void* userdata, const char* name);
+void expat_charData(void* userdata, const char* s, int len);
+#endif