xmlsecurity/source/helper/xmlsignaturehelper2.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 <xmlsecurity/xmlsignaturehelper.hxx>
  22 #include <xmlsignaturehelper2.hxx>
  23
  24 #include <tools/solar.h>
  25 #include <unotools/streamhelper.hxx>
  26
  27 #include <com/sun/star/embed/XStorage.hpp>
  28 #include <com/sun/star/embed/XStorageRawAccess.hpp>
  29 #include <com/sun/star/embed/ElementModes.hpp>
  30 #include <com/sun/star/beans/XPropertySet.hpp>
  31 #include "rtl/uri.hxx"
  32
  33 using namespace com::sun::star;
  34
  35 ImplXMLSignatureListener::ImplXMLSignatureListener( const Link& rCreationResultListenerListener, const Link rVerifyResultListenerListener, const Link rStartSignatureElement )
  36 {
  37     maCreationResultListenerListener = rCreationResultListenerListener;
  38     maVerifyResultListenerListener = rVerifyResultListenerListener;
  39     maStartVerifySignatureElementListener = rStartSignatureElement;
  40
  41 }
  42 ImplXMLSignatureListener::~ImplXMLSignatureListener()
  43 {
  44 }
  45
  46 void ImplXMLSignatureListener::setNextHandler(
  47     uno::Reference< xml::sax::XDocumentHandler > xNextHandler)
  48 {
  49     m_xNextHandler = xNextHandler;
  50 }
  51
  52 void SAL_CALL ImplXMLSignatureListener::signatureCreated( sal_Int32 securityId, com::sun::star::xml::crypto::SecurityOperationStatus nResult )
  53         throw (com::sun::star::uno::RuntimeException)
  54 {
  55     XMLSignatureCreationResult aResult( securityId, nResult );
  56     maCreationResultListenerListener.Call( &aResult );
  57 }
  58
  59 void SAL_CALL ImplXMLSignatureListener::signatureVerified( sal_Int32 securityId, com::sun::star::xml::crypto::SecurityOperationStatus nResult )
  60         throw (com::sun::star::uno::RuntimeException)
  61 {
  62     XMLSignatureVerifyResult aResult( securityId, nResult );
  63     maVerifyResultListenerListener.Call( &aResult );
  64 }
  65
  66 // ---------------------------------------------------------------------------------
  67 // XDocumentHandler
  68 // ---------------------------------------------------------------------------------
  69 void SAL_CALL ImplXMLSignatureListener::startDocument(  )
  70     throw (com::sun::star::xml::sax::SAXException, com::sun::star::uno::RuntimeException)
  71 {
  72     if (m_xNextHandler.is())
  73     {
  74         m_xNextHandler->startDocument();
  75     }
  76 }
  77
  78 void SAL_CALL ImplXMLSignatureListener::endDocument(  )
  79     throw (com::sun::star::xml::sax::SAXException, com::sun::star::uno::RuntimeException)
  80 {
  81     if (m_xNextHandler.is())
  82     {
  83         m_xNextHandler->endDocument();
  84     }
  85 }
  86
  87 void SAL_CALL ImplXMLSignatureListener::startElement( const OUString& aName, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList >& xAttribs )
  88         throw (com::sun::star::xml::sax::SAXException, com::sun::star::uno::RuntimeException)
  89 {
  90     if ( aName == OUString("Signature") )
  91     {
  92             maStartVerifySignatureElementListener.Call( (void*)&xAttribs );
  93     }
  94
  95     if (m_xNextHandler.is())
  96     {
  97         m_xNextHandler->startElement( aName, xAttribs );
  98     }
  99 }
 100
 101 void SAL_CALL ImplXMLSignatureListener::endElement( const OUString& aName )
 102     throw (com::sun::star::xml::sax::SAXException, com::sun::star::uno::RuntimeException)
 103 {
 104     if (m_xNextHandler.is())
 105     {
 106         m_xNextHandler->endElement( aName );
 107     }
 108 }
 109
 110 void SAL_CALL ImplXMLSignatureListener::characters( const OUString& aChars )
 111     throw (com::sun::star::xml::sax::SAXException, com::sun::star::uno::RuntimeException)
 112 {
 113     if (m_xNextHandler.is())
 114     {
 115         m_xNextHandler->characters( aChars );
 116     }
 117 }
 118
 119 void SAL_CALL ImplXMLSignatureListener::ignorableWhitespace( const OUString& aWhitespaces )
 120     throw (com::sun::star::xml::sax::SAXException, com::sun::star::uno::RuntimeException)
 121 {
 122     if (m_xNextHandler.is())
 123     {
 124         m_xNextHandler->ignorableWhitespace( aWhitespaces );
 125     }
 126 }
 127
 128 void SAL_CALL ImplXMLSignatureListener::processingInstruction( const OUString& aTarget, const OUString& aData )
 129     throw (com::sun::star::xml::sax::SAXException, com::sun::star::uno::RuntimeException)
 130 {
 131     if (m_xNextHandler.is())
 132     {
 133         m_xNextHandler->processingInstruction( aTarget, aData );
 134     }
 135 }
 136
 137 void SAL_CALL ImplXMLSignatureListener::setDocumentLocator( const com::sun::star::uno::Reference< com::sun::star::xml::sax::XLocator >& xLocator )
 138     throw (com::sun::star::xml::sax::SAXException, com::sun::star::uno::RuntimeException)
 139 {
 140     if (m_xNextHandler.is())
 141     {
 142         m_xNextHandler->setDocumentLocator( xLocator );
 143     }
 144 }
 145
 146 // ---------------------------------------------------------------------------------
 147 // XUriBinding
 148 // ---------------------------------------------------------------------------------
 149
 150 UriBindingHelper::UriBindingHelper()
 151 {
 152 }
 153
 154 UriBindingHelper::UriBindingHelper( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& rxStorage )
 155 {
 156     mxStorage = rxStorage;
 157 }
 158
 159
 160 void SAL_CALL UriBindingHelper::setUriBinding( const OUString& /*uri*/, const uno::Reference< io::XInputStream >&)
 161     throw (uno::Exception, uno::RuntimeException)
 162 {
 163 }
 164
 165 uno::Reference< io::XInputStream > SAL_CALL UriBindingHelper::getUriBinding( const OUString& uri )
 166     throw (uno::Exception, uno::RuntimeException)
 167 {
 168     uno::Reference< io::XInputStream > xInputStream;
 169     if ( mxStorage.is() )
 170     {
 171         xInputStream = OpenInputStream( mxStorage, uri );
 172     }
 173     else
 174     {
 175         SvFileStream* pStream = new SvFileStream( uri, STREAM_READ );
 176         pStream->Seek( STREAM_SEEK_TO_END );
 177         sal_uLong nBytes = pStream->Tell();
 178         pStream->Seek( STREAM_SEEK_TO_BEGIN );
 179         SvLockBytesRef xLockBytes = new SvLockBytes( pStream, sal_True );
 180         xInputStream = new utl::OInputStreamHelper( xLockBytes, nBytes );
 181     }
 182     return xInputStream;
 183 }
 184
 185 uno::Reference < io::XInputStream > UriBindingHelper::OpenInputStream( const uno::Reference < embed::XStorage >& rxStore, const OUString& rURI )
 186 {
 187     OSL_ASSERT(!rURI.isEmpty());
 188     uno::Reference < io::XInputStream > xInStream;
 189
 190     sal_Int32 nSepPos = rURI.indexOf( '/' );
 191     if ( nSepPos == -1 )
 192     {
 193         // Cloning because of I can't keep all storage references open
 194         // MBA with think about a better API...
 195         const OUString sName = ::rtl::Uri::decode(
 196             rURI, rtl_UriDecodeStrict, rtl_UriCharClassRelSegment);
 197         if (sName.isEmpty() && !rURI.isEmpty())
 198             throw uno::Exception(OUString(
 199             "Could not decode URI for stream element."), 0);
 200
 201         uno::Reference< io::XStream > xStream;
 202         xStream = rxStore->cloneStreamElement( sName );
 203         if ( !xStream.is() )
 204             throw uno::RuntimeException();
 205         xInStream = xStream->getInputStream();
 206     }
 207     else
 208     {
 209         const OUString aStoreName = ::rtl::Uri::decode(
 210             rURI.copy( 0, nSepPos ), rtl_UriDecodeStrict, rtl_UriCharClassRelSegment);
 211         if (aStoreName.isEmpty() && !rURI.isEmpty())
 212             throw uno::Exception(
 213             OUString(
 214             "Could not decode URI for stream element."), 0);
 215
 216         OUString aElement = rURI.copy( nSepPos+1 );
 217         uno::Reference < embed::XStorage > xSubStore = rxStore->openStorageElement( aStoreName, embed::ElementModes::READ );
 218         xInStream = OpenInputStream( xSubStore, aElement );
 219     }
 220     return xInStream;
 221 }
 222
 223
 224 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */