/src/libxml2/HTMLtree.c

Source (jump to first uncovered line)
/*
 * HTMLtree.c : implementation of access function for an HTML tree.
 *
 * See Copyright for the status of this software.
 *
 * Author: Daniel Veillard
 */


#define IN_LIBXML
#include "libxml.h"
#ifdef LIBXML_HTML_ENABLED

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

#include <libxml/xmlmemory.h>
#include <libxml/HTMLparser.h>
#include <libxml/HTMLtree.h>
#include <libxml/entities.h>
#include <libxml/xmlerror.h>
#include <libxml/parserInternals.h>
#include <libxml/uri.h>

#include "private/buf.h"
#include "private/html.h"
#include "private/error.h"
#include "private/html.h"
#include "private/io.h"
#include "private/save.h"
#include "private/tree.h"

/************************************************************************
 *                  *
 *    Getting/Setting encoding meta tags      *
 *                  *
 ************************************************************************/

typedef struct {
    xmlAttrPtr attr; /* charset or content */
    const xmlChar *attrValue;
    htmlMetaEncodingOffsets off;
} htmlMetaEncoding;

static htmlNodePtr
htmlFindFirstChild(htmlNodePtr parent, const char *name) {
    htmlNodePtr child;

    for (child = parent->children; child != NULL; child = child->next) {
        if ((child->type == XML_ELEMENT_NODE) &&
            (xmlStrcasecmp(child->name, BAD_CAST name) == 0))
            return(child);
    }

    return(NULL);
}

static htmlNodePtr
htmlFindHead(htmlDocPtr doc) {
    htmlNodePtr html;

    if (doc == NULL)
        return(NULL);

    html = htmlFindFirstChild((htmlNodePtr) doc, "html");
    if (html == NULL)
        return(NULL);

    return(htmlFindFirstChild(html, "head"));
}

int
htmlParseContentType(const xmlChar *val, htmlMetaEncodingOffsets *off) {
    const xmlChar *p = val;

    while (1) {
        size_t start, end;

        while ((*p != 'c') && (*p != 'C')) {
            if (*p == 0)
                return(0);
            p += 1;
        }
        p += 1;

        if (xmlStrncasecmp(p, BAD_CAST "harset", 6) != 0)
            continue;

        p += 6;
        while (IS_WS_HTML(*p)) p += 1;

        if (*p != '=')
            continue;

        p += 1;
        while (IS_WS_HTML(*p)) p += 1;

        if (*p == 0)
            return(0);

        if ((*p == '"') || (*p == '\'')) {
            int quote = *p;

            p += 1;
            while (IS_WS_HTML(*p)) p += 1;

            start = p - val;
            end = start;

            while (*p != quote) {
                if (*p == 0)
                    return(0);
                if (!IS_WS_HTML(*p))
                    end = p + 1 - val;
                p += 1;
            }
        } else {
            start = p - val;

            while ((*p != 0) && (*p != ';') && (!IS_WS_HTML(*p)))
                p += 1;

            end = p - val;
        }

        off->start = start;
        off->end = end;
        off->size = p - val + strlen((char *) p);

        return(1);
    }

    return(0);
}

static xmlAttrPtr
htmlFindMetaEncodingAttr(htmlNodePtr elem, int *outIsContentType) {
    xmlAttrPtr attr, contentAttr = NULL;
    int isContentType = 0;

    if (xmlStrcasecmp(elem->name, BAD_CAST "meta") != 0)
        return(NULL);

    for (attr = elem->properties; attr != NULL; attr = attr->next) {
        if (attr->ns != NULL)
            continue;
        if (xmlStrcasecmp(attr->name, BAD_CAST "charset") == 0) {
            *outIsContentType = 0;
            return(attr);
        }
        if (xmlStrcasecmp(attr->name, BAD_CAST "content") == 0)
            contentAttr = attr;
        if ((xmlStrcasecmp(attr->name, BAD_CAST "http-equiv") == 0) &&
            (attr->children != NULL) &&
            (attr->children->type == XML_TEXT_NODE) &&
            (attr->children->next == NULL) &&
            (xmlStrcasecmp(attr->children->content,
                           BAD_CAST "Content-Type") == 0))
            isContentType = 1;
    }

    if ((isContentType) && (contentAttr != NULL)) {
        *outIsContentType = 1;
        return(contentAttr);
    }

    return(NULL);
}

static int
htmlParseMetaEncoding(htmlNodePtr elem, htmlMetaEncoding *menc) {
    xmlAttrPtr attr;
    const xmlChar *val = NULL;
    int isContentType;

    if ((elem->type != XML_ELEMENT_NODE) ||
        (xmlStrcasecmp(elem->name, BAD_CAST "meta") != 0))
        return(0);

    attr = htmlFindMetaEncodingAttr(elem, &isContentType);
    if (attr == NULL)
        return(0);

    if ((attr->children != NULL) &&
        (attr->children->type == XML_TEXT_NODE) &&
        (attr->children->next == NULL) &&
        (attr->children->content != NULL))
        val = attr->children->content;
    else
        val = BAD_CAST "";


    if (!isContentType) {
        size_t size = strlen((char *) val);
        size_t start = 0;
        size_t end = size;

        while ((start < size) && (IS_WS_HTML(val[start])))
            start += 1;

        while ((end > 0) && (IS_WS_HTML(val[end-1])))
            end -= 1;

        menc->attr = attr;
        menc->attrValue = val;
        menc->off.start = start;
        menc->off.end = end;
        menc->off.size = size;

        return(1);
    } else {
        if (htmlParseContentType(val, &menc->off)) {
            menc->attr = attr;
            menc->attrValue = val;

            return(1);
        }
    }

    return(0);
}

static xmlChar *
htmlUpdateMetaEncoding(htmlMetaEncoding *menc, const char *encoding) {
    xmlChar *newVal, *p;
    size_t size, oldEncSize, newEncSize;

    /*
     * The pseudo "HTML" encoding only produces ASCII.
     */
    if (xmlStrcasecmp(BAD_CAST encoding, BAD_CAST "HTML") == 0)
        encoding = "ASCII";

    oldEncSize = menc->off.end - menc->off.start;
    newEncSize = strlen((char *) encoding);
    size = menc->off.size - oldEncSize + newEncSize;
    newVal = xmlMalloc(size + 1);
    if (newVal == NULL)
        return(NULL);

    p = newVal;
    memcpy(p, menc->attrValue, menc->off.start);
    p += menc->off.start;
    memcpy(p, encoding, newEncSize);
    p += newEncSize;
    memcpy(p, menc->attrValue + menc->off.end, menc->off.size - menc->off.end);
    newVal[size] = 0;

    return(newVal);
}

/**
 * Look up and encoding declaration in the meta tags.
 *
 * The returned string points into attribute content and can contain
 * trailing garbage. It should be copied before modifying or freeing
 * nodes.
 *
 * @param doc  the document
 * @returns the encoding ot NULL if not found.
 */
const xmlChar *
htmlGetMetaEncoding(xmlDoc *doc) {
    htmlNodePtr head, node;

    head = htmlFindHead(doc);
    if (head == NULL)
        return(NULL);

    for (node = head->children; node != NULL; node = node->next) {
        htmlMetaEncoding menc;

        if (htmlParseMetaEncoding(node, &menc)) {
            /*
             * Returning a `const xmlChar *` only allows to return
             * a suffix. In http-equiv meta tags, there could be
             * more data after the charset, although it's probably
             * rare in practice.
             */
            return(menc.attrValue + menc.off.start);
        }
    }

    return(NULL);
}

/**
 * Creates or updates a meta tag with an encoding declaration.
 *
 * NOTE: This will not change the document content encoding.
 *
 * @param doc  the document
 * @param encoding  the encoding string
 * @returns 0 in case of success, 1 if no head element was found or
 * arguments are invalid and -1 if memory allocation failed.
 */
int
htmlSetMetaEncoding(xmlDoc *doc, const xmlChar *encoding) {
    htmlNodePtr head, meta;
    int found = 0;

    if (encoding == NULL)
        return(1);

    head = htmlFindHead(doc);
    if (head == NULL)
        return(1);

    for (meta = head->children; meta != NULL; meta = meta->next) {
        htmlMetaEncoding menc;

        if (htmlParseMetaEncoding(meta, &menc)) {
            xmlChar *newVal;
            int ret;

            found = 1;

            newVal = htmlUpdateMetaEncoding(&menc, (char *) encoding);
            if (newVal == NULL)
                return(-1);
            xmlNodeSetContent((xmlNodePtr) menc.attr, NULL);
            ret = xmlNodeAddContent((xmlNodePtr) menc.attr, newVal);
            xmlFree(newVal);

            if (ret < 0)
                return(-1);
        }
    }

    if (found)
        return(0);

    meta = xmlNewDocNode(head->doc, NULL, BAD_CAST "meta", NULL);
    if (meta == NULL)
        return(-1);

    if (xmlNewProp(meta, BAD_CAST "charset", encoding) == NULL) {
        xmlFreeNode(meta);
        return(-1);
    }

    if (head->children == NULL)
        xmlAddChild(head, meta);
    else
        xmlAddPrevSibling(head->children, meta);

    return(0);
}

/**
 * Determine if a given attribute is a boolean attribute. This
 * doesn't handle HTML5.
 *
 * @deprecated Internal function, don't use.
 *
 * @param name  the name of the attribute to check
 * @returns false if the attribute is not boolean, true otherwise.
 */
int
htmlIsBooleanAttr(const xmlChar *name)
{
    const char *str = NULL;

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

    /*
     * 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":
     *
     * "checked", "compact", "declare", "defer", "disabled", "ismap",
     * "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
     * "selected"
     *
     * Additional attributes from HTML5 (not implemented yet):
     *
     * "allowfullscreen", "alpha", "async", "autofocus", "autoplay",
     * "controls", "default", "formnovalidate", "inert", "itemscope",
     * "loop", "muted", "nomodule", "novalidate", "open", "playsinline",
     * "required", "reversed", "shadowrootdelegatesfocus",
     * "shadowrootclonable", "shadowrootserializable",
     * "shadowrootcustomelementregistry", "truespeed"
     */

    switch (name[0] | 0x20) {
        case 'c':
            name += 1;
            switch (name[0] | 0x20) {
                case 'h': str = "ecked"; break;
                case 'o': str = "mpact"; break;
            }
            break;
        case 'd':
            name += 1;
            switch (name[0] | 0x20) {
                case 'e':
                    name += 1;
                    switch (name[0] | 0x20) {
                        case 'c': str = "lare"; break;
                        case 'f': str = "er"; break;
                    }
                    break;
                case 'i': str = "sabled"; break;
            }
            break;
        case 'i':
            str = "smap";
            break;
        case 'm':
            str = "ultiple";
            break;
        case 'n':
            name += 1;
            if ((name[0] | 0x20) != 'o')
                break;
            name += 1;
            switch (name[0] | 0x20) {
                case 'h': str = "ref"; break;
                case 'r': str = "esize"; break;
                case 's': str = "hade"; break;
                case 'w': str = "rap"; break;
            }
            break;
        case 'r':
            str = "eadonly";
            break;
        case 's':
            str = "elected";
            break;
    }

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

    return(xmlStrcasecmp(name + 1, BAD_CAST str) == 0);
}

#ifdef LIBXML_OUTPUT_ENABLED
/************************************************************************
 *                  *
 *    Dumping HTML tree content to a simple buffer    *
 *                  *
 ************************************************************************/

static xmlParserErrors
htmlFindOutputEncoder(const char *encoding, xmlCharEncodingHandler **out) {
    /*
     * Fallback to HTML if the encoding is unspecified
     */
    if (encoding == NULL)
        encoding = "HTML";

    return(xmlOpenCharEncodingHandler(encoding, /* output */ 1, out));
}

/**
 * Serialize an HTML document to an xmlBuf.
 *
 * @param buf  the xmlBuf output
 * @param doc  the document (unused)
 * @param cur  the current node
 * @param format  should formatting newlines been added
 * @returns the number of bytes written or -1 in case of error
 */
static size_t
htmlBufNodeDumpFormat(xmlBufPtr buf, xmlDocPtr doc ATTRIBUTE_UNUSED,
                      xmlNodePtr cur, int format) {
    size_t use;
    size_t ret;
    xmlOutputBufferPtr outbuf;

    if (cur == NULL) {
  return ((size_t) -1);
    }
    if (buf == NULL) {
  return ((size_t) -1);
    }
    outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
    if (outbuf == NULL)
  return ((size_t) -1);
    memset(outbuf, 0, sizeof(xmlOutputBuffer));
    outbuf->buffer = buf;
    outbuf->encoder = NULL;
    outbuf->writecallback = NULL;
    outbuf->closecallback = NULL;
    outbuf->context = NULL;
    outbuf->written = 0;

    use = xmlBufUse(buf);
    htmlNodeDumpInternal(outbuf, cur, NULL, format);
    if (outbuf->error)
        ret = (size_t) -1;
    else
        ret = xmlBufUse(buf) - use;
    xmlFree(outbuf);
    return (ret);
}

/**
 * Serialize an HTML node to an xmlBuffer. Always uses UTF-8.
 *
 * @param buf  the HTML buffer output
 * @param doc  the document
 * @param cur  the current node
 * @returns the number of bytes written or -1 in case of error
 */
int
htmlNodeDump(xmlBuffer *buf, xmlDoc *doc, xmlNode *cur) {
    xmlBufPtr buffer;
    size_t ret1;
    int ret2;

    if ((buf == NULL) || (cur == NULL))
        return(-1);

    xmlInitParser();
    buffer = xmlBufFromBuffer(buf);
    if (buffer == NULL)
        return(-1);

    ret1 = htmlBufNodeDumpFormat(buffer, doc, cur, 1);

    ret2 = xmlBufBackToBuffer(buffer, buf);

    if ((ret1 == (size_t) -1) || (ret2 < 0))
        return(-1);
    return(ret1 > INT_MAX ? INT_MAX : ret1);
}

/**
 * Serialize an HTML node to an xmlBuffer.
 *
 * If encoding is NULL, ASCII with HTML 4.0 named character entities
 * will be used. This is inefficient compared to UTF-8 and might be
 * changed in a future version.
 *
 * @param out  the FILE pointer
 * @param doc  the document (unused)
 * @param cur  the current node
 * @param encoding  the document encoding (optional)
 * @param format  should formatting newlines been added
 * @returns the number of bytes written or -1 in case of failure.
 */
int
htmlNodeDumpFileFormat(FILE *out, xmlDoc *doc ATTRIBUTE_UNUSED,
                 xmlNode *cur, const char *encoding, int format) {
    xmlOutputBufferPtr buf;
    xmlCharEncodingHandlerPtr handler;
    int ret;

    xmlInitParser();

    /*
     * save the content to a temp buffer.
     */
    if (htmlFindOutputEncoder(encoding, &handler) != XML_ERR_OK)
        return(-1);
    buf = xmlOutputBufferCreateFile(out, handler);
    if (buf == NULL) {
        xmlCharEncCloseFunc(handler);
        return(-1);
    }

    htmlNodeDumpInternal(buf, cur, NULL, format);

    ret = xmlOutputBufferClose(buf);
    return(ret);
}

/**
 * Same as #htmlNodeDumpFileFormat with `format` set to 1 which is
 * typically undesired. Use of this function is DISCOURAGED in favor
 * of #htmlNodeDumpFileFormat.
 *
 * @param out  the FILE pointer
 * @param doc  the document
 * @param cur  the current node
 */
void
htmlNodeDumpFile(FILE *out, xmlDoc *doc, xmlNode *cur) {
    htmlNodeDumpFileFormat(out, doc, cur, NULL, 1);
}

/**
 * Serialize an HTML node to a memory, also returning the size of
 * the result. It's up to the caller to free the memory.
 *
 * Uses the encoding of the document. If the document has no
 * encoding, ASCII with HTML 4.0 named character entities will
 * be used. This is inefficient compared to UTF-8 and might be
 * changed in a future version.
 *
 * @param cur  the document
 * @param mem  OUT: the memory pointer
 * @param size  OUT: the memory length
 * @param format  should formatting newlines been added
 */
void
htmlDocDumpMemoryFormat(xmlDoc *cur, xmlChar**mem, int *size, int format) {
    xmlOutputBufferPtr buf;
    xmlCharEncodingHandlerPtr handler = NULL;

    xmlInitParser();

    if ((mem == NULL) || (size == NULL))
        return;
    *mem = NULL;
    *size = 0;
    if (cur == NULL)
  return;

    if (htmlFindOutputEncoder((char *) cur->encoding, &handler) != XML_ERR_OK)
        return;
    buf = xmlAllocOutputBuffer(handler);
    if (buf == NULL) {
        xmlCharEncCloseFunc(handler);
  return;
    }

    htmlDocContentDumpFormatOutput(buf, cur, NULL, format);

    xmlOutputBufferFlush(buf);

    if (!buf->error) {
        if (buf->conv != NULL) {
            *size = xmlBufUse(buf->conv);
            *mem = xmlStrndup(xmlBufContent(buf->conv), *size);
        } else {
            *size = xmlBufUse(buf->buffer);
            *mem = xmlStrndup(xmlBufContent(buf->buffer), *size);
        }
    }

    xmlOutputBufferClose(buf);
}

/**
 * Same as #htmlDocDumpMemoryFormat with `format` set to 1 which
 * is typically undesired. Also see the warnings there. Use of
 * this function is DISCOURAGED in favor of
 * #htmlDocContentDumpFormatOutput.
 *
 * @param cur  the document
 * @param mem  OUT: the memory pointer
 * @param size  OUT: the memory length
 */
void
htmlDocDumpMemory(xmlDoc *cur, xmlChar**mem, int *size) {
    htmlDocDumpMemoryFormat(cur, mem, size, 1);
}


/************************************************************************
 *                  *
 *    Dumping HTML tree content to an I/O output buffer *
 *                  *
 ************************************************************************/

/**
 * Serialize the HTML document's DTD, if any.
 *
 * Ignores `encoding` and uses the encoding of the output buffer.
 *
 * @param buf  the HTML buffer output
 * @param doc  the document
 * @param encoding  the encoding string (unused)
 */
static void
htmlDtdDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
            const char *encoding ATTRIBUTE_UNUSED) {
    xmlDtdPtr cur = doc->intSubset;

    if (cur == NULL)
  return;
    xmlOutputBufferWrite(buf, 10, "<!DOCTYPE ");
    xmlOutputBufferWriteString(buf, (const char *)cur->name);
    if (cur->ExternalID != NULL) {
  xmlOutputBufferWrite(buf, 8, " PUBLIC ");
  xmlOutputBufferWriteQuotedString(buf, cur->ExternalID);
  if (cur->SystemID != NULL) {
      xmlOutputBufferWrite(buf, 1, " ");
      xmlOutputBufferWriteQuotedString(buf, cur->SystemID);
  }
    } else if (cur->SystemID != NULL &&
         xmlStrcmp(cur->SystemID, BAD_CAST "about:legacy-compat")) {
  xmlOutputBufferWrite(buf, 8, " SYSTEM ");
  xmlOutputBufferWriteQuotedString(buf, cur->SystemID);
    }
    xmlOutputBufferWrite(buf, 2, ">\n");
}

static void
htmlSerializeUri(xmlOutputBufferPtr buf, const xmlChar *content) {
    const xmlChar *tmp = content;

    /*
     * See appendix "B.2.1 Non-ASCII characters in URI attribute
     * values" in the HTML 4.01 spec. This is also recommended
     * by the HTML output method of the XSLT 1.0 spec.
     *
     * We also escape space and control chars.
     */

    /* Skip over initial whitespace */
    while (IS_WS_HTML(*tmp)) tmp++;
    if (tmp > content) {
        xmlOutputBufferWrite(buf, tmp - content, (char *) content);
        content = tmp;
    }

    while (1) {
        char escbuf[3];
        const char *repl;
        int replSize;
        int c = *tmp;

        while ((c > 0x20) && (c < 0x7F) && (c != '"') && (c != '&')) {
            tmp += 1;
            c = *tmp;
        }

        if (tmp > content)
            xmlOutputBufferWrite(buf, tmp - content, (char *) content);

        if ((c <= 0x20) || (c >= 0x7F)) {
            static const char hex[16] = {
                '0', '1', '2', '3', '4', '5', '6', '7',
                '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
            };

            if (c == 0)
                break;

            escbuf[0] = '%';
            escbuf[1] = hex[(c >> 4) & 0x0F];
            escbuf[2] = hex[c & 0x0F];
            repl = escbuf;
            replSize = 3;
        } else if (c == '"') {
            repl = "&quot;";
            replSize = 6;
        } else {
            repl = "&amp;";
            replSize = 5;
        }

        xmlOutputBufferWrite(buf, replSize, repl);
        tmp += 1;
        content = tmp;
    }
}

/**
 * Serialize an HTML attribute.
 *
 * @param buf  the HTML buffer output
 * @param cur  the attribute pointer
 */
static void
htmlAttrDumpOutput(xmlOutputBufferPtr buf, xmlAttrPtr cur) {
    xmlOutputBufferWrite(buf, 1, " ");

    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
        xmlOutputBufferWrite(buf, 1, ":");
    }
    xmlOutputBufferWriteString(buf, (const char *)cur->name);

    /*
     * The HTML5 spec requires to always serialize empty attribute
     * values as `=""`. We should probably align with HTML5 at some
     * point.
     */
    if ((cur->children != NULL) && (!htmlIsBooleanAttr(cur->name))) {
        xmlNodePtr child;
        int isUri;

        xmlOutputBufferWrite(buf, 2, "=\"");

        /*
         * Special handling of URIs doesn't conform to HTML5 and
         * should probably be removed at some point.
         */
        isUri = (cur->ns == NULL) && (cur->parent != NULL) &&
                (cur->parent->ns == NULL) &&
                ((!xmlStrcasecmp(cur->name, BAD_CAST "href")) ||
                 (!xmlStrcasecmp(cur->name, BAD_CAST "action")) ||
                 (!xmlStrcasecmp(cur->name, BAD_CAST "src")) ||
                 ((!xmlStrcasecmp(cur->name, BAD_CAST "name")) &&
                  (!xmlStrcasecmp(cur->parent->name, BAD_CAST "a"))));

        for (child = cur->children; child != NULL; child = child->next) {
            if (child->type == XML_TEXT_NODE) {
                const xmlChar *content = child->content;

                if (content == NULL)
                    continue;

                if (isUri) {
                    htmlSerializeUri(buf, content);
                } else {
                    xmlSerializeText(buf, content, SIZE_MAX,
                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
                }
            } else if (child->type == XML_ENTITY_REF_NODE) {
                /* TODO: We should probably expand entity refs */
                xmlOutputBufferWrite(buf, 1, "&");
                xmlOutputBufferWriteString(buf, (char *) child->name);
                xmlOutputBufferWrite(buf, 1, ";");
            }
        }

        xmlOutputBufferWrite(buf, 1, "\"");
    }
}

/**
 * Serialize an HTML node to an output buffer.
 *
 * If `encoding` is specified, it is used to create or update meta
 * tags containing the character encoding.
 *
 * @param buf  the HTML buffer output
 * @param cur  the current node
 * @param encoding  the encoding string (optional)
 * @param format  should formatting newlines been added
 */
void
htmlNodeDumpInternal(xmlOutputBuffer *buf, xmlNode *cur,
                     const char *encoding, int format) {
    xmlNodePtr root, parent, metaHead = NULL;
    xmlAttrPtr attr;
    const htmlElemDesc * info;
    int isRaw = 0;

    xmlInitParser();

    if ((cur == NULL) || (buf == NULL)) {
  return;
    }

    root = cur;
    parent = cur->parent;
    while (1) {
        switch (cur->type) {
        case XML_HTML_DOCUMENT_NODE:
        case XML_DOCUMENT_NODE:
            if (((xmlDocPtr) cur)->intSubset != NULL) {
                htmlDtdDumpOutput(buf, (xmlDocPtr) cur, NULL);
            }
            if (cur->children != NULL) {
                /* Always validate cur->parent when descending. */
                if (cur->parent == parent) {
                    parent = cur;
                    cur = cur->children;
                    continue;
                }
            } else {
                xmlOutputBufferWrite(buf, 1, "\n");
            }
            break;

        case XML_ELEMENT_NODE: {
            htmlMetaEncoding menc;
            int isMeta = 0;
            int addMeta = 0;

            /*
             * Some users like lxml are known to pass nodes with a corrupted
             * tree structure. Fall back to a recursive call to handle this
             * case.
             */
            if ((cur->parent != parent) && (cur->children != NULL)) {
                htmlNodeDumpInternal(buf, cur, encoding, format);
                break;
            }

            /*
             * Get specific HTML info for that node.
             */
            if (cur->ns == NULL)
                info = htmlTagLookup(cur->name);
            else
                info = NULL;

            if (encoding != NULL) {
                isMeta = htmlParseMetaEncoding(cur, &menc);

                /*
                 * Don't add meta tag for "HTML" encoding.
                 */
                if ((xmlStrcasecmp(BAD_CAST encoding,
                                   BAD_CAST "HTML") != 0) &&
                    (xmlStrcasecmp(cur->name, BAD_CAST "head") == 0) &&
                    (parent != NULL) &&
                    (xmlStrcasecmp(parent->name, BAD_CAST "html") == 0) &&
                    (parent->parent != NULL) &&
                    (parent->parent->parent == NULL) &&
                    (metaHead == NULL)) {
                    xmlNodePtr n;

                    metaHead = cur;
                    addMeta = 1;

                    for (n = cur->children; n != NULL; n = n->next) {
                        int unused;

                        if (htmlFindMetaEncodingAttr(n, &unused) != NULL) {
                            metaHead = NULL;
                            addMeta = 0;
                            break;
                        }
                    }
                }
            }

            xmlOutputBufferWrite(buf, 1, "<");
            if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
                xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
                xmlOutputBufferWrite(buf, 1, ":");
            }
            xmlOutputBufferWriteString(buf, (const char *)cur->name);
            if (cur->nsDef)
                xmlNsListDumpOutput(buf, cur->nsDef);
            attr = cur->properties;
            while (attr != NULL) {
                if ((!isMeta) || (attr != menc.attr)) {
                    htmlAttrDumpOutput(buf, attr);
                } else {
                    xmlOutputBufferWrite(buf, 1, " ");
                    xmlOutputBufferWriteString(buf, (char *) attr->name);

                    xmlOutputBufferWrite(buf, 2, "=\"");
                    xmlSerializeText(buf, menc.attrValue, menc.off.start,
                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
                    xmlSerializeText(buf, BAD_CAST encoding, SIZE_MAX,
                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
                    xmlSerializeText(buf, menc.attrValue + menc.off.end,
                                     menc.off.size - menc.off.end,
                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
                    xmlOutputBufferWrite(buf, 1, "\"");
                }
                attr = attr->next;
            }

            if ((info != NULL) && (info->empty)) {
                xmlOutputBufferWrite(buf, 1, ">");
            } else if (cur->children == NULL) {
                if (addMeta) {
                    xmlOutputBufferWrite(buf, 16, "><meta charset=\"");
                    xmlSerializeText(buf, BAD_CAST encoding, SIZE_MAX,
                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
                    xmlOutputBufferWrite(buf, 4, "\"></");
                } else {
                    xmlOutputBufferWrite(buf, 3, "></");
                }
                if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
                    xmlOutputBufferWriteString(buf,
                            (const char *)cur->ns->prefix);
                    xmlOutputBufferWrite(buf, 1, ":");
                }
                xmlOutputBufferWriteString(buf, (const char *)cur->name);
                xmlOutputBufferWrite(buf, 1, ">");
            } else {
                xmlOutputBufferWrite(buf, 1, ">");
                if ((format) &&
                    ((addMeta) ||
                     ((info != NULL) && (!info->isinline) &&
                      (cur->children->type != HTML_TEXT_NODE) &&
                      (cur->children->type != HTML_ENTITY_REF_NODE) &&
                      (cur->children != cur->last) &&
                      (cur->name != NULL) &&
                      (cur->name[0] != 'p')))) /* p, pre, param */
                    xmlOutputBufferWrite(buf, 1, "\n");
                if (addMeta) {
                    xmlOutputBufferWrite(buf, 15, "<meta charset=\"");
                    xmlSerializeText(buf, BAD_CAST encoding, SIZE_MAX,
                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
                    xmlOutputBufferWrite(buf, 2, "\">");
                    if ((format) &&
                        (cur->children->type != HTML_TEXT_NODE) &&
                        (cur->children->type != HTML_ENTITY_REF_NODE))
                        xmlOutputBufferWrite(buf, 1, "\n");
                }

                if ((info != NULL) && (info->dataMode >= DATA_RAWTEXT))
                    isRaw = 1;

                parent = cur;
                cur = cur->children;
                continue;
            }

            if ((format) && (cur->next != NULL) &&
                (info != NULL) && (!info->isinline)) {
                if ((cur->next->type != HTML_TEXT_NODE) &&
                    (cur->next->type != HTML_ENTITY_REF_NODE) &&
                    (parent != NULL) &&
                    (parent->name != NULL) &&
                    (parent->name[0] != 'p')) /* p, pre, param */
                    xmlOutputBufferWrite(buf, 1, "\n");
            }

            break;
        }

        case XML_ATTRIBUTE_NODE:
            htmlAttrDumpOutput(buf, (xmlAttrPtr) cur);
            break;

        case HTML_TEXT_NODE:
            if (cur->content == NULL)
                break;
            if ((cur->name == (const xmlChar *)xmlStringTextNoenc) ||
                (isRaw)) {
                xmlOutputBufferWriteString(buf, (const char *)cur->content);
            } else {
                xmlSerializeText(buf, cur->content, SIZE_MAX, XML_ESCAPE_HTML);
            }
            break;

        case HTML_COMMENT_NODE:
            if (cur->content != NULL) {
                xmlOutputBufferWrite(buf, 4, "<!--");
                xmlOutputBufferWriteString(buf, (const char *)cur->content);
                xmlOutputBufferWrite(buf, 3, "-->");
            }
            break;

        case HTML_PI_NODE:
            if (cur->name != NULL) {
                xmlOutputBufferWrite(buf, 2, "<?");
                xmlOutputBufferWriteString(buf, (const char *)cur->name);
                if (cur->content != NULL) {
                    xmlOutputBufferWrite(buf, 1, " ");
                    xmlOutputBufferWriteString(buf,
                            (const char *)cur->content);
                }
                xmlOutputBufferWrite(buf, 1, ">");
            }
            break;

        case HTML_ENTITY_REF_NODE:
            xmlOutputBufferWrite(buf, 1, "&");
            xmlOutputBufferWriteString(buf, (const char *)cur->name);
            xmlOutputBufferWrite(buf, 1, ";");
            break;

        case HTML_PRESERVE_NODE:
            if (cur->content != NULL) {
                xmlOutputBufferWriteString(buf, (const char *)cur->content);
            }
            break;

        default:
            break;
        }

        while (1) {
            if (cur == root)
                return;
            if (cur->next != NULL) {
                cur = cur->next;
                break;
            }

            isRaw = 0;

            cur = parent;
            /* cur->parent was validated when descending. */
            parent = cur->parent;

            if ((cur->type == XML_HTML_DOCUMENT_NODE) ||
                (cur->type == XML_DOCUMENT_NODE)) {
                xmlOutputBufferWrite(buf, 1, "\n");
            } else {
                if ((format) && (cur->ns == NULL))
                    info = htmlTagLookup(cur->name);
                else
                    info = NULL;

                if ((format) && (info != NULL) && (!info->isinline) &&
                    (cur->last->type != HTML_TEXT_NODE) &&
                    (cur->last->type != HTML_ENTITY_REF_NODE) &&
                    ((cur->children != cur->last) || (cur == metaHead)) &&
                    (cur->name != NULL) &&
                    (cur->name[0] != 'p')) /* p, pre, param */
                    xmlOutputBufferWrite(buf, 1, "\n");

                xmlOutputBufferWrite(buf, 2, "</");
                if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
                    xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
                    xmlOutputBufferWrite(buf, 1, ":");
                }
                xmlOutputBufferWriteString(buf, (const char *)cur->name);
                xmlOutputBufferWrite(buf, 1, ">");

                if ((format) && (info != NULL) && (!info->isinline) &&
                    (cur->next != NULL)) {
                    if ((cur->next->type != HTML_TEXT_NODE) &&
                        (cur->next->type != HTML_ENTITY_REF_NODE) &&
                        (parent != NULL) &&
                        (parent->name != NULL) &&
                        (parent->name[0] != 'p')) /* p, pre, param */
                        xmlOutputBufferWrite(buf, 1, "\n");
                }

                if (cur == metaHead)
                    metaHead = NULL;
            }
        }
    }
}

/**
 * Serialize an HTML node to an output buffer.
 *
 * @param buf  the HTML buffer output
 * @param doc  the document (unused)
 * @param cur  the current node
 * @param encoding  the encoding string (unused)
 * @param format  should formatting newlines been added
 */
void
htmlNodeDumpFormatOutput(xmlOutputBuffer *buf,
                         xmlDoc *doc ATTRIBUTE_UNUSED, xmlNode *cur,
                         const char *encoding ATTRIBUTE_UNUSED, int format) {
    htmlNodeDumpInternal(buf, cur, NULL, format);
}

/**
 * Same as #htmlNodeDumpFormatOutput with `format` set to 1 which is
 * typically undesired. Use of this function is DISCOURAGED in favor
 * of #htmlNodeDumpFormatOutput.
 *
 * @param buf  the HTML buffer output
 * @param doc  the document (unused)
 * @param cur  the current node
 * @param encoding  the encoding string (unused)
 */
void
htmlNodeDumpOutput(xmlOutputBuffer *buf, xmlDoc *doc ATTRIBUTE_UNUSED,
                   xmlNode *cur, const char *encoding ATTRIBUTE_UNUSED) {
    htmlNodeDumpInternal(buf, cur, NULL, 1);
}

/**
 * Serialize an HTML document to an output buffer.
 *
 * @param buf  the HTML buffer output
 * @param cur  the document
 * @param encoding  the encoding string (unused)
 * @param format  should formatting newlines been added
 */
void
htmlDocContentDumpFormatOutput(xmlOutputBuffer *buf, xmlDoc *cur,
                         const char *encoding ATTRIBUTE_UNUSED,
                               int format) {
    htmlNodeDumpInternal(buf, (xmlNodePtr) cur, NULL, format);
}

/**
 * Same as #htmlDocContentDumpFormatOutput with `format` set to 1
 * which is typically undesired. Use of this function is DISCOURAGED
 * in favor of #htmlDocContentDumpFormatOutput.
 *
 * @param buf  the HTML buffer output
 * @param cur  the document
 * @param encoding  the encoding string (unused)
 */
void
htmlDocContentDumpOutput(xmlOutputBuffer *buf, xmlDoc *cur,
                   const char *encoding ATTRIBUTE_UNUSED) {
    htmlNodeDumpInternal(buf, (xmlNodePtr) cur, NULL, 1);
}

/************************************************************************
 *                  *
 *    Saving functions front-ends       *
 *                  *
 ************************************************************************/

/**
 * Serialize an HTML document to an open `FILE`.
 *
 * Uses the encoding of the document. If the document has no
 * encoding, ASCII with HTML 4.0 named character entities will
 * be used. This is inefficient compared to UTF-8 and might be
 * changed in a future version.
 *
 * Enables "formatting" unconditionally which is typically
 * undesired.
 *
 * Use of this function is DISCOURAGED in favor of
 * #htmlNodeDumpFileFormat.
 *
 * @param f  the FILE*
 * @param cur  the document
 * @returns the number of bytes written or -1 in case of failure.
 */
int
htmlDocDump(FILE *f, xmlDoc *cur) {
    xmlOutputBufferPtr buf;
    xmlCharEncodingHandlerPtr handler = NULL;
    int ret;

    xmlInitParser();

    if ((cur == NULL) || (f == NULL)) {
  return(-1);
    }

    if (htmlFindOutputEncoder((char *) cur->encoding, &handler) != XML_ERR_OK)
        return(-1);
    buf = xmlOutputBufferCreateFile(f, handler);
    if (buf == NULL) {
        xmlCharEncCloseFunc(handler);
        return(-1);
    }
    htmlDocContentDumpOutput(buf, cur, NULL);

    ret = xmlOutputBufferClose(buf);
    return(ret);
}

/**
 * Serialize an HTML document to a file.
 *
 * Same as #htmlSaveFileFormat with `encoding` set to NULL and
 * `format` set to 1 which is typically undesired.
 *
 * Use of this function is DISCOURAGED in favor of
 * #htmlSaveFileFormat.
 *
 * @param filename  the filename (or URL)
 * @param cur  the document
 * @returns the number of bytes written or -1 in case of failure.
 */
int
htmlSaveFile(const char *filename, xmlDoc *cur) {
    return(htmlSaveFileFormat(filename, cur, NULL, 1));
}

/**
 * Serialize an HTML document to a file using a given encoding.
 *
 * If `filename` is `"-"`, stdout is used. This is potentially
 * insecure and might be changed in a future version.
 *
 * If encoding is NULL, ASCII with HTML 4.0 named character entities
 * will be used. This is inefficient compared to UTF-8 and might be
 * changed in a future version.
 *
 * Sets or updates meta tags containing the character encoding.
 *
 * @param filename  the filename
 * @param cur  the document
 * @param format  should formatting newlines been added
 * @param encoding  the document encoding (optional)
 * @returns the number of bytes written or -1 in case of failure.
 */
int
htmlSaveFileFormat(const char *filename, xmlDoc *cur,
             const char *encoding, int format) {
    xmlOutputBufferPtr buf;
    xmlCharEncodingHandlerPtr handler = NULL;
    int ret;

    if ((cur == NULL) || (filename == NULL))
        return(-1);

    xmlInitParser();

    if (htmlFindOutputEncoder(encoding, &handler) != XML_ERR_OK)
        return(-1);

    /*
     * save the content to a temp buffer.
     */
    buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
    if (buf == NULL) {
        xmlCharEncCloseFunc(handler);
        return(0);
    }

    htmlDocContentDumpFormatOutput(buf, cur, encoding, format);

    ret = xmlOutputBufferClose(buf);
    return(ret);
}

/**
 * Serialize an HTML document to a file.
 *
 * Same as #htmlSaveFileFormat with `format` set to 1 which is
 * typically undesired. Also see the warnings there. Use of this
 * function is DISCOURAGED in favor of #htmlSaveFileFormat.
 *
 * @param filename  the filename
 * @param cur  the document
 * @param encoding  the document encoding
 * @returns the number of bytes written or -1 in case of failure.
 */
int
htmlSaveFileEnc(const char *filename, xmlDoc *cur, const char *encoding) {
    return(htmlSaveFileFormat(filename, cur, encoding, 1));
}

#endif /* LIBXML_OUTPUT_ENABLED */

#endif /* LIBXML_HTML_ENABLED */

Coverage Report

Created: 2025-07-18 06:55