desktop/source/offacc/acceptor.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 "acceptor.hxx"
  23 #include <com/sun/star/bridge/BridgeFactory.hpp>
  24 #include <com/sun/star/connection/Acceptor.hpp>
  25 #include <com/sun/star/uno/XNamingService.hpp>
  26 #include <officecfg/Office/Security.hxx>
  27 #include <cppuhelper/supportsservice.hxx>
  28 #include <sal/log.hxx>
  29 #include <comphelper/diagnose_ex.hxx>
  30 #include <o3tl/string_view.hxx>
  31
  32 using namespace css::bridge;
  33 using namespace css::connection;
  34 using namespace css::lang;
  35 using namespace css::uno;
  36
  37 namespace desktop
  38 {
  39
  40 extern "C" {
  41
  42 static void offacc_workerfunc (void * acc)
  43 {
  44     osl_setThreadName("URP Acceptor");
  45
  46     static_cast<Acceptor*>(acc)->run();
  47 }
  48
  49 }
  50
  51 Acceptor::Acceptor( const Reference< XComponentContext >& rxContext )
  52     : m_thread(nullptr)
  53     , m_rContext(rxContext)
  54     , m_bInit(false)
  55     , m_bDying(false)
  56 {
  57     m_rAcceptor = css::connection::Acceptor::create(m_rContext);
  58     m_rBridgeFactory = BridgeFactory::create(m_rContext);
  59 }
  60
  61
  62 Acceptor::~Acceptor()
  63 {
  64     m_rAcceptor->stopAccepting();
  65     oslThread t;
  66     {
  67         std::unique_lock g(m_aMutex);
  68         t = m_thread;
  69     }
  70     //prevent locking if the thread is still waiting
  71     m_bDying = true;
  72     m_cEnable.set();
  73     osl_joinWithThread(t);
  74     osl_destroyThread(t);
  75     {
  76         // Make the final state of m_bridges visible to this thread (since
  77         // m_thread is joined, the code that follows is the only one left
  78         // accessing m_bridges):
  79         std::unique_lock g(m_aMutex);
  80     }
  81     for (;;) {
  82         css::uno::Reference< css::bridge::XBridge > b(m_bridges.remove());
  83         if (!b.is()) {
  84             break;
  85         }
  86         css::uno::Reference< css::lang::XComponent >(
  87             b, css::uno::UNO_QUERY_THROW)->dispose();
  88     }
  89 }
  90
  91 void Acceptor::run()
  92 {
  93     SAL_INFO( "desktop.offacc", "Acceptor::run" );
  94     for (;;)
  95     {
  96         try
  97         {
  98             // wait until we get enabled
  99             SAL_INFO( "desktop.offacc",
 100                 "Acceptor::run waiting for office to come up");
 101             m_cEnable.wait();
 102             if (m_bDying) //see destructor
 103                 break;
 104             SAL_INFO( "desktop.offacc",
 105                 "Acceptor::run now enabled and continuing");
 106
 107             std::unique_lock g(m_aMutex);
 108
 109             // accept connection
 110             Reference< XConnection > rConnection = m_rAcceptor->accept( m_aConnectString );
 111             // if we return without a valid connection we must assume that the acceptor
 112             // is destructed so we break out of the run method terminating the thread
 113             if (! rConnection.is()) break;
 114             OUString aDescription = rConnection->getDescription();
 115             SAL_INFO( "desktop.offacc", "Acceptor::run connection " << aDescription );
 116
 117             // create instanceprovider for this connection
 118             Reference< XInstanceProvider > rInstanceProvider(new AccInstanceProvider(m_rContext));
 119             // create the bridge. The remote end will have a reference to this bridge
 120             // thus preventing the bridge from being disposed. When the remote end releases
 121             // the bridge, it will be destructed.
 122             m_bridges.add(m_rBridgeFactory->createBridge(
 123                 u""_ustr, m_aProtocol, rConnection, rInstanceProvider));
 124         } catch (const Exception&) {
 125             TOOLS_WARN_EXCEPTION("desktop.offacc", "");
 126             // connection failed...
 127             // something went wrong during connection setup.
 128             // just wait for a new connection to accept
 129         }
 130     }
 131 }
 132
 133 // XInitialize
 134 void Acceptor::initialize( const Sequence<Any>& aArguments )
 135 {
 136     // prevent multiple initialization
 137     std::unique_lock aGuard( m_aMutex );
 138     SAL_INFO( "desktop.offacc", "Acceptor::initialize()" );
 139
 140     bool bOk = false;
 141
 142     // arg count
 143     int nArgs = aArguments.getLength();
 144
 145     // not yet initialized and accept-string
 146     if (!m_bInit && nArgs > 0 && (aArguments[0] >>= m_aAcceptString))
 147     {
 148         SAL_INFO( "desktop.offacc", "Acceptor::initialize string=" << m_aAcceptString );
 149
 150         // get connect string and protocol from accept string
 151         // "<connectString>;<protocol>"
 152         sal_Int32 nIndex1 = m_aAcceptString.indexOf( ';' );
 153         if (nIndex1 < 0)
 154             throw IllegalArgumentException(
 155                     u"Invalid accept-string format"_ustr, m_rContext, 1);
 156         m_aConnectString = o3tl::trim(m_aAcceptString.subView( 0 , nIndex1 ));
 157         nIndex1++;
 158         sal_Int32 nIndex2 = m_aAcceptString.indexOf( ';' , nIndex1 );
 159         if (nIndex2 < 0) nIndex2 = m_aAcceptString.getLength();
 160         m_aProtocol = m_aAcceptString.copy( nIndex1, nIndex2 - nIndex1 );
 161
 162         // start accepting in new thread...
 163         m_thread = osl_createThread(offacc_workerfunc, this);
 164         m_bInit = true;
 165         bOk = true;
 166     }
 167
 168     // do we want to enable accepting?
 169     bool bEnable = false;
 170     if (((nArgs == 1 && (aArguments[0] >>= bEnable)) ||
 171          (nArgs == 2 && (aArguments[1] >>= bEnable))) &&
 172         bEnable )
 173     {
 174         m_cEnable.set();
 175         bOk = true;
 176     }
 177
 178     if (!bOk)
 179     {
 180         throw IllegalArgumentException( u"invalid initialization"_ustr, m_rContext, 1);
 181     }
 182 }
 183
 184 // XServiceInfo
 185 OUString Acceptor::getImplementationName()
 186 {
 187     return u"com.sun.star.office.comp.Acceptor"_ustr;
 188 }
 189 Sequence<OUString> Acceptor::getSupportedServiceNames()
 190 {
 191     return { u"com.sun.star.office.Acceptor"_ustr };
 192 }
 193
 194 sal_Bool Acceptor::supportsService(OUString const & ServiceName)
 195 {
 196     return cppu::supportsService(this, ServiceName);
 197 }
 198
 199
 200 // InstanceProvider
 201 AccInstanceProvider::AccInstanceProvider(const Reference<XComponentContext>& rxContext)
 202   : m_rContext(rxContext)
 203 {
 204 }
 205
 206 AccInstanceProvider::~AccInstanceProvider()
 207 {
 208 }
 209
 210 Reference<XInterface> AccInstanceProvider::getInstance (const OUString& aName )
 211 {
 212
 213     Reference<XInterface> rInstance;
 214
 215     if ( aName == "StarOffice.ServiceManager" )
 216     {
 217         rInstance.set( m_rContext->getServiceManager() );
 218     }
 219     else if ( aName == "StarOffice.ComponentContext" )
 220     {
 221         rInstance = m_rContext;
 222     }
 223     else if ( aName == "StarOffice.NamingService" )
 224     {
 225         Reference< XNamingService > rNamingService(
 226             m_rContext->getServiceManager()->createInstanceWithContext(u"com.sun.star.uno.NamingService"_ustr, m_rContext),
 227             UNO_QUERY );
 228         if ( rNamingService.is() )
 229         {
 230             rNamingService->registerObject( u"StarOffice.ServiceManager"_ustr, m_rContext->getServiceManager() );
 231             rNamingService->registerObject( u"StarOffice.ComponentContext"_ustr, m_rContext );
 232             rInstance = rNamingService;
 233         }
 234     }
 235     return rInstance;
 236 }
 237
 238 }
 239
 240 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 241 desktop_Acceptor_get_implementation(
 242     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
 243 {
 244     if (!officecfg::Office::Security::Net::AllowInsecureUNORemoteProtocol::get())
 245     {
 246         // this is not allowed to throw
 247         SAL_WARN("desktop", "UNO Remote Protocol is disabled by configuration");
 248         return nullptr;
 249     }
 250     return cppu::acquire(new desktop::Acceptor(context));
 251 }
 252
 253
 254 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */