LCOV - code coverage report
Current view: top level - libreoffice/ucb/source/ucp/file - filglob.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 92 346 26.6 %
Date: 2012-12-27 Functions: 5 8 62.5 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <stdio.h>
      21             : #include "filglob.hxx"
      22             : #include "filerror.hxx"
      23             : #include "shell.hxx"
      24             : #include "bc.hxx"
      25             : #include <osl/file.hxx>
      26             : #include <vector>
      27             : #include <ucbhelper/cancelcommandexecution.hxx>
      28             : #include <com/sun/star/ucb/CommandAbortedException.hpp>
      29             : #include <com/sun/star/ucb/UnsupportedCommandException.hpp>
      30             : #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
      31             : #include <com/sun/star/lang/IllegalArgumentException.hpp>
      32             : #include <com/sun/star/ucb/IOErrorCode.hpp>
      33             : #include <com/sun/star/ucb/MissingPropertiesException.hpp>
      34             : #include <com/sun/star/ucb/MissingInputStreamException.hpp>
      35             : #include <com/sun/star/ucb/NameClashException.hpp>
      36             : #include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp>
      37             : #include <com/sun/star/ucb/UnsupportedNameClashException.hpp>
      38             : #include "com/sun/star/beans/PropertyState.hpp"
      39             : #include "com/sun/star/beans/PropertyValue.hpp"
      40             : #include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp>
      41             : #include "com/sun/star/uno/Any.hxx"
      42             : #include "com/sun/star/uno/Sequence.hxx"
      43             : #include "osl/diagnose.h"
      44             : #include "rtl/ustrbuf.hxx"
      45             : #include <rtl/uri.hxx>
      46             : #include <rtl/ustring.hxx>
      47             : #include "sal/types.h"
      48             : 
      49             : using namespace ucbhelper;
      50             : using namespace osl;
      51             : using namespace ::com::sun::star;
      52             : using namespace com::sun::star::task;
      53             : using namespace com::sun::star::beans;
      54             : using namespace com::sun::star::lang;
      55             : using namespace com::sun::star::uno;
      56             : using namespace com::sun::star::ucb;
      57             : 
      58             : namespace {
      59             : 
      60        2086 :     Sequence< Any > generateErrorArguments(
      61             :         rtl::OUString const & rPhysicalUrl)
      62             :     {
      63        2086 :         rtl::OUString aResourceName;
      64        2086 :         rtl::OUString aResourceType;
      65             :         sal_Bool      bRemovable;
      66        2086 :         bool bResourceName = false;
      67        2086 :         bool bResourceType = false;
      68        2086 :         bool bRemoveProperty = false;
      69             : 
      70        2086 :         if (osl::FileBase::getSystemPathFromFileURL(
      71             :                 rPhysicalUrl,
      72        2086 :                 aResourceName)
      73             :             == osl::FileBase::E_None)
      74        2086 :             bResourceName = true;
      75             : 
      76             :         // The resource types "folder" (i.e., directory) and
      77             :         // "volume" seem to be
      78             :         // the most interesting when producing meaningful error messages:
      79        2086 :         osl::DirectoryItem aItem;
      80        2086 :         if (osl::DirectoryItem::get(rPhysicalUrl, aItem) ==
      81             :             osl::FileBase::E_None)
      82             :         {
      83           0 :             osl::FileStatus aStatus( osl_FileStatus_Mask_Type );
      84           0 :             if (aItem.getFileStatus(aStatus) == osl::FileBase::E_None)
      85           0 :                 switch (aStatus.getFileType())
      86             :                 {
      87             :                     case osl::FileStatus::Directory:
      88           0 :                         aResourceType = rtl::OUString( "folder");
      89           0 :                         bResourceType = true;
      90           0 :                         break;
      91             : 
      92             :                     case osl::FileStatus::Volume:
      93             :                     {
      94           0 :                         aResourceType = rtl::OUString( "volume");
      95           0 :                         bResourceType = true;
      96             :                         osl::VolumeInfo aVolumeInfo(
      97           0 :                             osl_VolumeInfo_Mask_Attributes );
      98           0 :                         if( osl::Directory::getVolumeInfo(
      99           0 :                             rPhysicalUrl,aVolumeInfo ) ==
     100             :                             osl::FileBase::E_None )
     101             :                         {
     102           0 :                             bRemovable = aVolumeInfo.getRemoveableFlag();
     103           0 :                             bRemoveProperty = true;
     104           0 :                         }
     105             :                     }
     106           0 :                     break;
     107             :                     case osl::FileStatus::Regular:
     108             :                     case osl::FileStatus::Fifo:
     109             :                     case osl::FileStatus::Socket:
     110             :                     case osl::FileStatus::Link:
     111             :                     case osl::FileStatus::Special:
     112             :                     case osl::FileStatus::Unknown:
     113             :                         // do nothing for now
     114           0 :                         break;
     115           0 :                 }
     116             :         }
     117             : 
     118             :         Sequence< Any > aArguments( 1              +
     119             :                                     (bResourceName ? 1 : 0)     +
     120             :                                     (bResourceType ? 1 : 0)     +
     121        2086 :                                     (bRemoveProperty ? 1 : 0) );
     122        2086 :         sal_Int32 i = 0;
     123        2086 :         aArguments[i++]
     124             :             <<= PropertyValue(rtl::OUString( "Uri"),
     125             :                               -1,
     126             :                               makeAny(rPhysicalUrl),
     127        4172 :                               PropertyState_DIRECT_VALUE);
     128        2086 :         if (bResourceName)
     129        2086 :             aArguments[i++]
     130             :                 <<= PropertyValue(rtl::OUString( "ResourceName"),
     131             :                                   -1,
     132             :                                   makeAny(aResourceName),
     133        4172 :                                   PropertyState_DIRECT_VALUE);
     134        2086 :         if (bResourceType)
     135           0 :             aArguments[i++]
     136             :                 <<= PropertyValue(rtl::OUString( "ResourceType"),
     137             :                                   -1,
     138             :                                   makeAny(aResourceType),
     139           0 :                                   PropertyState_DIRECT_VALUE);
     140        2086 :         if (bRemoveProperty)
     141           0 :             aArguments[i++]
     142             :                 <<= PropertyValue(rtl::OUString( "Removable"),
     143             :                                   -1,
     144             :                                   makeAny(bRemovable),
     145           0 :                                   PropertyState_DIRECT_VALUE);
     146             : 
     147        2086 :         return aArguments;
     148             :     }
     149             : }
     150             : 
     151             : 
     152             : 
     153             : namespace fileaccess {
     154             : 
     155             : 
     156           0 :     sal_Bool isChild( const rtl::OUString& srcUnqPath,
     157             :                       const rtl::OUString& dstUnqPath )
     158             :     {
     159             :         static sal_Unicode slash = '/';
     160             :         // Simple lexical comparison
     161           0 :         sal_Int32 srcL = srcUnqPath.getLength();
     162           0 :         sal_Int32 dstL = dstUnqPath.getLength();
     163             : 
     164             :         return (
     165           0 :             ( srcUnqPath == dstUnqPath )
     166             :             ||
     167             :             ( ( dstL > srcL )
     168             :               &&
     169           0 :               ( srcUnqPath.compareTo( dstUnqPath, srcL ) == 0 )
     170             :               &&
     171           0 :               ( dstUnqPath[ srcL ] == slash ) )
     172           0 :         );
     173             :     }
     174             : 
     175             : 
     176           0 :     rtl::OUString newName(
     177             :         const rtl::OUString& aNewPrefix,
     178             :         const rtl::OUString& aOldPrefix,
     179             :         const rtl::OUString& old_Name )
     180             :     {
     181           0 :         sal_Int32 srcL = aOldPrefix.getLength();
     182             : 
     183           0 :         rtl::OUString new_Name = old_Name.copy( srcL );
     184           0 :         new_Name = ( aNewPrefix + new_Name );
     185           0 :         return new_Name;
     186             :     }
     187             : 
     188             : 
     189          73 :     rtl::OUString getTitle( const rtl::OUString& aPath )
     190             :     {
     191          73 :         sal_Unicode slash = '/';
     192          73 :         sal_Int32 lastIndex = aPath.lastIndexOf( slash );
     193          73 :         return aPath.copy( lastIndex + 1 );
     194             :     }
     195             : 
     196             : 
     197         470 :     rtl::OUString getParentName( const rtl::OUString& aFileName )
     198             :     {
     199         470 :         sal_Int32 lastIndex = aFileName.lastIndexOf( sal_Unicode('/') );
     200         470 :         rtl::OUString aParent = aFileName.copy( 0,lastIndex );
     201             : 
     202         470 :         if( aParent[ aParent.getLength()-1] == sal_Unicode(':') && aParent.getLength() == 6 )
     203           0 :             aParent += rtl::OUString("/");
     204             : 
     205         470 :         if ( aParent == "file://" )
     206           0 :             aParent = rtl::OUString("file:///");
     207             : 
     208         470 :         return aParent;
     209             :     }
     210             : 
     211             : 
     212         340 :     osl::FileBase::RC osl_File_copy( const rtl::OUString& strPath,
     213             :                                      const rtl::OUString& strDestPath,
     214             :                                      sal_Bool test )
     215             :     {
     216         340 :         if( test )
     217             :         {
     218           0 :             osl::DirectoryItem aItem;
     219           0 :             if( osl::DirectoryItem::get( strDestPath,aItem ) != osl::FileBase:: E_NOENT )
     220           0 :                 return osl::FileBase::E_EXIST;
     221             :         }
     222             : 
     223         340 :         return osl::File::copy( strPath,strDestPath );
     224             :     }
     225             : 
     226             : 
     227           0 :     osl::FileBase::RC osl_File_move( const rtl::OUString& strPath,
     228             :                                      const rtl::OUString& strDestPath,
     229             :                                      sal_Bool test )
     230             :     {
     231           0 :         if( test )
     232             :         {
     233           0 :             osl::DirectoryItem aItem;
     234           0 :             if( osl::DirectoryItem::get( strDestPath,aItem ) != osl::FileBase:: E_NOENT )
     235           0 :                 return osl::FileBase::E_EXIST;
     236             :         }
     237             : 
     238           0 :         return osl::File::move( strPath,strDestPath );
     239             :     }
     240             : 
     241        2151 :     void throw_handler(
     242             :         sal_Int32 errorCode,
     243             :         sal_Int32 minorCode,
     244             :         const Reference< XCommandEnvironment >& xEnv,
     245             :         const rtl::OUString& aUncPath,
     246             :         BaseContent* pContent,
     247             :         bool isHandled )
     248             :     {
     249        2151 :         Reference<XCommandProcessor> xComProc(pContent);
     250        2151 :         Any aAny;
     251             :         IOErrorCode ioErrorCode;
     252             : 
     253        2151 :         if( errorCode ==  TASKHANDLER_UNSUPPORTED_COMMAND )
     254             :         {
     255           0 :             aAny <<= UnsupportedCommandException( ::rtl::OUString(  OSL_LOG_PREFIX  ), uno::Reference< uno::XInterface >() );
     256           0 :             cancelCommandExecution( aAny,xEnv );
     257             :         }
     258        2151 :         else if( errorCode == TASKHANDLING_WRONG_SETPROPERTYVALUES_ARGUMENT ||
     259             :                  errorCode == TASKHANDLING_WRONG_GETPROPERTYVALUES_ARGUMENT ||
     260             :                  errorCode == TASKHANDLING_WRONG_OPEN_ARGUMENT              ||
     261             :                  errorCode == TASKHANDLING_WRONG_DELETE_ARGUMENT            ||
     262             :                  errorCode == TASKHANDLING_WRONG_TRANSFER_ARGUMENT          ||
     263             :                  errorCode == TASKHANDLING_WRONG_INSERT_ARGUMENT            ||
     264             :                  errorCode == TASKHANDLING_WRONG_CREATENEWCONTENT_ARGUMENT )
     265             :         {
     266           0 :             IllegalArgumentException excep;
     267           0 :             excep.ArgumentPosition = 0;
     268           0 :             aAny <<= excep;
     269             :             cancelCommandExecution(
     270           0 :                 aAny,xEnv);
     271             :         }
     272        2151 :         else if( errorCode == TASKHANDLING_UNSUPPORTED_OPEN_MODE )
     273             :         {
     274           0 :             UnsupportedOpenModeException excep;
     275           0 :             excep.Mode = sal::static_int_cast< sal_Int16 >(minorCode);
     276           0 :             aAny <<= excep;
     277           0 :                 cancelCommandExecution( aAny,xEnv );
     278             :         }
     279        2151 :         else if(errorCode == TASKHANDLING_DELETED_STATE_IN_OPEN_COMMAND  ||
     280             :                 errorCode == TASKHANDLING_INSERTED_STATE_IN_OPEN_COMMAND ||
     281             :                 errorCode == TASKHANDLING_NOFRESHINSERT_IN_INSERT_COMMAND )
     282             :         {
     283             :             // What to do here?
     284             :         }
     285        2151 :         else if(
     286             :             // error in opening file
     287             :             errorCode == TASKHANDLING_NO_OPEN_FILE_FOR_OVERWRITE ||
     288             :             // error in opening file
     289             :             errorCode == TASKHANDLING_NO_OPEN_FILE_FOR_WRITE     ||
     290             :             // error in opening file
     291             :             errorCode == TASKHANDLING_OPEN_FOR_STREAM            ||
     292             :             // error in opening file
     293             :             errorCode == TASKHANDLING_OPEN_FOR_INPUTSTREAM       ||
     294             :             // error in opening file
     295             :             errorCode == TASKHANDLING_OPEN_FILE_FOR_PAGING )
     296             :         {
     297        2020 :             switch( minorCode )
     298             :             {
     299             :                 case FileBase::E_NAMETOOLONG:
     300             :                     // pathname was too long
     301           0 :                     ioErrorCode = IOErrorCode_NAME_TOO_LONG;
     302           0 :                     break;
     303             :                 case FileBase::E_NXIO:
     304             :                     // No such device or address
     305             :                 case FileBase::E_NODEV:
     306             :                     // No such device
     307           0 :                     ioErrorCode = IOErrorCode_INVALID_DEVICE;
     308           0 :                     break;
     309             :                 case FileBase::E_NOTDIR:
     310           0 :                     ioErrorCode = IOErrorCode_NOT_EXISTING_PATH;
     311           0 :                     break;
     312             :                 case FileBase::E_NOENT:
     313             :                     // No such file or directory
     314        2020 :                     ioErrorCode = IOErrorCode_NOT_EXISTING;
     315        2020 :                     break;
     316             :                 case FileBase::E_ROFS:
     317             :                     // #i4735# handle ROFS transparently as ACCESS_DENIED
     318             :                 case FileBase::E_ACCES:
     319             :                     // permission denied<P>
     320           0 :                     ioErrorCode = IOErrorCode_ACCESS_DENIED;
     321           0 :                     break;
     322             :                 case FileBase::E_ISDIR:
     323             :                     // Is a directory<p>
     324           0 :                     ioErrorCode = IOErrorCode_NO_FILE;
     325           0 :                     break;
     326             :                 case FileBase::E_NOTREADY:
     327           0 :                     ioErrorCode = IOErrorCode_DEVICE_NOT_READY;
     328           0 :                     break;
     329             :                 case FileBase::E_MFILE:
     330             :                     // too many open files used by the process
     331             :                 case FileBase::E_NFILE:
     332             :                     // too many open files in the system
     333           0 :                     ioErrorCode = IOErrorCode_OUT_OF_FILE_HANDLES;
     334           0 :                     break;
     335             :                 case FileBase::E_INVAL:
     336             :                     // the format of the parameters was not valid
     337           0 :                     ioErrorCode = IOErrorCode_INVALID_PARAMETER;
     338           0 :                     break;
     339             :                 case FileBase::E_NOMEM:
     340             :                     // not enough memory for allocating structures
     341           0 :                     ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
     342           0 :                     break;
     343             :                 case FileBase::E_BUSY:
     344             :                     // Text file busy
     345           0 :                     ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
     346           0 :                     break;
     347             :                 case FileBase::E_AGAIN:
     348             :                     // Operation would block
     349           0 :                     ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
     350           0 :                     break;
     351             :                 case FileBase::E_NOLCK:  // No record locks available
     352           0 :                     ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
     353           0 :                     break;
     354             : 
     355             :                 case FileBase::E_FAULT: // Bad address
     356             :                 case FileBase::E_LOOP:  // Too many symbolic links encountered
     357             :                 case FileBase::E_NOSPC: // No space left on device
     358             :                 case FileBase::E_INTR:  // function call was interrupted
     359             :                 case FileBase::E_IO:    // I/O error
     360             :                 case FileBase::E_MULTIHOP:      // Multihop attempted
     361             :                 case FileBase::E_NOLINK:        // Link has been severed
     362             :                 default:
     363           0 :                     ioErrorCode = IOErrorCode_GENERAL;
     364           0 :                     break;
     365             :             }
     366             : 
     367             :             cancelCommandExecution(
     368             :                 ioErrorCode,
     369             :                 generateErrorArguments(aUncPath),
     370             :                 xEnv,
     371             :                 rtl::OUString( "an error occurred during file opening"),
     372        4040 :                 xComProc);
     373             :         }
     374         131 :         else if( errorCode == TASKHANDLING_OPEN_FOR_DIRECTORYLISTING  ||
     375             :                  errorCode == TASKHANDLING_OPENDIRECTORY_FOR_REMOVE )
     376             :         {
     377           5 :             switch( minorCode )
     378             :             {
     379             :                 case FileBase::E_INVAL:
     380             :                     // the format of the parameters was not valid
     381           0 :                     ioErrorCode = IOErrorCode_INVALID_PARAMETER;
     382           0 :                     break;
     383             :                 case FileBase::E_NOENT:
     384             :                     // the specified path doesn't exist
     385           5 :                     ioErrorCode = IOErrorCode_NOT_EXISTING;
     386           5 :                     break;
     387             :                 case FileBase::E_NOTDIR:
     388             :                     // the specified path is not an directory
     389           0 :                     ioErrorCode = IOErrorCode_NO_DIRECTORY;
     390           0 :                     break;
     391             :                 case FileBase::E_NOMEM:
     392             :                     // not enough memory for allocating structures
     393           0 :                     ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
     394           0 :                     break;
     395             :                 case FileBase::E_ROFS:
     396             :                     // #i4735# handle ROFS transparently as ACCESS_DENIED
     397             :                 case FileBase::E_ACCES:          // permission denied
     398           0 :                     ioErrorCode = IOErrorCode_ACCESS_DENIED;
     399           0 :                     break;
     400             :                 case FileBase::E_NOTREADY:
     401           0 :                     ioErrorCode = IOErrorCode_DEVICE_NOT_READY;
     402           0 :                     break;
     403             :                 case FileBase::E_MFILE:
     404             :                     // too many open files used by the process
     405             :                 case FileBase::E_NFILE:
     406             :                     // too many open files in the system
     407           0 :                     ioErrorCode = IOErrorCode_OUT_OF_FILE_HANDLES;
     408           0 :                     break;
     409             :                 case FileBase::E_NAMETOOLONG:
     410             :                     // File name too long
     411           0 :                     ioErrorCode = IOErrorCode_NAME_TOO_LONG;
     412           0 :                     break;
     413             :                 case FileBase::E_LOOP:
     414             :                     // Too many symbolic links encountered<p>
     415             :                 default:
     416           0 :                     ioErrorCode = IOErrorCode_GENERAL;
     417           0 :                     break;
     418             :             }
     419             : 
     420             :             cancelCommandExecution(
     421             :                 ioErrorCode,
     422             :                 generateErrorArguments(aUncPath),
     423             :                 xEnv,
     424             :                 rtl::OUString( "an error occurred during opening a directory"),
     425          10 :                 xComProc);
     426             :         }
     427         126 :         else if( errorCode == TASKHANDLING_NOTCONNECTED_FOR_WRITE          ||
     428             :                  errorCode == TASKHANDLING_BUFFERSIZEEXCEEDED_FOR_WRITE    ||
     429             :                  errorCode == TASKHANDLING_IOEXCEPTION_FOR_WRITE           ||
     430             :                  errorCode == TASKHANDLING_NOTCONNECTED_FOR_PAGING         ||
     431             :                  errorCode == TASKHANDLING_BUFFERSIZEEXCEEDED_FOR_PAGING   ||
     432             :                  errorCode == TASKHANDLING_IOEXCEPTION_FOR_PAGING         )
     433             :         {
     434           0 :             ioErrorCode = IOErrorCode_UNKNOWN;
     435             :             cancelCommandExecution(
     436             :                 ioErrorCode,
     437             :                 generateErrorArguments(aUncPath),
     438             :                 xEnv,
     439             :                 rtl::OUString( "an error occurred writing or reading from a file"),
     440           0 :                 xComProc );
     441             :         }
     442         126 :         else if( errorCode == TASKHANDLING_FILEIOERROR_FOR_NO_SPACE )
     443             :         {
     444           0 :             ioErrorCode = IOErrorCode_OUT_OF_DISK_SPACE;
     445             :             cancelCommandExecution(
     446             :                 ioErrorCode,
     447             :                 generateErrorArguments(aUncPath),
     448             :                 xEnv,
     449             :                 rtl::OUString( "device full"),
     450           0 :                 xComProc);
     451             :         }
     452         126 :         else if( errorCode == TASKHANDLING_FILEIOERROR_FOR_WRITE ||
     453             :                  errorCode == TASKHANDLING_READING_FILE_FOR_PAGING )
     454             :         {
     455           0 :             switch( minorCode )
     456             :             {
     457             :                 case FileBase::E_INVAL:
     458             :                     // the format of the parameters was not valid
     459           0 :                     ioErrorCode = IOErrorCode_INVALID_PARAMETER;
     460           0 :                     break;
     461             :                 case FileBase::E_FBIG:
     462             :                     // File too large
     463           0 :                     ioErrorCode = IOErrorCode_CANT_WRITE;
     464           0 :                     break;
     465             :                 case FileBase::E_NOSPC:
     466             :                     // No space left on device
     467           0 :                     ioErrorCode = IOErrorCode_OUT_OF_DISK_SPACE;
     468           0 :                     break;
     469             :                 case FileBase::E_NXIO:
     470             :                     // No such device or address
     471           0 :                     ioErrorCode = IOErrorCode_INVALID_DEVICE;
     472           0 :                     break;
     473             :                 case FileBase::E_NOLINK:
     474             :                     // Link has been severed
     475             :                 case FileBase::E_ISDIR:
     476             :                     // Is a directory
     477           0 :                     ioErrorCode = IOErrorCode_NO_FILE;
     478           0 :                     break;
     479             :                 case FileBase::E_AGAIN:
     480             :                     // Operation would block
     481           0 :                     ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
     482           0 :                     break;
     483             :                 case FileBase::E_TIMEDOUT:
     484           0 :                     ioErrorCode = IOErrorCode_DEVICE_NOT_READY;
     485           0 :                     break;
     486             :                 case FileBase::E_NOLCK:  // No record locks available
     487           0 :                     ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
     488           0 :                     break;
     489             :                 case FileBase::E_IO:     // I/O error
     490             :                 case FileBase::E_BADF:   // Bad file
     491             :                 case FileBase::E_FAULT:  // Bad address
     492             :                 case FileBase::E_INTR:   // function call was interrupted
     493             :                 default:
     494           0 :                     ioErrorCode = IOErrorCode_GENERAL;
     495           0 :                     break;
     496             :             }
     497             :             cancelCommandExecution(
     498             :                 ioErrorCode,
     499             :                 generateErrorArguments(aUncPath),
     500             :                 xEnv,
     501             :                 rtl::OUString( "an error occurred during opening a file"),
     502           0 :                 xComProc);
     503             :         }
     504         126 :         else if( errorCode == TASKHANDLING_NONAMESET_INSERT_COMMAND ||
     505             :                  errorCode == TASKHANDLING_NOCONTENTTYPE_INSERT_COMMAND )
     506             :         {
     507           0 :             Sequence< ::rtl::OUString > aSeq( 1 );
     508           0 :             aSeq[0] =
     509             :                 ( errorCode == TASKHANDLING_NONAMESET_INSERT_COMMAND )  ?
     510             :                 rtl::OUString("Title")               :
     511           0 :                 rtl::OUString("ContentType");
     512             : 
     513             :             aAny <<= MissingPropertiesException(
     514             :                 rtl::OUString( "a property is missing necessary"
     515             :                                "to create a content"),
     516             :                 xComProc,
     517           0 :                 aSeq);
     518           0 :             cancelCommandExecution(aAny,xEnv);
     519             :         }
     520         126 :         else if( errorCode == TASKHANDLING_FILESIZE_FOR_WRITE )
     521             :         {
     522           0 :             switch( minorCode )
     523             :             {
     524             :                 case FileBase::E_INVAL:
     525             :                     // the format of the parameters was not valid
     526             :                 case FileBase::E_OVERFLOW:
     527             :                     // The resulting file offset would be a value which cannot
     528             :                     // be represented correctly for regular files
     529           0 :                     ioErrorCode = IOErrorCode_INVALID_PARAMETER;
     530           0 :                     break;
     531             :                 default:
     532           0 :                     ioErrorCode = IOErrorCode_GENERAL;
     533           0 :                     break;
     534             :             }
     535             :             cancelCommandExecution(
     536             :                 ioErrorCode,
     537             :                 generateErrorArguments(aUncPath),
     538             :                 xEnv,
     539             :                 rtl::OUString( "there were problems with the filesize"),
     540           0 :                 xComProc);
     541             :         }
     542         126 :         else if(errorCode == TASKHANDLING_INPUTSTREAM_FOR_WRITE)
     543             :         {
     544           0 :             Reference<XInterface> xContext(xComProc,UNO_QUERY);
     545             :             aAny <<=
     546             :                 MissingInputStreamException(
     547             :                     rtl::OUString( "the inputstream is missing necessary"
     548             :                                    "to create a content"),
     549           0 :                     xContext);
     550           0 :             cancelCommandExecution(aAny,xEnv);
     551             :         }
     552         126 :         else if( errorCode == TASKHANDLING_NOREPLACE_FOR_WRITE )
     553             :             // Overwrite = false and file exists
     554             :         {
     555          57 :             NameClashException excep;
     556          57 :             excep.Name = getTitle(aUncPath);
     557          57 :             excep.Classification = InteractionClassification_ERROR;
     558          57 :             Reference<XInterface> xContext(xComProc,UNO_QUERY);
     559          57 :             excep.Context = xContext;
     560          57 :             excep.Message = rtl::OUString( "file exists and overwrite forbidden");
     561          57 :             aAny <<= excep;
     562         114 :             cancelCommandExecution( aAny,xEnv );
     563             :         }
     564          69 :         else if( errorCode == TASKHANDLING_INVALID_NAME_MKDIR )
     565             :         {
     566           0 :             InteractiveAugmentedIOException excep;
     567           0 :             excep.Code = IOErrorCode_INVALID_CHARACTER;
     568           0 :             PropertyValue prop;
     569           0 :             prop.Name = rtl::OUString("ResourceName");
     570           0 :             prop.Handle = -1;
     571             :             rtl::OUString m_aClashingName(
     572             :                 rtl::Uri::decode(
     573             :                     getTitle(aUncPath),
     574             :                     rtl_UriDecodeWithCharset,
     575           0 :                     RTL_TEXTENCODING_UTF8));
     576           0 :             prop.Value <<= m_aClashingName;
     577           0 :             Sequence<Any> seq(1);
     578           0 :             seq[0] <<= prop;
     579           0 :             excep.Arguments = seq;
     580           0 :             excep.Classification = InteractionClassification_ERROR;
     581           0 :             Reference<XInterface> xContext(xComProc,UNO_QUERY);
     582           0 :             excep.Context = xContext;
     583           0 :             excep.Message = rtl::OUString( "the name contained invalid characters");
     584           0 :             if(isHandled)
     585           0 :                 throw excep;
     586             :             else {
     587           0 :                 aAny <<= excep;
     588           0 :                 cancelCommandExecution( aAny,xEnv );
     589           0 :             }
     590             : //              ioErrorCode = IOErrorCode_INVALID_CHARACTER;
     591             : //              cancelCommandExecution(
     592             : //                  ioErrorCode,
     593             : //                  generateErrorArguments(aUncPath),
     594             : //                  xEnv,
     595             : //                  rtl::OUString( "the name contained invalid characters"),
     596             : //                  xComProc );
     597             :         }
     598          69 :         else if( errorCode == TASKHANDLING_FOLDER_EXISTS_MKDIR )
     599             :         {
     600           8 :             NameClashException excep;
     601           8 :             excep.Name = getTitle(aUncPath);
     602           8 :             excep.Classification = InteractionClassification_ERROR;
     603           8 :             Reference<XInterface> xContext(xComProc,UNO_QUERY);
     604           8 :             excep.Context = xContext;
     605           8 :             excep.Message = rtl::OUString( "folder exists and overwrite forbidden");
     606           8 :             if(isHandled)
     607           8 :                 throw excep;
     608             :             else {
     609           0 :                 aAny <<= excep;
     610           0 :                 cancelCommandExecution( aAny,xEnv );
     611           8 :             }
     612             : //              ioErrorCode = IOErrorCode_ALREADY_EXISTING;
     613             : //              cancelCommandExecution(
     614             : //                  ioErrorCode,
     615             : //                  generateErrorArguments(aUncPath),
     616             : //                  xEnv,
     617             : //                  rtl::OUString( "the folder exists"),
     618             : //                  xComProc );
     619             :         }
     620          61 :         else if( errorCode == TASKHANDLING_ENSUREDIR_FOR_WRITE  ||
     621             :                  errorCode == TASKHANDLING_CREATEDIRECTORY_MKDIR )
     622             :         {
     623           0 :             switch( minorCode )
     624             :             {
     625             :             case FileBase::E_ACCES:
     626           0 :                 ioErrorCode = IOErrorCode_ACCESS_DENIED;
     627           0 :                 break;
     628             :             case FileBase::E_ROFS:
     629           0 :                 ioErrorCode = IOErrorCode_WRITE_PROTECTED;
     630           0 :                 break;
     631             :             case FileBase::E_NAMETOOLONG:
     632           0 :                 ioErrorCode = IOErrorCode_NAME_TOO_LONG;
     633           0 :                 break;
     634             :             default:
     635           0 :                 ioErrorCode = IOErrorCode_NOT_EXISTING_PATH;
     636           0 :                 break;
     637             :             }
     638             :             cancelCommandExecution(
     639             :                 ioErrorCode,
     640             :                 generateErrorArguments(getParentName(aUncPath)),
     641             :                 //TODO! ok to supply physical URL to getParentName()?
     642             :                 xEnv,
     643             :                 rtl::OUString( "a folder could not be created"),
     644           0 :                 xComProc  );
     645             :         }
     646          61 :         else if( errorCode == TASKHANDLING_VALIDFILESTATUSWHILE_FOR_REMOVE  ||
     647             :                  errorCode == TASKHANDLING_VALIDFILESTATUS_FOR_REMOVE       ||
     648             :                  errorCode == TASKHANDLING_NOSUCHFILEORDIR_FOR_REMOVE )
     649             :         {
     650           2 :             switch( minorCode )
     651             :             {
     652             :                 case FileBase::E_INVAL:         // the format of the parameters was not valid
     653           0 :                     ioErrorCode = IOErrorCode_INVALID_PARAMETER;
     654           0 :                     break;
     655             :                 case FileBase::E_NOMEM:         // not enough memory for allocating structures
     656           0 :                     ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
     657           0 :                     break;
     658             :                 case FileBase::E_ROFS: // #i4735# handle ROFS transparently as ACCESS_DENIED
     659             :                 case FileBase::E_ACCES:         // permission denied
     660           0 :                     ioErrorCode = IOErrorCode_ACCESS_DENIED;
     661           0 :                     break;
     662             :                 case FileBase::E_MFILE:         // too many open files used by the process
     663             :                 case FileBase::E_NFILE:         // too many open files in the system
     664           0 :                     ioErrorCode = IOErrorCode_OUT_OF_FILE_HANDLES;
     665           0 :                     break;
     666             :                 case FileBase::E_NOLINK:        // Link has been severed
     667             :                 case FileBase::E_NOENT:         // No such file or directory
     668           2 :                     ioErrorCode = IOErrorCode_NOT_EXISTING;
     669           2 :                     break;
     670             :                 case FileBase::E_NAMETOOLONG:   // File name too long
     671           0 :                     ioErrorCode = IOErrorCode_NAME_TOO_LONG;
     672           0 :                     break;
     673             :                 case FileBase::E_NOTDIR:     // A component of the path prefix of path is not a directory
     674           0 :                     ioErrorCode = IOErrorCode_NOT_EXISTING_PATH;
     675           0 :                     break;
     676             :                 case FileBase::E_LOOP:          // Too many symbolic links encountered
     677             :                 case FileBase::E_IO:            // I/O error
     678             :                 case FileBase::E_MULTIHOP:      // Multihop attempted
     679             :                 case FileBase::E_FAULT:         // Bad address
     680             :                 case FileBase::E_INTR:          // function call was interrupted
     681             :                 case FileBase::E_NOSYS:         // Function not implemented
     682             :                 case FileBase::E_NOSPC:         // No space left on device
     683             :                 case FileBase::E_NXIO:          // No such device or address
     684             :                 case FileBase::E_OVERFLOW:      // Value too large for defined data type
     685             :                 case FileBase::E_BADF:          // Invalid oslDirectoryItem parameter
     686             :                 default:
     687           0 :                     ioErrorCode = IOErrorCode_GENERAL;
     688           0 :                     break;
     689             :             }
     690             :             cancelCommandExecution(
     691             :                 ioErrorCode,
     692             :                 generateErrorArguments(aUncPath),
     693             :                 xEnv,
     694             :                 rtl::OUString( "a file status object could not be filled"),
     695           4 :                 xComProc  );
     696             :         }
     697          59 :         else if( errorCode == TASKHANDLING_DELETEFILE_FOR_REMOVE  ||
     698             :                  errorCode == TASKHANDLING_DELETEDIRECTORY_FOR_REMOVE )
     699             :         {
     700           0 :             switch( minorCode )
     701             :             {
     702             :                 case FileBase::E_INVAL:         // the format of the parameters was not valid
     703           0 :                     ioErrorCode = IOErrorCode_INVALID_PARAMETER;
     704           0 :                     break;
     705             :                 case FileBase::E_NOMEM:         // not enough memory for allocating structures
     706           0 :                     ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
     707           0 :                     break;
     708             :                 case FileBase::E_ACCES:         // Permission denied
     709           0 :                     ioErrorCode = IOErrorCode_ACCESS_DENIED;
     710           0 :                     break;
     711             :                 case FileBase::E_PERM:          // Operation not permitted
     712           0 :                     ioErrorCode = IOErrorCode_NOT_SUPPORTED;
     713           0 :                     break;
     714             :                 case FileBase::E_NAMETOOLONG:   // File name too long
     715           0 :                     ioErrorCode = IOErrorCode_NAME_TOO_LONG;
     716           0 :                     break;
     717             :                 case FileBase::E_NOLINK:        // Link has been severed
     718             :                 case FileBase::E_NOENT:         // No such file or directory
     719           0 :                     ioErrorCode = IOErrorCode_NOT_EXISTING;
     720           0 :                     break;
     721             :                 case FileBase::E_ISDIR:         // Is a directory
     722             :                 case FileBase::E_ROFS:          // Read-only file system
     723           0 :                     ioErrorCode = IOErrorCode_NOT_SUPPORTED;
     724           0 :                     break;
     725             :                 case FileBase::E_BUSY:          // Device or resource busy
     726           0 :                     ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
     727           0 :                     break;
     728             :                 case FileBase::E_FAULT:         // Bad address
     729             :                 case FileBase::E_LOOP:          // Too many symbolic links encountered
     730             :                 case FileBase::E_IO:            // I/O error
     731             :                 case FileBase::E_INTR:          // function call was interrupted
     732             :                 case FileBase::E_MULTIHOP:      // Multihop attempted
     733             :                 default:
     734           0 :                     ioErrorCode = IOErrorCode_GENERAL;
     735           0 :                     break;
     736             :             }
     737             :             cancelCommandExecution(
     738             :                 ioErrorCode,
     739             :                 generateErrorArguments(aUncPath),
     740             :                 xEnv,
     741             :                 rtl::OUString( "a file or directory could not be deleted"),
     742           0 :                 xComProc );
     743             :         }
     744          59 :         else if( errorCode == TASKHANDLING_TRANSFER_BY_COPY_SOURCE         ||
     745             :                  errorCode == TASKHANDLING_TRANSFER_BY_COPY_SOURCESTAT     ||
     746             :                  errorCode == TASKHANDLING_TRANSFER_BY_MOVE_SOURCE         ||
     747             :                  errorCode == TASKHANDLING_TRANSFER_BY_MOVE_SOURCESTAT     ||
     748             :                  errorCode == TASKHANDLING_TRANSFER_DESTFILETYPE           ||
     749             :                  errorCode == TASKHANDLING_FILETYPE_FOR_REMOVE             ||
     750             :                  errorCode == TASKHANDLING_DIRECTORYEXHAUSTED_FOR_REMOVE   ||
     751             :                  errorCode == TASKHANDLING_TRANSFER_INVALIDURL )
     752             :         {
     753          59 :             rtl::OUString aMsg;
     754          59 :             switch( minorCode )
     755             :             {
     756             :                 case FileBase::E_NOENT:         // No such file or directory
     757           0 :                     if ( errorCode == TASKHANDLING_TRANSFER_BY_COPY_SOURCE         ||
     758             :                          errorCode == TASKHANDLING_TRANSFER_BY_COPY_SOURCESTAT     ||
     759             :                          errorCode == TASKHANDLING_TRANSFER_BY_MOVE_SOURCE         ||
     760             :                          errorCode == TASKHANDLING_TRANSFER_BY_MOVE_SOURCESTAT )
     761             :                     {
     762           0 :                         ioErrorCode = IOErrorCode_NOT_EXISTING;
     763           0 :                         aMsg = rtl::OUString( "source file/folder does not exist");
     764           0 :                         break;
     765             :                     }
     766             :                     else
     767             :                     {
     768           0 :                         ioErrorCode = IOErrorCode_GENERAL;
     769           0 :                         aMsg = rtl::OUString( "a general error during transfer command");
     770           0 :                     break;
     771             :                     }
     772             :                 default:
     773          59 :                     ioErrorCode = IOErrorCode_GENERAL;
     774          59 :                     aMsg = rtl::OUString( "a general error during transfer command");
     775          59 :                     break;
     776             :             }
     777             :             cancelCommandExecution(
     778             :                 ioErrorCode,
     779             :                 generateErrorArguments(aUncPath),
     780             :                 xEnv,
     781             :                 aMsg,
     782         118 :                 xComProc );
     783             :         }
     784           0 :         else if( errorCode == TASKHANDLING_TRANSFER_ACCESSINGROOT )
     785             :         {
     786           0 :             ioErrorCode = IOErrorCode_WRITE_PROTECTED;
     787             :             cancelCommandExecution(
     788             :                 ioErrorCode,
     789             :                 generateErrorArguments(aUncPath),
     790             :                 xEnv,
     791             :                 rtl::OUString( "accessing the root during transfer"),
     792           0 :                 xComProc );
     793             :         }
     794           0 :         else if( errorCode == TASKHANDLING_TRANSFER_INVALIDSCHEME )
     795             :         {
     796           0 :             Reference<XInterface> xContext(xComProc,UNO_QUERY);
     797             : 
     798             :             aAny <<=
     799             :                 InteractiveBadTransferURLException(
     800             :                     rtl::OUString( "bad tranfer url"),
     801           0 :                     xContext);
     802           0 :             cancelCommandExecution( aAny,xEnv );
     803             :         }
     804           0 :         else if( errorCode == TASKHANDLING_OVERWRITE_FOR_MOVE      ||
     805             :                  errorCode == TASKHANDLING_OVERWRITE_FOR_COPY      ||
     806             :                  errorCode == TASKHANDLING_NAMECLASHMOVE_FOR_MOVE  ||
     807             :                  errorCode == TASKHANDLING_NAMECLASHMOVE_FOR_COPY  ||
     808             :                  errorCode == TASKHANDLING_KEEPERROR_FOR_MOVE      ||
     809             :                  errorCode == TASKHANDLING_KEEPERROR_FOR_COPY      ||
     810             :                  errorCode == TASKHANDLING_RENAME_FOR_MOVE         ||
     811             :                  errorCode == TASKHANDLING_RENAME_FOR_COPY         ||
     812             :                  errorCode == TASKHANDLING_RENAMEMOVE_FOR_MOVE     ||
     813             :                  errorCode == TASKHANDLING_RENAMEMOVE_FOR_COPY    )
     814             :         {
     815             :             rtl::OUString aMsg(
     816           0 :                         "general error during transfer");
     817             : 
     818           0 :             switch( minorCode )
     819             :             {
     820             :                 case FileBase::E_EXIST:
     821           0 :                     ioErrorCode = IOErrorCode_ALREADY_EXISTING;
     822           0 :                     break;
     823             :                 case FileBase::E_INVAL:         // the format of the parameters was not valid
     824           0 :                     ioErrorCode = IOErrorCode_INVALID_PARAMETER;
     825           0 :                     break;
     826             :                 case FileBase::E_NOMEM:         // not enough memory for allocating structures
     827           0 :                     ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
     828           0 :                     break;
     829             :                 case FileBase::E_ACCES:         // Permission denied
     830           0 :                     ioErrorCode = IOErrorCode_ACCESS_DENIED;
     831           0 :                     break;
     832             :                 case FileBase::E_PERM:          // Operation not permitted
     833           0 :                     ioErrorCode = IOErrorCode_NOT_SUPPORTED;
     834           0 :                     break;
     835             :                 case FileBase::E_NAMETOOLONG:   // File name too long
     836           0 :                     ioErrorCode = IOErrorCode_NAME_TOO_LONG;
     837           0 :                     break;
     838             :                 case FileBase::E_NOENT:         // No such file or directory
     839           0 :                     ioErrorCode = IOErrorCode_NOT_EXISTING;
     840           0 :                     aMsg = rtl::OUString( "file/folder does not exist");
     841           0 :                     break;
     842             :                 case FileBase::E_ROFS:          // Read-only file system<p>
     843           0 :                     ioErrorCode = IOErrorCode_NOT_EXISTING;
     844           0 :                     break;
     845             :                 default:
     846           0 :                     ioErrorCode = IOErrorCode_GENERAL;
     847           0 :                     break;
     848             :             }
     849             :             cancelCommandExecution(
     850             :                 ioErrorCode,
     851             :                 generateErrorArguments(aUncPath),
     852             :                 xEnv,
     853             :                 aMsg,
     854           0 :                 xComProc );
     855             :         }
     856           0 :         else if( errorCode == TASKHANDLING_NAMECLASH_FOR_COPY   ||
     857             :                  errorCode == TASKHANDLING_NAMECLASH_FOR_MOVE )
     858             :         {
     859           0 :             NameClashException excep;
     860           0 :             excep.Name = getTitle(aUncPath);
     861           0 :             excep.Classification = InteractionClassification_ERROR;
     862           0 :             Reference<XInterface> xContext(xComProc,UNO_QUERY);
     863           0 :             excep.Context = xContext;
     864           0 :             excep.Message = rtl::OUString( "name clash during copy or move");
     865           0 :             aAny <<= excep;
     866             : 
     867           0 :             cancelCommandExecution(aAny,xEnv);
     868             :         }
     869           0 :         else if( errorCode == TASKHANDLING_NAMECLASHSUPPORT_FOR_MOVE   ||
     870             :                  errorCode == TASKHANDLING_NAMECLASHSUPPORT_FOR_COPY )
     871             :         {
     872             :             Reference<XInterface> xContext(
     873           0 :                 xComProc,UNO_QUERY);
     874           0 :             UnsupportedNameClashException excep;
     875           0 :             excep.NameClash = minorCode;
     876           0 :             excep.Context = xContext;
     877           0 :             excep.Message = rtl::OUString( "name clash value not supported during copy or move");
     878             : 
     879           0 :             aAny <<= excep;
     880           0 :             cancelCommandExecution(aAny,xEnv);
     881             :         }
     882             :         else
     883             :         {
     884             :             // case TASKHANDLER_NO_ERROR:
     885           0 :             return;
     886        2151 :         }
     887             :     }
     888             : 
     889             : 
     890             : }   // end namespace fileaccess
     891             : 
     892             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10