xmlsecurity/source/xmlsec/xmldocumentwrapper_xmlsecimpl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <osl/diagnose.h>
  23 #include <com/sun/star/uno/XComponentContext.hpp>
  24 #include <cppuhelper/supportsservice.hxx>
  25 #include "xmldocumentwrapper_xmlsecimpl.hxx"
  26
  27 #include <xmloff/attrlist.hxx>
  28 #include "xmlelementwrapper_xmlsecimpl.hxx"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36
  37 #include <vector>
  38
  39 #ifdef UNX
  40 #define stricmp strcasecmp
  41 #endif
  42
  43 namespace cssu = com::sun::star::uno;
  44 namespace cssl = com::sun::star::lang;
  45 namespace cssxc = com::sun::star::xml::crypto;
  46 namespace cssxcsax = com::sun::star::xml::csax;
  47 namespace cssxs = com::sun::star::xml::sax;
  48 namespace cssxw = com::sun::star::xml::wrapper;
  49
  50 #define IMPLEMENTATION_NAME "com.sun.star.xml.security.bridge.xmlsec.XMLDocumentWrapper_XmlSecImpl"
  51
  52 #define STRXMLNS "xmlns"
  53
  54 #define C2U( asciiStr ) asciiStr, strlen( asciiStr ), RTL_TEXTENCODING_UTF8
  55
  56 /* used by the recursiveDelete method */
  57 #define NODE_REMOVED    0
  58 #define NODE_NOTREMOVED 1
  59 #define NODE_STOPED     2
  60
  61 XMLDocumentWrapper_XmlSecImpl::XMLDocumentWrapper_XmlSecImpl()
  62     : m_nCurrentPosition(0)
  63     , m_pStopAtNode(0)
  64     , m_pCurrentReservedNode(0)
  65     , m_nReservedNodeIndex(0)
  66 {
  67     saxHelper.startDocument();
  68     m_pDocument = saxHelper.getDocument();
  69
  70     /*
  71      * creates the virtual root element
  72      */
  73     saxHelper.startElement(OUString(C2U( "root" )), cssu::Sequence<cssxcsax::XMLAttribute>());
  74
  75     m_pRootElement = saxHelper.getCurrentNode();
  76     m_pCurrentElement = m_pRootElement;
  77 }
  78
  79 XMLDocumentWrapper_XmlSecImpl::~XMLDocumentWrapper_XmlSecImpl()
  80 {
  81     saxHelper.endDocument();
  82     xmlFreeDoc(m_pDocument);
  83 }
  84
  85 void XMLDocumentWrapper_XmlSecImpl::getNextSAXEvent()
  86 /****** XMLDocumentWrapper_XmlSecImpl/getNextSAXEvent *************************
  87  *
  88  *   NAME
  89  *  getNextSAXEvent -- Prepares the next SAX event to be manipulate
  90  *
  91  *   SYNOPSIS
  92  *  getNextSAXEvent();
  93  *
  94  *   FUNCTION
  95  *  When converting the document into SAX events, this method is used to
  96  *  decide the next SAX event to be generated.
  97  *  Two member variables are checked to make the decision, the
  98  *  m_pCurrentElement and the m_nCurrentPosition.
  99  *  The m_pCurrentElement represents the node which have been covered, and
 100  *  the m_nCurrentPosition represents the event which have been sent.
 101  *  For example, suppose that the m_pCurrentElement
 102  *  points to element A, and the m_nCurrentPosition equals to
 103  *  NODEPOSITION_STARTELEMENT, then the next SAX event should be the
 104  *  endElement for element A if A has no child, or startElement for the
 105  *  first child element of element A otherwise.
 106  *  The m_nCurrentPosition can be one of following values:
 107  *  NODEPOSITION_STARTELEMENT for startElement;
 108  *  NODEPOSITION_ENDELEMENT for endElement;
 109  *  NODEPOSITION_NORMAL for other SAX events;
 110  *
 111  *   INPUTS
 112  *  empty
 113  *
 114  *   RESULT
 115  *  empty
 116  *
 117  *   AUTHOR
 118  *  Michael Mi
 119  *  Email: michael.mi@sun.com
 120  ******************************************************************************/
 121 {
 122     OSL_ASSERT( m_pCurrentElement != NULL );
 123
 124         /*
 125          * Get the next event through tree order.
 126          *
 127          * if the current event is a startElement, then the next
 128          * event depends on whether or not the current node has
 129          * children.
 130          */
 131     if (m_nCurrentPosition == NODEPOSITION_STARTELEMENT)
 132     {
 133             /*
 134              * If the current node has children, then its first child
 135              * should be next current node, and the next event will be
 136              * startElement or charaters(PI) based on that child's node
 137              * type. Otherwise, the endElement of current node is the
 138              * next event.
 139              */
 140         if (m_pCurrentElement->children != NULL)
 141         {
 142             m_pCurrentElement = m_pCurrentElement->children;
 143             m_nCurrentPosition
 144                 = (m_pCurrentElement->type == XML_ELEMENT_NODE)?
 145                     NODEPOSITION_STARTELEMENT:NODEPOSITION_NORMAL;
 146         }
 147         else
 148         {
 149             m_nCurrentPosition = NODEPOSITION_ENDELEMENT;
 150         }
 151     }
 152         /*
 153          * if the current event is a not startElement, then the next
 154          * event depends on whether or not the current node has
 155          * following sibling.
 156          */
 157     else if (m_nCurrentPosition == NODEPOSITION_ENDELEMENT || m_nCurrentPosition == NODEPOSITION_NORMAL)
 158     {
 159         xmlNodePtr pNextSibling = m_pCurrentElement->next;
 160
 161             /*
 162              * If the current node has following sibling, that sibling
 163              * should be next current node, and the next event will be
 164              * startElement or charaters(PI) based on that sibling's node
 165              * type. Otherwise, the endElement of current node's parent
 166              * becomes the next event.
 167              */
 168         if (pNextSibling != NULL)
 169         {
 170             m_pCurrentElement = pNextSibling;
 171             m_nCurrentPosition
 172                 = (m_pCurrentElement->type == XML_ELEMENT_NODE)?
 173                     NODEPOSITION_STARTELEMENT:NODEPOSITION_NORMAL;
 174         }
 175         else
 176         {
 177             m_pCurrentElement = m_pCurrentElement->parent;
 178             m_nCurrentPosition = NODEPOSITION_ENDELEMENT;
 179         }
 180     }
 181 }
 182
 183 void XMLDocumentWrapper_XmlSecImpl::sendStartElement(
 184     const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
 185     const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
 186     const xmlNodePtr pNode)
 187     throw (cssxs::SAXException)
 188 /****** XMLDocumentWrapper_XmlSecImpl/sendStartElement ************************
 189  *
 190  *   NAME
 191  *  sendStartElement -- Constructs a startElement SAX event
 192  *
 193  *   SYNOPSIS
 194  *  sendStartElement(xHandler, xHandler2, pNode);
 195  *
 196  *   FUNCTION
 197  *  Used when converting the document into SAX event stream.
 198  *  This method constructs a startElement SAX event for a particular
 199  *  element, then calls the startElement methods of the XDocumentHandlers.
 200  *
 201  *   INPUTS
 202  *  xHandler -  the first XDocumentHandler interface to receive the
 203  *          startElement SAX event. It can be NULL.
 204  *  xHandler2 - the second XDocumentHandler interface to receive the
 205  *          startElement SAX event. It can't be NULL.
 206  *  pNode -     the node on which the startElement should be generated.
 207  *          This node must be a element type.
 208  *
 209  *   RESULT
 210  *  empty
 211  *
 212  *   AUTHOR
 213  *  Michael Mi
 214  *  Email: michael.mi@sun.com
 215  ******************************************************************************/
 216 {
 217     SvXMLAttributeList* pAttributeList = new SvXMLAttributeList();
 218     cssu::Reference < cssxs::XAttributeList > xAttrList = cssu::Reference< cssxs::XAttributeList > (pAttributeList);
 219
 220     xmlNsPtr pNsDef = pNode->nsDef;
 221
 222     while (pNsDef != NULL)
 223     {
 224         const xmlChar* pNsPrefix = pNsDef->prefix;
 225         const xmlChar* pNsHref = pNsDef->href;
 226
 227         if (pNsDef->prefix == NULL)
 228         {
 229             pAttributeList->AddAttribute(
 230                 OUString(C2U( STRXMLNS )),
 231                 OUString(C2U( reinterpret_cast<char const *>(pNsHref) )));
 232         }
 233         else
 234         {
 235             pAttributeList->AddAttribute(
 236                 OUString(C2U( STRXMLNS ))
 237                 +OUString(C2U( ":" ))
 238                 +OUString(C2U( reinterpret_cast<char const *>(pNsPrefix) )),
 239                 OUString(C2U( reinterpret_cast<char const *>(pNsHref) )));
 240         }
 241
 242         pNsDef = pNsDef->next;
 243     }
 244
 245     xmlAttrPtr pAttr = pNode->properties;
 246
 247     while (pAttr != NULL)
 248     {
 249         const xmlChar* pAttrName = pAttr->name;
 250         xmlNsPtr pAttrNs = pAttr->ns;
 251
 252         OUString ouAttrName;
 253         if (pAttrNs == NULL)
 254         {
 255             ouAttrName = OUString(C2U( reinterpret_cast<char const *>(pAttrName) ));
 256         }
 257         else
 258         {
 259             ouAttrName = OUString(C2U( reinterpret_cast<char const *>(pAttrNs->prefix)))
 260                 + ":" + OUString(C2U( reinterpret_cast<char const *>(pAttrName) ));
 261         }
 262
 263         pAttributeList->AddAttribute(
 264             ouAttrName,
 265             OUString(C2U( reinterpret_cast<char*>(pAttr->children->content))));
 266         pAttr = pAttr->next;
 267     }
 268
 269     OString sNodeName = getNodeQName(pNode);
 270
 271     if (xHandler.is())
 272     {
 273         xHandler->startElement(
 274             OUString(C2U ( sNodeName.getStr() )),
 275             xAttrList);
 276     }
 277
 278     xHandler2->startElement(
 279         OUString(C2U ( sNodeName.getStr() )),
 280         xAttrList);
 281 }
 282
 283 void XMLDocumentWrapper_XmlSecImpl::sendEndElement(
 284     const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
 285     const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
 286     const xmlNodePtr pNode)
 287     throw (cssxs::SAXException)
 288 /****** XMLDocumentWrapper_XmlSecImpl/sendEndElement **************************
 289  *
 290  *   NAME
 291  *  sendEndElement -- Constructs a endElement SAX event
 292  *
 293  *   SYNOPSIS
 294  *  sendEndElement(xHandler, xHandler2, pNode);
 295  *
 296  *   FUNCTION
 297  *  Used when converting the document into SAX event stream.
 298  *  This method constructs a endElement SAX event for a particular
 299  *  element, then calls the endElement methods of the XDocumentHandlers.
 300  *
 301  *   INPUTS
 302  *  xHandler -  the first XDocumentHandler interface to receive the
 303  *          endElement SAX event. It can be NULL.
 304  *  xHandler2 - the second XDocumentHandler interface to receive the
 305  *          endElement SAX event. It can't be NULL.
 306  *  pNode -     the node on which the endElement should be generated.
 307  *          This node must be a element type.
 308  *
 309  *   RESULT
 310  *  empty
 311  *
 312  *   AUTHOR
 313  *  Michael Mi
 314  *  Email: michael.mi@sun.com
 315  ******************************************************************************/
 316 {
 317     OString sNodeName = getNodeQName(pNode);
 318
 319     if (xHandler.is())
 320     {
 321         xHandler->endElement(OUString(C2U ( sNodeName.getStr() )));
 322     }
 323
 324     xHandler2->endElement(OUString(C2U ( sNodeName.getStr() )));
 325 }
 326
 327 void XMLDocumentWrapper_XmlSecImpl::sendNode(
 328     const cssu::Reference< cssxs::XDocumentHandler >& xHandler,
 329     const cssu::Reference< cssxs::XDocumentHandler >& xHandler2,
 330     const xmlNodePtr pNode)
 331     throw (cssxs::SAXException)
 332 /****** XMLDocumentWrapper_XmlSecImpl/sendNode ********************************
 333  *
 334  *   NAME
 335  *  sendNode -- Constructs a characters SAX event or a
 336  *  processingInstruction SAX event
 337  *
 338  *   SYNOPSIS
 339  *  sendNode(xHandler, xHandler2, pNode);
 340  *
 341  *   FUNCTION
 342  *  Used when converting the document into SAX event stream.
 343  *  This method constructs a characters SAX event or a
 344  *  processingInstructionfor SAX event based on the type of a particular
 345  *  element, then calls the corresponding methods of the XDocumentHandlers.
 346  *
 347  *   INPUTS
 348  *  xHandler -  the first XDocumentHandler interface to receive the
 349  *          SAX event. It can be NULL.
 350  *  xHandler2 - the second XDocumentHandler interface to receive the
 351  *          SAX event. It can't be NULL.
 352  *  pNode -     the node on which the endElement should be generated.
 353  *          If it is a text node, then a characters SAX event is
 354  *          generated; if it is a PI node, then a
 355  *          processingInstructionfor SAX event is generated.
 356  *
 357  *   RESULT
 358  *  empty
 359  *
 360  *   AUTHOR
 361  *  Michael Mi
 362  *  Email: michael.mi@sun.com
 363  ******************************************************************************/
 364 {
 365     xmlElementType type = pNode->type;
 366
 367     if (type == XML_TEXT_NODE)
 368     {
 369         if (xHandler.is())
 370         {
 371             xHandler->characters(OUString(C2U ( reinterpret_cast<char*>(pNode->content) )));
 372         }
 373
 374         xHandler2->characters(OUString(C2U ( reinterpret_cast<char*>(pNode->content) )));
 375     }
 376     else if (type == XML_PI_NODE)
 377     {
 378         if (xHandler.is())
 379         {
 380             xHandler->processingInstruction(
 381                 OUString(C2U ( reinterpret_cast<char const *>(pNode->name) )),
 382                 OUString(C2U ( reinterpret_cast<char const *>(pNode->content) )));
 383         }
 384
 385         xHandler2->processingInstruction(
 386             OUString(C2U ( reinterpret_cast<char const *>(pNode->name) )),
 387             OUString(C2U ( reinterpret_cast<char*>(pNode->content) )));
 388     }
 389 }
 390
 391 OString XMLDocumentWrapper_XmlSecImpl::getNodeQName(const xmlNodePtr pNode)
 392 /****** XMLDocumentWrapper_XmlSecImpl/getNodeQName ****************************
 393  *
 394  *   NAME
 395  *  getNodeQName -- Retrieves the qualified name of a node
 396  *
 397  *   SYNOPSIS
 398  *  name = getNodeQName(pNode);
 399  *
 400  *   FUNCTION
 401  *  see NAME
 402  *
 403  *   INPUTS
 404  *  pNode - the node whose name will be retrieved
 405  *
 406  *   RESULT
 407  *  name - the node's qualified name
 408  *
 409  *   AUTHOR
 410  *  Michael Mi
 411  *  Email: michael.mi@sun.com
 412  ******************************************************************************/
 413 {
 414     OString sNodeName(reinterpret_cast<const char*>(pNode->name));
 415     if (pNode->ns != NULL)
 416     {
 417         xmlNsPtr pNs = pNode->ns;
 418
 419         if (pNs->prefix != NULL)
 420         {
 421             OString sPrefix(reinterpret_cast<const char*>(pNs->prefix));
 422             sNodeName = sPrefix+OString(":")+sNodeName;
 423         }
 424     }
 425
 426     return sNodeName;
 427 }
 428
 429 xmlNodePtr XMLDocumentWrapper_XmlSecImpl::checkElement( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement)
 430 /****** XMLDocumentWrapper_XmlSecImpl/checkElement ****************************
 431  *
 432  *   NAME
 433  *  checkElement -- Retrieves the node wrapped by an XXMLElementWrapper
 434  *  interface
 435  *
 436  *   SYNOPSIS
 437  *  node = checkElement(xXMLElement);
 438  *
 439  *   FUNCTION
 440  *  see NAME
 441  *
 442  *   INPUTS
 443  *  xXMLElement -   the XXMLElementWrapper interface wraping a node
 444  *
 445  *   RESULT
 446  *  node - the node wrapped in the XXMLElementWrapper interface
 447  *
 448  *   AUTHOR
 449  *  Michael Mi
 450  *  Email: michael.mi@sun.com
 451  ******************************************************************************/
 452 {
 453     xmlNodePtr rc = NULL;
 454
 455     if (xXMLElement.is())
 456     {
 457         cssu::Reference< cssl::XUnoTunnel > xNodTunnel( xXMLElement, cssu::UNO_QUERY ) ;
 458         if( !xNodTunnel.is() )
 459         {
 460             throw cssu::RuntimeException() ;
 461         }
 462
 463         XMLElementWrapper_XmlSecImpl* pElement
 464             = reinterpret_cast<XMLElementWrapper_XmlSecImpl*>(
 465                 sal::static_int_cast<sal_uIntPtr>(
 466                     xNodTunnel->getSomething(
 467                         XMLElementWrapper_XmlSecImpl::getUnoTunnelImplementationId() ))) ;
 468
 469         if( pElement == NULL ) {
 470             throw cssu::RuntimeException() ;
 471         }
 472
 473         rc = pElement->getNativeElement();
 474     }
 475
 476     return rc;
 477 }
 478
 479 sal_Int32 XMLDocumentWrapper_XmlSecImpl::recursiveDelete(
 480     const xmlNodePtr pNode)
 481 /****** XMLDocumentWrapper_XmlSecImpl/recursiveDelete *************************
 482  *
 483  *   NAME
 484  *  recursiveDelete -- Deletes a particular node with its branch.
 485  *
 486  *   SYNOPSIS
 487  *  result = recursiveDelete(pNode);
 488  *
 489  *   FUNCTION
 490  *  Deletes a particular node with its branch, while reserving the nodes
 491  *  (and their brance) listed in the m_aReservedNodes.
 492  *  The deletion process is preformed in the tree order, that is, a node
 493  *  is deleted after its previous sibling node is deleted, a parent node
 494  *  is deleted after its branch is deleted.
 495  *  During the deletion process when the m_pStopAtNode is reached, the
 496  *  progress is interrupted at once.
 497  *
 498  *   INPUTS
 499  *  pNode - the node to be deleted
 500  *
 501  *   RESULT
 502  *  result -    the result of the deletion process, can be one of following
 503  *          values:
 504  *          NODE_STOPED - the process is interrupted by meeting the
 505  *              m_pStopAtNode
 506  *          NODE_NOTREMOVED - the pNode is not completely removed
 507  *              because there is its descendant in the
 508  *              m_aReservedNodes list
 509  *          NODE_REMOVED - the pNode and its branch are completely
 510  *              removed
 511  *
 512  *   NOTES
 513  *  The node in the m_aReservedNodes list must be in the tree order, otherwise
 514  *  the result is unpredictable.
 515  *
 516  *   AUTHOR
 517  *  Michael Mi
 518  *  Email: michael.mi@sun.com
 519  ******************************************************************************/
 520 {
 521     if (pNode == m_pStopAtNode)
 522     {
 523         return NODE_STOPED;
 524     }
 525
 526     if (pNode != m_pCurrentReservedNode)
 527     {
 528         xmlNodePtr pChild = pNode->children;
 529
 530         xmlNodePtr pNextSibling;
 531         bool bIsRemoved = true;
 532         sal_Int32 nResult;
 533
 534         while( pChild != NULL )
 535         {
 536             pNextSibling = pChild->next;
 537             nResult = recursiveDelete(pChild);
 538
 539             switch (nResult)
 540             {
 541             case NODE_STOPED:
 542                 return NODE_STOPED;
 543             case NODE_NOTREMOVED:
 544                 bIsRemoved = false;
 545                 break;
 546             case NODE_REMOVED:
 547                 removeNode(pChild);
 548                 break;
 549             default:
 550                 throw cssu::RuntimeException();
 551             }
 552
 553             pChild = pNextSibling;
 554         }
 555
 556         if (pNode == m_pCurrentElement)
 557         {
 558             bIsRemoved = false;
 559         }
 560
 561         return bIsRemoved?NODE_REMOVED:NODE_NOTREMOVED;
 562     }
 563     else
 564     {
 565         getNextReservedNode();
 566         return NODE_NOTREMOVED;
 567     }
 568 }
 569
 570 void XMLDocumentWrapper_XmlSecImpl::getNextReservedNode()
 571 /****** XMLDocumentWrapper_XmlSecImpl/getNextReservedNode *********************
 572  *
 573  *   NAME
 574  *  getNextReservedNode -- Highlights the next reserved node in the
 575  *  reserved node list
 576  *
 577  *   SYNOPSIS
 578  *  getNextReservedNode();
 579  *
 580  *   FUNCTION
 581  *  The m_aReservedNodes array holds a node list, while the
 582  *  m_pCurrentReservedNode points to the one currently highlighted.
 583  *  This method is used to highlight the next node in the node list.
 584  *  This method is called at the time when the current highlighted node
 585  *  has been already processed, and the next node should be ready.
 586  *
 587  *   INPUTS
 588  *  empty
 589  *
 590  *   RESULT
 591  *  empty
 592  *
 593  *   AUTHOR
 594  *  Michael Mi
 595  *  Email: michael.mi@sun.com
 596  ******************************************************************************/
 597 {
 598     if (m_nReservedNodeIndex < m_aReservedNodes.getLength())
 599     {
 600         m_pCurrentReservedNode = checkElement( m_aReservedNodes[m_nReservedNodeIndex] );
 601         m_nReservedNodeIndex ++;
 602     }
 603     else
 604     {
 605         m_pCurrentReservedNode = NULL;
 606     }
 607 }
 608
 609 void XMLDocumentWrapper_XmlSecImpl::removeNode(const xmlNodePtr pNode) const
 610 /****** XMLDocumentWrapper_XmlSecImpl/removeNode ******************************
 611  *
 612  *   NAME
 613  *  removeNode -- Deletes a node with its branch unconditionaly
 614  *
 615  *   SYNOPSIS
 616  *  removeNode( pNode );
 617  *
 618  *   FUNCTION
 619  *  Delete the node along with its branch from the document.
 620  *
 621  *   INPUTS
 622  *  pNode - the node to be deleted
 623  *
 624  *   RESULT
 625  *  empty
 626  *
 627  *   AUTHOR
 628  *  Michael Mi
 629  *  Email: michael.mi@sun.com
 630  ******************************************************************************/
 631 {
 632     /* you can't remove the current node */
 633     OSL_ASSERT( m_pCurrentElement != pNode );
 634
 635     xmlAttrPtr pAttr = pNode->properties;
 636
 637     while (pAttr != NULL)
 638     {
 639         if (!stricmp(reinterpret_cast<char const *>(pAttr->name), "id"))
 640         {
 641             xmlRemoveID(m_pDocument, pAttr);
 642         }
 643
 644         pAttr = pAttr->next;
 645     }
 646
 647     xmlUnlinkNode(pNode);
 648     xmlFreeNode(pNode);
 649 }
 650
 651 void XMLDocumentWrapper_XmlSecImpl::buildIDAttr(xmlNodePtr pNode) const
 652 /****** XMLDocumentWrapper_XmlSecImpl/buildIDAttr *****************************
 653  *
 654  *   NAME
 655  *  buildIDAttr -- build the ID attribute of a node
 656  *
 657  *   SYNOPSIS
 658  *  buildIDAttr( pNode );
 659  *
 660  *   FUNCTION
 661  *  see NAME
 662  *
 663  *   INPUTS
 664  *  pNode - the node whose id attribute will be built
 665  *
 666  *   RESULT
 667  *  empty
 668  *
 669  *   AUTHOR
 670  *  Michael Mi
 671  *  Email: michael.mi@sun.com
 672  ******************************************************************************/
 673 {
 674     xmlAttrPtr idAttr = xmlHasProp( pNode, reinterpret_cast<const unsigned char *>("id") );
 675     if (idAttr == NULL)
 676     {
 677         idAttr = xmlHasProp( pNode, reinterpret_cast<const unsigned char *>("Id") );
 678     }
 679
 680     if (idAttr != NULL)
 681     {
 682         xmlChar* idValue = xmlNodeListGetString( m_pDocument, idAttr->children, 1 ) ;
 683         xmlAddID( NULL, m_pDocument, idValue, idAttr );
 684     }
 685 }
 686
 687 void XMLDocumentWrapper_XmlSecImpl::rebuildIDLink(xmlNodePtr pNode) const
 688 /****** XMLDocumentWrapper_XmlSecImpl/rebuildIDLink ***************************
 689  *
 690  *   NAME
 691  *  rebuildIDLink -- rebuild the ID link for the branch
 692  *
 693  *   SYNOPSIS
 694  *  rebuildIDLink( pNode );
 695  *
 696  *   FUNCTION
 697  *  see NAME
 698  *
 699  *   INPUTS
 700  *  pNode - the node, from which the branch will be rebuilt
 701  *
 702  *   RESULT
 703  *  empty
 704  *
 705  *   AUTHOR
 706  *  Michael Mi
 707  *  Email: michael.mi@sun.com
 708  ******************************************************************************/
 709 {
 710     if (pNode != NULL && pNode->type == XML_ELEMENT_NODE)
 711     {
 712         buildIDAttr( pNode );
 713
 714         xmlNodePtr child = pNode->children;
 715         while (child != NULL)
 716         {
 717             rebuildIDLink(child);
 718             child = child->next;
 719         }
 720     }
 721 }
 722
 723 /* XXMLDocumentWrapper */
 724 cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL XMLDocumentWrapper_XmlSecImpl::getCurrentElement(  )
 725     throw (cssu::RuntimeException, std::exception)
 726 {
 727     XMLElementWrapper_XmlSecImpl* pElement = new XMLElementWrapper_XmlSecImpl(m_pCurrentElement);
 728     return cssu::Reference< cssxw::XXMLElementWrapper >(pElement);
 729 }
 730
 731 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::setCurrentElement( const cssu::Reference< cssxw::XXMLElementWrapper >& element )
 732     throw (cssu::RuntimeException, std::exception)
 733 {
 734     m_pCurrentElement = checkElement( element );
 735     saxHelper.setCurrentNode( m_pCurrentElement );
 736 }
 737
 738 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::removeCurrentElement(  )
 739     throw (cssu::RuntimeException, std::exception)
 740 {
 741     OSL_ASSERT( m_pCurrentElement != NULL );
 742
 743     xmlNodePtr pOldCurrentElement = m_pCurrentElement;
 744
 745     /*
 746      * pop the top node in the parser context's
 747      * nodeTab stack, then the parent of that node will
 748      * automatically become the new stack top, and
 749      * the current node as well.
 750      */
 751     saxHelper.endElement(
 752         OUString(
 753             C2U (
 754                 reinterpret_cast<char const *>(pOldCurrentElement->name)
 755             )));
 756     m_pCurrentElement = saxHelper.getCurrentNode();
 757
 758     /*
 759      * remove the node
 760      */
 761     removeNode(pOldCurrentElement);
 762 }
 763
 764 sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::isCurrent( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
 765     throw (cssu::RuntimeException, std::exception)
 766 {
 767     xmlNodePtr pNode = checkElement(node);
 768     return (pNode == m_pCurrentElement);
 769 }
 770
 771 sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::isCurrentElementEmpty(  )
 772     throw (cssu::RuntimeException, std::exception)
 773 {
 774     bool rc = false;
 775
 776     if (m_pCurrentElement->children == NULL)
 777     {
 778         rc = true;
 779     }
 780
 781     return rc;
 782 }
 783
 784 OUString SAL_CALL XMLDocumentWrapper_XmlSecImpl::getNodeName( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
 785     throw (cssu::RuntimeException, std::exception)
 786 {
 787     xmlNodePtr pNode = checkElement(node);
 788     return OUString(C2U ( reinterpret_cast<char const *>(pNode->name) ));
 789 }
 790
 791 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::clearUselessData(
 792     const cssu::Reference< cssxw::XXMLElementWrapper >& node,
 793     const cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > >& reservedDescendants,
 794     const cssu::Reference< cssxw::XXMLElementWrapper >& stopAtNode )
 795     throw (cssu::RuntimeException, std::exception)
 796 {
 797     xmlNodePtr pTargetNode = checkElement(node);
 798
 799     m_pStopAtNode = checkElement(stopAtNode);
 800     m_aReservedNodes = reservedDescendants;
 801     m_nReservedNodeIndex = 0;
 802
 803     getNextReservedNode();
 804
 805     recursiveDelete(pTargetNode);
 806 }
 807
 808 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::collapse( const cssu::Reference< cssxw::XXMLElementWrapper >& node )
 809     throw (cssu::RuntimeException, std::exception)
 810 {
 811     xmlNodePtr pTargetNode = checkElement(node);
 812     xmlNodePtr pParent;
 813
 814     while (pTargetNode != NULL)
 815     {
 816         if (pTargetNode->children != NULL || pTargetNode == m_pCurrentElement)
 817         {
 818             break;
 819         }
 820
 821         pParent = pTargetNode->parent;
 822         removeNode(pTargetNode);
 823         pTargetNode = pParent;
 824     }
 825 }
 826
 827 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::getTree( const cssu::Reference< cssxs::XDocumentHandler >& handler )
 828     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
 829 {
 830     if (m_pRootElement != NULL)
 831     {
 832         xmlNodePtr pTempCurrentElement = m_pCurrentElement;
 833         sal_Int32 nTempCurrentPosition = m_nCurrentPosition;
 834
 835         m_pCurrentElement = m_pRootElement;
 836
 837         m_nCurrentPosition = NODEPOSITION_STARTELEMENT;
 838         cssu::Reference< cssxs::XDocumentHandler > xHandler = handler;
 839
 840         while(true)
 841         {
 842             switch (m_nCurrentPosition)
 843             {
 844             case NODEPOSITION_STARTELEMENT:
 845                 sendStartElement(NULL, xHandler, m_pCurrentElement);
 846                 break;
 847             case NODEPOSITION_ENDELEMENT:
 848                 sendEndElement(NULL, xHandler, m_pCurrentElement);
 849                 break;
 850             case NODEPOSITION_NORMAL:
 851                 sendNode(NULL, xHandler, m_pCurrentElement);
 852                 break;
 853             }
 854
 855             if ( (m_pCurrentElement == m_pRootElement) && (m_nCurrentPosition == NODEPOSITION_ENDELEMENT ))
 856             {
 857                 break;
 858             }
 859
 860             getNextSAXEvent();
 861         }
 862
 863         m_pCurrentElement = pTempCurrentElement;
 864         m_nCurrentPosition = nTempCurrentPosition;
 865     }
 866 }
 867
 868 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::generateSAXEvents(
 869     const cssu::Reference< cssxs::XDocumentHandler >& handler,
 870     const cssu::Reference< cssxs::XDocumentHandler >& xEventKeeperHandler,
 871     const cssu::Reference< cssxw::XXMLElementWrapper >& startNode,
 872     const cssu::Reference< cssxw::XXMLElementWrapper >& endNode )
 873     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
 874 {
 875         /*
 876          * The first SAX event is the startElement of the startNode
 877          * element.
 878          */
 879     bool bHasCurrentElementChild = (m_pCurrentElement->children != NULL);
 880
 881     xmlNodePtr pTempCurrentElement = m_pCurrentElement;
 882
 883     m_pCurrentElement = checkElement(startNode);
 884
 885     if (m_pCurrentElement->type == XML_ELEMENT_NODE)
 886     {
 887         m_nCurrentPosition = NODEPOSITION_STARTELEMENT;
 888     }
 889     else
 890     {
 891         m_nCurrentPosition = NODEPOSITION_NORMAL;
 892     }
 893
 894     xmlNodePtr pEndNode = checkElement(endNode);
 895
 896     cssu::Reference < cssxc::sax::XSAXEventKeeper > xSAXEventKeeper( xEventKeeperHandler, cssu::UNO_QUERY );
 897
 898     cssu::Reference< cssxs::XDocumentHandler > xHandler = handler;
 899
 900     while(true)
 901     {
 902         switch (m_nCurrentPosition)
 903         {
 904         case NODEPOSITION_STARTELEMENT:
 905             sendStartElement(xHandler, xEventKeeperHandler, m_pCurrentElement);
 906             break;
 907         case NODEPOSITION_ENDELEMENT:
 908             sendEndElement(xHandler, xEventKeeperHandler, m_pCurrentElement);
 909             break;
 910         case NODEPOSITION_NORMAL:
 911             sendNode(xHandler, xEventKeeperHandler, m_pCurrentElement);
 912             break;
 913         default:
 914             throw cssu::RuntimeException();
 915         }
 916
 917         if (xSAXEventKeeper->isBlocking())
 918         {
 919             xHandler = NULL;
 920         }
 921
 922         if (pEndNode == NULL &&
 923             ((bHasCurrentElementChild && m_pCurrentElement == xmlGetLastChild(pTempCurrentElement) && m_nCurrentPosition != NODEPOSITION_STARTELEMENT) ||
 924              (!bHasCurrentElementChild && m_pCurrentElement == pTempCurrentElement && m_nCurrentPosition == NODEPOSITION_STARTELEMENT)))
 925         {
 926             break;
 927         }
 928
 929         getNextSAXEvent();
 930
 931             /*
 932              * If there is an end point specified, then check whether
 933              * the current node equals to the end point. If so, stop
 934              * generating.
 935              */
 936         if (pEndNode != NULL && m_pCurrentElement == pEndNode)
 937         {
 938             break;
 939         }
 940     }
 941
 942     m_pCurrentElement = pTempCurrentElement;
 943 }
 944
 945 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::rebuildIDLink(
 946     const com::sun::star::uno::Reference< com::sun::star::xml::wrapper::XXMLElementWrapper >& node )
 947     throw (com::sun::star::uno::RuntimeException, std::exception)
 948 {
 949     xmlNodePtr pNode = checkElement( node );
 950     rebuildIDLink(pNode);
 951 }
 952
 953
 954 /* cssxs::XDocumentHandler */
 955 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::startDocument(  )
 956     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
 957 {
 958 }
 959
 960 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::endDocument(  )
 961     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
 962 {
 963 }
 964
 965 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::startElement( const OUString& aName, const cssu::Reference< cssxs::XAttributeList >& xAttribs )
 966     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
 967 {
 968     sal_Int32 nLength = xAttribs->getLength();
 969     cssu::Sequence< cssxcsax::XMLAttribute > aAttributes (nLength);
 970
 971     for (int i = 0; i < nLength; ++i)
 972     {
 973         aAttributes[i].sName = xAttribs->getNameByIndex((short)i);
 974         aAttributes[i].sValue =xAttribs->getValueByIndex((short)i);
 975     }
 976
 977     compressedStartElement(aName, aAttributes);
 978 }
 979
 980 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::endElement( const OUString& aName )
 981     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
 982 {
 983     saxHelper.endElement(aName);
 984     m_pCurrentElement = saxHelper.getCurrentNode();
 985 }
 986
 987 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::characters( const OUString& aChars )
 988     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
 989 {
 990     saxHelper.characters(aChars);
 991 }
 992
 993 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::ignorableWhitespace( const OUString& aWhitespaces )
 994     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
 995 {
 996     saxHelper.ignorableWhitespace(aWhitespaces);
 997 }
 998
 999 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::processingInstruction( const OUString& aTarget, const OUString& aData )
1000     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1001 {
1002     saxHelper.processingInstruction(aTarget, aData);
1003 }
1004
1005 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::setDocumentLocator( const cssu::Reference< cssxs::XLocator >& )
1006     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1007 {
1008 }
1009
1010 /* XCompressedDocumentHandler */
1011 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedStartDocument(  )
1012     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1013 {
1014 }
1015
1016 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedEndDocument(  )
1017     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1018 {
1019 }
1020
1021 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedStartElement( const OUString& aName, const cssu::Sequence< cssxcsax::XMLAttribute >& aAttributes )
1022     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1023 {
1024     saxHelper.startElement(aName, aAttributes);
1025     m_pCurrentElement = saxHelper.getCurrentNode();
1026
1027     buildIDAttr( m_pCurrentElement );
1028 }
1029
1030 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedEndElement( const OUString& aName )
1031     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1032 {
1033     endElement( aName );
1034 }
1035
1036 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedCharacters( const OUString& aChars )
1037     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1038 {
1039     characters( aChars );
1040 }
1041
1042 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedIgnorableWhitespace( const OUString& aWhitespaces )
1043     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1044 {
1045     ignorableWhitespace( aWhitespaces );
1046 }
1047
1048 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedProcessingInstruction( const OUString& aTarget, const OUString& aData )
1049     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1050 {
1051     processingInstruction( aTarget, aData );
1052 }
1053
1054 void SAL_CALL XMLDocumentWrapper_XmlSecImpl::compressedSetDocumentLocator( sal_Int32 /*columnNumber*/, sal_Int32 /*lineNumber*/, const OUString& /*publicId*/, const OUString& /*systemId*/ )
1055     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1056 {
1057 }
1058
1059 OUString XMLDocumentWrapper_XmlSecImpl_getImplementationName ()
1060     throw (cssu::RuntimeException)
1061 {
1062     return OUString ( IMPLEMENTATION_NAME );
1063 }
1064
1065 cssu::Sequence< OUString > SAL_CALL XMLDocumentWrapper_XmlSecImpl_getSupportedServiceNames(  )
1066     throw (cssu::RuntimeException)
1067 {
1068     cssu::Sequence < OUString > aRet(1);
1069     OUString* pArray = aRet.getArray();
1070     pArray[0] = "com.sun.star.xml.wrapper.XMLDocumentWrapper";
1071     return aRet;
1072 }
1073
1074 cssu::Reference< cssu::XInterface > SAL_CALL XMLDocumentWrapper_XmlSecImpl_createInstance(
1075     const cssu::Reference< cssu::XComponentContext > &)
1076     throw( cssu::Exception )
1077 {
1078     return (cppu::OWeakObject*) new XMLDocumentWrapper_XmlSecImpl( );
1079 }
1080
1081 /* XServiceInfo */
1082 OUString SAL_CALL XMLDocumentWrapper_XmlSecImpl::getImplementationName(  )
1083     throw (cssu::RuntimeException, std::exception)
1084 {
1085     return XMLDocumentWrapper_XmlSecImpl_getImplementationName();
1086 }
1087 sal_Bool SAL_CALL XMLDocumentWrapper_XmlSecImpl::supportsService( const OUString& rServiceName )
1088     throw (cssu::RuntimeException, std::exception)
1089 {
1090     return cppu::supportsService( this, rServiceName );
1091 }
1092 cssu::Sequence< OUString > SAL_CALL XMLDocumentWrapper_XmlSecImpl::getSupportedServiceNames(  )
1093     throw (cssu::RuntimeException, std::exception)
1094 {
1095     return XMLDocumentWrapper_XmlSecImpl_getSupportedServiceNames();
1096 }
1097
1098 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */