From 737dd7a227270737250118e74764f2d970d389e7 Mon Sep 17 00:00:00 2001
From: Stefan Ritt <stefan.ritt@psi.ch>
Date: Tue, 1 Mar 2005 23:48:18 +0000
Subject: [PATCH] Implemented MXML for password file

SVN revision: 1225
---
 src/elogd.c |  496 +++++++++++-------------
 src/mxml.c  | 1050 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/mxml.h  |   71 ++++
 3 files changed, 1336 insertions(+), 281 deletions(-)
 create mode 100755 src/mxml.c
 create mode 100755 src/mxml.h

diff --git a/src/elogd.c b/src/elogd.c
index 215c6ad9..0d97e776 100755
--- a/src/elogd.c
+++ b/src/elogd.c
@@ -6,6 +6,9 @@
    Contents:     Web server program for Electronic Logbook ELOG
 
    $Log$
+   Revision 1.572  2005/03/01 23:48:17  ritt
+   Implemented MXML for password file
+
    Revision 1.571  2005/02/22 09:34:04  ritt
    Fixed bug with logbook names containing blanks and 'List' link
 
@@ -932,6 +935,7 @@ char pidfile[256];              /* Pidfile name
 
 /* local includes */
 #include "regex.h"
+#include "mxml.h"
 
 BOOL running_as_daemon;         /* Running as a daemon/service? */
 int elog_tcp_port = (int) DEFAULT_PORT; /* Server's TCP port            */
@@ -1195,7 +1199,7 @@ int run_service(void);
 #endif
 
 void show_error(char *error);
-BOOL enum_user_line(LOGBOOK * lbs, int n, char *user);
+BOOL enum_user_line(LOGBOOK * lbs, int n, char *user, int size);
 int get_user_line(char *logbook_name, char *user, char *password, char *full_name,
                   char *email, char *email_notify);
 int strbreak(char *str, char list[][NAME_LENGTH], int size, char *brk);
@@ -1361,8 +1365,6 @@ char *xstrdup(const char *string)
    return s;
 }
 
-/*------------------------------------------------------------------*/
-
 /*----------------------- Message handling -------------------------*/
 
 /* Have vasprintf? (seems that only libc6 based Linux has this) */
@@ -3568,7 +3570,7 @@ void retrieve_email_from(LOGBOOK * lbs, char *ret, char attrib[MAX_N_ATTR][NAME_
    /* if nothing available, figure out email from an administrator */
    if (strchr(str, '@') == NULL) {
       for (i = 0;; i++) {
-         if (!enum_user_line(lbs, i, login_name))
+         if (!enum_user_line(lbs, i, login_name, sizeof(login_name)))
             break;
          get_user_line(lbs->name, login_name, NULL, NULL, str, NULL);
          if (is_admin_user(lbs->name, login_name) && strchr(str, '@'))
@@ -7254,9 +7256,8 @@ void add_subst_time(LOGBOOK * lbs,
 
 BOOL change_pwd(LOGBOOK * lbs, char *user, char *pwd)
 {
-   char str[256], file_name[256], line[256], *p, *pl;
-   char *buf;
-   int i, fh, size;
+   char str[256], file_name[256];
+   PMXML_NODE xml_tree, node;
 
    getcfg(lbs->name, "Password file", str, sizeof(str));
 
@@ -7267,75 +7268,23 @@ BOOL change_pwd(LOGBOOK * lbs, char *user, char *pwd)
       strlcat(file_name, str, sizeof(file_name));
    }
 
-   fh = open(file_name, O_RDWR | O_BINARY, 644);
-   if (fh > 0) {
-      lseek(fh, 0, SEEK_END);
-      size = TELL(fh);
-      lseek(fh, 0, SEEK_SET);
+   xml_tree = mxml_parse_file(file_name, str, sizeof(str));
+   if (!xml_tree)
+      return FALSE;
 
-      buf = xmalloc(size + 1);
-      read(fh, buf, size);
-      buf[size] = 0;
-      pl = buf;
-
-      while (pl < buf + size) {
-         for (i = 0; pl[i] && pl[i] != '\r' && pl[i] != '\n'; i++)
-            line[i] = pl[i];
-         line[i] = 0;
-
-         if (line[0] == ';' || line[0] == '#' || line[0] == 0) {
-            pl += strlen(line);
-            while (*pl && (*pl == '\r' || *pl == '\n'))
-               pl++;
-            continue;
-         }
-
-         strcpy(str, line);
-         if (strchr(str, ':'))
-            *strchr(str, ':') = 0;
-         if (strcmp(str, user) == 0)
-            break;
-
-         pl += strlen(line);
-         while (*pl && (*pl == '\r' || *pl == '\n'))
-            pl++;
-      }
-
-      /* return if not found */
-      if (pl >= buf + size) {
-         xfree(buf);
-         close(fh);
-         return FALSE;
-      }
-
-      p = strchr(line, ':');
-      if (p)
-         p = strchr(p + 1, ':');
-      if (p == NULL)
-         return FALSE;
-
-      /* replace password */
-      lseek(fh, 0, SEEK_SET);
-      write(fh, buf, pl - buf);
-
-      sprintf(str, "%s:%s%s\n", user, pwd, p);
-      write(fh, str, strlen(str));
-
-      pl += strlen(line);
-      while (*pl && (*pl == '\r' || *pl == '\n'))
-         pl++;
-
-      write(fh, pl, strlen(pl));
-
-      TRUNCATE(fh);
-
-      xfree(buf);
-      close(fh);
-
-      return TRUE;
+   sprintf(str, "/list/user[name=%s]/password", user);
+   node = mxml_find_node(xml_tree, str);
+   if (node == NULL) {
+      mxml_free_tree(xml_tree);
+      return FALSE;
    }
 
-   return FALSE;
+   mxml_replace_node_value(node, pwd);
+
+   mxml_write_tree(file_name, xml_tree);
+   mxml_free_tree(xml_tree);
+
+   return TRUE;
 }
 
 /*------------------------------------------------------------------*/
@@ -8347,7 +8296,7 @@ void show_edit_form(LOGBOOK * lbs, int message_id, BOOL breply, BOOL bedit, BOOL
                rsprintf("<option value=\"\">- %s -\n", loc("please select"));
 
                for (i = 0;; i++) {
-                  if (!enum_user_line(lbs, i, login_name))
+                  if (!enum_user_line(lbs, i, login_name, sizeof(login_name)))
                      break;
                   get_user_line(lbs->name, login_name, NULL, str, NULL, NULL);
 
@@ -9927,10 +9876,11 @@ int save_config(char *buffer, char *error)
 
 int save_user_config(LOGBOOK * lbs, char *user, BOOL new_user, BOOL activate)
 {
-   char file_name[256], str[256], line[256], *buf, *pl, new_pwd[80], new_pwd2[80];
+   char file_name[256], str[256], *pl, new_pwd[80], new_pwd2[80];
    char smtp_host[256], email_addr[256], mail_from[256], subject[256], mail_text[2000];
    char admin_user[80], enc_pwd[80], url[256];
-   int i, fh, size, self_register;
+   int self_register;
+   PMXML_NODE xml_tree, node;
 
    /* check for full name */
    if (!isparam("new_full_name") || *getparam("new_full_name") == 0) {
@@ -9979,92 +9929,50 @@ int save_user_config(LOGBOOK * lbs, char *user, BOOL new_user, BOOL activate)
          strlcat(file_name, str, sizeof(file_name));
       }
 
-      fh = open(file_name, O_RDWR | O_BINARY | O_CREAT, 0644);
-      if (fh < 0) {
-         sprintf(str, loc("Cannot open file <b>%s</b>"), file_name);
-         strcat(str, ": ");
-         strlcat(str, strerror(errno), sizeof(str));
+      xml_tree = mxml_parse_file(file_name, str, sizeof(str));
+      if (xml_tree == NULL) {
          show_error(str);
          return 0;
       }
+         
+      sprintf(str, "/list/user[name=%s]", user);
+      node = mxml_find_node(xml_tree, str);
 
-      lseek(fh, 0, SEEK_END);
-      size = TELL(fh);
-      lseek(fh, 0, SEEK_SET);
-
-      buf = xmalloc(size + 1);
-      read(fh, buf, size);
-      buf[size] = 0;
-      pl = buf;
-
-      while (pl < buf + size) {
-         for (i = 0; pl[i] && pl[i] != '\r' && pl[i] != '\n'; i++)
-            line[i] = pl[i];
-         line[i] = 0;
-
-         /* skip outcommented lines */
-         if (line[0] == ';' || line[0] == '#') {
-            pl += strlen(line);
-            while (*pl && (*pl == '\r' || *pl == '\n'))
-               pl++;
-            continue;
-         }
-
-         if (line[0] == 0)
-            break;
-
-         strcpy(str, line);
-         if (strchr(str, ':'))
-            *strchr(str, ':') = 0;
-         if (strcmp(str, user) == 0) {
-            if (new_user) {
-               sprintf(str, "%s \"%s\" %s", loc("Login name"), user, loc("exists already"));
-               show_error(str);
-               xfree(buf);
-               close(fh);
-               return 0;
-            }
-            break;
-         }
-
-         pl += strlen(line);
-         while (*pl && (*pl == '\r' || *pl == '\n'))
-            pl++;
+      if (node && new_user) {
+         sprintf(str, "%s \"%s\" %s", loc("Login name"), user, loc("exists already"));
+         show_error(str);
+         mxml_free_tree(xml_tree);
+         return 0;
       }
 
       if (new_user) {
-         lseek(fh, 0, SEEK_END);
-         if (strlen(buf) != 0 && (buf[strlen(buf) - 1] != '\r' && buf[strlen(buf) - 1] != '\n'))
-            write(fh, "\n", 1);
+         node = mxml_add_node(xml_tree, "user", NULL);
+
+         if (activate) {
+            mxml_add_node(node, "name", getparam("new_user_name"));
+            mxml_add_node(node, "password", getparam("encpwd"));
+            mxml_add_node(node, "full_name", getparam("new_full_name"));
+            mxml_add_node(node, "email", getparam("new_user_email"));
+            mxml_add_node(node, "email_notify", getparam("email_notify"));
+         } else {
+            mxml_add_node(node, "name", getparam("new_user_name"));
+            mxml_add_node(node, "password", new_pwd);
+            mxml_add_node(node, "full_name", getparam("new_full_name"));
+            mxml_add_node(node, "email", getparam("new_user_email"));
+            mxml_add_node(node, "email_notify", getparam("email_notify"));
+         }
 
-         if (activate)
-            sprintf(str, "%s:%s:%s:%s:%s\n", getparam("new_user_name"),
-                    getparam("encpwd"), getparam("new_full_name"),
-                    getparam("new_user_email"), getparam("email_notify"));
-         else
-            sprintf(str, "%s:%s:%s:%s:%s\n", getparam("new_user_name"),
-                    new_pwd, getparam("new_full_name"), getparam("new_user_email"), getparam("email_notify"));
-         write(fh, str, strlen(str));
       } else {
-         /* replace line */
-         lseek(fh, 0, SEEK_SET);
-         write(fh, buf, pl - buf);
-
-         sprintf(str, "%s:%s:%s:%s:%s\n", getparam("new_user_name"),
-                 new_pwd, getparam("new_full_name"), getparam("new_user_email"), getparam("email_notify"));
-         write(fh, str, strlen(str));
-
-         pl += strlen(line);
-         while (*pl && (*pl == '\r' || *pl == '\n'))
-            pl++;
-
-         write(fh, pl, strlen(pl));
-
-         TRUNCATE(fh);
+         /* replace record */
+         mxml_replace_subvalue(node, "name", getparam("new_user_name"));
+         mxml_replace_subvalue(node, "password", new_pwd);
+         mxml_replace_subvalue(node, "full_name", getparam("new_full_name"));
+         mxml_replace_subvalue(node, "email", getparam("new_user_email"));
+         mxml_replace_subvalue(node, "email_notify", getparam("email_notify"));
       }
 
-      xfree(buf);
-      close(fh);
+      mxml_write_tree(file_name, xml_tree);
+      mxml_free_tree(xml_tree);
    }
 
    /* if requested, send notification email to admin user */
@@ -10199,8 +10107,8 @@ int save_user_config(LOGBOOK * lbs, char *user, BOOL new_user, BOOL activate)
 
 int remove_user(LOGBOOK * lbs, char *user)
 {
-   char file_name[256], str[256], line[256], *buf, *pl;
-   int i, fh, size;
+   char file_name[256], str[256];
+   PMXML_NODE xml_tree, node;
 
    getcfg(lbs->name, "Password file", str, sizeof(str));
 
@@ -10211,63 +10119,26 @@ int remove_user(LOGBOOK * lbs, char *user)
       strlcat(file_name, str, sizeof(file_name));
    }
 
-   fh = open(file_name, O_RDWR | O_BINARY, 0644);
-   if (fh < 0) {
-      sprintf(str, loc("Cannot open file <b>%s</b>"), file_name);
-      strcat(str, ": ");
-      strcat(str, strerror(errno));
-      show_error(str);
-      return 0;
+   xml_tree = mxml_parse_file(file_name, str, sizeof(str));
+   if (xml_tree == NULL)
+      return FALSE;
+
+   sprintf(str, "/list/user[name=%s]", user);
+   node = mxml_find_node(xml_tree, str);
+   if (node == NULL) {
+      mxml_free_tree(xml_tree);
+      return FALSE;
    }
 
-   lseek(fh, 0, SEEK_END);
-   size = TELL(fh);
-   lseek(fh, 0, SEEK_SET);
+   mxml_delete_node(node);
 
-   buf = xmalloc(size + 1);
-   read(fh, buf, size);
-   buf[size] = 0;
-   pl = buf;
-
-   while (pl < buf + size) {
-      for (i = 0; pl[i] && pl[i] != '\r' && pl[i] != '\n'; i++)
-         line[i] = pl[i];
-      line[i] = 0;
-
-      if (line[0] == ';' || line[0] == '#' || line[0] == 0) {
-         pl += strlen(line);
-         while (*pl && (*pl == '\r' || *pl == '\n'))
-            pl++;
-         continue;
-      }
-
-      strcpy(str, line);
-      if (strchr(str, ':'))
-         *strchr(str, ':') = 0;
-      if (strcmp(str, user) == 0)
-         break;
-
-      pl += strlen(line);
-      while (*pl && (*pl == '\r' || *pl == '\n'))
-         pl++;
+   if (!mxml_write_tree(file_name, xml_tree)) {
+      mxml_free_tree(xml_tree);
+      return FALSE;
    }
 
-   /* remove line */
-   lseek(fh, 0, SEEK_SET);
-   write(fh, buf, pl - buf);
-
-   pl += strlen(line);
-   while (*pl && (*pl == '\r' || *pl == '\n'))
-      pl++;
-
-   write(fh, pl, strlen(pl));
-
-   TRUNCATE(fh);
-
-   xfree(buf);
-   close(fh);
-
-   return 1;
+   mxml_free_tree(xml_tree);
+   return TRUE;
 }
 
 /*------------------------------------------------------------------*/
@@ -10327,7 +10198,7 @@ void show_config_page(LOGBOOK * lbs)
 
       /* count user list */
       for (n = 0;; n++) {
-         if (!enum_user_line(lbs, n, str))
+         if (!enum_user_line(lbs, n, str, sizeof(str)))
             break;
       }
 
@@ -10337,7 +10208,7 @@ void show_config_page(LOGBOOK * lbs)
          user_list[i] = xcalloc(NAME_LENGTH, 1);
 
       for (i = 0; i < n; i++)
-         enum_user_line(lbs, i, user_list[i]);
+         enum_user_line(lbs, i, user_list[i], NAME_LENGTH);
 
       /* sort list */
       qsort(user_list, n, sizeof(char *), ascii_compare);
@@ -10422,7 +10293,7 @@ void show_forgot_pwd_page(LOGBOOK * lbs)
       strcpy(name, getparam("login_name"));
 
       for (i = 0;; i++) {
-         if (!enum_user_line(lbs, i, login_name))
+         if (!enum_user_line(lbs, i, login_name, sizeof(login_name)))
             break;
 
          get_user_line(lbs->name, login_name, NULL, full_name, user_email, NULL);
@@ -17122,7 +16993,7 @@ void submit_elog(LOGBOOK * lbs)
              || atoi(str) == 0) {
             /* go through password file */
             for (index = 0;; index++) {
-               if (!enum_user_line(lbs, index, user))
+               if (!enum_user_line(lbs, index, user, sizeof(user)))
                   break;
 
                get_user_line(lbs->name, user, NULL, NULL, user_email, email_notify);
@@ -18373,12 +18244,105 @@ BOOL check_password(LOGBOOK * lbs, char *name, char *password, char *redir)
 
 /*------------------------------------------------------------------*/
 
+BOOL convert_password_file(char *file_name)
+{
+   char name[256], password[256], full_name[256], email[256], email_notify[256];
+   int i, len, fh;
+   char *buf, *p;
+   PMXML_NODE root, list, node;
+
+   fh = open(file_name, O_RDONLY | O_TEXT);
+   if (fh < 0)
+      return FALSE;
+   len = lseek(fh, 0, SEEK_END);
+   lseek(fh, 0, SEEK_SET);
+   buf = malloc(len+1);
+   assert(buf);
+   i = read(fh, buf, len);
+   buf[i] = 0;
+   close(fh);
+
+   p = buf;
+
+   /* skip leading spaces or new lines */
+   while (*p && isspace(*p))
+      p++;
+
+   root = mxml_create_root_node();
+   list = mxml_add_node(root, "list", NULL);
+
+   while (*p) {
+
+      /* skip comment lines */
+      if (*p != ';' && *p != '#') {
+         for (i=0 ; i<sizeof(name) && *p && *p != ':' ; i++)
+            name[i] = *p++;
+         name[i] = 0;
+         if (*p++ != ':') {
+            free(buf);
+            return FALSE;
+         }
+
+         for (i=0 ; i<sizeof(password) && *p && *p != ':' ; i++)
+            password[i] = *p++;
+         password[i] = 0;
+         if (*p++ != ':') {
+            free(buf);
+            return FALSE;
+         }
+
+         for (i=0 ; i<sizeof(full_name) && *p && *p != ':' ; i++)
+            full_name[i] = *p++;
+         full_name[i] = 0;
+         if (*p++ != ':') {
+            free(buf);
+            return FALSE;
+         }
+
+         for (i=0 ; i<sizeof(email) && *p && *p != ':' ; i++)
+            email[i] = *p++;
+         email[i] = 0;
+         if (*p++ != ':') {
+            free(buf);
+            return FALSE;
+         }
+
+         for (i=0 ; i<sizeof(email_notify) && *p && *p != '\n' ; i++)
+            email_notify[i] = *p++;
+         email_notify[i] = 0;
+         if (*p++ != '\n') {
+            free(buf);
+            return FALSE;
+         }
+
+         node = mxml_add_node(list, "user", NULL);
+         mxml_add_node(node, "name", name);
+         mxml_add_node(node, "password", password);
+         mxml_add_node(node, "full_name", full_name);
+         mxml_add_node(node, "email", email);
+         mxml_add_node(node, "email_notify", email_notify);
+      }
+
+      while (*p && isspace(*p))
+         p++;
+   }
+
+   mxml_write_tree(file_name, root);
+   mxml_free_tree(root);
+
+   free(buf);
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
 int get_user_line(char *logbook_name, char *user, char *password, char *full_name,
                   char *email, char *email_notify)
 {
-   char str[256], line[256], file_name[256], *p;
+   char str[256], line[256], file_name[256];
    FILE *f;
-   int i, fd;
+   int fd;
+   PMXML_NODE xml_tree, user_node, node;
 
    if (password)
       password[0] = 0;
@@ -18418,51 +18382,37 @@ int get_user_line(char *logbook_name, char *user, char *password, char *full_nam
          return 1;
       }
 
-      while (!feof(f)) {
-         line[0] = 0;
-         fgets(line, sizeof(line), f);
-
-         if (line[0] == ';' || line[0] == '#' || line[0] == 0)
-            continue;
-
-         strcpy(str, line);
-         if (strchr(str, ':'))
-            *strchr(str, ':') = 0;
-         if (strcmp(str, user) == 0)
-            break;
+      /* check if in XML format, otherwise convert it */
+      line[0] = 0;
+      fgets(line, sizeof(line), f);
+      if (strstr(line, "<?xml") == 0) {
+         fclose(f);
+         if (!convert_password_file(file_name))
+            return 1;
       }
-      fclose(f);
 
-      if (strcmp(str, user) != 0)
+      if ((xml_tree = mxml_parse_file(file_name, str, sizeof(str))) == NULL) {
+         show_error(str);
+         return 1;
+      }
+
+      sprintf(str, "/list/user[name=%s]", user);
+      if ((user_node = mxml_find_node(xml_tree, str)) == NULL) {
+         mxml_free_tree(xml_tree);
          return 2;
+      }
 
       /* if user found, retrieve other info */
-      p = line;
-
-      for (i = 0; i < 4; i++) {
-         if (strchr(p, ':') == NULL)
-            break;
-         p = strchr(p, ':') + 1;
-
-         while (*p && *p == ' ')
-            p++;
-         strlcpy(str, p, sizeof(str));
-         if (strchr(str, ':'))
-            *strchr(str, ':') = 0;
-
-         while (str[strlen(str) - 1] == ' ' || str[strlen(str) - 1] == '\r' || str[strlen(str) - 1] == '\n')
-            str[strlen(str) - 1] = 0;
-
-         if (i == 0 && password)
-            strcpy(password, str);
-         else if (i == 1 && full_name)
-            strcpy(full_name, str);
-         else if (i == 2 && email)
-            strcpy(email, str);
-         else if (i == 3 && email_notify)
-            strcpy(email_notify, str);
-      }
+      if ((node = mxml_find_node(user_node, "password")) != NULL && password && mxml_get_value(node))
+         strlcpy(password, mxml_get_value(node), 256);
+      if ((node = mxml_find_node(user_node, "full_name")) != NULL && full_name && mxml_get_value(node))
+         strlcpy(full_name, mxml_get_value(node), 256);
+      if ((node = mxml_find_node(user_node, "email")) != NULL && email && mxml_get_value(node))
+         strlcpy(email, mxml_get_value(node), 256);
+      if ((node = mxml_find_node(user_node, "email_notify")) != NULL && email_notify && mxml_get_value(node))
+         strlcpy(email_notify, mxml_get_value(node), 256);
 
+      mxml_free_tree(xml_tree);
       return 1;
    } else {
       if (user[0])
@@ -18474,11 +18424,10 @@ int get_user_line(char *logbook_name, char *user, char *password, char *full_nam
 
 /*------------------------------------------------------------------*/
 
-BOOL enum_user_line(LOGBOOK * lbs, int n, char *user)
+BOOL enum_user_line(LOGBOOK * lbs, int n, char *user, int size)
 {
-   char str[256], line[256], file_name[256];
-   FILE *f;
-   int i;
+   char str[256], file_name[256];
+   PMXML_NODE xml_tree, node;
 
    getcfg(lbs->name, "Password file", str, sizeof(str));
 
@@ -18492,35 +18441,20 @@ BOOL enum_user_line(LOGBOOK * lbs, int n, char *user)
       strlcat(file_name, str, sizeof(file_name));
    }
 
-   f = fopen(file_name, "r");
-   i = 0;
-   if (f != NULL) {
-      while (!feof(f)) {
-         line[0] = 0;
-         fgets(line, sizeof(line), f);
-
-         if (line[0] == ';' || line[0] == '#' || line[0] == 0)
-            continue;
-
-         if (strchr(line, ':') == NULL)
-            continue;
-
-         strcpy(str, line);
-         if (strchr(str, ':'))
-            *strchr(str, ':') = 0;
-
-         if (i == n) {
-            strcpy(user, str);
-            fclose(f);
-            return TRUE;
-         }
-
-         i++;
-      }
-      fclose(f);
+   if ((xml_tree = mxml_parse_file(file_name, str, sizeof(str))) == NULL) {
+      show_error(str);
+      return FALSE;
    }
 
-   return FALSE;
+   sprintf(str, "/list/user[%d]/name", n);
+   if ((node = mxml_find_node(xml_tree, str)) == NULL) {
+      mxml_free_tree(xml_tree);
+      return FALSE;
+   }
+
+   strlcpy(user, mxml_get_value(node), size);
+   mxml_free_tree(xml_tree);
+   return TRUE;
 }
 
 /*------------------------------------------------------------------*/
diff --git a/src/mxml.c b/src/mxml.c
new file mode 100755
index 00000000..4eaf73c8
--- /dev/null
+++ b/src/mxml.c
@@ -0,0 +1,1050 @@
+/********************************************************************\
+
+   Name:         mxml.c
+   Created by:   Stefan Ritt
+
+   Contents:     Midas XML Library
+
+   $Log$
+   Revision 1.1  2005/03/01 23:48:18  ritt
+   Implemented MXML for password file
+
+\********************************************************************/
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <assert.h>
+
+#ifdef _MSC_VER
+
+#include <windows.h>
+#include <io.h>
+#include <time.h>
+
+#else
+
+#define TRUE 1
+#define FALSE 0
+
+typedef int BOOL;
+
+#define O_TEXT 0
+#define O_BINARY 0
+
+#include <sys/time.h>
+#include <time.h>
+
+#endif
+
+#include "mxml.h"
+
+/*------------------------------------------------------------------*/
+
+/* should come from midas.c, elogd.c etc. */
+extern size_t strlcpy(char *dst, const char *src, size_t size);
+extern size_t strlcat(char *dst, const char *src, size_t size);
+
+/*------------------------------------------------------------------*/
+
+MXML_WRITER *mxml_open_document(const char *file_name) 
+/* open a file and write XML header */
+{
+   char str[256], line[1000];
+   time_t now;
+   MXML_WRITER *writer;
+
+   writer = malloc(sizeof(MXML_WRITER));
+
+   writer->fh = open(file_name, O_WRONLY | O_CREAT | O_TRUNC | O_TEXT, 0644);
+
+   if (writer->fh == -1) {
+      sprintf(line, "Unable to open file \"%s\": ", file_name);
+      perror(line);
+      free(writer);
+      return NULL;
+   }
+
+   /* write XML header */
+   strcpy(line, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
+   write(writer->fh, line, strlen(line));
+   time(&now);
+   strcpy(str, ctime(&now));
+   str[24] = 0;
+   sprintf(line, "<!-- created by MXML on %s -->\n", str);
+   write(writer->fh, line, strlen(line));
+
+   /* initialize stack */
+   writer->level = 0;
+   writer->element_is_open = 0;
+
+   return writer;
+}
+
+/*------------------------------------------------------------------*/
+
+void mxml_encode(char *src, int size)
+/* convert '<' '>' '&' '"' ''' into &xx; */
+{
+   char *dst, *ps, *pd;
+
+   assert(size);
+   dst = (char*) malloc(size);
+   ps = src;
+   pd = dst;
+   for (ps = src ; *ps && (size_t)pd - (size_t)dst < (size_t)(size-10) ; ps++) {
+      switch (*ps) {
+      case '<':
+         strcpy(pd, "&lt;");
+         pd += 4;
+         break;
+      case '>':
+         strcpy(pd, "&gt;");
+         pd += 4;
+         break;
+      case '&':
+         strcpy(pd, "&amp;");
+         pd += 5;
+         break;
+      case '\"':
+         strcpy(pd, "&quot;");
+         pd += 6;
+         break;
+      case '\'':
+         strcpy(pd, "&apos;");
+         pd += 6;
+         break;
+      default:
+         *pd++ = *ps;
+      }
+   }
+   *pd = 0;
+
+   strlcpy(src, dst, size);
+   free(dst);
+}
+
+/*------------------------------------------------------------------*/
+
+void mxml_decode(char *str)
+/* reverse of mxml_encode, strip leading or trailing '"' */
+{
+   char *p;
+
+   p = str;
+   while ((p = strchr(p, '&')) != NULL) {
+      if (strncmp(p, "&lt;", 4) == 0) {
+         *(p++) = '<';
+         strcpy(p, p+3);
+      }
+      if (strncmp(p, "&gt;", 4) == 0) {
+         *(p++) = '>';
+         strcpy(p, p+3);
+      }
+      if (strncmp(p, "&amp;", 5) == 0) {
+         *(p++) = '&';
+         strcpy(p, p+4);
+      }
+      if (strncmp(p, "&quot;", 6) == 0) {
+         *(p++) = '\"';
+         strcpy(p, p+5);
+      }
+      if (strncmp(p, "&apos;", 6) == 0) {
+         *(p++) = '\'';
+         strcpy(p, p+5);
+      }
+   }
+
+   if (str[0] == '\"' && str[strlen(str)-1] == '\"') {
+      strcpy(str, str+1);
+      str[strlen(str)-1] = 0;
+   }
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_start_element(MXML_WRITER *writer, const char *name)
+/* start a new XML element, must be followed by mxml_end_elemnt */
+{
+   int i;
+   char line[1000], name_enc[1000];
+
+   if (writer->element_is_open) {
+      write(writer->fh, ">\n", 2);
+      writer->element_is_open = FALSE;
+   }
+
+   line[0] = 0;
+   for (i=0 ; i<writer->level ; i++)
+      strlcat(line, "     ", sizeof(line));
+   strlcat(line, "<", sizeof(line));
+   strlcpy(name_enc, name, sizeof(name_enc));
+   mxml_encode(name_enc, sizeof(name_enc));
+   strlcat(line, name_enc, sizeof(line));
+
+   /* put element on stack */
+   if (writer->level == 0)
+      writer->stack = malloc(sizeof(char *));
+   else
+      writer->stack = realloc(writer->stack, sizeof(char *)*(writer->level+1));
+   
+   writer->stack[writer->level] = (char *) malloc(strlen(name_enc)+1);
+   strcpy(writer->stack[writer->level], name_enc);
+   writer->level++;
+   writer->element_is_open = TRUE;
+   writer->data_was_written = FALSE;
+
+   return write(writer->fh, line, strlen(line)) == strlen(line);
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_end_element(MXML_WRITER *writer)
+/* close an open XML element */
+{
+   int i;
+   char line[1000];
+
+   if (writer->level == 0)
+      return 0;
+   
+   writer->level--;
+
+   if (writer->element_is_open) {
+      writer->element_is_open = FALSE;
+      free(writer->stack[writer->level]);
+      if (writer->level == 0)
+         free(writer->stack);
+      if (write(writer->fh, "/>\n", 3) != 3)
+         return FALSE;
+      return TRUE;
+   }
+
+   line[0] = 0;
+   if (!writer->data_was_written) {
+      for (i=0 ; i<writer->level ; i++)
+         strlcat(line, "     ", sizeof(line));
+   }
+
+   strlcat(line, "</", sizeof(line));
+   strlcat(line, writer->stack[writer->level], sizeof(line));
+   free(writer->stack[writer->level]);
+   if (writer->level == 0)
+      free(writer->stack);
+   strlcat(line, ">\n", sizeof(line));
+   writer->data_was_written = FALSE;
+
+   return write(writer->fh, line, strlen(line)) == strlen(line);
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_write_attribute(MXML_WRITER *writer, const char *name, const char *value)
+/* write an attribute to the currently open XML element */
+{
+   char name_enc[1000];
+
+   if (!writer->element_is_open)
+      return FALSE;
+
+   write(writer->fh, " ", 1);
+   strcpy(name_enc, name);
+   mxml_encode(name_enc, sizeof(name_enc));
+   write(writer->fh, name_enc, strlen(name_enc));
+   write(writer->fh, "=\"", 2);
+
+   strcpy(name_enc, value);
+   mxml_encode(name_enc, sizeof(name_enc));
+   write(writer->fh, name_enc, strlen(name_enc));
+   write(writer->fh, "\"", 1);
+
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_write_value(MXML_WRITER *writer, const char *data)
+/* write value of an XML element, like <[name]>[value]</[name]> */
+{
+   int i, j;
+   static char *data_enc;
+   static int data_size = 0;
+
+   if (!writer->element_is_open)
+      return FALSE;
+
+   if (write(writer->fh, ">", 1) != 1)
+      return FALSE;
+   writer->element_is_open = FALSE;
+   writer->data_was_written = TRUE;
+
+   if (data_size == 0) {
+      data_enc = malloc(1000);
+      data_size = 1000;
+   } else if ((int)strlen(data)*2+1000 > data_size) {
+      data_size = 1000+strlen(data)*2;
+      data_enc = realloc(data_enc, data_size);
+   }
+
+   strcpy(data_enc, data);
+   mxml_encode(data_enc, data_size);
+   j = strlen(data_enc);
+   i = write(writer->fh, data_enc, j);
+
+   return i == j;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_close_document(MXML_WRITER *writer)
+/* close a file opened with mxml_open_writer */
+{
+   int i;
+
+   if (writer->element_is_open) {
+      writer->element_is_open = FALSE;
+      if (write(writer->fh, ">\n", 2) != 2)
+         return FALSE;
+   }
+
+   /* close remaining open levels */
+   for (i = 0 ; i<writer->level ; i++)
+      mxml_end_element(writer);
+
+   close(writer->fh);
+   free(writer);
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+PMXML_NODE mxml_create_root_node()
+/* create root node of an XML tree */
+{
+   PMXML_NODE root;
+
+   root = (PMXML_NODE)calloc(sizeof(MXML_NODE), 1);
+   strcpy(root->name, "root");
+
+   return root;
+}
+
+/*------------------------------------------------------------------*/
+
+PMXML_NODE mxml_add_node(PMXML_NODE parent, char *node_name, char *value)
+/* add a subnode (child) to an existing parent node */
+{
+   PMXML_NODE pnode;
+
+   assert(parent);
+   if (parent->n_children == 0)
+      parent->child = malloc(sizeof(MXML_NODE));
+   else
+      parent->child = realloc(parent->child, sizeof(MXML_NODE)*(parent->n_children+1));
+   assert(parent->child);
+   pnode = &parent->child[parent->n_children];
+   memset(pnode, 0, sizeof(MXML_NODE));
+   strlcpy(pnode->name, node_name, sizeof(pnode->name));
+   pnode->parent = parent;
+   parent->n_children++;
+
+   if (value) {
+      pnode->value = malloc(strlen(value)+1);
+      assert(pnode->value);
+      strcpy(pnode->value, value);
+   }
+
+   return pnode;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_add_attribute(PMXML_NODE pnode, char *attrib_name, char *attrib_value)
+/* add an attribute to an existing node */
+{
+   if (pnode->n_attributes == 0) {
+      pnode->attribute_name  = malloc(MXML_NAME_LENGTH);
+      pnode->attribute_value = malloc(sizeof(char *));
+   } else {
+      pnode->attribute_name  = realloc(pnode->attribute_name,  MXML_NAME_LENGTH*(pnode->n_attributes+1));
+      pnode->attribute_value = realloc(pnode->attribute_value, sizeof(char *)*(pnode->n_attributes+1));
+   }
+
+   strlcpy(pnode->attribute_name+pnode->n_attributes*MXML_NAME_LENGTH, attrib_name, MXML_NAME_LENGTH);
+   pnode->attribute_value[pnode->n_attributes] = malloc(strlen(attrib_value)+1);
+   strcpy(pnode->attribute_value[pnode->n_attributes], attrib_value);
+   pnode->n_attributes++;
+
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+int mxml_get_number_of_children(PMXML_NODE pnode)
+/* return number of subnodes (children) of a node */
+{
+   assert(pnode);
+   return pnode->n_children;
+}
+
+/*------------------------------------------------------------------*/
+
+PMXML_NODE mxml_find_node(PMXML_NODE tree, char *xml_path)
+/*
+   Search for a specific XML node with a subset of XPATH specifications.
+   Following elemets are possible
+
+   /<node>/<node>/..../<node>          Find a node in the tree hierarchy
+   /<node>[index]                      Find child #[index] of node
+   /<node>[index]/<node>               Find subnode of the above
+   /<node>[<subnode>=<value>]          Find a node which has a specific subnode
+   /<node>[<subnode>=<value>]/<node>   Find subnode of the above
+*/
+{
+   PMXML_NODE pnode;
+   char *p1, *p2, *p3, node_name[256], condition[256], subnode[256], value[256];
+   int i, j, index;
+   size_t len;
+
+   p1 = xml_path;
+   pnode = tree;
+
+   /* skip leading '/' */
+   if (*p1 && *p1 == '/')
+      p1++;
+
+   do {
+      p2 = p1;
+      while (*p2 && *p2 != '/' && *p2 != '[')
+         p2++;
+      len = (size_t)p2 - (size_t)p1;
+      if (len >= sizeof(node_name))
+         return NULL;
+
+      memcpy(node_name, p1, len);
+      node_name[len] = 0;
+      index = 0;
+      subnode[0] = value[0] = 0;
+      if (*p2 == '[') {
+         p2++;
+         if (isdigit(*p2)) {
+            /* evaluate [index] */
+            index = atoi(p2);
+            p2 = strchr(p2, ']');
+            if (p2 == NULL)
+               return NULL;
+            p2++;
+         } else {
+            /* evaluate [<subnode>=<value>] */
+            while (*p2 && isspace(*p2))
+               p2++;
+            strlcpy(condition, p2, sizeof(condition));
+            if (strchr(condition, ']'))
+               *strchr(condition, ']') = 0;
+            else
+               return NULL;
+            p2 = strchr(p2, ']')+1;
+            if ((p3 = strchr(condition, '=')) != NULL) {
+               strlcpy(subnode, condition, sizeof(subnode));
+               *strchr(subnode, '=') = 0;
+               while (subnode[0] && isspace(subnode[strlen(subnode)-1]))
+                  subnode[strlen(subnode)-1] = 0;
+               p3++;
+               while (*p3 && isspace(*p3))
+                  p3++;
+               strlcpy(value, p3, sizeof(value));
+               while (value[0] && isspace(value[strlen(value)-1]))
+                  value[strlen(value)-1] = 0;
+            }
+         }
+      }
+
+      for (i=j=0 ; i<pnode->n_children ; i++) {
+         if (subnode[0]) {
+            /* search subnode */
+            for (j=0 ; j<pnode->child[i].n_children ; j++)
+               if (strcmp(pnode->child[i].child[j].name, subnode) == 0)
+                  break;
+            if (j == pnode->child[i].n_children)
+               return NULL;
+            if (strcmp(pnode->child[i].child[j].value, value) == 0)
+               break;
+         } else {
+            if (strcmp(pnode->child[i].name, node_name) == 0)
+               if (j++ == index)
+                  break;
+         }
+      }
+
+      if (i == pnode->n_children)
+         return NULL;
+
+      pnode = &pnode->child[i];
+      p1 = p2;
+      if (*p1 == '/')
+         p1++;
+
+   } while (*p2);
+
+   return pnode;
+}
+
+/*------------------------------------------------------------------*/
+
+char *mxml_get_value(PMXML_NODE pnode)
+{
+   assert(pnode);
+   return pnode->value;
+}
+
+/*------------------------------------------------------------------*/
+
+char *mxml_get_attribute(PMXML_NODE pnode, char *name)
+{
+   int i;
+
+   assert(pnode);
+   for (i=0 ; i<pnode->n_attributes ; i++) 
+      if (strcmp(pnode->attribute_name+i*MXML_NAME_LENGTH, name) == 0)
+         return pnode->attribute_value[i];
+
+   return NULL;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_replace_node_name(PMXML_NODE pnode, char *name)
+{
+   strlcpy(pnode->name, name, sizeof(pnode->name));
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_replace_node_value(PMXML_NODE pnode, char *value)
+{
+   if (pnode->value)
+      pnode->value = realloc(pnode->value, strlen(value)+1);
+   else
+      pnode->value = malloc(strlen(value)+1);
+   
+   strcpy(pnode->value, value);
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_replace_subvalue(PMXML_NODE pnode, char *name, char *value)
+/* 
+   replace value os a subnode, like
+
+   <parent>
+     <child>value</child>
+   </parent>
+
+   if pnode=parent, and "name"="child", then "value" gets replaced
+*/
+{
+   int i;
+
+   for (i=0 ; i<pnode->n_children ; i++) 
+      if (strcmp(pnode->child[i].name, name) == 0)
+         break;
+
+   if (i == pnode->n_children)
+      return FALSE;
+
+   return mxml_replace_node_value(&pnode->child[i], value);
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_replace_attribute_name(PMXML_NODE pnode, char *old_name, char *new_name)
+/* change the name of an attribute, keep its value */
+{
+   int i;
+
+   for (i=0 ; i<pnode->n_attributes ; i++) 
+      if (strcmp(pnode->attribute_name+i*MXML_NAME_LENGTH, old_name) == 0)
+         break;
+
+   if (i == pnode->n_attributes)
+      return FALSE;
+
+   strlcpy(pnode->attribute_name+i*MXML_NAME_LENGTH, new_name, MXML_NAME_LENGTH);
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_replace_attribute_value(PMXML_NODE pnode, char *attrib_name, char *attrib_value)
+/* change the value of an attribute */
+{
+   int i;
+
+   for (i=0 ; i<pnode->n_attributes ; i++) 
+      if (strcmp(pnode->attribute_name+i*MXML_NAME_LENGTH, attrib_name) == 0)
+         break;
+
+   if (i == pnode->n_attributes)
+      return FALSE;
+
+   pnode->attribute_value[i] = realloc(pnode->attribute_value[i], strlen(attrib_value)+1);
+   strcpy(pnode->attribute_value[i], attrib_value);
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_delete_node(PMXML_NODE pnode)
+/* free memory of a node and remove it from the parent's child list */
+{
+   PMXML_NODE parent;
+   int i, j;
+
+   /* remove node from parent's list */
+   parent = pnode->parent;
+
+   if (parent) {
+      for (i=0 ; i<parent->n_children ; i++)
+         if (&parent->child[i] == pnode)
+            break;
+
+      /* free allocated node memory recursively */
+      mxml_free_tree(pnode);
+
+      if (i < parent->n_children) {
+         for (j=i ; j<parent->n_children-1 ; j++)
+            memcpy(&parent->child[j], &parent->child[j+1], sizeof(MXML_NODE));
+         parent->n_children--;
+         if (parent->n_children)
+            parent->child = realloc(parent->child, sizeof(MXML_NODE)*(parent->n_children));
+         else
+            free(parent->child);
+      }
+   } else 
+      mxml_free_tree(pnode);
+
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_delete_attribute(PMXML_NODE pnode, char *attrib_name)
+{
+   int i, j;
+
+   for (i=0 ; i<pnode->n_attributes ; i++) 
+      if (strcmp(pnode->attribute_name+i*MXML_NAME_LENGTH, attrib_name) == 0)
+         break;
+
+   if (i == pnode->n_attributes)
+      return FALSE;
+
+   free(pnode->attribute_value[i]);
+   for (j=i ; j<pnode->n_attributes-1 ; j++) {
+      strcpy(pnode->attribute_name+j*MXML_NAME_LENGTH, pnode->attribute_name+(j+1)*MXML_NAME_LENGTH);
+      pnode->attribute_value[j] = pnode->attribute_value[j+1];
+   }
+
+   if (pnode->n_attributes > 0) {
+      pnode->attribute_name  = realloc(pnode->attribute_name,  MXML_NAME_LENGTH*(pnode->n_attributes-1));
+      pnode->attribute_value = realloc(pnode->attribute_value, sizeof(char *)*(pnode->n_attributes-1));
+   } else {
+      free(pnode->attribute_name);
+      free(pnode->attribute_value);
+   }
+
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+#define HERE root, file_name, line_number, error, error_size
+
+PMXML_NODE read_error(PMXML_NODE root, char *file_name, int line_number, char *error, int error_size, char *format, ...)
+/* used inside mxml_parse_file for reporting errors */
+{
+   char *msg, str[1000];
+   va_list argptr;
+
+   sprintf(str, "XML read error in file \"%s\", line %d: ", file_name, line_number);
+   msg = malloc(error_size);
+   strlcpy(error, str, error_size);
+
+   va_start(argptr, format);
+   vsprintf(str, (char *) format, argptr);
+   va_end(argptr);
+
+   strlcat(error, str, error_size);
+   free(msg);
+   mxml_free_tree(root);
+
+   return NULL;
+}
+
+/*------------------------------------------------------------------*/
+
+PMXML_NODE mxml_parse_file(char *file_name, char *error, int error_size)
+/* parse a XML file and convert it into a tree of MXML_NODE's. Return NULL
+   in case of an error, return error description */
+{
+   char line[1000], node_name[256], attrib_name[256], attrib_value[1000];
+   char *buf, *p, *pv;
+   int i, fh, length, line_number;
+   PMXML_NODE root, ptree, pnew;
+   BOOL end_element;
+   size_t len;
+
+   fh = open(file_name, O_RDONLY | O_TEXT, 0644);
+
+   if (fh == -1) {
+      sprintf(line, "Unable to open file \"%s\": ", file_name);
+      strlcat(line, strerror(errno), sizeof(line));
+      strlcpy(error, line, error_size);
+      return NULL;
+   }
+
+   length = lseek(fh, 0, SEEK_END);
+   lseek(fh, 0, SEEK_SET);
+   buf = malloc(length+1);
+   if (buf == NULL) {
+      close(fh);
+      sprintf(line, "Cannot allocate buffer: ");
+      strlcat(line, strerror(errno), sizeof(line));
+      strlcpy(error, line, error_size);
+      return NULL;
+   }
+
+   /* read complete file at once */
+   length = read(fh, buf, length);
+   buf[length] = 0;
+   close(fh);
+
+   p = buf;
+   line_number = 1;
+
+   root = mxml_create_root_node();
+   ptree = root;
+
+   /* store filename in attribute */
+   mxml_add_attribute(root, "filename", file_name);
+
+   /* parse file contents */
+   do {
+      if (*p == '<') {
+
+         end_element = FALSE;
+
+         /* found new element */
+         *p++;
+         while (*p && isspace(*p)) {
+            if (*p == '\n')
+               line_number++;
+            p++;
+         }
+         if (!*p)
+            return read_error(HERE, "Unexpected end of file");
+
+         if (strncmp(p, "!--", 3) == 0) {
+            
+            /* found comment */
+            p += 3;
+            if (strstr(p, "-->") == NULL)
+               return read_error(HERE, "Unterminated comment");
+            
+            while (strncmp(p, "-->", 3) != 0) {
+               if (*p == '\n')
+                  line_number++;
+               p++;
+            }
+            p += 3;
+
+         } else if (*p == '?') {
+
+            /* found ?...? element */
+            p++;
+            if (strstr(p, "?>") == NULL)
+               return read_error(HERE, "Unterminated ?...? element");
+            
+            while (strncmp(p, "?>", 2) != 0) {
+               if (*p == '\n')
+                  line_number++;
+               p++;
+            }
+            p += 2;
+
+         } else {
+            
+            /* found normal element */
+            if (*p == '/') {
+               end_element = TRUE;
+               p++;
+               while (*p && isspace(*p)) {
+                  if (*p == '\n')
+                     line_number++;
+                  p++;
+               }
+               if (!*p)
+                  return read_error(HERE, "Unexpected end of file");
+            }
+
+            /* extract node name */
+            i = 0;
+            node_name[i] = 0;
+            while (*p && !isspace(*p) && *p != '/' && *p != '>' && *p != '<')
+               node_name[i++] = *p++;
+            node_name[i] = 0;
+            if (!*p)
+               return read_error(HERE, "Unexpected end of file");
+            if (*p == '<')
+               return read_error(HERE, "Unexpected \'<\' inside element \"%s\"", node_name);
+
+            mxml_decode(node_name);
+
+            if (end_element) {
+
+               /* close previously opened element */
+               if (strcmp(ptree->name, node_name) != 0)
+                  return read_error(HERE, "Found </%s>, expected </%s>", node_name, ptree->name);
+            
+               /* go up one level on the tree */
+               ptree = ptree->parent;
+
+            } else {
+            
+               /* allocate new element structure in parent tree */
+               pnew = mxml_add_node(ptree, node_name, NULL);
+
+               while (*p && isspace(*p)) {
+                  if (*p == '\n')
+                     line_number++;
+                  p++;
+               }
+               if (!*p)
+                  return read_error(HERE, "Unexpected end of file");
+
+               while (*p != '>' && *p != '/') {
+
+                  /* found attribute */
+                  pv = p;
+                  while (*pv && !isspace(*pv) && *pv != '=' && *pv != '<' && *pv != '>')
+                     pv++;
+                  if (!*pv)
+                     return read_error(HERE, "Unexpected end of file");
+                  if (*pv == '<' || *pv == '>')
+                     return read_error(HERE, "Unexpected \'%c\' inside element \"%s\"", *pv, node_name);
+
+                  /* extract attribute name */
+                  len = (size_t)pv - (size_t)p;
+                  if (len > sizeof(attrib_name)-1)
+                     len = sizeof(attrib_name)-1;
+                  memcpy(attrib_name, p, len);
+                  attrib_name[len] = 0;
+
+                  p = pv;
+                  while (*p && isspace(*p)) {
+                     if (*p == '\n')
+                        line_number++;
+                     p++;
+                  }
+                  if (!*p)
+                     return read_error(HERE, "Unexpected end of file");
+                  if (*p != '=')
+                     return read_error(HERE, "Expect \"=\" here");
+
+                  p++;
+                  while (*p && isspace(*p)) {
+                     if (*p == '\n')
+                        line_number++;
+                     p++;
+                  }
+                  if (!*p)
+                     return read_error(HERE, "Unexpected end of file");
+                  if (*p != '\"')
+                     return read_error(HERE, "Expect \'\"\' here");
+                  p++;
+
+                  /* extract attribute value */
+                  pv = p;
+                  while (*pv && *pv != '\"' && *pv != '<' && *pv != '>')
+                     pv++;
+                  if (!*pv)
+                     return read_error(HERE, "Unexpected end of file");
+                  if (*pv == '<' || *pv == '>')
+                     return read_error(HERE, "Unexpected \'%c\' inside attribute value \"%s\" of element \"%s\"",
+                        *pv, attrib_name, node_name);
+
+                  len = (size_t)pv - (size_t)p;
+                  if (len > sizeof(attrib_value)-1)
+                     len = sizeof(attrib_value)-1;
+                  memcpy(attrib_value, p, len);
+                  attrib_value[len] = 0;
+
+                  /* add attribute to current node */
+                  mxml_add_attribute(pnew, attrib_name, attrib_value);
+
+                  p = pv+1;
+                  while (*p && isspace(*p)) {
+                     if (*p == '\n')
+                        line_number++;
+                     p++;
+                  }
+                  if (!*p)
+                     return read_error(HERE, "Unexpected end of file");
+               }
+
+               if (*p == '/') {
+
+                  /* found empty node, like <node/>, just skip closing bracket */
+                  p++;
+
+                  while (*p && isspace(*p)) {
+                     if (*p == '\n')
+                        line_number++;
+                     p++;
+                  }
+                  if (!*p)
+                     return read_error(HERE, "Unexpected end of file");
+                  if (*p != '>')
+                     return read_error(HERE, "Expected \">\" after \"/\"");
+                  p++;
+               }
+
+               if (*p == '>') {
+
+                  p++;
+
+                  /* check if we have sub-element or value */
+                  pv = p;
+                  while (*pv && isspace(*pv)) {
+                     if (*pv == '\n')
+                        line_number++;
+                     pv++;
+                  }
+                  if (!*pv)
+                     return read_error(HERE, "Unexpected end of file");
+
+                  if (*pv == '<') {
+
+                     /* start new subtree */
+                     ptree = pnew;
+                     p = pv;
+
+                  } else {
+
+                     /* extract value */
+                     while (*pv && *pv != '<' && *pv != '>') {
+                        if (*pv == '\n')
+                           line_number++;
+                        pv++;
+                     }
+                     if (!*pv)
+                        return read_error(HERE, "Unexpected end of file");
+                     if (*pv == '>')
+                        return read_error(HERE, "Unexpected \'>\' inside element \"%s\"", node_name);
+
+                     len = (size_t)pv - (size_t)p;
+                     pnew->value = malloc(len+1);
+                     memcpy(pnew->value, p, len);
+                     pnew->value[len] = 0;
+                     mxml_decode(pnew->value);
+                     p = pv;
+
+                     ptree = pnew;
+                  }
+               }
+            }
+         }
+      }
+
+      /* go to next element */
+      while (*p && *p != '<') {
+         if (*p == '\n')
+            line_number++;
+         p++;
+      }
+   } while (*p);
+
+   return root;
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_write_subtree(MXML_WRITER *writer, PMXML_NODE tree)
+/* write complete subtree recursively into file opened with mxml_open_document() */
+{
+   int i;
+
+   mxml_start_element(writer, tree->name);
+   for (i=0 ; i<tree->n_attributes ; i++)
+      if (!mxml_write_attribute(writer, tree->attribute_name+i*MXML_NAME_LENGTH, tree->attribute_value[i]))
+         return FALSE;
+   if (tree->value) {
+      if (!mxml_write_value(writer, tree->value))
+         return FALSE;
+   } else {
+      for (i=0 ; i<tree->n_children ; i++)
+         if (!mxml_write_subtree(writer, &tree->child[i]))
+            return FALSE;
+   }
+
+   return mxml_end_element(writer);
+}
+
+/*------------------------------------------------------------------*/
+
+BOOL mxml_write_tree(char *file_name, PMXML_NODE tree)
+/* write a complete XML tree to a file */
+{
+   MXML_WRITER *writer;
+   int i;
+
+   assert(tree);
+   writer = mxml_open_document(file_name);
+   if (!writer)
+      return FALSE;
+
+   for (i=0 ; i<tree->n_children ; i++)
+      if (!mxml_write_subtree(writer, &tree->child[i]))
+         return FALSE;
+
+   if (!mxml_close_document(writer))
+      return FALSE;
+
+   return TRUE;
+}
+
+/*------------------------------------------------------------------*/
+
+void mxml_free_tree(PMXML_NODE tree)
+/* free memory of XML tree, must be called after any 
+   mxml_create_root_node() or mxml_parse_file() */
+{
+   int i;
+
+   /* first free children recursively */
+   for (i=0 ; i<tree->n_children ; i++)
+      mxml_free_tree(&tree->child[i]);
+   if (tree->n_children)
+      free(tree->child);
+
+   /* now free dynamic data */
+   for (i=0 ; i<tree->n_attributes ; i++)
+      free(tree->attribute_value[i]);
+
+   if (tree->n_attributes) {
+      free(tree->attribute_name);
+      free(tree->attribute_value);
+   }
+   
+   if (tree->value)
+      free(tree->value);
+
+   /* if we are the root node, free it */
+   if (tree->parent == NULL)
+      free(tree);
+}
+
+/*------------------------------------------------------------------*/
+
diff --git a/src/mxml.h b/src/mxml.h
new file mode 100755
index 00000000..a5f4dfb6
--- /dev/null
+++ b/src/mxml.h
@@ -0,0 +1,71 @@
+/********************************************************************\
+
+   Name:         mxml.h
+   Created by:   Stefan Ritt
+
+   Contents:     Header file for mxml.c
+
+   $Log$
+   Revision 1.1  2005/03/01 23:48:18  ritt
+   Implemented MXML for password file
+
+\********************************************************************/
+
+/*------------------------------------------------------------------*/
+
+#define MXML_NAME_LENGTH 64
+
+typedef struct {
+   int  fh;
+   int  level;
+   BOOL element_is_open;
+   BOOL data_was_written;
+   char **stack;
+} MXML_WRITER;
+
+typedef struct mxml_struct *PMXML_NODE;
+
+typedef struct mxml_struct {
+   char       name[MXML_NAME_LENGTH];  // name of element    <[name]>[value]</[name]>
+   char       *value;                  // value of element
+   int        n_attributes;            // list of attributes
+   char       *attribute_name;
+   char       **attribute_value;
+   int        line_number;             // line number for source file
+   PMXML_NODE parent;                  // pointer to parent element
+   int        n_children;              // list of children
+   PMXML_NODE child;
+} MXML_NODE;
+
+/*------------------------------------------------------------------*/
+
+MXML_WRITER *mxml_open_document(const char *file_name);
+BOOL mxml_start_element(MXML_WRITER *writer, const char *name);
+BOOL mxml_end_element(MXML_WRITER *writer); 
+BOOL mxml_write_attribute(MXML_WRITER *writer, const char *name, const char *value);
+BOOL mxml_write_value(MXML_WRITER *writer, const char *value);
+BOOL mxml_close_document(MXML_WRITER *writer);
+
+int mxml_get_number_of_children(PMXML_NODE pnode);
+PMXML_NODE mxml_find_node(PMXML_NODE tree, char *xml_path);
+char *mxml_get_value(PMXML_NODE pnode);
+char *mxml_get_attribute(PMXML_NODE pnode, char *name);
+
+BOOL mxml_add_attribute(PMXML_NODE pnode, char *attrib_name, char *attrib_value);
+PMXML_NODE mxml_add_node(PMXML_NODE parent, char *node_name, char *value);
+
+BOOL mxml_replace_node_name(PMXML_NODE pnode, char *new_name);
+BOOL mxml_replace_node_value(PMXML_NODE pnode, char *value);
+BOOL mxml_replace_subvalue(PMXML_NODE pnode, char *name, char *value);
+BOOL mxml_replace_attribute_name(PMXML_NODE pnode, char *old_name, char *new_name);
+BOOL mxml_replace_attribute_value(PMXML_NODE pnode, char *attrib_name, char *attrib_value);
+
+BOOL mxml_delete_node(PMXML_NODE pnode);
+BOOL mxml_delete_attribute(PMXML_NODE, char *attrib_name);
+
+PMXML_NODE mxml_create_root_node();
+PMXML_NODE mxml_parse_file(char *file_name, char *error, int error_size);
+BOOL mxml_write_tree(char *file_name, PMXML_NODE tree);
+void mxml_free_tree(PMXML_NODE tree);
+
+/*------------------------------------------------------------------*/