ucb/source/ucp/file/prov.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 <osl/security.hxx>
  21 #include <osl/file.hxx>
  22 #include <osl/socket.h>
  23 #include <cppuhelper/queryinterface.hxx>
  24 #include <comphelper/processfactory.hxx>
  25 #include <com/sun/star/beans/PropertyAttribute.hpp>
  26 #include <com/sun/star/ucb/FileSystemNotation.hpp>
  27 #include <com/sun/star/ucb/IllegalIdentifierException.hpp>
  28 #include <cppuhelper/factory.hxx>
  29 #include <cppuhelper/supportsservice.hxx>
  30 #include "filglob.hxx"
  31 #include "filid.hxx"
  32 #include "filtask.hxx"
  33 #include "bc.hxx"
  34 #include "prov.hxx"
  35
  36 using namespace fileaccess;
  37 using namespace com::sun::star;
  38 using namespace com::sun::star::uno;
  39 using namespace com::sun::star::lang;
  40 using namespace com::sun::star::beans;
  41 using namespace com::sun::star::ucb;
  42 using namespace com::sun::star::container;
  43
  44 #if OSL_DEBUG_LEVEL > 0
  45 #define THROW_WHERE SAL_WHERE
  46 #else
  47 #define THROW_WHERE ""
  48 #endif
  49
  50
  51 extern "C" SAL_DLLPUBLIC_EXPORT void * ucpfile_component_getFactory(
  52     const sal_Char * pImplName, void * pServiceManager, void * )
  53 {
  54     void * pRet = nullptr;
  55
  56     Reference< XMultiServiceFactory > xSMgr(
  57             static_cast< XMultiServiceFactory * >( pServiceManager ) );
  58     Reference< XSingleServiceFactory > xFactory;
  59
  60
  61     // File Content Provider.
  62
  63
  64     if ( fileaccess::TaskManager::getImplementationName_static().
  65             equalsAscii( pImplName ) )
  66     {
  67         xFactory = FileProvider::createServiceFactory( xSMgr );
  68     }
  69
  70
  71     if ( xFactory.is() )
  72     {
  73         xFactory->acquire();
  74         pRet = xFactory.get();
  75     }
  76
  77     return pRet;
  78 }
  79
  80 /****************************************************************************/
  81 /*                                                                          */
  82 /*                                                                          */
  83 /*                        FileProvider                                      */
  84 /*                                                                          */
  85 /*                                                                          */
  86 /****************************************************************************/
  87 FileProvider::FileProvider( const Reference< XComponentContext >& rxContext )
  88     : m_xContext(rxContext)
  89     , m_FileSystemNotation(FileSystemNotation::UNKNOWN_NOTATION)
  90 {
  91 }
  92
  93 FileProvider::~FileProvider()
  94 {
  95 }
  96
  97 // XInitialization
  98 void FileProvider::init()
  99 {
 100     if( ! m_pMyShell )
 101         m_pMyShell.reset( new TaskManager( m_xContext, this, true ) );
 102 }
 103
 104
 105 void SAL_CALL
 106 FileProvider::initialize(
 107     const Sequence< Any >& aArguments )
 108 {
 109     if( ! m_pMyShell ) {
 110         OUString config;
 111         if( aArguments.hasElements() &&
 112             (aArguments[0] >>= config) &&
 113             config == "NoConfig" )
 114             m_pMyShell.reset( new TaskManager( m_xContext, this, false ) );
 115         else
 116             m_pMyShell.reset( new TaskManager( m_xContext, this, true ) );
 117     }
 118 }
 119
 120 // XServiceInfo methods.
 121 OUString SAL_CALL
 122 FileProvider::getImplementationName()
 123 {
 124     return fileaccess::TaskManager::getImplementationName_static();
 125 }
 126
 127 sal_Bool SAL_CALL FileProvider::supportsService(const OUString& ServiceName )
 128 {
 129     return cppu::supportsService(this, ServiceName);
 130 }
 131
 132 Sequence< OUString > SAL_CALL
 133 FileProvider::getSupportedServiceNames()
 134 {
 135     return fileaccess::TaskManager::getSupportedServiceNames_static();
 136 }
 137
 138 Reference< XSingleServiceFactory >
 139 FileProvider::createServiceFactory(
 140                    const Reference< XMultiServiceFactory >& rxServiceMgr )
 141 {
 142     return cppu::createSingleFactory(
 143         rxServiceMgr,
 144         fileaccess::TaskManager::getImplementationName_static(),
 145         FileProvider::CreateInstance,
 146         fileaccess::TaskManager::getSupportedServiceNames_static() );
 147 }
 148
 149 Reference< XInterface > SAL_CALL
 150 FileProvider::CreateInstance(
 151     const Reference< XMultiServiceFactory >& xMultiServiceFactory )
 152 {
 153     XServiceInfo* xP = new FileProvider(comphelper::getComponentContext(xMultiServiceFactory));
 154     return Reference< XInterface >::query( xP );
 155 }
 156
 157
 158 // XContent
 159
 160
 161 Reference< XContent > SAL_CALL
 162 FileProvider::queryContent(
 163     const Reference< XContentIdentifier >& xIdentifier )
 164 {
 165     init();
 166     OUString aUnc;
 167     bool err = fileaccess::TaskManager::getUnqFromUrl( xIdentifier->getContentIdentifier(),
 168                                               aUnc );
 169
 170     if(  err )
 171         throw IllegalIdentifierException( THROW_WHERE );
 172
 173     return Reference< XContent >( new BaseContent( m_pMyShell.get(), xIdentifier, aUnc ) );
 174 }
 175
 176
 177 sal_Int32 SAL_CALL
 178 FileProvider::compareContentIds(
 179                 const Reference< XContentIdentifier >& Id1,
 180                 const Reference< XContentIdentifier >& Id2 )
 181 {
 182     init();
 183     OUString aUrl1 = Id1->getContentIdentifier();
 184     OUString aUrl2 = Id2->getContentIdentifier();
 185
 186     sal_Int32   iComp = aUrl1.compareTo( aUrl2 );
 187
 188     if ( 0 != iComp )
 189     {
 190         OUString aPath1, aPath2;
 191
 192         fileaccess::TaskManager::getUnqFromUrl( aUrl1, aPath1 );
 193         fileaccess::TaskManager::getUnqFromUrl( aUrl2, aPath2 );
 194
 195         osl::FileBase::RC   error;
 196         osl::DirectoryItem  aItem1, aItem2;
 197
 198         error = osl::DirectoryItem::get( aPath1, aItem1 );
 199         if ( error == osl::FileBase::E_None )
 200             error = osl::DirectoryItem::get( aPath2, aItem2 );
 201
 202         if ( error != osl::FileBase::E_None )
 203             return iComp;
 204
 205         osl::FileStatus aStatus1( osl_FileStatus_Mask_FileURL );
 206         osl::FileStatus aStatus2( osl_FileStatus_Mask_FileURL );
 207         error = aItem1.getFileStatus( aStatus1 );
 208         if ( error == osl::FileBase::E_None )
 209             error = aItem2.getFileStatus( aStatus2 );
 210
 211         if ( error == osl::FileBase::E_None )
 212         {
 213             iComp = aStatus1.getFileURL().compareTo( aStatus2.getFileURL() );
 214
 215 // Quick hack for Windows to threat all file systems as case insensitive
 216 #ifdef _WIN32
 217             if ( 0 != iComp )
 218             {
 219                 error = osl::FileBase::getSystemPathFromFileURL( aStatus1.getFileURL(), aPath1 );
 220                 if ( error == osl::FileBase::E_None )
 221                     error = osl::FileBase::getSystemPathFromFileURL( aStatus2.getFileURL(), aPath2 );
 222
 223                 if ( error == osl::FileBase::E_None )
 224                     iComp = aPath1.compareToIgnoreAsciiCase( aPath2 );
 225             }
 226 #endif
 227         }
 228     }
 229
 230     return iComp;
 231 }
 232
 233
 234 Reference< XContentIdentifier > SAL_CALL
 235 FileProvider::createContentIdentifier(
 236                       const OUString& ContentId )
 237 {
 238     init();
 239     FileContentIdentifier* p = new FileContentIdentifier( ContentId,false );
 240     return Reference< XContentIdentifier >( p );
 241 }
 242
 243
 244 //XPropertySetInfoImpl
 245
 246 class XPropertySetInfoImpl2
 247     : public cppu::OWeakObject,
 248       public XPropertySetInfo
 249 {
 250 public:
 251     XPropertySetInfoImpl2();
 252
 253     // XInterface
 254     virtual Any SAL_CALL
 255     queryInterface( const Type& aType ) override;
 256
 257     virtual void SAL_CALL
 258     acquire()
 259         throw() override;
 260
 261     virtual void SAL_CALL
 262     release()
 263         throw() override;
 264
 265
 266     virtual Sequence< Property > SAL_CALL
 267     getProperties() override;
 268
 269     virtual Property SAL_CALL
 270     getPropertyByName( const OUString& aName ) override;
 271
 272     virtual sal_Bool SAL_CALL
 273     hasPropertyByName( const OUString& Name ) override;
 274
 275
 276 private:
 277     Sequence< Property > m_seq;
 278 };
 279
 280
 281 XPropertySetInfoImpl2::XPropertySetInfoImpl2()
 282     : m_seq( 3 )
 283 {
 284     m_seq[0] = Property( "HostName",
 285                          -1,
 286                          cppu::UnoType<OUString>::get(),
 287                          PropertyAttribute::READONLY );
 288
 289     m_seq[1] = Property( "HomeDirectory",
 290                          -1,
 291                          cppu::UnoType<OUString>::get(),
 292                          PropertyAttribute::READONLY );
 293
 294     m_seq[2] = Property( "FileSystemNotation",
 295                          -1,
 296                          cppu::UnoType<sal_Int32>::get(),
 297                          PropertyAttribute::READONLY );
 298 }
 299
 300 void SAL_CALL
 301 XPropertySetInfoImpl2::acquire()
 302     throw()
 303 {
 304     OWeakObject::acquire();
 305 }
 306
 307
 308 void SAL_CALL
 309 XPropertySetInfoImpl2::release()
 310     throw()
 311 {
 312     OWeakObject::release();
 313 }
 314
 315
 316 Any SAL_CALL
 317 XPropertySetInfoImpl2::queryInterface( const Type& rType )
 318 {
 319     Any aRet = cppu::queryInterface( rType,
 320                                      static_cast< XPropertySetInfo* >(this) );
 321     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 322 }
 323
 324
 325 Property SAL_CALL
 326 XPropertySetInfoImpl2::getPropertyByName( const OUString& aName )
 327 {
 328     auto pProp = std::find_if(m_seq.begin(), m_seq.end(),
 329             [&aName](const Property& rProp) { return rProp.Name == aName; });
 330     if (pProp != m_seq.end())
 331         return *pProp;
 332
 333     throw UnknownPropertyException( aName );
 334 }
 335
 336
 337 Sequence< Property > SAL_CALL
 338 XPropertySetInfoImpl2::getProperties()
 339 {
 340     return m_seq;
 341 }
 342
 343
 344 sal_Bool SAL_CALL
 345 XPropertySetInfoImpl2::hasPropertyByName(
 346     const OUString& aName )
 347 {
 348     return std::any_of(m_seq.begin(), m_seq.end(),
 349         [&aName](const Property& rProp) { return rProp.Name == aName; });
 350 }
 351
 352
 353 void FileProvider::initProperties()
 354 {
 355     osl::MutexGuard aGuard( m_aMutex );
 356     if( ! m_xPropertySetInfo.is() )
 357     {
 358         osl_getLocalHostname( &m_HostName.pData );
 359
 360 #if defined ( UNX )
 361         m_FileSystemNotation = FileSystemNotation::UNIX_NOTATION;
 362 #elif defined( WNT )
 363         m_FileSystemNotation = FileSystemNotation::DOS_NOTATION;
 364 #else
 365         m_FileSystemNotation = FileSystemNotation::UNKNOWN_NOTATION;
 366 #endif
 367         osl::Security aSecurity;
 368         aSecurity.getHomeDir( m_HomeDirectory );
 369
 370         // static const sal_Int32 UNKNOWN_NOTATION = (sal_Int32)0;
 371         // static const sal_Int32 UNIX_NOTATION = (sal_Int32)1;
 372         // static const sal_Int32 DOS_NOTATION = (sal_Int32)2;
 373         // static const sal_Int32 MAC_NOTATION = (sal_Int32)3;
 374
 375         XPropertySetInfoImpl2* p = new XPropertySetInfoImpl2();
 376         m_xPropertySetInfo.set( p );
 377     }
 378 }
 379
 380
 381 // XPropertySet
 382
 383 Reference< XPropertySetInfo > SAL_CALL
 384 FileProvider::getPropertySetInfo(  )
 385 {
 386     initProperties();
 387     return m_xPropertySetInfo;
 388 }
 389
 390
 391 void SAL_CALL
 392 FileProvider::setPropertyValue( const OUString& aPropertyName,
 393                                 const Any& )
 394 {
 395     if( !(aPropertyName == "FileSystemNotation" ||
 396         aPropertyName == "HomeDirectory"      ||
 397         aPropertyName == "HostName") )
 398         throw UnknownPropertyException( aPropertyName );
 399 }
 400
 401
 402 Any SAL_CALL
 403 FileProvider::getPropertyValue(
 404     const OUString& aPropertyName )
 405 {
 406     initProperties();
 407     if( aPropertyName == "FileSystemNotation" )
 408     {
 409         return Any(m_FileSystemNotation);
 410     }
 411     else if( aPropertyName == "HomeDirectory" )
 412     {
 413         return Any(m_HomeDirectory);
 414     }
 415     else if( aPropertyName == "HostName" )
 416     {
 417         return Any(m_HostName);
 418     }
 419     else
 420         throw UnknownPropertyException( aPropertyName );
 421 }
 422
 423
 424 void SAL_CALL
 425 FileProvider::addPropertyChangeListener(
 426     const OUString&,
 427     const Reference< XPropertyChangeListener >& )
 428 {
 429 }
 430
 431
 432 void SAL_CALL
 433 FileProvider::removePropertyChangeListener(
 434     const OUString&,
 435     const Reference< XPropertyChangeListener >& )
 436 {
 437 }
 438
 439 void SAL_CALL
 440 FileProvider::addVetoableChangeListener(
 441     const OUString&,
 442     const Reference< XVetoableChangeListener >& )
 443 {
 444 }
 445
 446
 447 void SAL_CALL
 448 FileProvider::removeVetoableChangeListener(
 449     const OUString&,
 450     const Reference< XVetoableChangeListener >& )
 451 {
 452 }
 453
 454
 455 // XFileIdentifierConverter
 456
 457 sal_Int32 SAL_CALL
 458 FileProvider::getFileProviderLocality( const OUString& BaseURL )
 459 {
 460     // If the base URL is a 'file' URL, return 10 (very 'local'), otherwise
 461     // return -1 (mismatch).  What is missing is a fast comparison to ASCII,
 462     // ignoring case:
 463     return BaseURL.getLength() >= 5
 464            && (BaseURL[0] == 'F' || BaseURL[0] == 'f')
 465            && (BaseURL[1] == 'I' || BaseURL[1] == 'i')
 466            && (BaseURL[2] == 'L' || BaseURL[2] == 'l')
 467            && (BaseURL[3] == 'E' || BaseURL[3] == 'e')
 468            && BaseURL[4] == ':' ?
 469                10 : -1;
 470 }
 471
 472 OUString SAL_CALL FileProvider::getFileURLFromSystemPath( const OUString&,
 473                                                                const OUString& SystemPath )
 474 {
 475     OUString aNormalizedPath;
 476     if ( osl::FileBase::getFileURLFromSystemPath( SystemPath,aNormalizedPath ) != osl::FileBase::E_None )
 477         return OUString();
 478
 479     return aNormalizedPath;
 480 }
 481
 482 OUString SAL_CALL FileProvider::getSystemPathFromFileURL( const OUString& URL )
 483 {
 484     OUString aSystemPath;
 485     if (osl::FileBase::getSystemPathFromFileURL( URL,aSystemPath ) != osl::FileBase::E_None )
 486         return OUString();
 487
 488     return aSystemPath;
 489 }
 490
 491 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */