/*

 * libxml2_htmltree.c : implementation of access function for an HTML tree.

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

 */

#define IN_LIBXML

#include "xmlenglibxml.h"

#include <string.h> /* for memset() only ! */

#ifdef HAVE_CTYPE_H

#include <ctype.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include <stdapis/libxml2/libxml2_xmlmemory.h>

#include "libxml2_htmlparser.h"

#include "libxml2_htmltree.h"

#include <stdapis/libxml2/libxml2_entities.h>

#include <stdapis/libxml2/libxml2_valid.h>

#include <stdapis/libxml2/libxml2_xmlerror.h>

#include "libxml2_xmlerror2.h"

#include <stdapis/libxml2/libxml2_xmlsave.h>

#include <stdapis/libxml2/libxml2_parserinternals.h>

#include <stdapis/libxml2/libxml2_globals.h>

#include <stdapis/libxml2/libxml2_uri.h>

#ifdef LIBXML_HTML_ENABLED

/************************************************************************

 *                                                                      *

 *          Getting/Setting encoding meta tags                          *

 *                                                                      *

 ************************************************************************/

/**

 * htmlGetMetaEncoding:

 * @param doc the document

 *

 * Encoding definition lookup in the Meta tags

 *

 * Returns the current encoding as flagged in the HTML source

 */

const xmlChar *

htmlGetMetaEncoding(htmlDocPtr doc) {

    htmlNodePtr cur;

    const xmlChar *content;

    const xmlChar *encoding;

    if (doc == NULL)

        return(NULL);

    cur = doc->children;

    /*

     * Search the html

     */

    while (cur != NULL) {

        if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {

            if (xmlStrEqual(cur->name, BAD_CAST"html"))

                break;

            if (xmlStrEqual(cur->name, BAD_CAST"head"))

                goto found_head;

            if (xmlStrEqual(cur->name, BAD_CAST"meta"))

                goto found_meta;

        }

        cur = cur->next;

    }

    if (cur == NULL)

        return(NULL);

    cur = cur->children;

    /*

     * Search the head

     */

    while (cur != NULL) {

        if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {

            if (xmlStrEqual(cur->name, BAD_CAST"head"))

                break;

            if (xmlStrEqual(cur->name, BAD_CAST"meta"))

                goto found_meta;

        }

        cur = cur->next;

    }

    if (cur == NULL)

        return(NULL);

found_head:

    cur = cur->children;

    /*

     * Search the meta elements

     */

found_meta:

    while (cur != NULL) {

        if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {

            if (xmlStrEqual(cur->name, BAD_CAST"meta")) {

                xmlAttrPtr attr = cur->properties;

                int http;

                const xmlChar *value;

                content = NULL;

                http = 0;

                while (attr != NULL) {

                    if ((attr->children != NULL) &&

                        (attr->children->type == XML_TEXT_NODE) &&

                        (attr->children->next == NULL)) {

                        value = attr->children->content;

                        if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))

                         && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))

                            http = 1;

                        else if ((value != NULL)

                         && (!xmlStrcasecmp(attr->name, BAD_CAST"content")))

                            content = value;

                        if ((http != 0) && (content != NULL))

                            goto found_content;

                    }

                    attr = attr->next;

                }

            }

        }

        cur = cur->next;

    }

    return(NULL);

found_content:

    encoding = xmlStrstr(content, BAD_CAST"charset=");

    if (encoding == NULL)

        encoding = xmlStrstr(content, BAD_CAST"Charset=");

    if (encoding == NULL)

        encoding = xmlStrstr(content, BAD_CAST"CHARSET=");

    if (encoding != NULL) {

        encoding += 8;

    } else {

        encoding = xmlStrstr(content, BAD_CAST"charset =");

        if (encoding == NULL)

            encoding = xmlStrstr(content, BAD_CAST"Charset =");

        if (encoding == NULL)

            encoding = xmlStrstr(content, BAD_CAST"CHARSET =");

        if (encoding != NULL)

            encoding += 9;

    }

    if (encoding != NULL) {

        while ((*encoding == ' ') || (*encoding == '\t')) encoding++;

    }

    return(encoding);

}

#endif /* LIBXML_HTML_ENABLED */

#if defined(LIBXML_HTML_ENABLED) || defined(XMLENGINE_XSLT)

/**

 * htmlSetMetaEncoding:

 * @param doc the document

 * @param encoding the encoding string

 *

 * Sets the current encoding in the Meta tags

 * NOTE: this will not change the document content encoding, just

 * the META flag associated.

 *

 * Returns 0 in case of success and -1 in case of error

 */

XMLPUBFUNEXPORT int

htmlSetMetaEncoding(htmlDocPtr doc, const xmlChar *encoding) {

    htmlNodePtr cur, meta;

    const xmlChar *content;

    char newcontent[100];

	LOAD_GS_SAFE_DOC(doc)

    if (doc == NULL)

        return(-1);

    if (encoding != NULL) {

        snprintf(newcontent, sizeof(newcontent), "text/html; charset=%s",

                encoding);

        newcontent[sizeof(newcontent) - 1] = 0;

    }

    cur = doc->children;

    /*

     * Search the html

     */

    while (cur != NULL) {

        if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {

            if (xmlStrcasecmp(cur->name, BAD_CAST"html") == 0)

                break;

            if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)

                goto found_head;

            if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0)

                goto found_meta;

        }

        cur = cur->next;

    }

    if (cur == NULL)

        return(-1);

    cur = cur->children;

    /*

     * Search the head

     */

    while (cur != NULL) {

        if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {

            if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)

                break;

            if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0)

                goto found_meta;

        }

        cur = cur->next;

    }

    if (cur == NULL)

        return(-1);

found_head:

    if (cur->children == NULL) {

        if (encoding == NULL)

            return(0);

        meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);

        xmlAddChild(cur, meta);

        xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");

        xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);

        if ( OOM_FLAG )     //oom set in xmlNewProp

            return(-1);

        return(0);

    }

    cur = cur->children;

found_meta:

    if (encoding != NULL) {

        /*

         * Create a new Meta element with the right attributes

         */

        meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);

        xmlAddPrevSibling(cur, meta);

        xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");

        xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);

    }

    /*

     * Search and destroy all the remaining the meta elements carrying

     * encoding informations

     */

    while (cur != NULL) {

        if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {

            if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {

                xmlAttrPtr attr = cur->properties;

                int http;

                const xmlChar *value;

                content = NULL;

                http = 0;

                while (attr != NULL) {

                    if ((attr->children != NULL) &&

                        (attr->children->type == XML_TEXT_NODE) &&

                        (attr->children->next == NULL)) {

                        value = attr->children->content;

                        if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))

                         && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))

                            http = 1;

                        else

                        {

                           if ((value != NULL) &&

                                (!xmlStrcasecmp(attr->name, BAD_CAST"content")))

                              content = value;

                        }

                        if ((http != 0) && (content != NULL))

                            break;

                    }

                    attr = attr->next;

                }

                if ((http != 0) && (content != NULL)) {

                    meta = cur;

                    cur = cur->next;

                    xmlUnlinkNode(meta);

                    xmlFreeNode(meta);

                    continue;

                }

            }

        }

        cur = cur->next;

    }

    return(0);

}

/**

 * booleanHTMLAttrs:

 *

 * These are the HTML attributes which will be output

 * in minimized form, i.e. <option selected="selected"> will be

 * output as <option selected>, as per XSLT 1.0 16.2 "HTML Output Method"

 *

 */

static const char* const htmlBooleanAttrs[] = {

  "checked", "compact", "declare", "defer", "disabled", "ismap",

  "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",

  "selected", NULL

};

/**

 * htmlIsBooleanAttr:

 * @param name the name of the attribute to check

 *

 * Determine if a given attribute is a boolean attribute.

 *

 * returns: false if the attribute is not boolean, true otherwise.

 */

XMLPUBFUNEXPORT int

htmlIsBooleanAttr(const xmlChar *name)

{

    int i = 0;

    while (htmlBooleanAttrs[i] != NULL) {

        if (xmlStrcasecmp((const xmlChar *)htmlBooleanAttrs[i], name) == 0)

            return 1;

        i++;

    }

    return 0;

}

#endif // HTML or XSLT

#ifdef LIBXML_HTML_ENABLED

#ifdef LIBXML_OUTPUT_ENABLED

/************************************************************************

 *                                                                      *

 *          Output error handlers                                       *

 *                                                                      *

 ************************************************************************/

/**

 * htmlSaveErrMemory:

 * @param extra extra informations

 *

 * Handle an out of memory condition

 */

static void

htmlSaveErrMemory(const char *extra)

{

    __xmlSimpleError(XML_FROM_OUTPUT, XML_ERR_NO_MEMORY, NULL, NULL, extra);

}

/**

 * htmlSaveErr:

 * @param code the error number

 * @param node the location of the error.

 * @param extra extra informations

 *

 * Handle an out of memory condition

 */

static void

htmlSaveErr(int code, xmlNodePtr node, const char *extra); // Moved to XSLT-enabled part of the file

/************************************************************************

 *                                                                      *

 *          Dumping HTML tree content to a simple buffer                *

 *                                                                      *

 ************************************************************************/

static int

htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,

                   int format);

/**

 * htmlNodeDumpFormat:

 * @param buf the HTML buffer output

 * @param doc the document

 * @param cur the current node

 * @param format should formatting spaces been added

 *

 * Dump an HTML node, recursive behaviour,children are printed too.

 *

 * Returns the number of byte written or -1 in case of error

 */

static int

htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,

                   int format) {

    unsigned int use;

    int ret;

    xmlOutputBufferPtr outbuf;

    if (cur == NULL) {

        return (-1);

    }

    if (buf == NULL) {

        return (-1);

    }

    outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));

    if (outbuf == NULL) {

        htmlSaveErrMemory("allocating HTML output buffer");

        return (-1);

    }

    memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));

    outbuf->buffer = buf;

    outbuf->encoder = NULL;

    outbuf->writecallback = NULL;

    outbuf->closecallback = NULL;

    outbuf->context = NULL;

    outbuf->written = 0;

    use = buf->use;

    htmlNodeDumpFormatOutput(outbuf, doc, cur, NULL, format);

    xmlFree(outbuf);

    ret = buf->use - use;

    return (ret);

}

/**

 * htmlNodeDump:

 * @param buf the HTML buffer output

 * @param doc the document

 * @param cur the current node

 *

 * Dump an HTML node, recursive behaviour,children are printed too,

 * and formatting returns are added.

 *

 * Returns the number of byte written or -1 in case of error

 */

int

htmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur) {

    xmlInitParser();

    return(htmlNodeDumpFormat(buf, doc, cur, 1));

}

/**

 * htmlNodeDumpFileFormat:

 * @param out the FILE pointer

 * @param doc the document

 * @param cur the current node

 * @param encoding the document encoding

 * @param format should formatting spaces been added

 *

 * Dump an HTML node, recursive behaviour,children are printed too.

 *

 *

 * returns: the number of byte written or -1 in case of failure.

 */

int

htmlNodeDumpFileFormat(FILE *out, xmlDocPtr doc,

                       xmlNodePtr cur, const char *encoding, int format) {

    xmlOutputBufferPtr buf;

    xmlCharEncodingHandlerPtr handler = NULL;

    int ret;

    xmlInitParser();

    if (encoding != NULL) {

        xmlCharEncoding enc;

        enc = xmlParseCharEncoding(encoding);

        if (enc != XML_CHAR_ENCODING_UTF8) {

            handler = xmlFindCharEncodingHandler(encoding);

            if (handler == NULL)

                return(-1);

        }

    }

    /*

     * Fallback to HTML or ASCII when the encoding is unspecified

     */

    if (handler == NULL)

        handler = xmlFindCharEncodingHandler("HTML");

    if (handler == NULL)

        handler = xmlFindCharEncodingHandler("ascii");

    /*

     * save the content to a temp buffer.

     */

    buf = xmlOutputBufferCreateFile(out, handler);

    if (buf == NULL) return(0);

    htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);

    ret = xmlOutputBufferClose(buf);

    return(ret);

}

/**

 * htmlNodeDumpFile:

 * @param out the FILE pointer

 * @param doc the document

 * @param cur the current node

 *

 * Dump an HTML node, recursive behaviour,children are printed too,

 * and formatting returns are added.

 */

void

htmlNodeDumpFile(FILE *out, xmlDocPtr doc, xmlNodePtr cur) {

    htmlNodeDumpFileFormat(out, doc, cur, NULL, 1);

}

/**

 * htmlDocDumpMemory:

 * @param cur the document

 * @param mem OUT: the memory pointer

 * @param size OUT: the memory length

 *

 * Dump an HTML document in memory and return the xmlChar * and it's size.

 * It's up to the caller to free the memory.

 */

void

htmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {

    xmlOutputBufferPtr buf;

    xmlCharEncodingHandlerPtr handler = NULL;

    const char *encoding;

    xmlInitParser();

    if (cur == NULL) {

        *mem = NULL;

        *size = 0;

        return;

    }

    encoding = (const char *) htmlGetMetaEncoding(cur);

    if (encoding != NULL) {

        xmlCharEncoding enc;

        enc = xmlParseCharEncoding(encoding);

        if (enc != cur->charset) {