mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
937 lines
34 KiB
937 lines
34 KiB
/*
|
|
|
|
$Log: S:\oiwh\filing\fiocopy.c_v $
|
|
*
|
|
* Rev 1.25 05 Feb 1996 14:38:28 RWR
|
|
* Eliminate static links to OIDIS400 and OIADM400 for NT builds
|
|
*
|
|
* Rev 1.24 23 Jan 1996 10:22:06 RWR
|
|
* Follow CopyFile() call with SetFileAttributes() call to clear readonly flag
|
|
*
|
|
* Rev 1.23 10 Jan 1996 11:14:48 JFC
|
|
* Have to recognize when the input file name isn't really a file name at all,
|
|
* but actually an encoded storage pointer that we have to copy.
|
|
*
|
|
* Rev 1.22 06 Nov 1995 17:35:18 RWR
|
|
* Replace IMGFileCopyFile() logic w/direct call to Win95 CopyFile() function
|
|
*
|
|
* Rev 1.21 02 Nov 1995 11:49:36 RWR
|
|
* Delete all obsolete functions, prototypes and EXPORTs
|
|
* Eliminate use of the "privapis.h" header file in the FILING build
|
|
* Move miscellaneous required constants/prototypes from privapis.h to filing.h
|
|
*
|
|
* Rev 1.20 08 Sep 1995 08:45:42 RWR
|
|
* Add support for new FIO_FILE_NOEXIST error & clean up related error handling
|
|
*
|
|
* Rev 1.19 07 Sep 1995 10:16:06 RWR
|
|
* Verify destination page for FIO_OVERWRITE_PAGE option
|
|
*
|
|
* Rev 1.18 28 Aug 1995 15:14:14 RWR
|
|
* Change FIO_NEW_FILE to FIO_APPEND_PAGE after first page of multipage copy
|
|
*
|
|
* Rev 1.17 22 Aug 1995 11:01:36 JAR
|
|
* added global flag bUpdatingCache to be set and cleared around calls to
|
|
* IMGCacheUpdate, this is due to the call that is in IMGFileOpenForRead, ( which
|
|
* we needed for doing multiple page access for AWD). This flag prevents us
|
|
* from getting into a bizarro recursive call situation with IMGCacheUpdate!
|
|
*
|
|
* Rev 1.16 13 Aug 1995 17:47:30 RWR
|
|
* Add logic to turn off the FIO_NEGATE bit before calling IMGFileConvertPage()
|
|
*
|
|
* Rev 1.15 03 Aug 1995 19:07:18 RWR
|
|
* Remove logic to twiddle the FIO_NEGATE bit (already done in OpenForWrite())
|
|
*
|
|
* Rev 1.14 01 Aug 1995 15:28:50 RWR
|
|
* Fix IMGFileCopyPages() to turn off FIO_OVERWRITE_FILE after the first page
|
|
*
|
|
* Rev 1.13 12 Jul 1995 16:56:36 RWR
|
|
* Switch from \include\oiutil.h to (private) \filing\fileutil.h
|
|
*
|
|
* Rev 1.12 12 Jul 1995 11:28:40 RWR
|
|
* Check return code from IMGCacheUpdate() calls and abort operation if nonzero
|
|
*
|
|
* Rev 1.11 10 Jul 1995 11:03:32 JAR
|
|
* Intermediate check in for awd support, some of the items are commented out until
|
|
* this support is added in the GFS dll.
|
|
*
|
|
* Rev 1.10 23 Jun 1995 10:39:42 RWR
|
|
* Change "wiisfio2.h" include file to "filing.h"
|
|
*
|
|
* Rev 1.9 22 Jun 1995 17:25:56 RWR
|
|
* Change internal IMGFileInfoCgbw() call to new IMGFileGetInfo() call
|
|
*
|
|
* Rev 1.8 14 Jun 1995 15:40:18 RWR
|
|
* Switch to IMGFileDeleteFileNC() for OVERWRITE option
|
|
* Remove IMGCacheUpdate() calls for Delete Source options (done in Delete code)
|
|
*
|
|
* Rev 1.7 13 Jun 1995 17:06:36 RWR
|
|
* Correct loop to call IMGCacheUpdate() for deleted source (IMGFileCopyPages())
|
|
* Also add IMGCacheUpdate() call for IMGFileCopyFile(), but this is the wrong
|
|
* one (we're using CACHE_UPDATE_OVERWRITE_FILE because we don't have a
|
|
* CACHE_UPDATE_DELETE_FILE available yet - when it is, I'll change this)
|
|
*
|
|
* Rev 1.6 12 Jun 1995 15:23:04 RWR
|
|
* Add calls to IMGCacheUpdate() when deleting destination file (OVERWRITE set)
|
|
* or when deleting pages from the source file after successful copy
|
|
*
|
|
* Rev 1.5 22 May 1995 18:35:24 RWR
|
|
* More changes to account for admin.h->oiadm.h and new LIB file location
|
|
*
|
|
* Rev 1.4 09 May 1995 13:21:42 RWR
|
|
* #include file modifications to match changes to oiadm.h/admin.h/privapis.h
|
|
*
|
|
* Rev 1.3 24 Apr 1995 15:42:14 JCW
|
|
* Removed the oiuidll.h.
|
|
* Rename wiissubs.h to oiutil.h.
|
|
*
|
|
* Rev 1.2 12 Apr 1995 03:56:34 JAR
|
|
* massaged to get compilation under windows 95
|
|
*
|
|
* Rev 1.1 07 Apr 1995 16:19:28 RWR
|
|
* Replace call to IMGFileInfoCgbw() with IMGFileGetInfo()
|
|
*
|
|
* Rev 1.0 06 Apr 1995 13:55:40 JAR
|
|
* Initial entry
|
|
|
|
*/
|
|
|
|
//*****************************************************************
|
|
//
|
|
// fiocopy.c
|
|
//
|
|
//*****************************************************************
|
|
|
|
#include "abridge.h"
|
|
#undef NO_IMAGE
|
|
#include <windows.h>
|
|
#include "fiodata.h"
|
|
#include "oierror.h"
|
|
#include "oifile.h"
|
|
#include "oidisp.h"
|
|
//#include "privapis.h"
|
|
#include "oiadm.h"
|
|
|
|
// 9504.11 jar unused
|
|
//#include "oirpc.h"
|
|
|
|
//#include "oiuidll.h"
|
|
#include <string.h>
|
|
#include "filing.h"
|
|
#include "fileutil.h"
|
|
|
|
//#define DEBUGIT 2
|
|
|
|
#ifdef DEBUGIT
|
|
#include "monit.h"
|
|
#endif
|
|
|
|
int FAR PASCAL IMGFileDeleteFileNC (HWND, LPSTR);
|
|
extern int IsStorage (char *szFileName);
|
|
extern int CopyStorage (char *srcname, char *destname, int deletedest);
|
|
|
|
LPSTR AllocBuffer(int, LPINT, LPINT, HANDLE far *);
|
|
|
|
// 9504.11 jar changed 1st parameter to int!
|
|
//WORD FreeBuffer(WORD, HANDLE);
|
|
WORD FreeBuffer(int, HANDLE);
|
|
|
|
|
|
// 9508.22 jar global cache flag
|
|
extern BOOL bUpdatingCache;
|
|
|
|
|
|
// Note: old buffersize were 8k for remote and 16k for local....
|
|
|
|
// 9504.11 jar LocalMem changed to int!
|
|
//WORD FreeBuffer(LocalMem, bufhandle)
|
|
//WORD LocalMem;
|
|
//HANDLE bufhandle;
|
|
//*****************************************************************
|
|
//
|
|
// FreeBuffer
|
|
//
|
|
//*****************************************************************
|
|
WORD FreeBuffer( int LocalMem, HANDLE bufhandle)
|
|
{
|
|
|
|
if (LocalMem)
|
|
{
|
|
LocalUnlock (bufhandle);
|
|
LocalFree (bufhandle);
|
|
}
|
|
else
|
|
{
|
|
GlobalUnlock (bufhandle);
|
|
GlobalFree (bufhandle);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
//*****************************************************************
|
|
//
|
|
// AllocBuffer
|
|
//
|
|
//*****************************************************************
|
|
LPSTR AllocBuffer(max_buffsize, LocalMem, buffsize, bufhandle)
|
|
int max_buffsize;
|
|
LPINT LocalMem;
|
|
LPINT buffsize;
|
|
HANDLE far *bufhandle;
|
|
{
|
|
LPSTR buffer;
|
|
|
|
*LocalMem = FALSE;
|
|
|
|
for (*buffsize = max_buffsize; (*buffsize >= MIN_BUFFSIZE) &&
|
|
((*bufhandle = GlobalAlloc (GMEM_FIXED | GMEM_ZEROINIT | GMEM_NOT_BANKED,
|
|
(DWORD) (*buffsize * sizeof (char)))) == NULL); *buffsize /= 2);
|
|
|
|
/* If GlobalAlloc didn't work, try a LocalAlloc */
|
|
if (*buffsize < MIN_BUFFSIZE)
|
|
{
|
|
*buffsize = MIN_BUFFSIZE;
|
|
*LocalMem = TRUE;
|
|
// 9504.05 jar altered siuze field of LocalAlloc to UINT
|
|
//if ((*bufhandle = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT,
|
|
// (WORD) (*buffsize * sizeof (char)))) == NULL) {
|
|
if ((*bufhandle = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT,
|
|
(UINT)(*buffsize * sizeof (char)))) == NULL)
|
|
{
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
if (*LocalMem)
|
|
buffer = (LPSTR) LocalLock (*bufhandle);
|
|
else
|
|
{
|
|
buffer = (LPSTR) GlobalLock (*bufhandle);
|
|
}
|
|
|
|
return (buffer);
|
|
}
|
|
|
|
//*****************************************************************
|
|
//
|
|
// IMGFileCopyFile
|
|
//
|
|
//*****************************************************************
|
|
int FAR PASCAL IMGFileCopyFile (HWND hWnd, LPSTR path_in, LPSTR path_out,
|
|
WORD copyflags)
|
|
{
|
|
int status;
|
|
int source, dest;
|
|
HANDLE srcsvrhndl;
|
|
HANDLE dstsvrhndl;
|
|
|
|
BOOL del_src;
|
|
|
|
int srchandle;
|
|
char srcname[MAXFILESPECLENGTH], destname[MAXFILESPECLENGTH];
|
|
int localremote;
|
|
int rpcerror=0;
|
|
|
|
int access_ret;
|
|
HCURSOR hNewCursor, hOldCursor = NULL;
|
|
|
|
if (!ISVALIDSPEC(path_in))
|
|
{
|
|
return (FIO_INVALIDFILESPEC);
|
|
}
|
|
|
|
if (!ISVALIDSPEC(path_out))
|
|
{
|
|
return (FIO_INVALIDFILESPEC);
|
|
}
|
|
|
|
//if (!LockData (0))
|
|
// return (FIO_LOCK_DATA_SEGMENT_ERROR);
|
|
|
|
/***** check for same file name *****/
|
|
|
|
if ((lstrcmpi(path_in, path_out)) == 0)
|
|
{
|
|
//UnlockData (0);
|
|
return ( FIO_CANNOT_CONVERT_IN_PLACE );
|
|
}
|
|
|
|
lstrcpy (destname, path_out);
|
|
|
|
#ifdef DEBUGIT
|
|
monit1("over write dest =%s\n", (LPSTR) path_out);
|
|
#endif
|
|
if ((status = IMGFileAccessCheck (hWnd, destname, 0, (LPINT)
|
|
&access_ret)) == SUCCESS)
|
|
{
|
|
if (!(access_ret)) /* IF Destination file exists, ERROR */
|
|
{
|
|
if (!(copyflags & OVERWRITEFLAG))
|
|
{
|
|
status = DESTFILEEXISTS;
|
|
goto exit1;
|
|
}
|
|
else // Caller wants it deleted
|
|
{
|
|
// 9508.22 jar set the global flag
|
|
bUpdatingCache = TRUE;
|
|
status = FioCacheUpdate(hWnd, destname, 0, CACHE_UPDATE_OVERWRITE_FILE);
|
|
bUpdatingCache = FALSE;
|
|
if (status == SUCCESS)
|
|
status = IMGFileDeleteFileNC (hWnd, destname);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
goto exit1;
|
|
}
|
|
|
|
if (copyflags & DELETESRCFLAG)
|
|
{
|
|
del_src = TRUE;
|
|
}
|
|
else
|
|
{
|
|
del_src = FALSE;
|
|
}
|
|
|
|
#ifdef DEBUGIT
|
|
monit1("copy source file=%s\n", (LPSTR) path_in);
|
|
monit1("copy dest file=%s\n", (LPSTR) path_out);
|
|
#endif
|
|
|
|
if (!(srcsvrhndl = GlobalAlloc (GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_NOT_BANKED,
|
|
(long)MAXSERVERLENGTH)))
|
|
{
|
|
status = FIO_GLOBAL_ALLOC_FAILED;
|
|
goto exit1;
|
|
}
|
|
|
|
if (!(dstsvrhndl = GlobalAlloc (GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_NOT_BANKED,
|
|
(long)MAXSERVERLENGTH)))
|
|
{
|
|
GlobalFree (srcsvrhndl);
|
|
status = FIO_GLOBAL_ALLOC_FAILED;
|
|
goto exit1;
|
|
}
|
|
|
|
lstrcpy (srcname, path_in);
|
|
hNewCursor = LoadCursor (NULL, IDC_WAIT);
|
|
hOldCursor = SetCursor (hNewCursor);
|
|
|
|
if ((status = IMGFileParsePath (srcname, srcsvrhndl, &localremote)) == SUCCESS)
|
|
{
|
|
source = localremote;
|
|
if ((status = IMGFileParsePath (destname, dstsvrhndl, &localremote))== SUCCESS)
|
|
{
|
|
dest = localremote;
|
|
|
|
switch (source)
|
|
{
|
|
|
|
// 9504.10 jar for windows 95 norwegians, this is commented out!
|
|
// case REMOTE:
|
|
// switch (dest) {
|
|
// case LOCAL: /* Copy REMOTE file to LOCAL file */
|
|
//#ifdef DEBUGIT
|
|
//monit1("Remote to Local copy ");
|
|
//#endif
|
|
// if (!(srcsvrname = (LPSTR) GlobalLock (srcsvrhndl))) {
|
|
// status = FIO_GLOBAL_LOCK_FAILED;
|
|
// goto exit2;
|
|
// }
|
|
//
|
|
// /* Allocate buffers for read/write operations */
|
|
// if (!(buffer = AllocBuffer(MAXRPCBUFSIZE, &LocalMem, &buffsize, &bufhandle)))
|
|
// {
|
|
// GlobalUnlock (srcsvrhndl);
|
|
// if (bufhandle)
|
|
// {
|
|
// if (LocalMem) {
|
|
// LocalFree (bufhandle);
|
|
// status = FIO_LOCAL_LOCK_FAILED;
|
|
// }
|
|
// else {
|
|
// GlobalFree (bufhandle);
|
|
// status = FIO_GLOBAL_LOCK_FAILED;
|
|
// }
|
|
// }
|
|
// else
|
|
// status = FIO_LOCAL_ALLOC_FAILED;
|
|
// goto exit2;
|
|
// }
|
|
//
|
|
// if ((desthandle = fio_lcreat (destname, 0)) != -1)
|
|
// {
|
|
// status = RPCIFSopen (hWnd, srcsvrname, &cid, srcname, IFS_RDONLY,
|
|
// (LPINT) &fid, &rpcerror);
|
|
// if (!status) //remap error to o/i error...
|
|
// {
|
|
// actual = status = 0;
|
|
// do
|
|
// {
|
|
// status = RPCIFSread (hWnd, &cid, fid, (long) buffsize,
|
|
// (LPSTR) buffer, &actual, &rpcerror);
|
|
// if (status) //remap error to o/i error...
|
|
// status = FIO_READ_ERROR;
|
|
// else if (actual == 0) // do nothing...
|
|
// {
|
|
// actual = 0; //do not optimize out...
|
|
// }
|
|
// else if ((actual != (unsigned long)
|
|
// fio_lwrite (desthandle, buffer,
|
|
// (int) actual)))
|
|
// {
|
|
// status = FIO_WRITE_ERROR;
|
|
// }
|
|
// else
|
|
// status = 0;
|
|
// }
|
|
// while (!(status) && (actual > 0));
|
|
// }
|
|
// else
|
|
// status = FIO_OPEN_READ_ERROR;
|
|
//
|
|
// RPCIFSclose (hWnd, &cid, fid, &tmperror);
|
|
// fio_lclose (desthandle);
|
|
// }
|
|
// else
|
|
// status = FIO_OPEN_WRITE_ERROR;
|
|
//
|
|
// FreeBuffer(LocalMem, bufhandle);
|
|
//
|
|
// if (status != SUCCESS)
|
|
// {
|
|
// if (rpcerror)
|
|
// status = rpcerror;
|
|
// IMGFileDeleteFile(hWnd, destname);
|
|
// }
|
|
// GlobalUnlock (srcsvrhndl);
|
|
// break;
|
|
//
|
|
// case REMOTE: /* Copy REMOTE file to REMOTE file */
|
|
// default:
|
|
//#ifdef DEBUGIT
|
|
//monit1("Remote to Remote copy ");
|
|
//#endif
|
|
// if (!(srcsvrname = (LPSTR) GlobalLock (srcsvrhndl))) {
|
|
// status = FIO_GLOBAL_LOCK_FAILED;
|
|
// goto exit2;
|
|
// }
|
|
//
|
|
// if (!(dstsvrname = (LPSTR) GlobalLock (dstsvrhndl))) {
|
|
// GlobalUnlock (srcsvrhndl);
|
|
// status = FIO_GLOBAL_LOCK_FAILED;
|
|
// goto exit2;
|
|
// }
|
|
//
|
|
// // If copy is using same server for both source and dest
|
|
// // then just call ifscopy...
|
|
// status = -1;
|
|
// lstrcpy(sourcesvr,srcsvrname);
|
|
// lstrcpy(targetsvr,dstsvrname);
|
|
// if (lpTemp = lstrchr(sourcesvr,'.')) *lpTemp = '\0';
|
|
// if (lpTemp = lstrchr(targetsvr,'.')) *lpTemp = '\0';
|
|
// if (!(lstrcmp(sourcesvr, targetsvr)))
|
|
// {
|
|
// status = RPCIFScopy ( hWnd, srcsvrname,
|
|
// srcname, destname,
|
|
// (copyflags & OVERWRITEFLAG) ? 1 : 0,
|
|
// &rpcerror);
|
|
// /* Not supported on earlier UNIX releases! */
|
|
// /* I'm not sure what all the other error codes are,
|
|
// so ANY error will fall into the Read/Write loop */
|
|
// if (status) /* unsupported function? */
|
|
// {
|
|
// status = -1;
|
|
// RPCIFSremove (hWnd, srcsvrname, destname, &rpcerror);
|
|
// }
|
|
// }
|
|
// if (status == -1) /* didn't call IFScopy or it didn't work */
|
|
// {
|
|
// /* Allocate buffers for read/write operations */
|
|
// if (!(buffer = AllocBuffer(MAXRPCBUFSIZE, &LocalMem, &buffsize, &bufhandle)))
|
|
// {
|
|
// GlobalUnlock (srcsvrhndl);
|
|
// GlobalUnlock (dstsvrhndl);
|
|
// if (bufhandle)
|
|
// {
|
|
// if (LocalMem) {
|
|
// LocalFree (bufhandle);
|
|
// status = FIO_LOCAL_LOCK_FAILED;
|
|
// }
|
|
// else {
|
|
// GlobalFree (bufhandle);
|
|
// status = FIO_GLOBAL_LOCK_FAILED;
|
|
// }
|
|
// }
|
|
// else
|
|
// status = FIO_LOCAL_ALLOC_FAILED;
|
|
// goto exit2;
|
|
// }
|
|
//
|
|
// status = RPCIFSopen (hWnd, srcsvrname, &srccid, srcname, IFS_RDONLY,
|
|
// (LPINT) &srcfid, &rpcerror);
|
|
// if (!status) //remap error to o/i error...
|
|
// {
|
|
// status = RPCIFScreate (hWnd, dstsvrname, &dstcid, destname,
|
|
// (LPINT) &dstfid, &rpcerror);
|
|
// if (!status) //remap error to o/i error...
|
|
// {
|
|
// actual = status = 0;
|
|
// do
|
|
// {
|
|
// if ((status = RPCIFSread (hWnd, &srccid, srcfid, (long) buffsize,
|
|
// (LPSTR) buffer, &actual, &rpcerror)))
|
|
// status = FIO_READ_ERROR;
|
|
// else if (actual == 0) // do nothing...
|
|
// {
|
|
// actual = 0; //do not optimize out...
|
|
// }
|
|
// else if ((status = RPCIFSwrite (hWnd, &dstcid, dstfid,
|
|
// (LPSTR) buffer, actual, &rpcerror)))
|
|
// {
|
|
// status = FIO_WRITE_ERROR;
|
|
// }
|
|
// }
|
|
// while (!(status) && (actual > 0));
|
|
//// NOTE: I have to now check for close error on destination file
|
|
////because while the server is caching the file write, it may not actually write
|
|
////to server disk on close.
|
|
// if (RPCIFSclose (hWnd, &dstcid, dstfid, &tmperror))
|
|
// {
|
|
// if (!status) // If we do not already have an error..
|
|
// status = FIO_WRITE_ERROR;
|
|
// }
|
|
// }
|
|
// else
|
|
// status = FIO_OPEN_WRITE_ERROR;
|
|
//
|
|
// //RPCIFSclose (hWnd, &srccid, srcfid, &tmperror);
|
|
// }
|
|
// else
|
|
// status = FIO_OPEN_READ_ERROR;
|
|
//
|
|
// RPCIFSclose (hWnd, &srccid, srcfid, &tmperror);
|
|
// FreeBuffer(LocalMem, bufhandle);
|
|
// }
|
|
//
|
|
// if (status != SUCCESS)
|
|
// {
|
|
// IMGFileDeleteFile(hWnd, path_out);
|
|
// if (rpcerror)
|
|
// status = rpcerror;
|
|
// }
|
|
// GlobalUnlock (srcsvrhndl);
|
|
// GlobalUnlock (dstsvrhndl);
|
|
// break;
|
|
//
|
|
// } /* end switch (dest) */
|
|
// break;
|
|
// 9504.10 jar for windows 95 norwegians, this is commented out!
|
|
|
|
case LOCAL:
|
|
default:
|
|
switch (dest)
|
|
{
|
|
|
|
// 9504.10 jar for windows 95 norwegians, this is commented out!
|
|
// case REMOTE: /* Copy LOCAL file to REMOTE file */
|
|
//#ifdef DEBUGIT
|
|
//monit1("Local to Remote copy ");
|
|
//#endif
|
|
// if (!(dstsvrname = (LPSTR) GlobalLock (dstsvrhndl))) {
|
|
// status = FIO_GLOBAL_LOCK_FAILED;
|
|
// goto exit2;
|
|
// }
|
|
// /* Allocate buffers for read/write operations */
|
|
//
|
|
// if (!(buffer = AllocBuffer(MAXRPCBUFSIZE, &LocalMem, &buffsize, &bufhandle)))
|
|
// {
|
|
// GlobalUnlock (dstsvrhndl);
|
|
// if (bufhandle)
|
|
// {
|
|
// if (LocalMem) {
|
|
// LocalFree (bufhandle);
|
|
// status = FIO_LOCAL_LOCK_FAILED;
|
|
// }
|
|
// else {
|
|
// GlobalFree (bufhandle);
|
|
// status = FIO_GLOBAL_LOCK_FAILED;
|
|
// }
|
|
// }
|
|
// else
|
|
// status = FIO_LOCAL_ALLOC_FAILED;
|
|
//
|
|
// goto exit2;
|
|
// }
|
|
// if ((srchandle = fio_lopen (srcname, READ)) != -1)
|
|
// {
|
|
// if (!(status = RPCIFScreate (hWnd, dstsvrname, &cid, destname, (LPINT) &fid, &rpcerror)))
|
|
// {
|
|
// while (((bytesread = fio_lread (srchandle, buffer,
|
|
// buffsize)) > 0) && (!status))
|
|
// {
|
|
// if (bytesread <= 0)
|
|
// {
|
|
// if (bytesread == -1)
|
|
// status = FIO_READ_ERROR;
|
|
// break;
|
|
// }
|
|
// status = RPCIFSwrite (hWnd, &cid, fid,
|
|
// (LPSTR) buffer, (long) bytesread, &rpcerror);
|
|
// if (status)
|
|
// {
|
|
// status = FIO_WRITE_ERROR;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// else
|
|
// status = FIO_OPEN_WRITE_ERROR;
|
|
//// NOTE: I have to now check for close error on destination file
|
|
////because while the server is caching the file write, it may not actually write
|
|
////to server disk on close.
|
|
// if (RPCIFSclose (hWnd, &cid, fid, &tmperror))
|
|
// {
|
|
// if (!status) // If we do not already have an error..
|
|
// status = FIO_WRITE_ERROR;
|
|
// }
|
|
// fio_lclose (srchandle);
|
|
// }
|
|
// else
|
|
// status = FIO_OPEN_READ_ERROR;
|
|
//
|
|
// FreeBuffer(LocalMem, bufhandle);
|
|
//
|
|
// if (status != SUCCESS)
|
|
// {
|
|
// IMGFileDeleteFile(hWnd, path_out);
|
|
// if (rpcerror)
|
|
// status = rpcerror;
|
|
// }
|
|
//
|
|
// GlobalUnlock (dstsvrhndl);
|
|
// break;
|
|
// 9504.10 jar for windows 95 norwegians, this is commented out!
|
|
|
|
case LOCAL: /* Copy LOCAL file to LOCAL file */
|
|
default:
|
|
#ifdef DEBUGIT
|
|
monit1("Local to local copy ");
|
|
#endif
|
|
/* TRUE setting (arg 3) means no auto-create */
|
|
status = SUCCESS;
|
|
if (!CopyFile(srcname,destname,TRUE))
|
|
{
|
|
if (!IMGAnExistingPathOrFile(srcname))
|
|
{
|
|
// If the source of this copy is the inbox,
|
|
// then srcname isn't a file, but rather an
|
|
// encoded storage pointer. Have to check
|
|
// for this, and call special copy routine.
|
|
|
|
if (!IsStorage(srcname))
|
|
status = FIO_FILE_NOEXIST;
|
|
else
|
|
status = CopyStorage(srcname,destname,TRUE);
|
|
}
|
|
else
|
|
{
|
|
if (IMGAnExistingPathOrFile(destname))
|
|
{
|
|
status = FIO_FILE_EXISTS;
|
|
}
|
|
else
|
|
{
|
|
if ((srchandle = fio_lopen ((LPSTR)srcname, OF_READ)) != -1)
|
|
{
|
|
fio_lclose(srchandle);
|
|
status = FIO_OPEN_WRITE_ERROR;
|
|
}
|
|
else
|
|
{
|
|
status = FIO_OPEN_READ_ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else /* CopyFile() was successful */
|
|
{
|
|
SetFileAttributes(destname,FILE_ATTRIBUTE_NORMAL);
|
|
}
|
|
break;
|
|
} /* end switch (dest) */
|
|
|
|
break;
|
|
} /* end switch (source) */
|
|
|
|
} /* end if (SUCCESS) */
|
|
} /* end if (SUCCESS) */
|
|
|
|
/* only delete source if user says to AND we were successful in copy */
|
|
if ((del_src) && ( status == SUCCESS))
|
|
{
|
|
lstrcpy(srcname, path_in);
|
|
IMGFileDeleteFile (hWnd, srcname);
|
|
}
|
|
|
|
if (hOldCursor)
|
|
SetCursor (hOldCursor);
|
|
|
|
GlobalFree (srcsvrhndl);
|
|
GlobalFree (dstsvrhndl);
|
|
|
|
exit1:
|
|
|
|
//UnlockData (0);
|
|
return (status);
|
|
}
|
|
|
|
// 9504.05 jar return as int
|
|
//WORD FAR PASCAL IMGFileCopyPages(hWnd, path_in, unSrcPage, unTotalPages, path_out,
|
|
// lpunDestPage, unPageOptions, bDeleteSrcPgs)
|
|
//HWND hWnd;
|
|
//LPSTR path_in;
|
|
//UINT unSrcPage;
|
|
//UINT unTotalPages;
|
|
//LPSTR path_out;
|
|
//LPUINT lpunDestPage;
|
|
//UINT unPageOptions;
|
|
//BOOL bDeleteSrcPgs;
|
|
int FAR PASCAL IMGFileCopyPages( HWND hWnd, LPSTR path_in, UINT unSrcPage,
|
|
UINT unTotalPages, LPSTR path_out,
|
|
LPUINT lpunDestPage, UINT unPageOptions,
|
|
BOOL bDeleteSrcPgs)
|
|
{
|
|
char switch_to_append = 0;
|
|
char first = 1;
|
|
char dst_not_exist = 0;
|
|
int i;
|
|
int status = 0;
|
|
int Access;
|
|
int AccessMode;
|
|
UINT page_in;
|
|
UINT page_out;
|
|
WORD ErrCode = SUCCESS;
|
|
WORD copy_flag = 0;
|
|
FIO_INFORMATION fileinfodst;
|
|
FIO_INFORMATION fileinfosrc;
|
|
FIO_INFO_CGBW colorinfosrc;
|
|
|
|
if (!IsWindow(hWnd))
|
|
return (FIO_INVALID_WINDOW_HANDLE);
|
|
|
|
if (path_in == NULL || path_out == NULL )
|
|
return (FIO_NULL_POINTER);
|
|
|
|
if (!ISVALIDSPEC(path_in))
|
|
return (FIO_INVALIDFILESPEC);
|
|
|
|
if (!ISVALIDSPEC(path_out))
|
|
return (FIO_INVALIDFILESPEC);
|
|
|
|
//if (!LockData (0))
|
|
// return (FIO_LOCK_DATA_SEGMENT_ERROR);
|
|
|
|
/* Check for same input, output file name. This is illegal. */
|
|
if ((lstrcmpi(path_in, path_out)) == 0)
|
|
{
|
|
//UnlockData (0);
|
|
return (FIO_CANNOT_CONVERT_IN_PLACE);
|
|
}
|
|
|
|
// Make sure that the source file exists and can be accessed.
|
|
if (bDeleteSrcPgs)
|
|
AccessMode = (ACCESS_WR | ACCESS_RD);
|
|
else
|
|
AccessMode = ACCESS_RD;
|
|
status = IMGFileAccessCheck(hWnd, (LPSTR)path_in, (WORD)AccessMode,
|
|
(LPINT)&Access);
|
|
if (status)
|
|
{
|
|
//UnlockData (0);
|
|
// 9504.05 jar return int
|
|
//return ((WORD) status);
|
|
return ( status);
|
|
}
|
|
if (Access)
|
|
{
|
|
//UnlockData (0);
|
|
return(FIO_OPEN_READ_ERROR);
|
|
}
|
|
|
|
// Check to see if destination file already exists.
|
|
AccessMode = (ACCESS_WR | ACCESS_RD);
|
|
status = IMGFileAccessCheck(hWnd, (LPSTR)path_out, (WORD)AccessMode,
|
|
(LPINT)&Access);
|
|
if (status)
|
|
{
|
|
//UnlockData (0);
|
|
// 9504.05 jar return int
|
|
//return ((WORD) status);
|
|
return ( status);
|
|
}
|
|
|
|
if (Access == FIO_ACCESS_DENIED)// Can't access destination file for read/write.
|
|
{
|
|
//UnlockData (0);
|
|
return(FIO_ACCESS_DENIED);
|
|
}
|
|
else if (Access == FIO_FILE_NOEXIST)// Destination file doesn't exist
|
|
{
|
|
if (unPageOptions == FIO_OVERWRITE_PAGE)
|
|
{
|
|
//UnlockData (0);
|
|
return (FIO_INVALID_PAGE_NUMBER);
|
|
}
|
|
dst_not_exist = 1;
|
|
}
|
|
else if (Access == 0)// Destination exists and can be accessed for read/write.
|
|
{
|
|
// 9504.11 jar change to memset
|
|
//_fmemset((char FAR *) &fileinfodst, 0, sizeof(fileinfodst));
|
|
memset((char FAR *) &fileinfodst, 0, sizeof(fileinfodst));
|
|
fileinfodst.page_number = 1;
|
|
fileinfodst.filename = path_out;
|
|
ErrCode = IMGFileGetInfo((HANDLE)0,hWnd,&fileinfodst,NULL,NULL);
|
|
if (ErrCode)
|
|
{
|
|
//UnlockData (0);
|
|
return(ErrCode);
|
|
}
|
|
if (unPageOptions == FIO_OVERWRITE_PAGE)
|
|
{
|
|
// Overwrite MUST begin within the existing portion of the file!
|
|
if ( (*lpunDestPage > fileinfodst.page_count) ||
|
|
(*lpunDestPage < 1) )
|
|
return(ErrCode=FIO_INVALID_PAGE_NUMBER);
|
|
|
|
// If we are overwriting pages, and there are more pages to copy
|
|
// from the source than there are pages in the destination to
|
|
// overwrite, we must start appending pages to the destination once
|
|
// there are no more pages to overwrite.
|
|
if ((*lpunDestPage + unTotalPages - 1) > fileinfodst.page_count)
|
|
{
|
|
switch_to_append = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
page_in = unSrcPage;
|
|
page_out = *lpunDestPage;
|
|
for (i = unTotalPages; i > 0; i--)
|
|
{
|
|
// 9504.11 jar change to memset
|
|
//_fmemset((char FAR *) &fileinfosrc, 0, sizeof(fileinfosrc));
|
|
//_fmemset((char FAR *) &colorinfosrc, 0, sizeof(colorinfosrc));
|
|
memset((char FAR *) &fileinfosrc, 0, sizeof(fileinfosrc));
|
|
memset((char FAR *) &colorinfosrc, 0, sizeof(colorinfosrc));
|
|
fileinfosrc.page_number = page_in;
|
|
fileinfosrc.filename = path_in;
|
|
// ErrCode = IMGFileInfoCgbw(hWnd, &fileinfosrc, &colorinfosrc);
|
|
ErrCode = IMGFileGetInfo((HANDLE)0, hWnd, &fileinfosrc, &colorinfosrc, NULL);
|
|
if (ErrCode)
|
|
{
|
|
//UnlockData (0);
|
|
return(ErrCode);
|
|
}
|
|
|
|
// See if we can use IMGFileCopyFile to do the copy.
|
|
if (first)
|
|
{
|
|
if ((page_in == 1) && (unTotalPages == fileinfosrc.page_count))
|
|
{
|
|
// We are copying all of the pages in the source file. Can use
|
|
// IMGFileCopyFile if we are copying to a new file or overwriting
|
|
// an existing one.
|
|
if (unPageOptions == FIO_OVERWRITE_FILE)
|
|
{
|
|
copy_flag = OVERWRITEFLAG;
|
|
if (bDeleteSrcPgs)
|
|
copy_flag |= DELETESRCFLAG;
|
|
status = IMGFileCopyFile(hWnd, path_in, path_out, copy_flag);
|
|
*lpunDestPage = 1;
|
|
//UnlockData (0);
|
|
// 9504.05 jar return int
|
|
//return ((WORD) status);
|
|
return ( status);
|
|
}
|
|
else if ((unPageOptions == FIO_NEW_FILE) && (dst_not_exist))
|
|
{
|
|
if (bDeleteSrcPgs)
|
|
copy_flag |= DELETESRCFLAG;
|
|
status = IMGFileCopyFile(hWnd, path_in, path_out, copy_flag);
|
|
*lpunDestPage = 1;
|
|
//UnlockData (0);
|
|
// 9504.05 jar return int
|
|
//return ((WORD) status);
|
|
return ( status);
|
|
}
|
|
else if ((unPageOptions == FIO_APPEND_PAGE) && (dst_not_exist))
|
|
{
|
|
if (bDeleteSrcPgs)
|
|
copy_flag |= DELETESRCFLAG;
|
|
status = IMGFileCopyFile(hWnd, path_in, path_out, copy_flag);
|
|
*lpunDestPage = 1;
|
|
//UnlockData (0);
|
|
// 9504.05 jar return int
|
|
//return ((WORD) status);
|
|
return ( status);
|
|
}
|
|
else if ((unPageOptions == FIO_INSERT_PAGE) && (dst_not_exist)
|
|
&& (*lpunDestPage == 1))
|
|
{
|
|
if (bDeleteSrcPgs)
|
|
copy_flag |= DELETESRCFLAG;
|
|
status = IMGFileCopyFile(hWnd, path_in, path_out, copy_flag);
|
|
//UnlockData (0);
|
|
// 9504.05 jar return int
|
|
//return ((WORD) status);
|
|
return ( status);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 8/13/95 rwr Make sure the FIO_NEGATE bit is turned off before converting
|
|
// (otherwise we'll end up with a negative image)
|
|
if (colorinfosrc.compress_type != FIO_TJPEG)
|
|
colorinfosrc.compress_info1 &= (~FIO_NEGATE);
|
|
|
|
if ((unPageOptions == FIO_OVERWRITE_PAGE) && (switch_to_append) &&
|
|
(page_out == (fileinfodst.page_count + 1)))
|
|
unPageOptions = FIO_APPEND_PAGE;
|
|
|
|
ErrCode = IMGFileConvertPage(hWnd, path_in, page_in, path_out,
|
|
&page_out, fileinfosrc.file_type,
|
|
colorinfosrc.compress_type,
|
|
colorinfosrc.compress_info1, unPageOptions);
|
|
if (ErrCode)
|
|
{
|
|
//UnlockData (0);
|
|
return (ErrCode);
|
|
}
|
|
|
|
// If we did an Overwrite or New File, don't do it any more!
|
|
if ( (unPageOptions == FIO_OVERWRITE_FILE)
|
|
|| (unPageOptions == FIO_NEW_FILE) )
|
|
unPageOptions = FIO_APPEND_PAGE;
|
|
|
|
if (first)
|
|
{
|
|
*lpunDestPage = page_out;
|
|
first = 0;
|
|
}
|
|
|
|
++page_in;
|
|
++page_out;
|
|
}
|
|
|
|
if (bDeleteSrcPgs && !ErrCode)
|
|
{
|
|
ErrCode = IMGFileDeletePages(hWnd, path_in, unSrcPage, unTotalPages);
|
|
}
|
|
|
|
//UnlockData (0);
|
|
return (ErrCode);
|
|
}
|