/* #############################################################################
 * code for all xml stuff
 * #############################################################################
 * Copyright (C) 2005-2009 Harry Brueckner
 *
 * 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 any later version.
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Contact: Harry Brueckner <harry_b@mm.st>
 *          Muenchener Strasse 12a
 *          85253 Kleinberghofen
 *          Germany
 * #############################################################################
 */

/* #############################################################################
 * includes
 */
#include "cpm.h"
#include <stdarg.h>
#ifdef HAVE_LIBZ
  #include <zlib.h>
#endif
#include "configuration.h"
#include "general.h"
#include "gpg.h"
#include "interface_keys.h"
#include "interface_xml.h"
#include "listhandler.h"
#include "memory.h"
#include "string.h"
#include "xml.h"
#include "zlib.h"


/* #############################################################################
 * internal functions
 */
int checkDtd(SHOWERROR_FN showerror_cb);
void xmlRemoveDtd(void);
void xmlVersionNodeUpdate(long oldversion, xmlNode* rootnode);
void xmlVersionUpdate(int silent);
void xmlValidateError(void* context, const char* msg, ...);
void xmlValidateWarning(void* context, const char* msg, ...);


/* #############################################################################
 * global variables
 */
xmlDocPtr               xmldoc;
SHOWERROR_FN            validateShowError = NULL;
const static char*      dtd_1 =
    "<!ENTITY % creation \"\n"
    "    created-by    CDATA #REQUIRED\n"
    "    created-on    CDATA #REQUIRED\n"
    "    \">\n"
    "<!ENTITY % creationtime \"\n"
    "    created-on    CDATA #REQUIRED\n"
    "    \">\n"
    "<!ENTITY % modification \"\n"
    "    modified-by   CDATA #IMPLIED\n"
    "    modified-on   CDATA #IMPLIED\n"
    "    \">\n"
    "<!ENTITY % modificationtime \"\n"
    "    modified-on   CDATA #IMPLIED\n"
    "    \">\n"
    "<!ELEMENT root ((node*|template?|editor?)*)>\n"
    "<!ATTLIST root\n"
    "    version       CDATA #REQUIRED\n"
    "    %creation;\n"
    "    %modification;\n"
    ">\n";

const static char*      dtd_2 =
    "<!ELEMENT comment (#PCDATA)>\n"
    "<!ATTLIST comment\n"
    "    %creation;\n"
    "    %modification;\n"
    ">\n"
    "<!ELEMENT editor (user*)>\n"
    "<!ATTLIST editor\n"
    "    %creationtime;\n"
    ">\n"
    "<!ELEMENT node ((comment?|node*)*)>\n"
    "<!ATTLIST node\n"
    "    %creation;\n"
    "    %modification;\n"
    "    label         CDATA #REQUIRED\n"
    ">\n"
    "<!ELEMENT template (title*)>\n"
    "<!ATTLIST template\n"
    "    %creationtime;\n"
    "    %modification;\n"
    ">\n";

const static char*      dtd_3 =
    "<!ELEMENT title (#PCDATA)>\n"
    "<!ATTLIST title\n"
    "    %creationtime;\n"
    "    %modificationtime;\n"
    "    level         CDATA #REQUIRED\n"
    ">\n"
    "<!ELEMENT user (#PCDATA)>\n"
    "<!ATTLIST user\n"
    "    uid           CDATA #REQUIRED\n"
    "    %creationtime;\n"
    ">\n";


/* #############################################################################
 *
 * Description    add a DTD to the xml document
 * Author         Harry Brueckner
 * Date           2005-05-04
 * Arguments      SHOWERROR_FN - callback function for error messages
 * Return         -1 if the DTD could not be updated, 0 if the document did not
 *                validate and 1 if everything is ok
 */
int checkDtd(SHOWERROR_FN showerror_cb)
  {
    xmlDtd*             dtd;
    xmlParserInputBuffer*   inputbuffer;
    xmlValidCtxt*       context = xmlNewValidCtxt();
    char*               dtdbuffer;

    TRACE(99, "checkDtd()", NULL);

    if (!xmldoc)
      { return -1; }

    xmlRemoveDtd();

    /* first we create the DTD as a whole */
    dtdbuffer = memAlloc(__FILE__, __LINE__,
        strlen(dtd_1) + strlen(dtd_2) + strlen(dtd_3) + 1);
    if (!dtdbuffer)
      { return -1; }

    strStrncpy(dtdbuffer, dtd_1, strlen(dtd_1) + 1);
    strStrncat(dtdbuffer, dtd_2, strlen(dtd_2) + 1);
    strStrncat(dtdbuffer, dtd_3, strlen(dtd_3) + 1);

    /* create the xml buffer */
    inputbuffer = xmlParserInputBufferCreateMem(dtdbuffer, strlen(dtdbuffer),
        XML_CHAR_ENCODING_8859_1);
    memFreeString(__FILE__, __LINE__, dtdbuffer);
    if (!dtdbuffer)
      { return -1; }

    /* and finally create the DTD */
    dtd = xmlIOParseDTD(NULL, inputbuffer, XML_CHAR_ENCODING_8859_1);

    if (!dtd)
      { return -1; }

    /* and attach the DTD to the document */
    if (!xmldoc -> children)
      { xmlAddChild((xmlNode*)xmldoc, (xmlNode*)dtd); }
    else
      { xmlAddPrevSibling(xmldoc -> children, (xmlNode*)dtd); }

    /* we set our own error handler */
    validateShowError = showerror_cb;
    context -> error = xmlValidateError;
    context -> warning = xmlValidateWarning;

    return xmlValidateDtd(context, xmldoc, dtd);
  }


/* #############################################################################
 *
 * Description    free the XML parser stuff
 * Author         Harry Brueckner
 * Date           2005-03-18
 * Arguments      void
 * Return         void
 */
void freeXML(void)
  {
    TRACE(99, "freeXML()", NULL);

    if (xmldoc)
      { xmlFreeDoc(xmldoc); }

    /* cleanup function for the XML library. */
    xmlCleanupParser();

    /* this is to debug memory for regression tests */
    xmlMemoryDump();
  }


/* #############################################################################
 *
 * Description    initialize the XML parser
 * Author         Harry Brueckner
 * Date           2005-03-18
 * Arguments      void
 * Return         void
 */
void initXML(void)
  {
    TRACE(99, "initXML()", NULL);

    xmldoc = NULL;

    /* this initialize the library and check potential ABI mismatches
     * between the version it was compiled for and the actual shared
     * library used.
     */
    LIBXML_TEST_VERSION
  }


/* #############################################################################
 *
 * Description    read, decrypt and parse the given filename
 * Author         Harry Brueckner
 * Date           2005-03-18
 * Arguments      char* filename  - filename to read
 *                char** errormsg - pointer to the GpgMe error message, if any
 *                PASSPHRASE_FN   - passphrase callback function
 *                SHOWERROR_FN    - callback function for error messages
 * Return         1 on error, otherwise 0
 */
int xmlDataFileRead(char* filename, char** errormsg,
    PASSPHRASE_FN passphrase_cb, SHOWERROR_FN showerror_cb)
  {
    xmlNode*            node;
    struct stat         filestat;
    off_t               size;
    int                 error = 0,
                        fd,
                        gpgsize = 0,
                        validate;
    char*               buffer = NULL;
    char*               gpgbuffer = NULL;
    char*               tmpbuffer = NULL;

    TRACE(99, "xmlDataFileRead()", NULL);

    /* we initialize the error message */
    *errormsg = NULL;

    fd = fileLockOpen(filename, O_RDONLY, -1, &tmpbuffer);
    if (fd == -1)
      {   /* unable to read the file, we start a new one */
        showerror_cb(_("file error"), tmpbuffer);
        memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);

        if (fileExists(filename))
          {   /* if the file exists and we can't read it it's a hard error and
               * we must not continue; we don't need another error message since
               * we already had one displayed.
               */
            return 1;
          }

        /* we create a new, empty document */
        xmldoc = xmlNewDoc(BAD_CAST "1.0");
        node = xmlNewDocNode(xmldoc, NULL, BAD_CAST "root", NULL);
        xmlDocSetRootElement(xmldoc, node);
        createEditorsNode();
        createTemplateNode();

        /* we insert the current version and also create the created and
         * modified entries.
         */
        xmlVersionUpdate(1);

        checkDtd(showerror_cb);

        keyDefaults();

        /* we created a new document, so it's changed */
        runtime -> datachanged = 1;
      }
    else if (!fstat(fd, &filestat) &&
        filestat.st_size)
      {   /* we found a file and have to read it */
        size = filestat.st_size;
        buffer = memAlloc(__FILE__, __LINE__, size);
        /* Flawfinder: ignore */
        if (read(fd, buffer, size) != size)
          {
            memFree(__FILE__, __LINE__, buffer, size);
            return 1;
          }
        close(fd);

        if (config -> encryptdata)
          {
            error = gpgDecrypt(buffer, size, &gpgbuffer, &gpgsize,
                passphrase_cb, showerror_cb);
            if (error)
              { *errormsg = _("could not decrypt database file."); }

            /* since we decrypted the file, we swap buffers */
            memFree(__FILE__, __LINE__, buffer, size);
            buffer = gpgbuffer;
            size = gpgsize;

#ifdef TEST_OPTION
            if (config -> testrun &&
                !strcmp("decrypt", config -> testrun) &&
                buffer)
              { printf("%s", buffer); }
#endif

            /* TODO: add the same keys as used in the encrypted file;
             *       For now we just always add the default keys
             */
            if (runtime -> realmhint)
              {   /* if we have a realm, we add it to the default keys since we
                   * probably want to encrypt data for ourselves as well
                   */
                config -> defaultkeys = listAdd(config -> defaultkeys,
                    runtime -> realmhint);
              }

            keyDefaults();
          }
        else
          {
            /* if we run in unencrypted mode, we must add all default keys */
            keyDefaults();

            showerror_cb(_("warning"), _("the database file is read in unecrypted mode."));
          }

        if (!error &&
            buffer[0] == '\x1f' && buffer[1] == '\x8b')
          {   /* we have a gzipped buffer and must compress it */
            error = zlibDecompress(buffer, size, &gpgbuffer, &gpgsize,
                errormsg);
            if (error)
              {
                tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
                snprintf(tmpbuffer, STDBUFFERLENGTH,
                    _("error (%s) compressing file '%s'."),
                    *errormsg,
                    filename);
                showerror_cb(_("compression error"), tmpbuffer);
                memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);

                memFree(__FILE__, __LINE__, buffer, size);
                return 1;
              }

            memFree(__FILE__, __LINE__, buffer, size);
            buffer = gpgbuffer;
            size = gpgsize;
          }
        else
          {
            if (!error && config -> compression > 0)
              {
                tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
                snprintf(tmpbuffer, STDBUFFERLENGTH,
                    _("database '%s' was not compressed."),
                    filename);
                showerror_cb(_("warning"), tmpbuffer);
                memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
              }
          }

        if (!error)
          {
            xmldoc = xmlReadMemory(buffer, size, filename, config -> encoding,
                XML_PARSE_PEDANTIC | XML_PARSE_NONET | XML_PARSE_NOCDATA);
            if (!xmldoc)
              {
                memFree(__FILE__, __LINE__, buffer, size);

                tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
                snprintf(tmpbuffer, STDBUFFERLENGTH,
                    _("failed to parse xml document '%s'."),
                    filename);
                showerror_cb(_("file error"), tmpbuffer);
                memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);

                return 1;
              }
          }

        if (buffer)
          { memFree(__FILE__, __LINE__, buffer, size); }

        /* we update our document version */
        if (!error)
          { xmlVersionUpdate(0); }

        if (!error)
          {
            validate = checkDtd(showerror_cb);

            if (validate != 1)
              {
                tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
                snprintf(tmpbuffer, STDBUFFERLENGTH,
                    _("failed to validate xml document '%s'."),
                    filename);
                showerror_cb(_("file error"), tmpbuffer);
                memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);

                return 1;
              }
          }
      }
    else
      {   /* the given file has size 0 */
        error = 1;
      }

    return error;
  }


/* #############################################################################
 *
 * Description    encrypt and write our data to the given filename
 * Author         Harry Brueckner
 * Date           2005-03-18
 * Arguments      char* filename  - filename to write to
 *                char** errormsg - pointer to the GpgMe error message, if any
 *                PASSPHRASE_FN   - passphrase callback function
 *                SHOWERROR_FN    - callback function for error messages
 * Return         1 on error, otherwise 0
 */
int xmlDataFileWrite(char* filename, char** errormsg,
    PASSPHRASE_FN passphrase_cb, SHOWERROR_FN showerror_cb)
  {
    xmlNode*            rootnode;
    xmlChar*            xmlbuffer = NULL;
    int                 error = 0,
                        fd,
                        gpgsize = 0,
                        size;
    char*               buffer = NULL;
    char*               gpgbuffer = NULL;
    char*               tmpbuffer = NULL;


    /* we initialize the error message */
    *errormsg = NULL;

    /* update the modification date of the root node */
    rootnode = xmlDocGetRootElement(xmldoc);
    if (rootnode)
      { xmlSetModification(rootnode); }

    /* we create the memory buffer */
    xmlDocDumpMemoryEnc(xmldoc, &xmlbuffer, &size, config -> encoding);
    buffer = (char*)xmlbuffer;

    if (buffer && !error && config -> encryptdata)
      {   /* we have a buffer and must compress it */
        error = zlibCompress(buffer, size, &gpgbuffer, &gpgsize, errormsg);
        if (error)
          {
            tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
            snprintf(tmpbuffer, STDBUFFERLENGTH,
                _("error (%s) compressing file '%s'."),
                *errormsg,
                filename);
            showerror_cb(_("compression error"), tmpbuffer);
            memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);

            memFree(__FILE__, __LINE__, buffer, size);
            return 1;
          }

        xmlFree(buffer);
        buffer = gpgbuffer;
        size = gpgsize;
      }
    else if (buffer && !error && !config -> encryptdata)
      {   /* we don't have to encrypt data, so nothing is compressed */
        gpgbuffer = memAlloc(__FILE__, __LINE__, size);
        /* Flawfinder: ignore */
        memcpy(gpgbuffer, buffer, size);

        xmlFree(buffer);
        buffer = gpgbuffer;
      }

    if (buffer && !error &&
        config -> encryptdata)
      {
        error = gpgEncrypt(buffer, size, &gpgbuffer, &gpgsize, passphrase_cb,
            showerror_cb);
        if (error)
          { *errormsg = _("could not encrypt database file."); }

        memFree(__FILE__, __LINE__, buffer, size);
        buffer = gpgbuffer;
        size = gpgsize;
      }
    else
      {
        showerror_cb(_("warning"),
            _("the database file is written in unecrypted mode."));
      }

    if (buffer && !error)
      {   /* if we have a buffer we write the file */
        createBackupfile(filename, showerror_cb);

        fd = fileLockOpen(filename, O_WRONLY | O_CREAT | O_TRUNC,
            S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, &tmpbuffer);
        if (fd == -1)
          {   /* error opening the file */
            showerror_cb(_("file error"), tmpbuffer);
            memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);

            *errormsg = strerror(errno);

            memFree(__FILE__, __LINE__, buffer, size);
            return 1;
          }

        if (write(fd, buffer, size) != size)
          {   /* error writing the file */
            tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);
            snprintf(tmpbuffer, STDBUFFERLENGTH,
                _("error %d (%s) writing file '%s'."),
                errno,
                strerror(errno),
                filename);
            showerror_cb(_("file error"), tmpbuffer);
            memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);

            *errormsg = strerror(errno);

            memFree(__FILE__, __LINE__, buffer, size);
            return 1;
          }

        lockf(fd, F_UNLCK, 0L);
        close(fd);
      }

    if (buffer && size)
      { memFree(__FILE__, __LINE__, buffer, size); }

    return error;
  }


/* #############################################################################
 *
 * Description    encode the XML entities in the given string
 * Author         Harry Brueckner
 * Date           2005-07-08
 * Arguments      xmlChar* string   - string to encode the entities
 * Return         xmlChar* encoded string
 */
xmlChar* xmlEncodeCommentEntities(xmlChar* string)
  {
    TRACE(99, "xmlEncodeCommentEntities()", NULL);

    return xmlEncodeEntitiesReentrant(xmldoc, string);
  }


/* #############################################################################
 *
 * Description    get the documents root node
 * Author         Harry Brueckner
 * Date           2005-04-18
 * Arguments      void
 * Return         xmlNode* node pointer to the root element
 */
xmlNode* xmlGetDocumentRoot(void)
  {
    TRACE(99, "xmlGetDocumentRoot()", NULL);

    if (xmldoc)
      { return xmlDocGetRootElement(xmldoc); }
    else
      { return NULL; }
  }


/* #############################################################################
 *
 * Description    remove all DTDs from the XML document
 * Author         Harry Brueckner
 * Date           2005-05-06
 * Arguments      void
 * Return         void
 */
void xmlRemoveDtd(void)
  {
    xmlNode*            curnode;
    xmlNode*            delnode = NULL;

    TRACE(99, "xmlRemoveDtd()", NULL);

    if (!xmldoc)
      { return; }

    /* we delete all DTDs in the document */
    curnode = xmldoc -> children;
    while (curnode)
      {
        if (curnode -> type == XML_DTD_NODE)
          { delnode = curnode; }

        curnode = curnode -> next;

        if (delnode)
          {
            xmlUnlinkNode(delnode);
            delnode = NULL;
          }
      }
  }


/* #############################################################################
 *
 * Description    error/warning callback for DTD validation
 * Author         Harry Brueckner
 * Date           2005-05-06
 * Arguments      void* context     - the validation context
 *                const char* msg   - format message
 *                ...               - arguments for the message
 * Return         void
 */
void xmlValidateError(void* context, const char* msg, ...)
  {
    va_list             list;
    int                 size;
    char*               tmpbuffer;

    TRACE(99, "xmlValidateError()", NULL);

    tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);

    va_start(list, msg);
    /* Flawfinder: ignore */
    vsnprintf(tmpbuffer, STDBUFFERLENGTH, msg, list);
    va_end(list);

    /* the message has a \n at the end so we remove it */
    size = strlen(tmpbuffer);
    if (size > 0 && size < STDBUFFERLENGTH)
      { tmpbuffer[size - 1] = 0; }

    validateShowError(_("validation error"), tmpbuffer);

    memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
  }


/* #############################################################################
 *
 * Description    error/warning callback for DTD validation
 * Author         Harry Brueckner
 * Date           2005-05-06
 * Arguments      void* context     - the validation context
 *                const char* msg   - format message
 *                ...               - arguments for the message
 * Return         void
 */
void xmlValidateWarning(void* context, const char* msg, ...)
  {
    va_list             list;
    int                 size;
    char*               tmpbuffer;

    TRACE(99, "xmlValidateWarning()", NULL);

    tmpbuffer = memAlloc(__FILE__, __LINE__, STDBUFFERLENGTH);

    va_start(list, msg);
    /* Flawfinder: ignore */
    vsnprintf(tmpbuffer, STDBUFFERLENGTH, msg, list);
    va_end(list);

    /* the message has a \n at the end so we remove it */
    size = strlen(tmpbuffer);
    if (size > 0 && size < STDBUFFERLENGTH)
      { tmpbuffer[size - 1] = 0; }

    validateShowError(_("validation warning"), tmpbuffer);

    memFree(__FILE__, __LINE__, tmpbuffer, STDBUFFERLENGTH);
  }


/* #############################################################################
 *
 * Description    walk the tree and update all nodes
 * Author         Harry Brueckner
 * Date           2005-04-04
 * Arguments      long oldversion     - the version to convert from
 *                xmlNode* rootnode   - the node to walk
 * Return         void
 */
void xmlVersionNodeUpdate(long oldversion, xmlNode* rootnode)
  {
    xmlNode*            curnode;

    TRACE(99, "xmlVersionNodeUpdate()", NULL);

    if (!rootnode)
      { return; }

    curnode = rootnode -> children;
    while (curnode)
      {
        if (curnode -> type == XML_ELEMENT_NODE)
          {
            if (oldversion < 0x000000002)
              {   /* we upgrade from 'unknown' version; before 0.2alpha,
                   * the version attribute did not exist
                   */
                xmlSetCreation(curnode);
              }
          }

        xmlVersionNodeUpdate(oldversion, curnode);

        curnode = curnode -> next;
      }
  }


/* #############################################################################
 *
 * Description    check if our current document has the correct version, if not
 *                update it
 * Author         Harry Brueckner
 * Date           2005-04-04
 * Arguments      xmlNode* node   - the node to walk
 * Return         void
 */
void xmlVersionUpdate(int silent)
  {
    static char*        curversion = PACKAGE_VERSION;
    xmlNode*            rootnode;
    xmlChar*            prop;
    unsigned long       version;
    int                 size;
    char*               old;
    char*               ptr;

    TRACE(99, "xmlVersionUpdate()", NULL);

    rootnode = xmlDocGetRootElement(xmldoc);
    if (!rootnode)
      { return; }

    /* get the current version of the document */
    prop = xmlGetProp(rootnode, BAD_CAST "version");
    if (prop && !strcmp(curversion, (char*)prop))
      { return; }

    if (!prop)
      {   /* we do not even have a version info, so we add a new one */
        xmlVersionNodeUpdate(0, rootnode);

        xmlNewProp(rootnode, BAD_CAST "version", BAD_CAST curversion);
        xmlSetCreation(rootnode);
      }
    else
      {   /* we have version information but its not up to date */
        size = strlen((char*)prop) + 1;
        old = memAlloc(__FILE__, __LINE__, size);
        strStrncpy(old, (char*)prop, size);

        ptr = old;
        while (*ptr && *ptr != '.')
          { ptr++; }
        if (*ptr == '.')
          {
            *ptr = '\x0';
          }
        /* Flawfinder: ignore */
        version = (atoi(old) << 16) + atoi(ptr + 1);

        xmlSetProp(rootnode, BAD_CAST "version", BAD_CAST curversion);
        xmlVersionNodeUpdate(version, rootnode);


        memFree(__FILE__, __LINE__, old, size);
      }

    /* we update the modified timestamp */
    xmlSetModification(rootnode);

    runtime -> datachanged = 1;
    if (!silent)
      { runtime -> updatestatus = 1; }
  }


/* #############################################################################
 */