| /************************************************************** |
| * |
| * 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_tools.hxx" |
| |
| #if defined WNT |
| #ifndef _SVWIN_H |
| #include <io.h> |
| #include <tools/svwin.h> |
| #endif |
| |
| #elif defined(OS2) |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <share.h> |
| #include <io.h> |
| |
| #elif defined UNX |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <sys/stat.h> |
| |
| #endif |
| |
| #include <ctype.h> |
| #include <errno.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <stdio.h> |
| #include "comdep.hxx" |
| #include <tools/fsys.hxx> |
| #include <tools/stream.hxx> |
| #include <osl/file.hxx> |
| |
| using namespace ::osl; |
| |
| /************************************************************************* |
| |* |
| |* FileCopier::FileCopier() |
| |* |
| |* Beschreibung FSYS.SDW |
| |* Ersterstellung MI 13.04.94 |
| |* Letzte Aenderung MI 13.04.94 |
| |* |
| *************************************************************************/ |
| |
| FileCopier::FileCopier() : |
| |
| nBytesTotal ( 0 ), |
| nBytesCopied( 0 ), |
| nBlockSize ( 4096 ), |
| pImp ( new FileCopier_Impl ) |
| |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| FileCopier::FileCopier( const DirEntry& rSource, const DirEntry& rTarget ) : |
| |
| aSource ( rSource ), |
| aTarget ( rTarget ), |
| nBytesTotal ( 0 ), |
| nBytesCopied( 0 ), |
| nBlockSize ( 4096 ), |
| pImp ( new FileCopier_Impl ) |
| |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| FileCopier::FileCopier( const FileCopier& rCopier ) : |
| |
| aSource ( rCopier.aSource ), |
| aTarget ( rCopier.aTarget ), |
| nBytesTotal ( 0 ), |
| nBytesCopied ( 0 ), |
| aProgressLink ( rCopier.aProgressLink ), |
| nBlockSize ( 4096 ), |
| pImp ( new FileCopier_Impl ) |
| |
| { |
| } |
| |
| /************************************************************************* |
| |* |
| |* FileCopier::~FileCopier() |
| |* |
| |* Beschreibung FSYS.SDW |
| |* Ersterstellung MI 13.04.94 |
| |* Letzte Aenderung MI 13.04.94 |
| |* |
| *************************************************************************/ |
| |
| FileCopier::~FileCopier() |
| { |
| delete pImp; |
| } |
| |
| /************************************************************************* |
| |* |
| |* FileCopier::operator =() |
| |* |
| |* Beschreibung FSYS.SDW |
| |* Ersterstellung MI 13.04.94 |
| |* Letzte Aenderung MI 13.04.94 |
| |* |
| *************************************************************************/ |
| |
| FileCopier& FileCopier::operator = ( const FileCopier &rCopier ) |
| { |
| aSource = rCopier.aSource; |
| aTarget = rCopier.aTarget; |
| nBytesTotal = rCopier.nBytesTotal; |
| nBytesCopied = rCopier.nBytesCopied; |
| nBytesCopied = rCopier.nBytesCopied; |
| nBlockSize = rCopier.nBlockSize; |
| aProgressLink = rCopier.aProgressLink; |
| *pImp = *(rCopier.pImp); |
| return *this; |
| } |
| |
| /************************************************************************* |
| |* |
| |* FileCopier::Progress() |
| |* |
| |* Beschreibung FSYS.SDW |
| |* Ersterstellung MI 13.04.94 |
| |* Letzte Aenderung MI 13.04.94 |
| |* |
| *************************************************************************/ |
| |
| sal_Bool FileCopier::Progress() |
| { |
| if ( !aProgressLink ) |
| return sal_True; |
| else |
| { |
| if ( aProgressLink.Call( this ) ) |
| return sal_True; |
| return ( 0 == Error( ERRCODE_ABORT, 0, 0 ) ); |
| } |
| } |
| |
| //--------------------------------------------------------------------------- |
| |
| ErrCode FileCopier::Error( ErrCode eErr, const DirEntry* pSource, const DirEntry* pTarget ) |
| { |
| // kein Fehler oder kein ErrorHandler? |
| if ( !eErr || !pImp->aErrorLink ) |
| // => Error beibehalten |
| return eErr; |
| |
| // sonst gesetzten ErrorHandler fragen |
| pImp->pErrSource = pSource; |
| pImp->pErrTarget = pTarget; |
| pImp->eErr = eErr; |
| ErrCode eRet = (ErrCode) pImp->aErrorLink.Call( this ); |
| pImp->pErrSource = 0; |
| pImp->pErrTarget = 0; |
| return eRet; |
| } |
| |
| //--------------------------------------------------------------------------- |
| |
| const DirEntry* FileCopier::GetErrorSource() const |
| { |
| return pImp->pErrSource; |
| } |
| |
| //--------------------------------------------------------------------------- |
| |
| const DirEntry* FileCopier::GetErrorTarget() const |
| { |
| return pImp->pErrTarget; |
| } |
| |
| //--------------------------------------------------------------------------- |
| |
| ErrCode FileCopier::GetError() const |
| { |
| return pImp->eErr; |
| } |
| |
| //--------------------------------------------------------------------------- |
| |
| void FileCopier::SetErrorHdl( const Link &rLink ) |
| { |
| pImp->aErrorLink = rLink; |
| } |
| |
| //--------------------------------------------------------------------------- |
| |
| const Link& FileCopier::GetErrorHdl() const |
| { |
| return pImp->aErrorLink ; |
| } |
| |
| /************************************************************************* |
| |* |
| |* FileCopier::Execute() |
| |* |
| |* Beschreibung FSYS.SDW |
| |* Ersterstellung MI 13.04.94 |
| |* Letzte Aenderung PB 16.06.00 |
| |* |
| *************************************************************************/ |
| |
| FSysError FileCopier::DoCopy_Impl( |
| const DirEntry &rSource, const DirEntry &rTarget ) |
| { |
| FSysError eRet = FSYS_ERR_OK; |
| ErrCode eWarn = FSYS_ERR_OK; |
| |
| // HPFS->FAT? |
| FSysPathStyle eSourceStyle = DirEntry::GetPathStyle( rSource.ImpGetTopPtr()->GetName() ); |
| FSysPathStyle eTargetStyle = DirEntry::GetPathStyle( rTarget.ImpGetTopPtr()->GetName() ); |
| sal_Bool bMakeShortNames = ( eSourceStyle == FSYS_STYLE_HPFS && eTargetStyle == FSYS_STYLE_FAT ); |
| |
| // Zieldateiname ggf. kuerzen |
| DirEntry aTgt; |
| if ( bMakeShortNames ) |
| { |
| aTgt = rTarget.GetPath(); |
| aTgt.MakeShortName( rTarget.GetName() ); |
| } |
| else |
| aTgt = rTarget; |
| |
| // kein Move wenn Namen gekuerzt werden muessten |
| if ( bMakeShortNames && FSYS_ACTION_MOVE == ( pImp->nActions & FSYS_ACTION_MOVE ) && aTgt != rTarget ) |
| return ERRCODE_IO_NAMETOOLONG; |
| |
| // source is directory? |
| FileStat aSourceFileStat( rSource ); |
| if ( aSourceFileStat.IsKind( FSYS_KIND_DIR ) ) |
| { |
| #ifdef OS2 |
| CHAR szSource[CCHMAXPATHCOMP]; |
| HOBJECT hSourceObject; |
| |
| strcpy(szSource, ByteString(rSource.GetFull(), osl_getThreadTextEncoding()).GetBuffer()); |
| hSourceObject = WinQueryObject(szSource); |
| |
| if ( hSourceObject ) |
| { |
| PSZ pszSourceName; |
| PSZ pszTargetName; |
| CHAR szTarget[CCHMAXPATHCOMP]; |
| HOBJECT hTargetObject; |
| HOBJECT hReturn = NULLHANDLE; |
| |
| strcpy(szTarget, ByteString(rTarget.GetFull(), osl_getThreadTextEncoding()).GetBuffer()); |
| pszTargetName = strrchr(szTarget, '\\'); |
| pszSourceName = strrchr(szSource, '\\'); |
| |
| hTargetObject = WinQueryObject(szTarget); |
| |
| if ( hTargetObject ) |
| WinDestroyObject(hTargetObject); |
| |
| if ( pszTargetName && pszSourceName ) |
| { |
| *pszTargetName = '\0'; |
| pszSourceName++; |
| pszTargetName++; |
| |
| if(strcmp(pszSourceName, pszTargetName) == 0) |
| { |
| hTargetObject = WinQueryObject(szTarget); |
| |
| if(pImp->nActions & FSYS_ACTION_MOVE) |
| { |
| hReturn = WinMoveObject(hSourceObject, hTargetObject, 0); |
| } |
| else |
| { |
| hReturn = WinCopyObject(hSourceObject, hTargetObject, 0); |
| } |
| if ( bMakeShortNames && aTarget.Exists() ) |
| aTarget.Kill(); |
| return hReturn ? FSYS_ERR_OK : FSYS_ERR_UNKNOWN; |
| } |
| } |
| } |
| #endif |
| // recursive copy |
| eRet = Error( aTgt.MakeDir() ? FSYS_ERR_OK : FSYS_ERR_UNKNOWN, 0, &aTgt ); |
| Dir aSourceDir( rSource, FSYS_KIND_DIR|FSYS_KIND_FILE ); |
| for ( sal_uInt16 n = 0; ERRCODE_TOERROR(eRet) == FSYS_ERR_OK && n < aSourceDir.Count(); ++n ) |
| { |
| const DirEntry &rSubSource = aSourceDir[n]; |
| DirEntryFlag eFlag = rSubSource.GetFlag(); |
| if ( eFlag != FSYS_FLAG_CURRENT && eFlag != FSYS_FLAG_PARENT ) |
| { |
| DirEntry aSubTarget( aTgt ); |
| aSubTarget += rSubSource.GetName(); |
| eRet = DoCopy_Impl( rSubSource, aSubTarget ); |
| if ( eRet && !eWarn ) |
| eWarn = eRet; |
| } |
| } |
| } |
| else if ( aSourceFileStat.IsKind(FSYS_KIND_FILE) ) |
| { |
| if ( ( FSYS_ACTION_KEEP_EXISTING == ( pImp->nActions & FSYS_ACTION_KEEP_EXISTING ) ) && |
| aTgt.Exists() ) |
| { |
| // Do not overwrite existing file in target folder. |
| return ERRCODE_NONE; |
| } |
| |
| // copy file |
| nBytesCopied = 0; |
| nBytesTotal = FileStat( rSource ).GetSize(); |
| |
| ::rtl::OUString aFileName; |
| FileBase::getFileURLFromSystemPath( ::rtl::OUString(rSource.GetFull()), aFileName ); |
| SvFileStream aSrc( aFileName, STREAM_READ|STREAM_NOCREATE|STREAM_SHARE_DENYNONE ); |
| |
| if ( !aSrc.GetError() ) |
| { |
| #ifdef UNX |
| struct stat buf; |
| if ( fstat( aSrc.GetFileHandle(), &buf ) == -1 ) |
| eRet = Error( FSYS_ERR_ACCESSDENIED, 0, &aTgt ); |
| #endif |
| ::rtl::OUString aTargetFileName; |
| FileBase::getFileURLFromSystemPath( ::rtl::OUString(aTgt.GetFull()), aTargetFileName ); |
| |
| SvFileStream aTargetStream( aTargetFileName, STREAM_WRITE | STREAM_TRUNC | STREAM_SHARE_DENYWRITE ); |
| if ( !aTargetStream.GetError() ) |
| { |
| #ifdef UNX |
| if ( fchmod( aTargetStream.GetFileHandle(), buf.st_mode ) == -1 ) |
| eRet = Error( FSYS_ERR_ACCESSDENIED, 0, &aTgt ); |
| #endif |
| size_t nAllocSize = 0, nSize = 0; |
| char *pBuf = 0; |
| while ( Progress() && nSize == nAllocSize && eRet == FSYS_ERR_OK ) |
| { |
| // adjust the block-size |
| if ( nBlockSize > nAllocSize ) |
| { |
| delete[] pBuf; |
| nAllocSize = nBlockSize; |
| pBuf = new char[nAllocSize]; |
| } |
| |
| // copy one block |
| nSize = aSrc.Read( pBuf, nBlockSize ); |
| aTargetStream.Write( pBuf, nSize ); |
| if ( aTargetStream.GetError() ) |
| eRet = Error( aTargetStream.GetError(), 0, &aTgt ); |
| |
| // adjust counters |
| nBytesCopied += nSize; |
| if ( nBytesCopied > nBytesTotal ) |
| nBytesTotal = nBytesCopied; |
| } |
| delete[] pBuf; |
| } |
| else |
| eRet = Error( aTargetStream.GetError(), 0, &aTgt ); |
| |
| // unvollstaendiges File wieder loeschen |
| aTargetStream.Close(); |
| |
| if ( nBytesCopied != nBytesTotal ) |
| { |
| aTgt.Kill(); |
| } |
| } |
| else |
| eRet = Error( aSrc.GetError(), &rSource, 0 ); |
| } |
| else if ( aSourceFileStat.IsKind(FSYS_KIND_NONE) ) |
| eRet = Error( ERRCODE_IO_NOTEXISTS, &rSource, 0 ); |
| else |
| eRet = Error( ERRCODE_IO_NOTSUPPORTED, &rSource, 0 ); |
| |
| #ifdef WNT |
| // Set LastWriteTime and Attributes of the target identical with the source |
| |
| if ( FSYS_ERR_OK == ERRCODE_TOERROR(eRet) ) |
| { |
| WIN32_FIND_DATA fdSource; |
| ByteString aFullSource(aSource.GetFull(), osl_getThreadTextEncoding()); |
| ByteString aFullTarget(aTgt.GetFull(), osl_getThreadTextEncoding()); |
| HANDLE hFind = FindFirstFile( aFullSource.GetBuffer() , &fdSource ); |
| if ( hFind != INVALID_HANDLE_VALUE ) |
| { |
| FindClose( hFind ); |
| |
| HANDLE hFile = CreateFile( aFullTarget.GetBuffer(), GENERIC_WRITE, |
| FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, |
| OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); |
| |
| if ( hFile != INVALID_HANDLE_VALUE ) |
| { |
| SetFileTime( hFile, NULL, NULL, &fdSource.ftLastWriteTime ); |
| CloseHandle( hFile ); |
| } |
| |
| SetFileAttributes( aFullTarget.GetBuffer(), fdSource.dwFileAttributes ); |
| } |
| } |
| #endif |
| // bei Move ggf. das File/Dir loeschen |
| if ( FSYS_ERR_OK == ERRCODE_TOERROR(eRet) && ( pImp->nActions & FSYS_ACTION_MOVE ) ) |
| { |
| ErrCode eKillErr = Error( rSource.Kill() | ERRCODE_WARNING_MASK, &rSource, 0 ); |
| if ( eKillErr != ERRCODE_WARNING_MASK ) |
| { |
| if ( rSource.Exists() ) |
| // loeschen ging nicht => dann die Kopie wieder loeschen |
| aTgt.Kill( pImp->nActions ); |
| if ( !eWarn ) |
| eWarn = eKillErr; |
| } |
| } |
| |
| return !eRet ? eWarn : eRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| FSysError FileCopier::Execute( FSysAction nActions ) |
| { |
| return ExecuteExact( nActions ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| FSysError FileCopier::ExecuteExact( FSysAction nActions, FSysExact eExact ) |
| { |
| DirEntry aAbsSource = DirEntry( aSource); |
| DirEntry aAbsTarget = DirEntry( aTarget ); |
| pImp->nActions = nActions; |
| |
| // check if both pathes are accessible and source and target are different |
| if ( !aAbsTarget.ToAbs() || !aAbsSource.ToAbs() || aAbsTarget == aAbsSource ) |
| return FSYS_ERR_ACCESSDENIED; |
| |
| // check if copy would be endless recursive into itself |
| if ( FSYS_ACTION_RECURSIVE == ( nActions & FSYS_ACTION_RECURSIVE ) && |
| aAbsSource.Contains( aAbsTarget ) ) |
| return ERRCODE_IO_RECURSIVE; |
| |
| // target is directory? |
| if ( eExact == FSYS_NOTEXACT && |
| FileStat( aAbsTarget ).IsKind(FSYS_KIND_DIR) && FileStat( aAbsSource ).IsKind(FSYS_KIND_FILE) ) |
| // append name of source |
| aAbsTarget += aSource.GetName(); |
| |
| // recursive copy |
| return DoCopy_Impl( aAbsSource, aAbsTarget ); |
| } |
