scripting/source/protocolhandler/scripthandler.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 "scripthandler.hxx"
  21
  22 #include <com/sun/star/frame/DispatchResultEvent.hpp>
  23 #include <com/sun/star/frame/DispatchResultState.hpp>
  24 #include <com/sun/star/frame/XController.hpp>
  25 #include <com/sun/star/frame/XModel.hpp>
  26
  27 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  28 #include <com/sun/star/document/XScriptInvocationContext.hpp>
  29
  30 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  31 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  32 #include <com/sun/star/script/provider/ScriptFrameworkErrorException.hpp>
  33 #include <com/sun/star/script/provider/XScriptProviderSupplier.hpp>
  34 #include <com/sun/star/script/provider/theMasterScriptProviderFactory.hpp>
  35 #include <com/sun/star/script/provider/ScriptFrameworkErrorType.hpp>
  36
  37 #include <sfx2/objsh.hxx>
  38 #include <sfx2/frame.hxx>
  39 #include <sfx2/sfxdlg.hxx>
  40 #include <vcl/abstdlg.hxx>
  41 #include <tools/diagnose_ex.h>
  42 #include <sal/log.hxx>
  43
  44 #include <comphelper/processfactory.hxx>
  45 #include <cppuhelper/factory.hxx>
  46 #include <cppuhelper/exc_hlp.hxx>
  47 #include <cppuhelper/supportsservice.hxx>
  48 #include <framework/documentundoguard.hxx>
  49 #include <officecfg/Office/Common.hxx>
  50
  51 #include <com/sun/star/uno/XComponentContext.hpp>
  52 #include <com/sun/star/uri/XUriReference.hpp>
  53 #include <com/sun/star/uri/XVndSunStarScriptUrlReference.hpp>
  54 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  55
  56 #include <memory>
  57
  58 using namespace ::com::sun::star;
  59 using namespace ::com::sun::star::uno;
  60 using namespace ::com::sun::star::frame;
  61 using namespace ::com::sun::star::util;
  62 using namespace ::com::sun::star::beans;
  63 using namespace ::com::sun::star::lang;
  64 using namespace ::com::sun::star::script;
  65 using namespace ::com::sun::star::script::provider;
  66 using namespace ::com::sun::star::document;
  67
  68 namespace scripting_protocolhandler
  69 {
  70
  71 void SAL_CALL ScriptProtocolHandler::initialize(
  72     const css::uno::Sequence < css::uno::Any >& aArguments )
  73 {
  74     if ( m_bInitialised )
  75     {
  76         return ;
  77     }
  78
  79     // first argument contains a reference to the frame (may be empty or the desktop,
  80     // but usually it's a "real" frame)
  81     if ( aArguments.hasElements() && !( aArguments[ 0 ] >>= m_xFrame ) )
  82     {
  83         OUString temp = "ScriptProtocolHandler::initialize: could not extract reference to the frame";
  84         throw RuntimeException( temp );
  85     }
  86
  87     ENSURE_OR_THROW( m_xContext.is(), "ScriptProtocolHandler::initialize: No Service Manager available" );
  88     m_bInitialised = true;
  89 }
  90
  91 Reference< XDispatch > SAL_CALL ScriptProtocolHandler::queryDispatch(
  92     const URL& aURL, const OUString&, sal_Int32 )
  93 {
  94     Reference< XDispatch > xDispatcher;
  95     // get scheme of url
  96
  97     Reference< uri::XUriReferenceFactory > xFac = uri::UriReferenceFactory::create( m_xContext );
  98     Reference<  uri::XUriReference > uriRef = xFac->parse( aURL.Complete );
  99     if ( uriRef.is() )
 100     {
 101         if ( uriRef->getScheme() == "vnd.sun.star.script" )
 102         {
 103             xDispatcher = this;
 104         }
 105     }
 106
 107     return xDispatcher;
 108 }
 109
 110 Sequence< Reference< XDispatch > > SAL_CALL
 111 ScriptProtocolHandler::queryDispatches(
 112 const Sequence < DispatchDescriptor >& seqDescriptor )
 113 {
 114     sal_Int32 nCount = seqDescriptor.getLength();
 115     Sequence< Reference< XDispatch > > lDispatcher( nCount );
 116     std::transform(seqDescriptor.begin(), seqDescriptor.end(), lDispatcher.begin(),
 117         [this](const DispatchDescriptor& rDescr) -> Reference<XDispatch> {
 118             return queryDispatch(rDescr.FeatureURL, rDescr.FrameName, rDescr.SearchFlags); });
 119     return lDispatcher;
 120 }
 121
 122 void SAL_CALL ScriptProtocolHandler::dispatchWithNotification(
 123     const URL& aURL, const Sequence < PropertyValue >& lArgs,
 124     const Reference< XDispatchResultListener >& xListener )
 125 {
 126     if (officecfg::Office::Common::Security::Scripting::DisableMacrosExecution::get())
 127         return;
 128
 129     bool bSuccess = false;
 130     Any invokeResult;
 131     bool bCaughtException = false;
 132     Any aException;
 133
 134     if ( m_bInitialised )
 135     {
 136         try
 137         {
 138             css::uno::Reference<css::uri::XUriReferenceFactory> urifac(
 139                 css::uri::UriReferenceFactory::create(m_xContext));
 140             css::uno::Reference<css::uri::XVndSunStarScriptUrlReference> uri(
 141                 urifac->parse(aURL.Complete), css::uno::UNO_QUERY_THROW);
 142             auto const loc = uri->getParameter("location");
 143             bool bIsDocumentScript = loc == "document";
 144
 145             if ( bIsDocumentScript )
 146             {
 147                 // obtain the component for our security check
 148                 Reference< XEmbeddedScripts > xDocumentScripts;
 149                 if ( getScriptInvocation() )
 150                     xDocumentScripts.set( m_xScriptInvocation->getScriptContainer(), UNO_SET_THROW );
 151
 152                 OSL_ENSURE( xDocumentScripts.is(), "ScriptProtocolHandler::dispatchWithNotification: can't do the security check!" );
 153                 if ( !xDocumentScripts.is() || !xDocumentScripts->getAllowMacroExecution() )
 154                 {
 155                     if ( xListener.is() )
 156                     {
 157                         css::frame::DispatchResultEvent aEvent(
 158                                 static_cast< ::cppu::OWeakObject* >( this ),
 159                                 css::frame::DispatchResultState::FAILURE,
 160                                 invokeResult );
 161                         try
 162                         {
 163                             xListener->dispatchFinished( aEvent ) ;
 164                         }
 165                         catch(const RuntimeException &)
 166                         {
 167                             TOOLS_WARN_EXCEPTION("scripting",
 168                                 "ScriptProtocolHandler::dispatchWithNotification: caught RuntimeException"
 169                                 "while dispatchFinished with failure of the execution");
 170                         }
 171                     }
 172                     return;
 173                 }
 174             }
 175
 176             // Creates a ScriptProvider ( if one is not created already )
 177             createScriptProvider();
 178
 179             Reference< provider::XScript > xFunc =
 180                 m_xScriptProvider->getScript( aURL.Complete );
 181             ENSURE_OR_THROW( xFunc.is(),
 182                 "ScriptProtocolHandler::dispatchWithNotification: validate xFunc - unable to obtain XScript interface" );
 183
 184
 185             Sequence< Any > inArgs( 0 );
 186             Sequence< Any > outArgs( 0 );
 187             Sequence< sal_Int16 > outIndex;
 188
 189             if ( lArgs.hasElements() )
 190             {
 191                int argCount = 0;
 192                for ( const auto& rArg : lArgs )
 193                {
 194                    // Sometimes we get a propertyval with name = "Referer" or "SynchronMode". These
 195                    // are not actual arguments to be passed to script, but flags describing the
 196                    // call, so ignore. Who thought that passing such "meta-arguments" mixed in with
 197                    // real arguments was a good idea?
 198                    if ( (rArg.Name != "Referer" &&
 199                          rArg.Name != "SynchronMode") ||
 200                         rArg.Name.isEmpty() ) //TODO:???
 201                    {
 202                        inArgs.realloc( ++argCount );
 203                        inArgs[ argCount - 1 ] = rArg.Value;
 204                    }
 205                }
 206             }
 207
 208             // attempt to protect the document against the script tampering with its Undo Context
 209             std::unique_ptr< ::framework::DocumentUndoGuard > pUndoGuard;
 210             if ( bIsDocumentScript )
 211                 pUndoGuard.reset( new ::framework::DocumentUndoGuard( m_xScriptInvocation ) );
 212
 213             bSuccess = false;
 214             while ( !bSuccess )
 215             {
 216                 std::exception_ptr aFirstCaughtException;
 217                 try
 218                 {
 219                     invokeResult = xFunc->invoke( inArgs, outIndex, outArgs );
 220                     bSuccess = true;
 221                 }
 222                 catch( const provider::ScriptFrameworkErrorException& se )
 223                 {
 224                     if  (!aFirstCaughtException)
 225                         aFirstCaughtException = std::current_exception();
 226
 227                     if ( se.errorType != provider::ScriptFrameworkErrorType::NO_SUCH_SCRIPT )
 228                         // the only condition which allows us to retry is if there is no method with the
 229                         // given name/signature
 230                         std::rethrow_exception(aFirstCaughtException);
 231
 232                     if ( !inArgs.hasElements() )
 233                         // no chance to retry if we can't strip more in-args
 234                         std::rethrow_exception(aFirstCaughtException);
 235
 236                     // strip one argument, then retry
 237                     inArgs.realloc( inArgs.getLength() - 1 );
 238                 }
 239             }
 240         }
 241         // Office doesn't handle exceptions rethrown here very well, it cores,
 242         // all we can is log them and then set fail for the dispatch event!
 243         // (if there is a listener of course)
 244         catch ( const Exception & e )
 245         {
 246             aException = ::cppu::getCaughtException();
 247
 248             OUString reason = "ScriptProtocolHandler::dispatch: caught ";
 249
 250             invokeResult <<= reason.concat( aException.getValueTypeName() ).concat( ": " ).concat( e.Message );
 251
 252             bCaughtException = true;
 253         }
 254     }
 255     else
 256     {
 257         invokeResult <<= OUString(
 258             "ScriptProtocolHandler::dispatchWithNotification failed, ScriptProtocolHandler not initialised"
 259         );
 260     }
 261
 262     if ( bCaughtException )
 263     {
 264         SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
 265         ScopedVclPtr<VclAbstractDialog> pDlg(
 266                 pFact->CreateScriptErrorDialog( aException ));
 267         pDlg->Execute();
 268     }
 269
 270     if ( xListener.is() )
 271     {
 272         // always call dispatchFinished(), because we didn't load a document but
 273         // executed a macro instead!
 274         css::frame::DispatchResultEvent aEvent;
 275
 276         aEvent.Source = static_cast< ::cppu::OWeakObject* >( this );
 277         aEvent.Result = invokeResult;
 278         if ( bSuccess )
 279         {
 280             aEvent.State = css::frame::DispatchResultState::SUCCESS;
 281         }
 282         else
 283         {
 284             aEvent.State = css::frame::DispatchResultState::FAILURE;
 285         }
 286
 287         try
 288         {
 289             xListener->dispatchFinished( aEvent ) ;
 290         }
 291         catch(const RuntimeException &)
 292         {
 293             TOOLS_WARN_EXCEPTION("scripting",
 294                 "ScriptProtocolHandler::dispatchWithNotification: caught RuntimeException"
 295                 "while dispatchFinished" );
 296         }
 297     }
 298 }
 299
 300 void SAL_CALL ScriptProtocolHandler::dispatch(
 301 const URL& aURL, const Sequence< PropertyValue >& lArgs )
 302 {
 303     dispatchWithNotification( aURL, lArgs, Reference< XDispatchResultListener >() );
 304 }
 305
 306 void SAL_CALL ScriptProtocolHandler::addStatusListener(
 307 const Reference< XStatusListener >&, const URL& )
 308 {
 309     // implement if status is supported
 310 }
 311
 312 void SAL_CALL ScriptProtocolHandler::removeStatusListener(
 313 const Reference< XStatusListener >&, const URL& )
 314 {}
 315
 316 bool
 317 ScriptProtocolHandler::getScriptInvocation()
 318 {
 319     if ( !m_xScriptInvocation.is() && m_xFrame.is() )
 320     {
 321         Reference< XController > xController = m_xFrame->getController();
 322         if ( xController .is() )
 323         {
 324             // try to obtain an XScriptInvocationContext interface, preferred from the
 325             // mode, then from the controller
 326             if ( !m_xScriptInvocation.set( xController->getModel(), UNO_QUERY ) )
 327                 m_xScriptInvocation.set( xController, UNO_QUERY );
 328         }
 329         else
 330         {
 331             if ( m_xFrame.is() )
 332             {
 333                 SfxFrame* pFrame = nullptr;
 334                 for ( pFrame = SfxFrame::GetFirst(); pFrame; pFrame = SfxFrame::GetNext( *pFrame ) )
 335                 {
 336                     if ( pFrame->GetFrameInterface() == m_xFrame )
 337                         break;
 338                 }
 339                 SfxObjectShell* pDocShell = pFrame ? pFrame->GetCurrentDocument() : SfxObjectShell::Current();
 340                 if ( pDocShell )
 341                 {
 342                     Reference< XModel > xModel( pDocShell->GetModel() );
 343                     m_xScriptInvocation.set( xModel, UNO_QUERY );
 344                 }
 345             }
 346         }
 347     }
 348     return m_xScriptInvocation.is();
 349 }
 350
 351 void ScriptProtocolHandler::createScriptProvider()
 352 {
 353     if ( m_xScriptProvider.is() )
 354         return;
 355
 356     try
 357     {
 358         // first, ask the component supporting the XScriptInvocationContext interface
 359         // (if there is one) for a script provider
 360         if ( getScriptInvocation() )
 361         {
 362             Reference< XScriptProviderSupplier > xSPS( m_xScriptInvocation, UNO_QUERY );
 363             if ( xSPS.is() )
 364                 m_xScriptProvider = xSPS->getScriptProvider();
 365         }
 366
 367         // second, ask the model in our frame
 368         if ( !m_xScriptProvider.is() && m_xFrame.is() )
 369         {
 370             Reference< XController > xController = m_xFrame->getController();
 371             if ( xController .is() )
 372             {
 373                 Reference< XScriptProviderSupplier > xSPS( xController->getModel(), UNO_QUERY );
 374                 if ( xSPS.is() )
 375                     m_xScriptProvider = xSPS->getScriptProvider();
 376             }
 377         }
 378
 379
 380         // as a fallback, ask the controller
 381         if ( !m_xScriptProvider.is() && m_xFrame.is() )
 382         {
 383             Reference< XScriptProviderSupplier > xSPS( m_xFrame->getController(), UNO_QUERY );
 384             if ( xSPS.is() )
 385                 m_xScriptProvider = xSPS->getScriptProvider();
 386         }
 387
 388         // if nothing of this is successful, use the master script provider
 389         if ( !m_xScriptProvider.is() )
 390         {
 391             Reference< provider::XScriptProviderFactory > xFac =
 392                 provider::theMasterScriptProviderFactory::get( m_xContext );
 393
 394             Any aContext;
 395             if ( getScriptInvocation() )
 396                 aContext <<= m_xScriptInvocation;
 397             m_xScriptProvider.set( xFac->createScriptProvider( aContext ), UNO_SET_THROW );
 398         }
 399     }
 400     catch ( const Exception & e )
 401     {
 402         css::uno::Any anyEx = cppu::getCaughtException();
 403         throw css::lang::WrappedTargetRuntimeException(
 404             "ScriptProtocolHandler::createScriptProvider: " + e.Message,
 405             nullptr, anyEx );
 406     }
 407 }
 408
 409 ScriptProtocolHandler::ScriptProtocolHandler( const Reference< css::uno::XComponentContext > & xContext )
 410   : m_bInitialised( false ), m_xContext( xContext )
 411 {
 412 }
 413
 414 ScriptProtocolHandler::~ScriptProtocolHandler()
 415 {
 416 }
 417
 418 /* XServiceInfo */
 419 OUString SAL_CALL ScriptProtocolHandler::getImplementationName( )
 420 {
 421     return impl_getStaticImplementationName();
 422 }
 423
 424 /* XServiceInfo */
 425 sal_Bool SAL_CALL ScriptProtocolHandler::supportsService(const OUString& sServiceName )
 426 {
 427     return cppu::supportsService(this, sServiceName);
 428 }
 429
 430 /* XServiceInfo */
 431 Sequence< OUString > SAL_CALL ScriptProtocolHandler::getSupportedServiceNames()
 432 {
 433     return impl_getStaticSupportedServiceNames();
 434 }
 435
 436 /* Helper for XServiceInfo */
 437 Sequence< OUString > ScriptProtocolHandler::impl_getStaticSupportedServiceNames()
 438 {
 439     return {"com.sun.star.frame.ProtocolHandler"};
 440 }
 441
 442 /* Helper for XServiceInfo */
 443 OUString ScriptProtocolHandler::impl_getStaticImplementationName()
 444 {
 445     return "com.sun.star.comp.ScriptProtocolHandler";
 446 }
 447
 448 /* Helper for registry */
 449 Reference< XInterface > SAL_CALL ScriptProtocolHandler::impl_createInstance(
 450 const Reference< css::lang::XMultiServiceFactory >& xServiceManager )
 451 {
 452     return Reference< XInterface > ( *new ScriptProtocolHandler( comphelper::getComponentContext(xServiceManager) ) );
 453 }
 454
 455 /* Factory for registration */
 456 Reference< XSingleServiceFactory > ScriptProtocolHandler::impl_createFactory(
 457 const Reference< XMultiServiceFactory >& xServiceManager )
 458 {
 459     Reference< XSingleServiceFactory > xReturn (
 460         cppu::createSingleFactory( xServiceManager,
 461             ScriptProtocolHandler::impl_getStaticImplementationName(),
 462             ScriptProtocolHandler::impl_createInstance,
 463             ScriptProtocolHandler::impl_getStaticSupportedServiceNames() )
 464     );
 465     return xReturn;
 466 }
 467
 468 } // namespace scripting_protocolhandler
 469
 470 extern "C"
 471 {
 472     SAL_DLLPUBLIC_EXPORT void* protocolhandler_component_getFactory( const sal_Char * pImplementationName ,
 473                                          void * pServiceManager ,
 474                                          void * )
 475     {
 476         // Set default return value for this operation - if it failed.
 477         void * pReturn = nullptr ;
 478
 479         if (
 480             ( pImplementationName != nullptr ) &&
 481             ( pServiceManager != nullptr )
 482         )
 483         {
 484             // Define variables which are used in following macros.
 485             css::uno::Reference< css::lang::XSingleServiceFactory > xFactory;
 486             css::uno::Reference< css::lang::XMultiServiceFactory > xServiceManager(
 487                 static_cast< css::lang::XMultiServiceFactory* >( pServiceManager ) ) ;
 488
 489             if ( ::scripting_protocolhandler::ScriptProtocolHandler::impl_getStaticImplementationName().equalsAscii(
 490                     pImplementationName ) )
 491             {
 492                 xFactory = ::scripting_protocolhandler::ScriptProtocolHandler::impl_createFactory( xServiceManager );
 493             }
 494
 495             // Factory is valid - service was found.
 496             if ( xFactory.is() )
 497             {
 498                 xFactory->acquire();
 499                 pReturn = xFactory.get();
 500             }
 501         }
 502
 503         // Return with result of this operation.
 504         return pReturn ;
 505     }
 506 } // extern "C"
 507
 508
 509 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */