Beispiel #1
0
WBXML_DECLARE(void) wbxml_tree_node_destroy(WBXMLTreeNode *node)
{
    if (node == NULL)
        return;

    wbxml_tag_destroy(node->name);
    wbxml_list_destroy(node->attrs, wbxml_attribute_destroy_item);
    wbxml_buffer_destroy(node->content);
    wbxml_tree_destroy(node->tree);

    wbxml_free(node);
}
Beispiel #2
0
WBXML_DECLARE_NONSTD(void) wbxml_buffer_destroy_item(void *buff)
{
    wbxml_buffer_destroy((WBXMLBuffer *) buff);
}
void wbxml_tree_clb_xml_end_element(void           *ctx,
                                    const XML_Char *localName)
{
    WBXMLTreeClbCtx *tree_ctx = (WBXMLTreeClbCtx *) ctx;
    WBXMLBuffer *content = NULL;
    WBXMLTreeNode *node = NULL;
    WBXMLError ret = WBXML_OK;

    WBXML_DEBUG((WBXML_PARSER, "Expat element end callback ('%s')", localName));

    /* If the node is flagged as binary node
     * then the data is base64 encoded in the XML document
     * and the data must be decoded in one step.
     * Examples: Microsoft ActiveSync tags ConversationId or MIME
     */

    node = tree_ctx->current;
    if (node && node->type == WBXML_TREE_ELEMENT_NODE &&
            node->name->type == WBXML_VALUE_TOKEN &&
            node->name->u.token->options & WBXML_TAG_OPTION_BINARY)
    {
        if (node->content == NULL)
        {
            WBXML_DEBUG((WBXML_PARSER, "    Binary tag: No content => no conversion!"));
        } else {
            WBXML_DEBUG((WBXML_PARSER, "    Binary tag: Convert base64 data"));
            ret = wbxml_buffer_decode_base64(node->content);
            if (ret != WBXML_OK)
            {
                WBXML_DEBUG((WBXML_PARSER, "    Binary tag: Base64 decoder failed!"));
                tree_ctx->error = ret;
            } else {
                /* Add the buffer as a regular string node (since libwbxml doesn't
                 * offer a way to specify an opaque data node). The WBXML
                 * encoder is responsible for generating correct opaque data for
                 * nodes like this.
                 */
                if (wbxml_tree_add_text(tree_ctx->tree,
                                        tree_ctx->current,
                                        (const WB_UTINY*)wbxml_buffer_get_cstr(node->content),
                                        wbxml_buffer_len(node->content)) == NULL)
                {
                    WBXML_DEBUG((WBXML_PARSER, "    Binary tag: Cannot add base64 decoded node!"));
                    tree_ctx->error = WBXML_ERROR_INTERNAL;
                }
            }
            /* safe cleanup */
            content = node->content;
            node->content = NULL;
            wbxml_buffer_destroy(content);
        }
    }

    if (tree_ctx->expat_utf16) {
        /** @todo Convert from UTF-16 to UTF-8 */
    }

    /* Check for Error */
    if (tree_ctx->error != WBXML_OK)
        return;

    /* Are we skipping a whole node ? */
    if (tree_ctx->skip_lvl > 0) {
        if (tree_ctx->skip_lvl == 1)
        {
            /* End of skipped node */

#if defined( WBXML_SUPPORT_SYNCML )
            if (WBXML_STRCMP(localName, "syncml:devinf:DevInf") == 0 ||
                    WBXML_STRCMP(localName, "syncml:dmddf1.2:MgmtTree") == 0) {
                /* definitions first ... or some compilers don't like it */
                WBXMLBuffer *embed_doc = NULL;
                WBXMLTree *tree = NULL;
                const WBXMLLangEntry *lang;

                /* Get embedded DevInf or DM DDF Document */
                embed_doc = wbxml_buffer_create(tree_ctx->input_buff + tree_ctx->skip_start,
                                                XML_GetCurrentByteIndex(tree_ctx->xml_parser) - tree_ctx->skip_start,
                                                XML_GetCurrentByteIndex(tree_ctx->xml_parser) - tree_ctx->skip_start + 10);
                if (embed_doc == NULL) {
                    tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
                    wbxml_buffer_destroy(embed_doc);
                    return;
                }

                if (tree_ctx->expat_utf16) {
                    /** @todo Convert from UTF-16 to UTF-8 */
                }

                /* Check Buffer Creation and add the closing tag */
                if ((WBXML_STRCMP(localName, "syncml:devinf:DevInf") == 0 &&
                        (!wbxml_buffer_append_cstr(embed_doc, "</DevInf>")))
                        ||
                        (WBXML_STRCMP(localName, "syncml:dmddf1.2:MgmtTree") == 0 &&
                         (!wbxml_buffer_append_cstr(embed_doc, "</MgmtTree>"))))
                {
                    tree_ctx->error = WBXML_ERROR_NOT_ENOUGH_MEMORY;
                    wbxml_buffer_destroy(embed_doc);
                    return;
                }

                /* Add doctype to give the XML parser a chance */
                if (WBXML_STRCMP(localName, "syncml:dmddf1.2:MgmtTree") == 0 &&
                        tree_ctx->tree->lang->langID != WBXML_LANG_SYNCML_SYNCML12)
                {
                    tree_ctx->error = WBXML_ERROR_UNKNOWN_XML_LANGUAGE;
                    wbxml_buffer_destroy(embed_doc);
                    return;
                }
                switch(tree_ctx->tree->lang->langID)
                {
                case WBXML_LANG_SYNCML_SYNCML10:
                    lang = wbxml_tables_get_table(WBXML_LANG_SYNCML_DEVINF10);
                    break;
                case WBXML_LANG_SYNCML_SYNCML11:
                    lang = wbxml_tables_get_table(WBXML_LANG_SYNCML_DEVINF11);
                    break;
                case WBXML_LANG_SYNCML_SYNCML12:
                    if (WBXML_STRCMP(localName, "syncml:dmddf1.2:MgmtTree") == 0) {
                        lang = wbxml_tables_get_table(WBXML_LANG_SYNCML_DMDDF12);
                    } else {
                        lang = wbxml_tables_get_table(WBXML_LANG_SYNCML_DEVINF12);
                    }
                    break;
                default:
                    tree_ctx->error = WBXML_ERROR_UNKNOWN_XML_LANGUAGE;
                    wbxml_buffer_destroy(embed_doc);
                    return;
                }

                assert (lang!= NULL);
                if (lang == NULL) {
                    tree_ctx->error = WBXML_ERROR_UNKNOWN_XML_LANGUAGE;
                    wbxml_buffer_destroy(embed_doc);
                    return;
                }

                /* DOCTYPE in reverse order */
                if (!wbxml_buffer_insert_cstr(embed_doc,(WB_UTINY *) "\">\n", 0) ||                     /* > */
                        !wbxml_buffer_insert_cstr(embed_doc, (WB_UTINY *) lang->publicID->xmlDTD, 0) ||      /* DTD */
                        !wbxml_buffer_insert_cstr(embed_doc, (WB_UTINY *) "\" \"", 0) ||                     /* DTD */
                        !wbxml_buffer_insert_cstr(embed_doc, (WB_UTINY *) lang->publicID->xmlPublicID, 0) || /* Public ID */
                        !wbxml_buffer_insert_cstr(embed_doc, (WB_UTINY *) " PUBLIC \"", 0) ||                /*  PUBLIC " */
                        !wbxml_buffer_insert_cstr(embed_doc, (WB_UTINY *) lang->publicID->xmlRootElt, 0) ||  /* Root Element */
                        !wbxml_buffer_insert_cstr(embed_doc, (WB_UTINY *) "<!DOCTYPE ", 0))                  /* <!DOCTYPE */
                {
                    tree_ctx->error = WBXML_ERROR_ENCODER_APPEND_DATA;
                    wbxml_buffer_destroy(embed_doc);
                    return;
                }

                WBXML_DEBUG((WBXML_PARSER, "\t Embedded Doc : '%s'", wbxml_buffer_get_cstr(embed_doc)));

                /* Parse 'DevInf' Document */
                if ((ret = wbxml_tree_from_xml(wbxml_buffer_get_cstr(embed_doc),
                                               wbxml_buffer_len(embed_doc),
                                               &tree)) != WBXML_OK)
                {
                    tree_ctx->error = ret;
                    wbxml_buffer_destroy(embed_doc);
                    return;
                }

                /* Add Tree Node */
                tree_ctx->current = wbxml_tree_add_tree(tree_ctx->tree,
                                                        tree_ctx->current,
                                                        tree);
                if (tree_ctx->current == NULL)
                {
                    tree_ctx->error = WBXML_ERROR_INTERNAL;
                    wbxml_tree_destroy(tree);
                    wbxml_buffer_destroy(embed_doc);
                    return;
                }

                /* Clean-up */
                wbxml_buffer_destroy(embed_doc);
                tree_ctx->skip_lvl = 0;
            }
#endif /* WBXML_SUPPORT_SYNCML */
        }
        else {
            tree_ctx->skip_lvl--;
            return;
        }
    }

    if (tree_ctx->current == NULL) {
        tree_ctx->error = WBXML_ERROR_INTERNAL;
        return;
    }

    if (tree_ctx->current->parent == NULL) {
        /* This must be the Root Element */
        if (tree_ctx->current != tree_ctx->tree->root) {
            tree_ctx->error = WBXML_ERROR_INTERNAL;
        }
    }
    else {
#if defined ( WBXML_SUPPORT_SYNCML )
        /* Have we added a missing CDATA section ?
         * If so, we assume that now that we have reached an end of Element,
         * the CDATA section ended, and so we go back to parent.
         */
        if ((tree_ctx->current != NULL) && (tree_ctx->current->type == WBXML_TREE_CDATA_NODE))
            tree_ctx->current = tree_ctx->current->parent;
#endif /* WBXML_SUPPORT_SYNCML */

        /* Go back one step upper in the tree */
        tree_ctx->current = tree_ctx->current->parent;
    }
}
Beispiel #4
0
/** @todo Rewrite this function (use wbxml_tree_node_* functions) */
WBXML_DECLARE(WB_BOOL) wbxml_tree_add_node(WBXMLTree *tree, WBXMLTreeNode *parent, WBXMLTreeNode *node)
{
    WBXMLTreeNode *tmp = NULL;

    if ((tree == NULL) || (node == NULL))
        return FALSE;

    /* Set parent to new node */
    node->parent = parent;    

    /* Check if this is the Root Element */
    if (parent != NULL) {
        /* This is not the Root Element... search for previous sibbling element */
        if (parent->children != NULL) {
            /* Add this Node to end of Sibbling Node list of Parent */
            tmp = parent->children;

            /* !!! WARNING !!!
             * EXPAT splits &lt;html&gt; into three separate text nodes.
             * Therefore it is necessary to scan for splitted text nodes and
             * join them to get consistent text nodes.
             */

            /* If the handled node is a text node and the last node is a text node
             * then the last node must be replace.
             * Otherwise the node will be appended.
             */
            while (tmp->next != NULL)
                tmp = tmp->next;

	    if (node->type == WBXML_TREE_TEXT_NODE &&
                tmp->type == WBXML_TREE_TEXT_NODE) {

                /* join the two text nodes and replace the present text node */
                if (!wbxml_buffer_append(tmp->content, node->content))
                    return FALSE;

		if (tmp->prev == NULL) {
                    /* tmp is first child */
                    parent->children = node;
                } else {
                    /* tmp is not first child */
                    tmp->prev->next = node;
                    node->prev = tmp->prev;
                }

                wbxml_buffer_destroy(node->content);
                node->content = tmp->content;
                tmp->content = NULL;
                wbxml_tree_node_destroy(tmp);
            } else {
                /* normal situation => append node */
                node->prev = tmp;
                tmp->next = node;
            }
        }
        else {
            /* No previous sibbling element */
            parent->children = node;
        }
    }
    else {
        /* We do NOT allow replacement of an existing Tree Node */
        if (tree->root != NULL)
            return FALSE;

        /* This is the Root Element */
        tree->root = node;
    }

    return TRUE;
}