xmloff/source/meta/xmlversion.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 <com/sun/star/embed/ElementModes.hpp>
  21 #include <xmlversion.hxx>
  22 #include <xmloff/xmlnamespace.hxx>
  23 #include <xmloff/xmlmetae.hxx>
  24 #include <osl/diagnose.h>
  25 #include <sal/log.hxx>
  26 #include <o3tl/string_view.hxx>
  27
  28 #include <xmloff/xmltoken.hxx>
  29 #include <comphelper/processfactory.hxx>
  30 #include <com/sun/star/beans/XPropertySet.hpp>
  31 #include <com/sun/star/io/IOException.hpp>
  32 #include <com/sun/star/io/XOutputStream.hpp>
  33 #include <com/sun/star/util/DateTime.hpp>
  34 #include <com/sun/star/util/MeasureUnit.hpp>
  35 #include <com/sun/star/xml/sax/InputSource.hpp>
  36 #include <com/sun/star/xml/sax/Writer.hpp>
  37 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  38 #include <cppuhelper/supportsservice.hxx>
  39
  40 using namespace ::com::sun::star::xml::sax;
  41 using namespace ::com::sun::star::uno;
  42 using namespace ::com::sun::star;
  43
  44 constexpr OUString XMLN_VERSIONSLIST = u"VersionList.xml"_ustr;
  45
  46 XMLVersionListExport::XMLVersionListExport(
  47     const css::uno::Reference< css::uno::XComponentContext >& rContext,
  48     const css::uno::Sequence < css::util::RevisionTag >& rVersions,
  49     const OUString &rFileName,
  50     Reference< XDocumentHandler > const &rHandler )
  51 :   SvXMLExport( rContext, u""_ustr, rFileName, util::MeasureUnit::CM, rHandler ),
  52     maVersions( rVersions )
  53 {
  54     GetNamespaceMap_().AddAtIndex( xmloff::token::GetXMLToken(xmloff::token::XML_NP_DC),
  55                                    xmloff::token::GetXMLToken(xmloff::token::XML_N_DC), XML_NAMESPACE_DC );
  56     GetNamespaceMap_().AddAtIndex( xmloff::token::GetXMLToken(xmloff::token::XML_NP_VERSIONS_LIST),
  57                                    xmloff::token::GetXMLToken(xmloff::token::XML_N_VERSIONS_LIST), XML_NAMESPACE_FRAMEWORK );
  58 }
  59
  60 ErrCode XMLVersionListExport::exportDoc( enum ::xmloff::token::XMLTokenEnum )
  61 {
  62     GetDocHandler()->startDocument();
  63
  64     addChaffWhenEncryptedStorage();
  65
  66     sal_uInt16 nPos = SvXMLNamespaceMap::GetIndexByKey( XML_NAMESPACE_DC );
  67
  68     AddAttribute( XML_NAMESPACE_NONE, GetNamespaceMap_().GetAttrNameByIndex( nPos ),
  69                              GetNamespaceMap_().GetNameByIndex ( nPos ) );
  70
  71     nPos = SvXMLNamespaceMap::GetIndexByKey( XML_NAMESPACE_FRAMEWORK );
  72     AddAttribute( XML_NAMESPACE_NONE, GetNamespaceMap_().GetAttrNameByIndex( nPos ),
  73                              GetNamespaceMap_().GetNameByIndex ( nPos ) );
  74
  75     {
  76         // the following object will write all collected attributes in its dtor
  77         SvXMLElementExport aRoot( *this, XML_NAMESPACE_FRAMEWORK, xmloff::token::XML_VERSION_LIST, true, true );
  78
  79         for ( const util::RevisionTag& rInfo : maVersions )
  80         {
  81             AddAttribute( XML_NAMESPACE_FRAMEWORK,
  82                           xmloff::token::XML_TITLE,
  83                           rInfo.Identifier );
  84             AddAttribute( XML_NAMESPACE_FRAMEWORK,
  85                           xmloff::token::XML_COMMENT,
  86                           rInfo.Comment );
  87             AddAttribute( XML_NAMESPACE_FRAMEWORK,
  88                           xmloff::token::XML_CREATOR,
  89                           rInfo.Author );
  90
  91             OUString aDateStr =
  92                 SvXMLMetaExport::GetISODateTimeString( rInfo.TimeStamp );
  93
  94             AddAttribute( XML_NAMESPACE_DC, xmloff::token::XML_DATE_TIME, aDateStr );
  95
  96             // the following object will write all collected attributes in its dtor
  97             SvXMLElementExport aEntry( *this, XML_NAMESPACE_FRAMEWORK, xmloff::token::XML_VERSION_ENTRY, true, true );
  98         }
  99     }
 100     GetDocHandler()->endDocument();
 101     return ERRCODE_NONE;
 102 }
 103
 104 XMLVersionListImport::XMLVersionListImport(
 105     const css::uno::Reference< css::uno::XComponentContext >& rContext,
 106     css::uno::Sequence < css::util::RevisionTag >& rVersions )
 107 :   SvXMLImport(rContext, u""_ustr),
 108     maVersions( rVersions )
 109 {
 110 }
 111
 112 XMLVersionListImport::~XMLVersionListImport() noexcept
 113 {}
 114
 115 SvXMLImportContext *XMLVersionListImport::CreateFastContext( sal_Int32 nElement,
 116         const ::css::uno::Reference< ::css::xml::sax::XFastAttributeList >& /*xAttrList*/ )
 117 {
 118     SvXMLImportContext *pContext = nullptr;
 119
 120     if ( nElement == XML_ELEMENT(VERSIONS_LIST, xmloff::token::XML_VERSION_LIST) )
 121     {
 122         pContext = new XMLVersionListContext( *this );
 123     }
 124
 125     return pContext;
 126 }
 127
 128 XMLVersionListContext::XMLVersionListContext( XMLVersionListImport& rImport)
 129     : SvXMLImportContext( rImport )
 130 {
 131 }
 132
 133 XMLVersionListContext::~XMLVersionListContext()
 134 {}
 135
 136 css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL
 137 XMLVersionListContext::createFastChildContext(sal_Int32 nElement,
 138             const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList)
 139 {
 140     SvXMLImportContext *pContext = nullptr;
 141
 142     if ( nElement == XML_ELEMENT(FRAMEWORK, xmloff::token::XML_VERSION_ENTRY)
 143         || nElement == XML_ELEMENT(VERSIONS_LIST, xmloff::token::XML_VERSION_ENTRY) )
 144     {
 145         pContext = new XMLVersionContext( GetImport(), xAttrList );
 146     }
 147
 148     return pContext;
 149 }
 150
 151 XMLVersionContext::XMLVersionContext( XMLVersionListImport& rImport,
 152                                         const Reference< XFastAttributeList > & xAttrList )
 153     : SvXMLImportContext( rImport )
 154 {
 155     sax_fastparser::FastAttributeList& rAttribList =
 156         sax_fastparser::castToFastAttributeList( xAttrList );
 157     if ( rAttribList.getFastAttributeTokens().empty() )
 158         return;
 159     util::RevisionTag aInfo;
 160     for (auto &aIter : rAttribList)
 161     {
 162         switch( aIter.getToken() )
 163         {
 164         case XML_ELEMENT(FRAMEWORK, xmloff::token::XML_TITLE):
 165         case XML_ELEMENT(VERSIONS_LIST, xmloff::token::XML_TITLE):
 166         {
 167             aInfo.Identifier = aIter.toString();
 168             break;
 169         }
 170         case XML_ELEMENT(FRAMEWORK, xmloff::token::XML_COMMENT):
 171         case XML_ELEMENT(VERSIONS_LIST, xmloff::token::XML_COMMENT):
 172         {
 173             aInfo.Comment = aIter.toString();
 174             break;
 175         }
 176         case XML_ELEMENT(FRAMEWORK, xmloff::token::XML_CREATOR):
 177         case XML_ELEMENT(VERSIONS_LIST, xmloff::token::XML_CREATOR):
 178         {
 179             aInfo.Author = aIter.toString();
 180             break;
 181         }
 182         case XML_ELEMENT(DC, xmloff::token::XML_DATE_TIME):
 183         {
 184             util::DateTime aTime;
 185             if ( ParseISODateTimeString( aIter.toString(), aTime ) )
 186                 aInfo.TimeStamp = aTime;
 187             break;
 188         }
 189         default:
 190             XMLOFF_WARN_UNKNOWN("xmloff", aIter);
 191             break;
 192         }
 193     }
 194
 195     uno::Sequence < util::RevisionTag >& aList = rImport.GetList();
 196     sal_Int32 nLength = aList.getLength();
 197     aList.realloc( nLength+1 );
 198     aList.getArray()[nLength] = std::move(aInfo);
 199 }
 200
 201 XMLVersionContext::~XMLVersionContext()
 202 {}
 203
 204 bool XMLVersionContext::ParseISODateTimeString(
 205                                 std::u16string_view rString,
 206                                 util::DateTime& rDateTime )
 207 {
 208     bool bSuccess = true;
 209
 210     std::u16string_view aDateStr, aTimeStr;
 211     size_t nPos = rString.find( 'T' );
 212     if ( nPos != std::u16string_view::npos )
 213     {
 214         aDateStr = rString.substr( 0, nPos );
 215         aTimeStr = rString.substr( nPos + 1 );
 216     }
 217     else
 218         aDateStr = rString;         // no separator: only date part
 219
 220     sal_Int32 nYear  = 0;
 221     sal_Int32 nMonth = 1;
 222     sal_Int32 nDay   = 1;
 223     sal_Int32 nHour  = 0;
 224     sal_Int32 nMin   = 0;
 225     sal_Int32 nSec   = 0;
 226
 227     auto pStr = aDateStr.begin();
 228     sal_Int32 nDateTokens = 1;
 229     while ( pStr != aDateStr.end() )
 230     {
 231         if ( *pStr == '-' )
 232             nDateTokens++;
 233         pStr++;
 234     }
 235     if ( nDateTokens > 3 || aDateStr.empty() )
 236         bSuccess = false;
 237     else
 238     {
 239         sal_Int32 n = 0;
 240         nYear = o3tl::toInt32(o3tl::getToken(aDateStr, 0, '-', n ));
 241         if ( nYear > 9999 )
 242             bSuccess = false;
 243         else if ( nDateTokens >= 2 )
 244         {
 245             nMonth = o3tl::toInt32(o3tl::getToken(aDateStr, 0, '-', n ));
 246             if ( nMonth > 12 )
 247                 bSuccess = false;
 248             else if ( nDateTokens >= 3 )
 249             {
 250                 nDay = o3tl::toInt32(o3tl::getToken(aDateStr, 0, '-', n ));
 251                 if ( nDay > 31 )
 252                     bSuccess = false;
 253             }
 254         }
 255     }
 256
 257     if ( bSuccess && !aTimeStr.empty() )         // time is optional
 258     {
 259         pStr = aTimeStr.begin();
 260         sal_Int32 nTimeTokens = 1;
 261         while ( pStr != aTimeStr.end() )
 262         {
 263             if ( *pStr == ':' )
 264                 nTimeTokens++;
 265             pStr++;
 266         }
 267         if ( nTimeTokens > 3 )
 268             bSuccess = false;
 269         else
 270         {
 271             sal_Int32 n = 0;
 272             nHour = o3tl::toInt32(o3tl::getToken(aTimeStr, 0, ':', n ));
 273             if ( nHour > 23 )
 274                 bSuccess = false;
 275             else if ( nTimeTokens >= 2 )
 276             {
 277                 nMin = o3tl::toInt32(o3tl::getToken(aTimeStr, 0, ':', n ));
 278                 if ( nMin > 59 )
 279                     bSuccess = false;
 280                 else if ( nTimeTokens >= 3 )
 281                 {
 282                     nSec = o3tl::toInt32(o3tl::getToken(aTimeStr, 0, ':', n ));
 283                     if ( nSec > 59 )
 284                         bSuccess = false;
 285                 }
 286             }
 287         }
 288     }
 289
 290     if ( bSuccess )
 291     {
 292         rDateTime.Day = sal::static_int_cast< sal_uInt16 >(nDay);
 293         rDateTime.Month = sal::static_int_cast< sal_uInt16 >(nMonth);
 294         rDateTime.Year = sal::static_int_cast< sal_uInt16 >(nYear);
 295         rDateTime.Hours = sal::static_int_cast< sal_uInt16 >(nHour);
 296         rDateTime.Minutes = sal::static_int_cast< sal_uInt16 >(nMin);
 297         rDateTime.Seconds = sal::static_int_cast< sal_uInt16 >(nSec);
 298     }
 299
 300     return bSuccess;
 301 }
 302
 303 void SAL_CALL XMLVersionListPersistence::store( const uno::Reference< embed::XStorage >& xRoot, const uno::Sequence< util::RevisionTag >& rVersions )
 304 {
 305     // no storage, no version list!
 306     if ( !xRoot.is() )
 307         return;
 308
 309     // get the services needed for writing the xml data
 310     const Reference< uno::XComponentContext >& xContext =
 311             comphelper::getProcessComponentContext();
 312
 313     Reference< XWriter > xWriter = Writer::create(xContext);
 314
 315     // check whether there's already a sub storage with the version info
 316     // and delete it
 317     OUString sVerName( XMLN_VERSIONSLIST  );
 318
 319     try {
 320         // open (create) the sub storage with the version info
 321         uno::Reference< io::XStream > xVerStream = xRoot->openStreamElement(
 322                                         sVerName,
 323                                         embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
 324         if ( !xVerStream.is() )
 325             throw uno::RuntimeException();
 326
 327         Reference< io::XOutputStream > xOut = xVerStream->getOutputStream();
 328         if ( !xOut.is() )
 329             throw uno::RuntimeException(u"The stream was successfully opened for writing already!"_ustr);
 330
 331         xWriter->setOutputStream(xOut);
 332
 333         rtl::Reference< XMLVersionListExport > xExp( new XMLVersionListExport( xContext, rVersions, sVerName, xWriter ) );
 334
 335         xExp->exportDoc( ::xmloff::token::XML_VERSION );
 336
 337         xVerStream.clear(); // use refcounting for now to dispose
 338     }
 339     catch( uno::Exception& )
 340     {
 341         // TODO: error handling
 342     }
 343 }
 344
 345 uno::Sequence< util::RevisionTag > SAL_CALL XMLVersionListPersistence::load( const uno::Reference< embed::XStorage >& xRoot )
 346 {
 347     css::uno::Sequence < css::util::RevisionTag > aVersions;
 348
 349     const OUString sDocName( XMLN_VERSIONSLIST  );
 350
 351     try {
 352         if ( xRoot.is() && xRoot->hasByName( sDocName ) && xRoot->isStreamElement( sDocName ) )
 353         {
 354             const Reference< uno::XComponentContext >& xContext = comphelper::getProcessComponentContext();
 355
 356             InputSource aParserInput;
 357
 358             uno::Reference< beans::XPropertySet > xProps( xRoot, uno::UNO_QUERY );
 359             OSL_ENSURE( xProps.is(), "Storage must implement XPropertySet!" );
 360             if ( xProps.is() )
 361             {
 362                 try {
 363                     xProps->getPropertyValue(u"URL"_ustr) >>= aParserInput.sSystemId;
 364                 }
 365                 catch( uno::Exception& )
 366                 {}
 367             }
 368
 369             uno::Reference< io::XStream > xDocStream = xRoot->openStreamElement(
 370                                                             sDocName,
 371                                                             embed::ElementModes::READ );
 372             if ( !xDocStream.is() )
 373                 throw uno::RuntimeException();
 374
 375             aParserInput.aInputStream = xDocStream->getInputStream();
 376             OSL_ENSURE( aParserInput.aInputStream.is(),
 377                         "The stream was successfully opened for reading, the input part must be accessible!" );
 378             if ( !aParserInput.aInputStream.is() )
 379                 throw uno::RuntimeException();
 380
 381             // get filter
 382             rtl::Reference< XMLVersionListImport > xImport = new XMLVersionListImport( xContext, aVersions );
 383
 384             // parse
 385             try
 386             {
 387                 xImport->parseStream( aParserInput );
 388             }
 389             catch( SAXParseException&  ) {}
 390             catch( SAXException&  )      {}
 391             catch( io::IOException& )    {}
 392         }
 393     }
 394     catch( uno::Exception& )
 395     {
 396         // TODO: error handling
 397     }
 398
 399     return aVersions;
 400 }
 401
 402 OUString XMLVersionListPersistence::getImplementationName()
 403 {
 404     return u"XMLVersionListPersistence"_ustr;
 405 }
 406
 407 sal_Bool XMLVersionListPersistence::supportsService(
 408     OUString const & ServiceName)
 409 {
 410     return cppu::supportsService(this, ServiceName);
 411 }
 412
 413 css::uno::Sequence<OUString>
 414 XMLVersionListPersistence::getSupportedServiceNames()
 415 {
 416     return css::uno::Sequence<OUString>{
 417         u"com.sun.star.document.DocumentRevisionListPersistence"_ustr};
 418 }
 419
 420 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 421 XMLVersionListPersistence_get_implementation(
 422     css::uno::XComponentContext *,
 423     css::uno::Sequence<css::uno::Any> const &)
 424 {
 425     return cppu::acquire(new XMLVersionListPersistence);
 426 }
 427
 428 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */