/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_ucb.hxx"
#include <stdio.h>
#include "filglob.hxx"
#ifndef _FILERROR_HXX_
#include "filerror.hxx"
#endif
#include "shell.hxx"
#include "bc.hxx"
#include <osl/file.hxx>
#ifndef INCLUDED_STL_VECTOR
#include <vector>
#define INCLUDED_STL_VECTOR
#endif
#include <ucbhelper/cancelcommandexecution.hxx>
#include <com/sun/star/ucb/CommandAbortedException.hpp>
#include <com/sun/star/ucb/UnsupportedCommandException.hpp>
#include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
#include <com/sun/star/lang/IllegalArgumentException.hpp>
#include <com/sun/star/ucb/IOErrorCode.hpp>
#include <com/sun/star/ucb/MissingPropertiesException.hpp>
#include <com/sun/star/ucb/MissingInputStreamException.hpp>
#include <com/sun/star/ucb/NameClashException.hpp>
#include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp>
#include <com/sun/star/ucb/UnsupportedNameClashException.hpp>
#include "com/sun/star/beans/PropertyState.hpp"
#include "com/sun/star/beans/PropertyValue.hpp"
#include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp>
#include "com/sun/star/uno/Any.hxx"
#include "com/sun/star/uno/Sequence.hxx"
#include "osl/diagnose.h"
#include "rtl/ustrbuf.hxx"
#include <rtl/uri.hxx>
#include <rtl/ustring.hxx>
#include "sal/types.h"
using namespace ucbhelper;
using namespace osl;
using namespace ::com::sun::star;
using namespace com::sun::star::task;
using namespace com::sun::star::beans;
using namespace com::sun::star::lang;
using namespace com::sun::star::uno;
using namespace com::sun::star::ucb;
namespace {
Sequence< Any > generateErrorArguments(
rtl::OUString const & rPhysicalUrl)
{
rtl::OUString aResourceName;
rtl::OUString aResourceType;
sal_Bool bRemovable;
bool bResourceName = false;
bool bResourceType = false;
bool bRemoveProperty = false;
if (osl::FileBase::getSystemPathFromFileURL(
rPhysicalUrl,
aResourceName)
== osl::FileBase::E_None)
bResourceName = true;
// The resource types "folder" (i.e., directory) and
// "volume" seem to be
// the most interesting when producing meaningful error messages:
osl::DirectoryItem aItem;
if (osl::DirectoryItem::get(rPhysicalUrl, aItem) ==
osl::FileBase::E_None)
{
osl::FileStatus aStatus( FileStatusMask_Type );
if (aItem.getFileStatus(aStatus) == osl::FileBase::E_None)
switch (aStatus.getFileType())
{
case osl::FileStatus::Directory:
aResourceType
= rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("folder"));
bResourceType = true;
break;
case osl::FileStatus::Volume:
{
aResourceType
= rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("volume"));
bResourceType = true;
osl::VolumeInfo aVolumeInfo(
VolumeInfoMask_Attributes );
if( osl::Directory::getVolumeInfo(
rPhysicalUrl,aVolumeInfo ) ==
osl::FileBase::E_None )
{
bRemovable = aVolumeInfo.getRemoveableFlag();
bRemoveProperty = true;
}
}
break;
case osl::FileStatus::Regular:
case osl::FileStatus::Fifo:
case osl::FileStatus::Socket:
case osl::FileStatus::Link:
case osl::FileStatus::Special:
case osl::FileStatus::Unknown:
// do nothing for now
break;
}
}
Sequence< Any > aArguments( 1 +
(bResourceName ? 1 : 0) +
(bResourceType ? 1 : 0) +
(bRemoveProperty ? 1 : 0) );
sal_Int32 i = 0;
aArguments[i++]
<<= PropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
"Uri")),
-1,
makeAny(rPhysicalUrl),
PropertyState_DIRECT_VALUE);
if (bResourceName)
aArguments[i++]
<<= PropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
"ResourceName")),
-1,
makeAny(aResourceName),
PropertyState_DIRECT_VALUE);
if (bResourceType)
aArguments[i++]
<<= PropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
"ResourceType")),
-1,
makeAny(aResourceType),
PropertyState_DIRECT_VALUE);
if (bRemoveProperty)
aArguments[i++]
<<= PropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
"Removable")),
-1,
makeAny(bRemovable),
PropertyState_DIRECT_VALUE);
return aArguments;
}
}
namespace fileaccess {
sal_Bool isChild( const rtl::OUString& srcUnqPath,
const rtl::OUString& dstUnqPath )
{
static sal_Unicode slash = '/';
// Simple lexical comparison
sal_Int32 srcL = srcUnqPath.getLength();
sal_Int32 dstL = dstUnqPath.getLength();
return (
( srcUnqPath == dstUnqPath )
||
( ( dstL > srcL )
&&
( srcUnqPath.compareTo( dstUnqPath, srcL ) == 0 )
&&
( dstUnqPath[ srcL ] == slash ) )
);
}
rtl::OUString newName(
const rtl::OUString& aNewPrefix,
const rtl::OUString& aOldPrefix,
const rtl::OUString& old_Name )
{
sal_Int32 srcL = aOldPrefix.getLength();
rtl::OUString new_Name = old_Name.copy( srcL );
new_Name = ( aNewPrefix + new_Name );
return new_Name;
}
rtl::OUString getTitle( const rtl::OUString& aPath )
{
sal_Unicode slash = '/';
sal_Int32 lastIndex = aPath.lastIndexOf( slash );
return aPath.copy( lastIndex + 1 );
}
rtl::OUString getParentName( const rtl::OUString& aFileName )
{
sal_Int32 lastIndex = aFileName.lastIndexOf( sal_Unicode('/') );
rtl::OUString aParent = aFileName.copy( 0,lastIndex );
if( aParent[ aParent.getLength()-1] == sal_Unicode(':') && aParent.getLength() == 6 )
aParent += rtl::OUString::createFromAscii( "/" );
if( 0 == aParent.compareToAscii( "file://" ) )
aParent = rtl::OUString::createFromAscii( "file:///" );
return aParent;
}
osl::FileBase::RC osl_File_copy( const rtl::OUString& strPath,
const rtl::OUString& strDestPath,
sal_Bool test )
{
if( test )
{
osl::DirectoryItem aItem;
if( osl::DirectoryItem::get( strDestPath,aItem ) != osl::FileBase:: E_NOENT )
return osl::FileBase::E_EXIST;
}
return osl::File::copy( strPath,strDestPath );
}
osl::FileBase::RC osl_File_move( const rtl::OUString& strPath,
const rtl::OUString& strDestPath,
sal_Bool test )
{
if( test )
{
osl::DirectoryItem aItem;
if( osl::DirectoryItem::get( strDestPath,aItem ) != osl::FileBase:: E_NOENT )
return osl::FileBase::E_EXIST;
}
return osl::File::move( strPath,strDestPath );
}
void throw_handler(
sal_Int32 errorCode,
sal_Int32 minorCode,
const Reference< XCommandEnvironment >& xEnv,
const rtl::OUString& aUncPath,
BaseContent* pContent,
bool isHandled )
{
Reference<XCommandProcessor> xComProc(pContent);
Any aAny;
IOErrorCode ioErrorCode;
if( errorCode == TASKHANDLER_UNSUPPORTED_COMMAND )
{
aAny <<= UnsupportedCommandException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
cancelCommandExecution( aAny,xEnv );
}
else if( errorCode == TASKHANDLING_WRONG_SETPROPERTYVALUES_ARGUMENT ||
errorCode == TASKHANDLING_WRONG_GETPROPERTYVALUES_ARGUMENT ||
errorCode == TASKHANDLING_WRONG_OPEN_ARGUMENT ||
errorCode == TASKHANDLING_WRONG_DELETE_ARGUMENT ||
errorCode == TASKHANDLING_WRONG_TRANSFER_ARGUMENT ||
errorCode == TASKHANDLING_WRONG_INSERT_ARGUMENT ||
errorCode == TASKHANDLING_WRONG_CREATENEWCONTENT_ARGUMENT )
{
IllegalArgumentException excep;
excep.ArgumentPosition = 0;
aAny <<= excep;
cancelCommandExecution(
aAny,xEnv);
}
else if( errorCode == TASKHANDLING_UNSUPPORTED_OPEN_MODE )
{
UnsupportedOpenModeException excep;
excep.Mode = sal::static_int_cast< sal_Int16 >(minorCode);
aAny <<= excep;
cancelCommandExecution( aAny,xEnv );
}
else if(errorCode == TASKHANDLING_DELETED_STATE_IN_OPEN_COMMAND ||
errorCode == TASKHANDLING_INSERTED_STATE_IN_OPEN_COMMAND ||
errorCode == TASKHANDLING_NOFRESHINSERT_IN_INSERT_COMMAND )
{
// What to do here?
}
else if(
// error in opening file
errorCode == TASKHANDLING_NO_OPEN_FILE_FOR_OVERWRITE ||
// error in opening file
errorCode == TASKHANDLING_NO_OPEN_FILE_FOR_WRITE ||
// error in opening file
errorCode == TASKHANDLING_OPEN_FOR_STREAM ||
// error in opening file
errorCode == TASKHANDLING_OPEN_FOR_INPUTSTREAM ||
// error in opening file
errorCode == TASKHANDLING_OPEN_FILE_FOR_PAGING )
{
switch( minorCode )
{
case FileBase::E_NAMETOOLONG:
// pathname was too long
ioErrorCode = IOErrorCode_NAME_TOO_LONG;
break;
case FileBase::E_NXIO:
// No such device or address
case FileBase::E_NODEV:
// No such device
ioErrorCode = IOErrorCode_INVALID_DEVICE;
break;
case FileBase::E_NOENT:
// No such file or directory
ioErrorCode = IOErrorCode_NOT_EXISTING;
break;
case FileBase::E_ROFS:
// #i4735# handle ROFS transparently as ACCESS_DENIED
case FileBase::E_ACCES:
// permission denied<P>
ioErrorCode = IOErrorCode_ACCESS_DENIED;
break;
case FileBase::E_ISDIR:
// Is a directory<p>
ioErrorCode = IOErrorCode_NO_FILE;
break;
case FileBase::E_NOTREADY:
ioErrorCode = IOErrorCode_DEVICE_NOT_READY;
break;
case FileBase::E_MFILE:
// too many open files used by the process
case FileBase::E_NFILE:
// too many open files in the system
ioErrorCode = IOErrorCode_OUT_OF_FILE_HANDLES;
break;
case FileBase::E_INVAL:
// the format of the parameters was not valid
ioErrorCode = IOErrorCode_INVALID_PARAMETER;
break;
case FileBase::E_NOMEM:
// not enough memory for allocating structures
ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
break;
case FileBase::E_BUSY:
// Text file busy
ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
break;
case FileBase::E_AGAIN:
// Operation would block
ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
break;
case FileBase::E_NOLCK: // No record locks available
ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
break;
case FileBase::E_FAULT: // Bad address
case FileBase::E_LOOP: // Too many symbolic links encountered
case FileBase::E_NOSPC: // No space left on device
case FileBase::E_INTR: // function call was interrupted
case FileBase::E_IO: // I/O error
case FileBase::E_MULTIHOP: // Multihop attempted
case FileBase::E_NOLINK: // Link has been severed
default:
ioErrorCode = IOErrorCode_GENERAL;
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"an error occured during file opening")),
xComProc);
}
else if( errorCode == TASKHANDLING_OPEN_FOR_DIRECTORYLISTING ||
errorCode == TASKHANDLING_OPENDIRECTORY_FOR_REMOVE )
{
switch( minorCode )
{
case FileBase::E_INVAL:
// the format of the parameters was not valid
ioErrorCode = IOErrorCode_INVALID_PARAMETER;
break;
case FileBase::E_NOENT:
// the specified path doesn't exist
ioErrorCode = IOErrorCode_NOT_EXISTING;
break;
case FileBase::E_NOTDIR:
// the specified path is not an directory
ioErrorCode = IOErrorCode_NO_DIRECTORY;
break;
case FileBase::E_NOMEM:
// not enough memory for allocating structures
ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
break;
case FileBase::E_ROFS:
// #i4735# handle ROFS transparently as ACCESS_DENIED
case FileBase::E_ACCES: // permission denied
ioErrorCode = IOErrorCode_ACCESS_DENIED;
break;
case FileBase::E_NOTREADY:
ioErrorCode = IOErrorCode_DEVICE_NOT_READY;
break;
case FileBase::E_MFILE:
// too many open files used by the process
case FileBase::E_NFILE:
// too many open files in the system
ioErrorCode = IOErrorCode_OUT_OF_FILE_HANDLES;
break;
case FileBase::E_NAMETOOLONG:
// File name too long
ioErrorCode = IOErrorCode_NAME_TOO_LONG;
break;
case FileBase::E_LOOP:
// Too many symbolic links encountered<p>
default:
ioErrorCode = IOErrorCode_GENERAL;
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"an error occured during opening a directory")),
xComProc);
}
else if( errorCode == TASKHANDLING_NOTCONNECTED_FOR_WRITE ||
errorCode == TASKHANDLING_BUFFERSIZEEXCEEDED_FOR_WRITE ||
errorCode == TASKHANDLING_IOEXCEPTION_FOR_WRITE ||
errorCode == TASKHANDLING_NOTCONNECTED_FOR_PAGING ||
errorCode == TASKHANDLING_BUFFERSIZEEXCEEDED_FOR_PAGING ||
errorCode == TASKHANDLING_IOEXCEPTION_FOR_PAGING )
{
ioErrorCode = IOErrorCode_UNKNOWN;
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"an error occured writing or reading from a file")),
xComProc );
}
else if( errorCode == TASKHANDLING_FILEIOERROR_FOR_NO_SPACE )
{
ioErrorCode = IOErrorCode_OUT_OF_DISK_SPACE;
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"device full")),
xComProc);
}
else if( errorCode == TASKHANDLING_FILEIOERROR_FOR_WRITE ||
errorCode == TASKHANDLING_READING_FILE_FOR_PAGING )
{
switch( minorCode )
{
case FileBase::E_INVAL:
// the format of the parameters was not valid
ioErrorCode = IOErrorCode_INVALID_PARAMETER;
break;
case FileBase::E_FBIG:
// File too large
ioErrorCode = IOErrorCode_CANT_WRITE;
break;
case FileBase::E_NOSPC:
// No space left on device
ioErrorCode = IOErrorCode_OUT_OF_DISK_SPACE;
break;
case FileBase::E_NXIO:
// No such device or address
ioErrorCode = IOErrorCode_INVALID_DEVICE;
break;
case FileBase::E_NOLINK:
// Link has been severed
case FileBase::E_ISDIR:
// Is a directory
ioErrorCode = IOErrorCode_NO_FILE;
break;
case FileBase::E_AGAIN:
// Operation would block
ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
break;
case FileBase::E_TIMEDOUT:
ioErrorCode = IOErrorCode_DEVICE_NOT_READY;
break;
case FileBase::E_NOLCK: // No record locks available
ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
break;
case FileBase::E_IO: // I/O error
case FileBase::E_BADF: // Bad file
case FileBase::E_FAULT: // Bad address
case FileBase::E_INTR: // function call was interrupted
default:
ioErrorCode = IOErrorCode_GENERAL;
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"an error occured during opening a file")),
xComProc);
}
else if( errorCode == TASKHANDLING_NONAMESET_INSERT_COMMAND ||
errorCode == TASKHANDLING_NOCONTENTTYPE_INSERT_COMMAND )
{
Sequence< ::rtl::OUString > aSeq( 1 );
aSeq[0] =
( errorCode == TASKHANDLING_NONAMESET_INSERT_COMMAND ) ?
rtl::OUString::createFromAscii( "Title" ) :
rtl::OUString::createFromAscii( "ContentType" );
aAny <<= MissingPropertiesException(
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"a property is missing necessary"
"to create a content")),
xComProc,
aSeq);
cancelCommandExecution(aAny,xEnv);
}
else if( errorCode == TASKHANDLING_FILESIZE_FOR_WRITE )
{
switch( minorCode )
{
case FileBase::E_INVAL:
// the format of the parameters was not valid
case FileBase::E_OVERFLOW:
// The resulting file offset would be a value which cannot
// be represented correctly for regular files
ioErrorCode = IOErrorCode_INVALID_PARAMETER;
break;
default:
ioErrorCode = IOErrorCode_GENERAL;
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"there were problems with the filesize")),
xComProc);
}
else if(errorCode == TASKHANDLING_INPUTSTREAM_FOR_WRITE)
{
Reference<XInterface> xContext(xComProc,UNO_QUERY);
aAny <<=
MissingInputStreamException(
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"the inputstream is missing necessary"
"to create a content")),
xContext);
cancelCommandExecution(aAny,xEnv);
}
else if( errorCode == TASKHANDLING_NOREPLACE_FOR_WRITE )
// Overwrite = false and file exists
{
NameClashException excep;
excep.Name = getTitle(aUncPath);
excep.Classification = InteractionClassification_ERROR;
Reference<XInterface> xContext(xComProc,UNO_QUERY);
excep.Context = xContext;
excep.Message = rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"file exists and overwrite forbidden"));
aAny <<= excep;
cancelCommandExecution( aAny,xEnv );
}
else if( errorCode == TASKHANDLING_INVALID_NAME_MKDIR )
{
InteractiveAugmentedIOException excep;
excep.Code = IOErrorCode_INVALID_CHARACTER;
PropertyValue prop;
prop.Name = rtl::OUString::createFromAscii("ResourceName");
prop.Handle = -1;
rtl::OUString m_aClashingName(
rtl::Uri::decode(
getTitle(aUncPath),
rtl_UriDecodeWithCharset,
RTL_TEXTENCODING_UTF8));
prop.Value <<= m_aClashingName;
Sequence<Any> seq(1);
seq[0] <<= prop;
excep.Arguments = seq;
excep.Classification = InteractionClassification_ERROR;
Reference<XInterface> xContext(xComProc,UNO_QUERY);
excep.Context = xContext;
excep.Message = rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"the name contained invalid characters"));
if(isHandled)
throw excep;
else {
aAny <<= excep;
cancelCommandExecution( aAny,xEnv );
}
// ioErrorCode = IOErrorCode_INVALID_CHARACTER;
// cancelCommandExecution(
// ioErrorCode,
// generateErrorArguments(aUncPath),
// xEnv,
// rtl::OUString(
// RTL_CONSTASCII_USTRINGPARAM(
// "the name contained invalid characters")),
// xComProc );
}
else if( errorCode == TASKHANDLING_FOLDER_EXISTS_MKDIR )
{
NameClashException excep;
excep.Name = getTitle(aUncPath);
excep.Classification = InteractionClassification_ERROR;
Reference<XInterface> xContext(xComProc,UNO_QUERY);
excep.Context = xContext;
excep.Message = rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"folder exists and overwrite forbidden"));
if(isHandled)
throw excep;
else {
aAny <<= excep;
cancelCommandExecution( aAny,xEnv );
}
// ioErrorCode = IOErrorCode_ALREADY_EXISTING;
// cancelCommandExecution(
// ioErrorCode,
// generateErrorArguments(aUncPath),
// xEnv,
// rtl::OUString(
// RTL_CONSTASCII_USTRINGPARAM(
// "the folder exists")),
// xComProc );
}
else if( errorCode == TASKHANDLING_ENSUREDIR_FOR_WRITE ||
errorCode == TASKHANDLING_CREATEDIRECTORY_MKDIR )
{
switch( minorCode )
{
case FileBase::E_ACCES:
ioErrorCode = IOErrorCode_ACCESS_DENIED;
break;
case FileBase::E_ROFS:
ioErrorCode = IOErrorCode_WRITE_PROTECTED;
break;
case FileBase::E_NAMETOOLONG:
ioErrorCode = IOErrorCode_NAME_TOO_LONG;
break;
default:
ioErrorCode = IOErrorCode_NOT_EXISTING_PATH;
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(getParentName(aUncPath)),
//TODO! ok to supply physical URL to getParentName()?
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"a folder could not be created")),
xComProc );
}
else if( errorCode == TASKHANDLING_VALIDFILESTATUSWHILE_FOR_REMOVE ||
errorCode == TASKHANDLING_VALIDFILESTATUS_FOR_REMOVE ||
errorCode == TASKHANDLING_NOSUCHFILEORDIR_FOR_REMOVE )
{
switch( minorCode )
{
case FileBase::E_INVAL: // the format of the parameters was not valid
ioErrorCode = IOErrorCode_INVALID_PARAMETER;
break;
case FileBase::E_NOMEM: // not enough memory for allocating structures
ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
break;
case FileBase::E_ROFS: // #i4735# handle ROFS transparently as ACCESS_DENIED
case FileBase::E_ACCES: // permission denied
ioErrorCode = IOErrorCode_ACCESS_DENIED;
break;
case FileBase::E_MFILE: // too many open files used by the process
case FileBase::E_NFILE: // too many open files in the system
ioErrorCode = IOErrorCode_OUT_OF_FILE_HANDLES;
break;
case FileBase::E_NOLINK: // Link has been severed
case FileBase::E_NOENT: // No such file or directory
ioErrorCode = IOErrorCode_NOT_EXISTING;
break;
case FileBase::E_NAMETOOLONG: // File name too long
ioErrorCode = IOErrorCode_NAME_TOO_LONG;
break;
case FileBase::E_NOTDIR: // A component of the path prefix of path is not a directory
ioErrorCode = IOErrorCode_NOT_EXISTING_PATH;
break;
case FileBase::E_LOOP: // Too many symbolic links encountered
case FileBase::E_IO: // I/O error
case FileBase::E_MULTIHOP: // Multihop attempted
case FileBase::E_FAULT: // Bad address
case FileBase::E_INTR: // function call was interrupted
case FileBase::E_NOSYS: // Function not implemented
case FileBase::E_NOSPC: // No space left on device
case FileBase::E_NXIO: // No such device or address
case FileBase::E_OVERFLOW: // Value too large for defined data type
case FileBase::E_BADF: // Invalid oslDirectoryItem parameter
default:
ioErrorCode = IOErrorCode_GENERAL;
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"a file status object could not be filled")),
xComProc );
}
else if( errorCode == TASKHANDLING_DELETEFILE_FOR_REMOVE ||
errorCode == TASKHANDLING_DELETEDIRECTORY_FOR_REMOVE )
{
switch( minorCode )
{
case FileBase::E_INVAL: // the format of the parameters was not valid
ioErrorCode = IOErrorCode_INVALID_PARAMETER;
break;
case FileBase::E_NOMEM: // not enough memory for allocating structures
ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
break;
case FileBase::E_ACCES: // Permission denied
ioErrorCode = IOErrorCode_ACCESS_DENIED;
break;
case FileBase::E_PERM: // Operation not permitted
ioErrorCode = IOErrorCode_NOT_SUPPORTED;
break;
case FileBase::E_NAMETOOLONG: // File name too long
ioErrorCode = IOErrorCode_NAME_TOO_LONG;
break;
case FileBase::E_NOLINK: // Link has been severed
case FileBase::E_NOENT: // No such file or directory
ioErrorCode = IOErrorCode_NOT_EXISTING;
break;
case FileBase::E_ISDIR: // Is a directory
case FileBase::E_ROFS: // Read-only file system
ioErrorCode = IOErrorCode_NOT_SUPPORTED;
break;
case FileBase::E_BUSY: // Device or resource busy
ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
break;
case FileBase::E_FAULT: // Bad address
case FileBase::E_LOOP: // Too many symbolic links encountered
case FileBase::E_IO: // I/O error
case FileBase::E_INTR: // function call was interrupted
case FileBase::E_MULTIHOP: // Multihop attempted
default:
ioErrorCode = IOErrorCode_GENERAL;
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"a file or directory could not be deleted")),
xComProc );
}
else if( errorCode == TASKHANDLING_TRANSFER_BY_COPY_SOURCE ||
errorCode == TASKHANDLING_TRANSFER_BY_COPY_SOURCESTAT ||
errorCode == TASKHANDLING_TRANSFER_BY_MOVE_SOURCE ||
errorCode == TASKHANDLING_TRANSFER_BY_MOVE_SOURCESTAT ||
errorCode == TASKHANDLING_TRANSFER_DESTFILETYPE ||
errorCode == TASKHANDLING_FILETYPE_FOR_REMOVE ||
errorCode == TASKHANDLING_DIRECTORYEXHAUSTED_FOR_REMOVE ||
errorCode == TASKHANDLING_TRANSFER_INVALIDURL )
{
rtl::OUString aMsg;
switch( minorCode )
{
case FileBase::E_NOENT: // No such file or directory
if ( errorCode == TASKHANDLING_TRANSFER_BY_COPY_SOURCE ||
errorCode == TASKHANDLING_TRANSFER_BY_COPY_SOURCESTAT ||
errorCode == TASKHANDLING_TRANSFER_BY_MOVE_SOURCE ||
errorCode == TASKHANDLING_TRANSFER_BY_MOVE_SOURCESTAT )
{
ioErrorCode = IOErrorCode_NOT_EXISTING;
aMsg = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"source file/folder does not exist"));
break;
}
else
{
ioErrorCode = IOErrorCode_GENERAL;
aMsg = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"a general error during transfer command"));
break;
}
default:
ioErrorCode = IOErrorCode_GENERAL;
aMsg = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"a general error during transfer command"));
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
aMsg,
xComProc );
}
else if( errorCode == TASKHANDLING_TRANSFER_ACCESSINGROOT )
{
ioErrorCode = IOErrorCode_WRITE_PROTECTED;
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"accessing the root during transfer")),
xComProc );
}
else if( errorCode == TASKHANDLING_TRANSFER_INVALIDSCHEME )
{
Reference<XInterface> xContext(xComProc,UNO_QUERY);
aAny <<=
InteractiveBadTransferURLException(
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"bad tranfer url")),
xContext);
cancelCommandExecution( aAny,xEnv );
}
else if( errorCode == TASKHANDLING_OVERWRITE_FOR_MOVE ||
errorCode == TASKHANDLING_OVERWRITE_FOR_COPY ||
errorCode == TASKHANDLING_NAMECLASHMOVE_FOR_MOVE ||
errorCode == TASKHANDLING_NAMECLASHMOVE_FOR_COPY ||
errorCode == TASKHANDLING_KEEPERROR_FOR_MOVE ||
errorCode == TASKHANDLING_KEEPERROR_FOR_COPY ||
errorCode == TASKHANDLING_RENAME_FOR_MOVE ||
errorCode == TASKHANDLING_RENAME_FOR_COPY ||
errorCode == TASKHANDLING_RENAMEMOVE_FOR_MOVE ||
errorCode == TASKHANDLING_RENAMEMOVE_FOR_COPY )
{
rtl::OUString aMsg(RTL_CONSTASCII_USTRINGPARAM(
"general error during transfer"));
switch( minorCode )
{
case FileBase::E_EXIST:
ioErrorCode = IOErrorCode_ALREADY_EXISTING;
break;
case FileBase::E_INVAL: // the format of the parameters was not valid
ioErrorCode = IOErrorCode_INVALID_PARAMETER;
break;
case FileBase::E_NOMEM: // not enough memory for allocating structures
ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
break;
case FileBase::E_ACCES: // Permission denied
ioErrorCode = IOErrorCode_ACCESS_DENIED;
break;
case FileBase::E_PERM: // Operation not permitted
ioErrorCode = IOErrorCode_NOT_SUPPORTED;
break;
case FileBase::E_NAMETOOLONG: // File name too long
ioErrorCode = IOErrorCode_NAME_TOO_LONG;
break;
case FileBase::E_NOENT: // No such file or directory
ioErrorCode = IOErrorCode_NOT_EXISTING;
aMsg = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
"file/folder does not exist"));
break;
case FileBase::E_ROFS: // Read-only file system<p>
ioErrorCode = IOErrorCode_NOT_EXISTING;
break;
default:
ioErrorCode = IOErrorCode_GENERAL;
break;
}
cancelCommandExecution(
ioErrorCode,
generateErrorArguments(aUncPath),
xEnv,
aMsg,
xComProc );
}
else if( errorCode == TASKHANDLING_NAMECLASH_FOR_COPY ||
errorCode == TASKHANDLING_NAMECLASH_FOR_MOVE )
{
NameClashException excep;
excep.Name = getTitle(aUncPath);
excep.Classification = InteractionClassification_ERROR;
Reference<XInterface> xContext(xComProc,UNO_QUERY);
excep.Context = xContext;
excep.Message = rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"name clash during copy or move"));
aAny <<= excep;
cancelCommandExecution(aAny,xEnv);
}
else if( errorCode == TASKHANDLING_NAMECLASHSUPPORT_FOR_MOVE ||
errorCode == TASKHANDLING_NAMECLASHSUPPORT_FOR_COPY )
{
Reference<XInterface> xContext(
xComProc,UNO_QUERY);
UnsupportedNameClashException excep;
excep.NameClash = minorCode;
excep.Context = xContext;
excep.Message = rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"name clash value not supported during copy or move"));
aAny <<= excep;
cancelCommandExecution(aAny,xEnv);
}
else
{
// case TASKHANDLER_NO_ERROR:
return;
}
}
} // end namespace fileaccess