ucb/source/ucp/ftp/ftpcontentprovider.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 <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  23 #include <com/sun/star/ucb/IllegalIdentifierException.hpp>
  24 #include <com/sun/star/ucb/UniversalContentBroker.hpp>
  25 #include <cppuhelper/exc_hlp.hxx>
  26 #include <cppuhelper/queryinterface.hxx>
  27 #include <cppuhelper/typeprovider.hxx>
  28 #include <cppuhelper/supportsservice.hxx>
  29 #include <cppuhelper/weak.hxx>
  30 #include "ftpcontentprovider.hxx"
  31 #include "ftpcontent.hxx"
  32 #include "ftploaderthread.hxx"
  33
  34 using namespace ftp;
  35 using namespace com::sun::star::lang;
  36 using namespace com::sun::star::container;
  37 using namespace com::sun::star::uno;
  38 using namespace com::sun::star::ucb;
  39 using namespace com::sun::star::beans;
  40
  41 // ContentProvider Implementation.
  42
  43 FTPContentProvider::FTPContentProvider( const Reference< XComponentContext >& rxContext)
  44     : ::ucbhelper::ContentProviderImplHelper(rxContext)
  45 {
  46 }
  47
  48
  49 // virtual
  50 FTPContentProvider::~FTPContentProvider()
  51 {
  52     m_ftpLoaderThread.reset();
  53     m_pProxyDecider.reset();
  54 }
  55
  56 // XInterface methods.
  57 void SAL_CALL FTPContentProvider::acquire()
  58     noexcept
  59 {
  60     OWeakObject::acquire();
  61 }
  62
  63 void SAL_CALL FTPContentProvider::release()
  64     noexcept
  65 {
  66     OWeakObject::release();
  67 }
  68
  69 css::uno::Any SAL_CALL FTPContentProvider::queryInterface( const css::uno::Type & rType )
  70 {
  71     css::uno::Any aRet = cppu::queryInterface( rType,
  72                                                static_cast< XTypeProvider* >(this),
  73                                                static_cast< XServiceInfo* >(this),
  74                                                static_cast< XContentProvider* >(this)
  75         );
  76     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
  77 }
  78
  79 // XTypeProvider methods.
  80 css::uno::Sequence< sal_Int8 > SAL_CALL FTPContentProvider::getImplementationId()
  81 {
  82     return css::uno::Sequence<sal_Int8>();
  83 }
  84
  85 css::uno::Sequence< css::uno::Type > SAL_CALL FTPContentProvider::getTypes()
  86 {
  87     static cppu::OTypeCollection s_aCollection(
  88                     cppu::UnoType<XTypeProvider>::get(),
  89                     cppu::UnoType<XServiceInfo>::get(),
  90                     cppu::UnoType<XContentProvider>::get()
  91                 );
  92
  93     return s_aCollection.getTypes();
  94 }
  95
  96
  97 // XServiceInfo methods.
  98
  99 OUString SAL_CALL FTPContentProvider::getImplementationName()
 100 {
 101     return "com.sun.star.comp.FTPContentProvider";
 102 }
 103
 104 sal_Bool SAL_CALL FTPContentProvider::supportsService( const OUString& ServiceName )
 105 {
 106     return cppu::supportsService( this, ServiceName );
 107 }
 108
 109 css::uno::Sequence< OUString > SAL_CALL FTPContentProvider::getSupportedServiceNames()
 110 {
 111     return { FTP_CONTENT_PROVIDER_SERVICE_NAME };
 112 }
 113
 114
 115
 116 // XContentProvider methods.
 117
 118 // virtual
 119 Reference<XContent> SAL_CALL FTPContentProvider::queryContent(
 120         const Reference< XContentIdentifier >& xCanonicId)
 121 {
 122     // Check, if a content with given id already exists...
 123     Reference<XContent> xContent = queryExistingContent(xCanonicId);
 124     if(xContent.is())
 125         return xContent;
 126
 127     // A new content has to be returned:
 128     {
 129         // Initialize
 130         osl::MutexGuard aGuard( m_aMutex );
 131         if(!m_ftpLoaderThread || !m_pProxyDecider)
 132         {
 133             try {
 134                 init();
 135             } catch (css::uno::Exception const & ex) {
 136                 css::uno::Any anyEx = cppu::getCaughtException();
 137                 throw css::lang::WrappedTargetRuntimeException( ex.Message,
 138                                 css::uno::Reference< css::uno::XInterface >(),
 139                                 anyEx );
 140             } catch( ... ) {
 141                 throw RuntimeException();
 142             }
 143
 144             if(!m_ftpLoaderThread || !m_pProxyDecider)
 145                 throw RuntimeException();
 146         }
 147     }
 148
 149     try {
 150         FTPURL aURL(xCanonicId->getContentIdentifier(),
 151                     this);
 152
 153         if(!m_pProxyDecider->shouldUseProxy(
 154             "ftp",
 155             aURL.host(),
 156             aURL.port().toInt32()))
 157         {
 158             xContent = new FTPContent( m_xContext, this,xCanonicId,aURL);
 159             registerNewContent(xContent);
 160         }
 161         else {
 162             Reference<XContentProvider> xProvider(UniversalContentBroker::create( m_xContext )->queryContentProvider("http:"));
 163             if(!xProvider.is())
 164                 throw RuntimeException();
 165             return xProvider->queryContent(xCanonicId);
 166         }
 167     } catch(const malformed_exception&) {
 168         throw IllegalIdentifierException();
 169     }
 170
 171     // may throw IllegalIdentifierException
 172     return xContent;
 173 }
 174
 175 void FTPContentProvider::init()
 176 {
 177     m_ftpLoaderThread.reset( new FTPLoaderThread() );
 178     m_pProxyDecider.reset( new ucbhelper::InternetProxyDecider( m_xContext ) );
 179 }
 180
 181 CURL* FTPContentProvider::handle()
 182 {
 183     // Cannot be zero if called from here;
 184     return m_ftpLoaderThread->handle();
 185 }
 186
 187
 188 void FTPContentProvider::forHost( std::u16string_view host,
 189                                   std::u16string_view port,
 190                                   std::u16string_view username,
 191                                   OUString& password,
 192                                   OUString& account)
 193 {
 194     osl::MutexGuard aGuard(m_aMutex);
 195     for(const ServerInfo & i : m_ServerInfo)
 196         if(host == i.host &&
 197            port == i.port &&
 198            username == i.username )
 199         {
 200             password = i.password;
 201             account = i.account;
 202             return;
 203         }
 204 }
 205
 206 bool  FTPContentProvider::setHost( const OUString& host,
 207                                    const OUString& port,
 208                                    const OUString& username,
 209                                    const OUString& password,
 210                                    const OUString& account)
 211 {
 212     ServerInfo inf;
 213     inf.host = host;
 214     inf.port = port;
 215     inf.username = username;
 216     inf.password = password;
 217     inf.account = account;
 218
 219     bool present(false);
 220     osl::MutexGuard aGuard(m_aMutex);
 221     for(ServerInfo & i : m_ServerInfo)
 222         if(host == i.host &&
 223            port == i.port &&
 224            username == i.username)
 225         {
 226             present = true;
 227             i.password = password;
 228             i.account = account;
 229         }
 230
 231     if(!present)
 232         m_ServerInfo.push_back(inf);
 233
 234     return !present;
 235 }
 236
 237 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 238 ucb_ftp_FTPContentProvider_get_implementation(
 239     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
 240 {
 241     return cppu::acquire(new FTPContentProvider(context));
 242 }
 243
 244 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */