document.cpp

Go to the documentation of this file.

/*******************************************************************************
 *
 * Copyright (c) 2000-2003 Intel Corporation
 * All rights reserved.
 * Copyright (c) 2012 France Telecom All rights reserved.
 * Copyright (C) 2022 GPL 3 and higher by Ingo Höft,  <Ingo@Hoeft-online.de>
 * Redistribution only with this Copyright remark. Last modified: 2026-03-31
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * - Neither name of Intel Corporation nor the names of its contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 ******************************************************************************/
// Last compare with ./Pupnp source file, based on 2026-03-16, ver 1.14.30
 
#include <ixml/ixmldebug.hpp>
#include <ixml/ixmlparser.hpp>
 
#include <cstring>
 
void ixmlDocument_init(IXML_Document* doc) {
    memset(doc, 0, sizeof(IXML_Document));
}
 
void ixmlDocument_free(IXML_Document* doc) {
    if (doc) {
        ixmlNode_free((IXML_Node*)doc);
    }
}
 
static void ixmlDocument_setOwnerDocument(
    IXML_Document* doc,
    IXML_Node* nodeptr) {
    if (nodeptr) {
        nodeptr->ownerDocument = doc;
        ixmlDocument_setOwnerDocument(doc, ixmlNode_getFirstChild(nodeptr));
        ixmlDocument_setOwnerDocument(doc, ixmlNode_getNextSibling(nodeptr));
    }
}
 
int ixmlDocument_importNode(IXML_Document* doc, IXML_Node* importNode, int deep,
                            IXML_Node** rtNode) {
    unsigned short nodeType;
    IXML_Node* newNode;
 
    *rtNode = NULL;
 
    if (!doc || !importNode) {
        return IXML_INVALID_PARAMETER;
    }
 
    nodeType = ixmlNode_getNodeType(importNode);
    if (nodeType == eDOCUMENT_NODE) {
        return IXML_NOT_SUPPORTED_ERR;
    }
 
    newNode = ixmlNode_cloneNode(importNode, deep);
    if (!newNode) {
        return IXML_FAILED;
    }
 
    ixmlDocument_setOwnerDocument(doc, newNode);
    *rtNode = newNode;
 
    return IXML_SUCCESS;
}
 
int ixmlDocument_createElementEx(IXML_Document* doc, const DOMString tagName,
                                 IXML_Element** rtElement) {
    int errCode = IXML_SUCCESS;
    IXML_Element* newElement = NULL;
 
    if (!doc || !tagName) {
        errCode = IXML_INVALID_PARAMETER;
        goto ErrorHandler;
    }
 
    newElement = (IXML_Element*)malloc(sizeof(IXML_Element));
    if (!newElement) {
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
 
    ixmlElement_init(newElement);
    newElement->tagName = strdup(tagName);
    if (!newElement->tagName) {
        ixmlElement_free(newElement);
        newElement = NULL;
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
    /* set the node fields */
    newElement->n.nodeType = eELEMENT_NODE;
    newElement->n.nodeName = strdup(tagName);
    if (!newElement->n.nodeName) {
        free(newElement->tagName);
        ixmlElement_free(newElement);
        newElement = NULL;
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
 
    newElement->n.ownerDocument = doc;
 
ErrorHandler:
    *rtElement = newElement;
 
    return errCode;
}
 
IXML_Element* ixmlDocument_createElement(IXML_Document* doc,
                                         const DOMString tagName) {
    IXML_Element* newElement = NULL;
    int ret = IXML_SUCCESS;
 
    ret = ixmlDocument_createElementEx(doc, tagName, &newElement);
    if (ret != IXML_SUCCESS) {
        IxmlPrintf(__FILE__, __LINE__, "ixmlDocument_createElement",
                   "Error %d\n", ret);
        return NULL;
    }
    return newElement;
}
 
int ixmlDocument_createDocumentEx(IXML_Document** rtDoc) {
    IXML_Document* doc;
    int errCode = IXML_SUCCESS;
 
    doc = NULL;
    doc = (IXML_Document*)malloc(sizeof(IXML_Document));
    if (!doc) {
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
 
    ixmlDocument_init(doc);
 
    doc->n.nodeName = strdup((const char*)DOCUMENTNODENAME);
    if (!doc->n.nodeName) {
        ixmlDocument_free(doc);
        doc = NULL;
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
 
    doc->n.nodeType = eDOCUMENT_NODE;
    doc->n.ownerDocument = doc;
 
ErrorHandler:
    /* doc is NULL on failure */
    *rtDoc = doc;
    return errCode;
}
 
IXML_Document* ixmlDocument_createDocument(void) {
    IXML_Document* doc = NULL;
 
    ixmlDocument_createDocumentEx(&doc);
 
    return doc;
}
 
int ixmlDocument_createTextNodeEx(IXML_Document* doc, const DOMString data,
                                  IXML_Node** textNode) {
    IXML_Node* returnNode;
    int rc = IXML_SUCCESS;
 
    returnNode = NULL;
    if (!doc || !data) {
        rc = IXML_INVALID_PARAMETER;
        goto ErrorHandler;
    }
 
    returnNode = (IXML_Node*)malloc(sizeof(IXML_Node));
    if (!returnNode) {
        rc = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
    /* initialize the node */
    ixmlNode_init(returnNode);
 
    returnNode->nodeName = strdup((const char*)TEXTNODENAME);
    if (!returnNode->nodeName) {
        ixmlNode_free(returnNode);
        returnNode = NULL;
        rc = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
    /* add in node value */
    if (data) {
        returnNode->nodeValue = strdup(data);
        if (!returnNode->nodeValue) {
            ixmlNode_free(returnNode);
            returnNode = NULL;
            rc = IXML_INSUFFICIENT_MEMORY;
            goto ErrorHandler;
        }
    }
 
    returnNode->nodeType = eTEXT_NODE;
    returnNode->ownerDocument = doc;
 
ErrorHandler:
    *textNode = returnNode;
    return rc;
}
 
IXML_Node* ixmlDocument_createTextNode(IXML_Document* doc,
                                       const DOMString data) {
    IXML_Node* returnNode = NULL;
 
    ixmlDocument_createTextNodeEx(doc, data, &returnNode);
 
    return returnNode;
}
 
int ixmlDocument_createAttributeEx(IXML_Document* doc, const DOMString name,
                                   IXML_Attr** rtAttr) {
    int errCode = IXML_SUCCESS;
    IXML_Attr* attrNode = NULL;
 
    if (!doc || !name) {
        errCode = IXML_INVALID_PARAMETER;
        goto ErrorHandler;
    }
    attrNode = (IXML_Attr*)malloc(sizeof(IXML_Attr));
    if (!attrNode) {
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
    ixmlAttr_init(attrNode);
    attrNode->n.nodeType = eATTRIBUTE_NODE;
    /* set the node fields */
    attrNode->n.nodeName = strdup(name);
    if (!attrNode->n.nodeName) {
        ixmlAttr_free(attrNode);
        attrNode = NULL;
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
    attrNode->n.ownerDocument = doc;
 
ErrorHandler:
    *rtAttr = attrNode;
    return errCode;
}
 
IXML_Attr* ixmlDocument_createAttribute(IXML_Document* doc,
                                        const DOMString name) {
    IXML_Attr* attrNode = NULL;
 
    if (ixmlDocument_createAttributeEx(doc, name, &attrNode) != IXML_SUCCESS)
        return NULL;
 
    return attrNode;
}
 
int ixmlDocument_createAttributeNSEx(IXML_Document* doc,
                                     const DOMString namespaceURI,
                                     const DOMString qualifiedName,
                                     IXML_Attr** rtAttr) {
    int errCode = IXML_SUCCESS;
    IXML_Attr* attrNode = NULL;
 
    if (!doc || !namespaceURI || !qualifiedName) {
        errCode = IXML_INVALID_PARAMETER;
        goto ErrorHandler;
    }
 
    errCode = ixmlDocument_createAttributeEx(doc, qualifiedName, &attrNode);
    if (errCode != IXML_SUCCESS) {
        goto ErrorHandler;
    }
    /* set the namespaceURI field */
    attrNode->n.namespaceURI = strdup(namespaceURI);
    if (!attrNode->n.namespaceURI) {
        ixmlAttr_free(attrNode);
        attrNode = NULL;
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
    /* set the localName and prefix */
    errCode = ixmlNode_setNodeName((IXML_Node*)attrNode, qualifiedName);
    if (errCode != IXML_SUCCESS) {
        ixmlAttr_free(attrNode);
        attrNode = NULL;
        goto ErrorHandler;
    }
 
ErrorHandler:
    *rtAttr = attrNode;
    return errCode;
}
 
IXML_Attr* ixmlDocument_createAttributeNS(IXML_Document* doc,
                                          const DOMString namespaceURI,
                                          const DOMString qualifiedName) {
    IXML_Attr* attrNode = NULL;
 
    ixmlDocument_createAttributeNSEx(doc, namespaceURI, qualifiedName,
                                     &attrNode);
 
    return attrNode;
}
 
int ixmlDocument_createCDATASectionEx(IXML_Document* doc, const DOMString data,
                                      IXML_CDATASection** rtCD) {
    int errCode = IXML_SUCCESS;
    IXML_CDATASection* cDSectionNode = NULL;
 
    if (!doc || !data) {
        errCode = IXML_INVALID_PARAMETER;
        goto ErrorHandler;
    }
 
    cDSectionNode = (IXML_CDATASection*)malloc(sizeof(IXML_CDATASection));
    if (!cDSectionNode) {
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
 
    ixmlCDATASection_init(cDSectionNode);
    cDSectionNode->n.nodeType = eCDATA_SECTION_NODE;
    cDSectionNode->n.nodeName = strdup((const char*)CDATANODENAME);
    if (!cDSectionNode->n.nodeName) {
        ixmlCDATASection_free(cDSectionNode);
        cDSectionNode = NULL;
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
 
    cDSectionNode->n.nodeValue = strdup(data);
    if (!cDSectionNode->n.nodeValue) {
        ixmlCDATASection_free(cDSectionNode);
        cDSectionNode = NULL;
        errCode = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
 
    cDSectionNode->n.ownerDocument = doc;
 
ErrorHandler:
    *rtCD = cDSectionNode;
    return errCode;
}
 
IXML_CDATASection* ixmlDocument_createCDATASection(IXML_Document* doc,
                                                   const DOMString data) {
    IXML_CDATASection* cDSectionNode = NULL;
 
    ixmlDocument_createCDATASectionEx(doc, data, &cDSectionNode);
 
    return cDSectionNode;
}
 
int ixmlDocument_createElementNSEx(IXML_Document* doc,
                                   const DOMString namespaceURI,
                                   const DOMString qualifiedName,
                                   IXML_Element** rtElement) {
    IXML_Element* newElement = NULL;
    int ret = IXML_SUCCESS;
    int line = 0;
 
    if (!doc || !namespaceURI || !qualifiedName) {
        line = __LINE__;
        ret = IXML_INVALID_PARAMETER;
        goto ErrorHandler;
    }
 
    ret = ixmlDocument_createElementEx(doc, qualifiedName, &newElement);
    if (ret != IXML_SUCCESS) {
        line = __LINE__;
        goto ErrorHandler;
    }
    /* set the namespaceURI field */
    newElement->n.namespaceURI = strdup(namespaceURI);
    if (!newElement->n.namespaceURI) {
        line = __LINE__;
        ixmlElement_free(newElement);
        newElement = NULL;
        ret = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
    /* set the localName and prefix */
    ret = ixmlNode_setNodeName((IXML_Node*)newElement, qualifiedName);
    if (ret != IXML_SUCCESS) {
        line = __LINE__;
        ixmlElement_free(newElement);
        newElement = NULL;
        ret = IXML_INSUFFICIENT_MEMORY;
        goto ErrorHandler;
    }
 
    newElement->n.nodeValue = NULL;
 
ErrorHandler:
    *rtElement = newElement;
    if (ret != IXML_SUCCESS) {
        IxmlPrintf(__FILE__, line, "ixmlDocument_createElementNSEx",
                   "Error %d\n", ret);
    }
 
    return ret;
}
 
IXML_Element* ixmlDocument_createElementNS(IXML_Document* doc,
                                           const DOMString namespaceURI,
                                           const DOMString qualifiedName) {
    IXML_Element* newElement = NULL;
 
    ixmlDocument_createElementNSEx(doc, namespaceURI, qualifiedName,
                                   &newElement);
 
    return newElement;
}
 
IXML_NodeList* ixmlDocument_getElementsByTagName(IXML_Document* doc,
                                                 const DOMString tagName) {
    IXML_NodeList* returnNodeList = NULL;
 
    if (!doc || !tagName) {
        return NULL;
    }
 
    ixmlNode_getElementsByTagName((IXML_Node*)doc, tagName, &returnNodeList);
 
    return returnNodeList;
}
 
IXML_NodeList* ixmlDocument_getElementsByTagNameNS(IXML_Document* doc,
                                                   const DOMString namespaceURI,
                                                   const DOMString localName) {
    IXML_NodeList* returnNodeList = NULL;
 
    if (!doc || !namespaceURI || !localName) {
        return NULL;
    }
 
    ixmlNode_getElementsByTagNameNS((IXML_Node*)doc, namespaceURI, localName,
                                    &returnNodeList);
 
    return returnNodeList;
}
 
IXML_Element* ixmlDocument_getElementById(IXML_Document* doc,
                                          const DOMString tagName) {
    IXML_Element* rtElement = NULL;
    IXML_Node* nodeptr = (IXML_Node*)doc;
    const char* name;
 
    if (!nodeptr || !tagName) {
        return rtElement;
    }
 
    if (ixmlNode_getNodeType(nodeptr) == eELEMENT_NODE) {
        name = ixmlNode_getNodeName(nodeptr);
        if (!name) {
            return rtElement;
        }
 
        if (strcmp(tagName, name) == 0) {
            rtElement = (IXML_Element*)nodeptr;
            return rtElement;
        } else {
            rtElement = ixmlDocument_getElementById(
                (IXML_Document*)ixmlNode_getFirstChild(nodeptr), tagName);
            if (!rtElement) {
                rtElement = ixmlDocument_getElementById(
                    (IXML_Document*)ixmlNode_getNextSibling(nodeptr), tagName);
            }
        }
    } else {
        rtElement = ixmlDocument_getElementById(
            (IXML_Document*)ixmlNode_getFirstChild(nodeptr), tagName);
        if (!rtElement) {
            rtElement = ixmlDocument_getElementById(
                (IXML_Document*)ixmlNode_getNextSibling(nodeptr), tagName);
        }
    }
 
    return rtElement;
}