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