зеркало из https://github.com/mozilla/pjs.git
594 строки
18 KiB
C
594 строки
18 KiB
C
/*
|
|
** Apple Macintosh Developer Technical Support
|
|
**
|
|
** FileCopy: A robust, general purpose file copy routine.
|
|
**
|
|
** by Jim Luther, Apple Developer Technical Support Emeritus
|
|
**
|
|
** File: FileCopy.c
|
|
**
|
|
** Copyright © 1992-1998 Apple Computer, Inc.
|
|
** All rights reserved.
|
|
**
|
|
** You may incorporate this sample code into your applications without
|
|
** restriction, though the sample code has been provided "AS IS" and the
|
|
** responsibility for its operation is 100% yours. However, what you are
|
|
** not permitted to do is to redistribute the source as "DSC Sample Code"
|
|
** after having made changes. If you're going to re-distribute the source,
|
|
** we require that you make it clear in the source that the code was
|
|
** descended from Apple Sample Code, but that you've made changes.
|
|
*/
|
|
|
|
#include <Types.h>
|
|
#include <Errors.h>
|
|
#include <Memory.h>
|
|
#include <Files.h>
|
|
|
|
#define __COMPILINGMOREFILES
|
|
|
|
#include "MoreFiles.h"
|
|
#include "MoreFilesExtras.h"
|
|
#include "MoreDesktopMgr.h"
|
|
#include "FileCopy.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* local constants */
|
|
|
|
/* The deny-mode privileges to use when opening the source and destination files. */
|
|
|
|
enum
|
|
{
|
|
srcCopyMode = dmRdDenyWr,
|
|
dstCopyMode = dmWrDenyRdWr
|
|
};
|
|
|
|
/* The largest (16K) and smallest (.5K) copy buffer to use if the caller doesn't supply
|
|
** their own copy buffer. */
|
|
|
|
enum
|
|
{
|
|
bigCopyBuffSize = 0x00004000,
|
|
minCopyBuffSize = 0x00000200
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* static prototypes */
|
|
|
|
static OSErr GetDestinationDirInfo(short vRefNum,
|
|
long dirID,
|
|
ConstStr255Param name,
|
|
long *theDirID,
|
|
Boolean *isDirectory,
|
|
Boolean *isDropBox);
|
|
/* GetDestinationDirInfo tells us if the destination is a directory, it's
|
|
directory ID, and if it's an AppleShare drop box (write privileges only --
|
|
no read or search privileges).
|
|
vRefNum input: Volume specification.
|
|
dirID input: Directory ID.
|
|
name input: Pointer to object name, or nil when dirID
|
|
specifies a directory that's the object.
|
|
theDirID output: If the object is a file, then its parent directory
|
|
ID. If the object is a directory, then its ID.
|
|
isDirectory output: True if object is a directory; false if
|
|
object is a file.
|
|
isDropBox output: True if directory is an AppleShare drop box.
|
|
*/
|
|
|
|
static OSErr CheckForForks(short vRefNum,
|
|
long dirID,
|
|
ConstStr255Param name,
|
|
Boolean *hasDataFork,
|
|
Boolean *hasResourceFork);
|
|
/* CheckForForks tells us if there is a data or resource fork to copy.
|
|
vRefNum input: Volume specification of the file's current
|
|
location.
|
|
dirID input: Directory ID of the file's current location.
|
|
name input: The name of the file.
|
|
*/
|
|
|
|
static OSErr PreflightFileCopySpace(short srcVRefNum,
|
|
long srcDirID,
|
|
ConstStr255Param srcName,
|
|
ConstStr255Param dstVolName,
|
|
short dstVRefNum,
|
|
Boolean *spaceOK);
|
|
/* PreflightFileCopySpace determines if there's enough space on a
|
|
volume to copy the specified file to that volume.
|
|
Note: The results of this routine are not perfect. For example if the
|
|
volume's catalog or extents overflow file grows when the new file is
|
|
created, more allocation blocks may be needed beyond those needed for
|
|
the file's data and resource forks.
|
|
|
|
srcVRefNum input: Volume specification of the file's current
|
|
location.
|
|
srcDirID input: Directory ID of the file's current location.
|
|
srcName input: The name of the file.
|
|
dstVolName input: A pointer to the name of the volume where
|
|
the file will be copied or NULL.
|
|
dstVRefNum input: Volume specification indicating the volume
|
|
where the file will be copied.
|
|
spaceOK output: true if there's enough space on the volume for
|
|
the file's data and resource forks.
|
|
*/
|
|
|
|
/*****************************************************************************/
|
|
|
|
static OSErr GetDestinationDirInfo(short vRefNum,
|
|
long dirID,
|
|
ConstStr255Param name,
|
|
long *theDirID,
|
|
Boolean *isDirectory,
|
|
Boolean *isDropBox)
|
|
{
|
|
CInfoPBRec pb;
|
|
OSErr error;
|
|
|
|
pb.dirInfo.ioACUser = 0; /* ioACUser used to be filler2, clear it before calling GetCatInfo */
|
|
error = GetCatInfoNoName(vRefNum, dirID, name, &pb);
|
|
*theDirID = pb.dirInfo.ioDrDirID;
|
|
*isDirectory = (pb.dirInfo.ioFlAttrib & ioDirMask) != 0;
|
|
/* see if access priviledges are make changes, not see folder, and not see files (drop box) */
|
|
*isDropBox = ((pb.dirInfo.ioACUser & 0x07) == 0x03);
|
|
|
|
return ( error );
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static OSErr CheckForForks(short vRefNum,
|
|
long dirID,
|
|
ConstStr255Param name,
|
|
Boolean *hasDataFork,
|
|
Boolean *hasResourceFork)
|
|
{
|
|
HParamBlockRec pb;
|
|
OSErr error;
|
|
|
|
pb.fileParam.ioNamePtr = (StringPtr)name;
|
|
pb.fileParam.ioVRefNum = vRefNum;
|
|
pb.fileParam.ioFVersNum = 0;
|
|
pb.fileParam.ioDirID = dirID;
|
|
pb.fileParam.ioFDirIndex = 0;
|
|
error = PBHGetFInfoSync(&pb);
|
|
*hasDataFork = (pb.fileParam.ioFlLgLen != 0);
|
|
*hasResourceFork = (pb.fileParam.ioFlRLgLen != 0);
|
|
|
|
return ( error );
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static OSErr PreflightFileCopySpace(short srcVRefNum,
|
|
long srcDirID,
|
|
ConstStr255Param srcName,
|
|
ConstStr255Param dstVolName,
|
|
short dstVRefNum,
|
|
Boolean *spaceOK)
|
|
{
|
|
UniversalFMPB pb;
|
|
OSErr error;
|
|
unsigned long dstFreeBlocks;
|
|
unsigned long dstBlksPerAllocBlk;
|
|
unsigned long srcDataBlks;
|
|
unsigned long srcResourceBlks;
|
|
|
|
error = XGetVolumeInfoNoName(dstVolName, dstVRefNum, &pb.xPB);
|
|
if ( error == noErr )
|
|
{
|
|
/* get allocation block size (always multiple of 512) and divide by 512
|
|
to get number of 512-byte blocks per allocation block */
|
|
dstBlksPerAllocBlk = ((unsigned long)pb.xPB.ioVAlBlkSiz >> 9);
|
|
|
|
/* Convert freeBytes to free disk blocks (512-byte blocks) */
|
|
dstFreeBlocks = (pb.xPB.ioVFreeBytes.hi << 23) + (pb.xPB.ioVFreeBytes.lo >> 9);
|
|
|
|
/* Now, get the size of the file's data resource forks */
|
|
pb.hPB.fileParam.ioNamePtr = (StringPtr)srcName;
|
|
pb.hPB.fileParam.ioVRefNum = srcVRefNum;
|
|
pb.hPB.fileParam.ioFVersNum = 0;
|
|
pb.hPB.fileParam.ioDirID = srcDirID;
|
|
pb.hPB.fileParam.ioFDirIndex = 0;
|
|
error = PBHGetFInfoSync(&pb.hPB);
|
|
if ( error == noErr )
|
|
{
|
|
/* Since space on Mac OS disks is always allocated in allocation blocks, */
|
|
/* this code takes into account rounding up to the end of an allocation block. */
|
|
|
|
/* get number of 512-byte blocks needed for data fork */
|
|
if ( ((unsigned long)pb.hPB.fileParam.ioFlLgLen & 0x000001ff) != 0 )
|
|
{
|
|
srcDataBlks = ((unsigned long)pb.hPB.fileParam.ioFlLgLen >> 9) + 1;
|
|
}
|
|
else
|
|
{
|
|
srcDataBlks = (unsigned long)pb.hPB.fileParam.ioFlLgLen >> 9;
|
|
}
|
|
|
|
/* now, calculate number of new allocation blocks needed */
|
|
if ( srcDataBlks % dstBlksPerAllocBlk )
|
|
{
|
|
srcDataBlks = (srcDataBlks / dstBlksPerAllocBlk) + 1;
|
|
}
|
|
else
|
|
{
|
|
srcDataBlks /= dstBlksPerAllocBlk;
|
|
}
|
|
|
|
/* get number of 512-byte blocks needed for resource fork */
|
|
if ( ((unsigned long)pb.hPB.fileParam.ioFlRLgLen & 0x000001ff) != 0 )
|
|
{
|
|
srcResourceBlks = ((unsigned long)pb.hPB.fileParam.ioFlRLgLen >> 9) + 1;
|
|
}
|
|
else
|
|
{
|
|
srcResourceBlks = (unsigned long)pb.hPB.fileParam.ioFlRLgLen >> 9;
|
|
}
|
|
|
|
/* now, calculate number of new allocation blocks needed */
|
|
if ( srcResourceBlks % dstBlksPerAllocBlk )
|
|
{
|
|
srcResourceBlks = (srcResourceBlks / dstBlksPerAllocBlk) + 1;
|
|
}
|
|
else
|
|
{
|
|
srcResourceBlks /= dstBlksPerAllocBlk;
|
|
}
|
|
|
|
/* Is there enough room on the destination volume for the source file? */
|
|
*spaceOK = ( ((srcDataBlks + srcResourceBlks) * dstBlksPerAllocBlk) <= dstFreeBlocks );
|
|
}
|
|
}
|
|
|
|
return ( error );
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
pascal OSErr FileCopy(short srcVRefNum,
|
|
long srcDirID,
|
|
ConstStr255Param srcName,
|
|
short dstVRefNum,
|
|
long dstDirID,
|
|
ConstStr255Param dstPathname,
|
|
ConstStr255Param copyName,
|
|
void *copyBufferPtr,
|
|
long copyBufferSize,
|
|
Boolean preflight)
|
|
{
|
|
OSErr err;
|
|
|
|
short srcRefNum = 0, /* 0 when source data and resource fork are closed */
|
|
dstDataRefNum = 0, /* 0 when destination data fork is closed */
|
|
dstRsrcRefNum = 0; /* 0 when destination resource fork is closed */
|
|
|
|
Str63 dstName; /* The filename of the destination. It might be the
|
|
** source filename, it might be a new name... */
|
|
|
|
GetVolParmsInfoBuffer infoBuffer; /* Where PBGetVolParms dumps its info */
|
|
long srcServerAdr; /* AppleTalk server address of source (if any) */
|
|
|
|
Boolean dstCreated = false, /* true when destination file has been created */
|
|
ourCopyBuffer = false, /* true if we had to allocate the copy buffer */
|
|
isDirectory, /* true if destination is really a directory */
|
|
isDropBox; /* true if destination is an AppleShare drop box */
|
|
|
|
long tempLong;
|
|
short tempInt;
|
|
|
|
Boolean spaceOK; /* true if there's enough room to copy the file to the destination volume */
|
|
|
|
Boolean hasDataFork;
|
|
Boolean hasResourceFork;
|
|
|
|
/* Preflight for size */
|
|
if ( preflight )
|
|
{
|
|
err = PreflightFileCopySpace(srcVRefNum, srcDirID, srcName,
|
|
dstPathname, dstVRefNum, &spaceOK);
|
|
if ( err != noErr )
|
|
{
|
|
return ( err );
|
|
}
|
|
|
|
if ( !spaceOK )
|
|
{
|
|
return ( dskFulErr );
|
|
}
|
|
}
|
|
|
|
/* get the destination's real dirID and make sure it really is a directory */
|
|
err = GetDestinationDirInfo(dstVRefNum, dstDirID, dstPathname,
|
|
&dstDirID, &isDirectory, &isDropBox);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if ( !isDirectory )
|
|
{
|
|
return ( dirNFErr );
|
|
}
|
|
|
|
/* get the destination's real vRefNum */
|
|
err = DetermineVRefNum(dstPathname, dstVRefNum, &dstVRefNum);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
/* See if PBHCopyFile can be used. Using PBHCopyFile saves time by letting the file server
|
|
** copy the file if the source and destination locations are on the same file server. */
|
|
tempLong = sizeof(infoBuffer);
|
|
err = HGetVolParms(srcName, srcVRefNum, &infoBuffer, &tempLong);
|
|
if ( (err != noErr) && (err != paramErr) )
|
|
{
|
|
return ( err );
|
|
}
|
|
|
|
if ( (err != paramErr) && hasCopyFile(infoBuffer) )
|
|
{
|
|
/* The source volume supports PBHCopyFile. */
|
|
srcServerAdr = infoBuffer.vMServerAdr;
|
|
|
|
/* Now, see if the destination volume is on the same file server. */
|
|
tempLong = sizeof(infoBuffer);
|
|
err = HGetVolParms(NULL, dstVRefNum, &infoBuffer, &tempLong);
|
|
if ( (err != noErr) && (err != paramErr) )
|
|
{
|
|
return ( err );
|
|
}
|
|
if ( (err != paramErr) && (srcServerAdr == infoBuffer.vMServerAdr) )
|
|
{
|
|
/* Source and Dest are on same server and PBHCopyFile is supported. Copy with CopyFile. */
|
|
err = HCopyFile(srcVRefNum, srcDirID, srcName, dstVRefNum, dstDirID, NULL, copyName);
|
|
if ( err != noErr )
|
|
{
|
|
return ( err );
|
|
}
|
|
|
|
/* AppleShare's CopyFile clears the isAlias bit, so I still need to attempt to copy
|
|
the File's attributes to attempt to get things right. */
|
|
if ( copyName != NULL ) /* Did caller supply copy file name? */
|
|
{
|
|
/* Yes, use the caller supplied copy file name. */
|
|
(void) CopyFileMgrAttributes(srcVRefNum, srcDirID, srcName,
|
|
dstVRefNum, dstDirID, copyName, true);
|
|
}
|
|
else
|
|
{
|
|
/* They didn't, so get the source file name and use it. */
|
|
if ( GetFilenameFromPathname(srcName, dstName) == noErr )
|
|
{
|
|
/* */
|
|
(void) CopyFileMgrAttributes(srcVRefNum, srcDirID, srcName,
|
|
dstVRefNum, dstDirID, dstName, true);
|
|
}
|
|
}
|
|
return ( err );
|
|
}
|
|
}
|
|
|
|
/* If we're here, then PBHCopyFile couldn't be used so we have to copy the file by hand. */
|
|
|
|
/* Make sure a copy buffer is allocated. */
|
|
if ( copyBufferPtr == NULL )
|
|
{
|
|
/* The caller didn't supply a copy buffer so grab one from the application heap.
|
|
** Try to get a big copy buffer, if we can't, try for a 512-byte buffer.
|
|
** If 512 bytes aren't available, we're in trouble. */
|
|
copyBufferSize = bigCopyBuffSize;
|
|
copyBufferPtr = NewPtr(copyBufferSize);
|
|
if ( copyBufferPtr == NULL )
|
|
{
|
|
copyBufferSize = minCopyBuffSize;
|
|
copyBufferPtr = NewPtr(copyBufferSize);
|
|
if ( copyBufferPtr == NULL )
|
|
{
|
|
return ( memFullErr );
|
|
}
|
|
}
|
|
ourCopyBuffer = true;
|
|
}
|
|
|
|
/* Open the source data fork. */
|
|
err = HOpenAware(srcVRefNum, srcDirID, srcName, srcCopyMode, &srcRefNum);
|
|
if ( err != noErr )
|
|
return ( err );
|
|
|
|
/* Once a file is opened, we have to exit via ErrorExit to make sure things are cleaned up */
|
|
|
|
/* See if the copy will be renamed. */
|
|
if ( copyName != NULL ) /* Did caller supply copy file name? */
|
|
BlockMoveData(copyName, dstName, copyName[0] + 1); /* Yes, use the caller supplied copy file name. */
|
|
else
|
|
{ /* They didn't, so get the source file name and use it. */
|
|
err = GetFileLocation(srcRefNum, &tempInt, &tempLong, dstName);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
/* Create the destination file. */
|
|
err = HCreateMinimum(dstVRefNum, dstDirID, dstName);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
dstCreated = true; /* After creating the destination file, any
|
|
** error conditions should delete the destination file */
|
|
|
|
/* An AppleShare dropbox folder is a folder for which the user has the Make Changes
|
|
** privilege (write access), but not See Files (read access) and See Folders (search access).
|
|
** Copying a file into an AppleShare dropbox presents some special problems. Here are the
|
|
** rules we have to follow to copy a file into a dropbox:
|
|
** ¥ File attributes can be changed only when both forks of a file are empty.
|
|
** ¥ DeskTop Manager comments can be added to a file only when both forks of a file
|
|
** are empty.
|
|
** ¥ A fork can be opened for write access only when both forks of a file are empty.
|
|
** So, with those rules to live with, we'll do those operations now while both forks
|
|
** are empty. */
|
|
|
|
if ( isDropBox )
|
|
{
|
|
/* We only set the file attributes now if the file is being copied into a
|
|
** drop box. In all other cases, it is better to set the attributes last
|
|
** so that if FileCopy is modified to give up time to other processes
|
|
** periodicly, the Finder won't try to read any bundle information (because
|
|
** the bundle-bit will still be clear) from a partially copied file. If the
|
|
** copy is into a drop box, we have to set the attributes now, but since the
|
|
** destination forks are opened with write/deny-read/deny-write permissions,
|
|
** any Finder that might see the file in the drop box won't be able to open
|
|
** its resource fork until the resource fork is closed.
|
|
**
|
|
** Note: if you do modify FileCopy to give up time to other processes, don't
|
|
** give up time between the time the destination file is created (above) and
|
|
** the time both forks are opened (below). That way, you stand the best chance
|
|
** of making sure the Finder doesn't read a partially copied resource fork.
|
|
*/
|
|
/* Copy attributes but don't lock the destination. */
|
|
err = CopyFileMgrAttributes(srcVRefNum, srcDirID, srcName,
|
|
dstVRefNum, dstDirID, dstName, false);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
/* Attempt to copy the comments while both forks are empty.
|
|
** Ignore the result because we really don't care if it worked or not. */
|
|
(void) DTCopyComment(srcVRefNum, srcDirID, srcName, dstVRefNum, dstDirID, dstName);
|
|
|
|
/* See which forks we need to copy. By doing this, we won't create a data or resource fork
|
|
** for the destination unless it's really needed (some foreign file systems such as
|
|
** the ProDOS File System and Macintosh PC Exchange have to create additional disk
|
|
** structures to support resource forks). */
|
|
err = CheckForForks(srcVRefNum, srcDirID, srcName, &hasDataFork, &hasResourceFork);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if ( hasDataFork )
|
|
{
|
|
/* Open the destination data fork. */
|
|
err = HOpenAware(dstVRefNum, dstDirID, dstName, dstCopyMode, &dstDataRefNum);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
if ( hasResourceFork )
|
|
{
|
|
/* Open the destination resource fork. */
|
|
err = HOpenRFAware(dstVRefNum, dstDirID, dstName, dstCopyMode, &dstRsrcRefNum);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
if ( hasDataFork )
|
|
{
|
|
/* Copy the data fork. */
|
|
err = CopyFork(srcRefNum, dstDataRefNum, copyBufferPtr, copyBufferSize);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
/* Close both data forks and clear reference numbers. */
|
|
(void) FSClose(srcRefNum);
|
|
(void) FSClose(dstDataRefNum);
|
|
srcRefNum = dstDataRefNum = 0;
|
|
}
|
|
else
|
|
{
|
|
/* Close the source data fork since it was opened earlier */
|
|
(void) FSClose(srcRefNum);
|
|
srcRefNum = 0;
|
|
}
|
|
|
|
if ( hasResourceFork )
|
|
{
|
|
/* Open the source resource fork. */
|
|
err = HOpenRFAware(srcVRefNum, srcDirID, srcName, srcCopyMode, &srcRefNum);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
/* Copy the resource fork. */
|
|
err = CopyFork(srcRefNum, dstRsrcRefNum, copyBufferPtr, copyBufferSize);
|
|
if ( err != noErr )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
/* Close both resource forks and clear reference numbers. */
|
|
(void) FSClose(srcRefNum);
|
|
(void) FSClose(dstRsrcRefNum);
|
|
srcRefNum = dstRsrcRefNum = 0;
|
|
}
|
|
|
|
/* Get rid of the copy buffer if we allocated it. */
|
|
if ( ourCopyBuffer )
|
|
{
|
|
DisposePtr((Ptr)copyBufferPtr);
|
|
}
|
|
|
|
/* Attempt to copy attributes again to set mod date. Copy lock condition this time
|
|
** since we're done with the copy operation. This operation will fail if we're copying
|
|
** into an AppleShare dropbox, so we don't check for error conditions. */
|
|
CopyFileMgrAttributes(srcVRefNum, srcDirID, srcName,
|
|
dstVRefNum, dstDirID, dstName, true);
|
|
|
|
/* Hey, we did it! */
|
|
return ( noErr );
|
|
|
|
ErrorExit:
|
|
if ( srcRefNum != 0 )
|
|
{
|
|
(void) FSClose(srcRefNum); /* Close the source file */
|
|
}
|
|
if ( dstDataRefNum != 0 )
|
|
{
|
|
(void) FSClose(dstDataRefNum); /* Close the destination file data fork */
|
|
}
|
|
if ( dstRsrcRefNum != 0 )
|
|
{
|
|
(void) FSClose(dstRsrcRefNum); /* Close the destination file resource fork */
|
|
}
|
|
if ( dstCreated )
|
|
{
|
|
(void) HDelete(dstVRefNum, dstDirID, dstName); /* Delete dest file. This may fail if the file
|
|
is in a "drop folder" */
|
|
}
|
|
if ( ourCopyBuffer ) /* dispose of any memory we allocated */
|
|
{
|
|
DisposePtr((Ptr)copyBufferPtr);
|
|
}
|
|
|
|
return ( err );
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
pascal OSErr FSpFileCopy(const FSSpec *srcSpec,
|
|
const FSSpec *dstSpec,
|
|
ConstStr255Param copyName,
|
|
void *copyBufferPtr,
|
|
long copyBufferSize,
|
|
Boolean preflight)
|
|
{
|
|
return ( FileCopy(srcSpec->vRefNum, srcSpec->parID, srcSpec->name,
|
|
dstSpec->vRefNum, dstSpec->parID, dstSpec->name,
|
|
copyName, copyBufferPtr, copyBufferSize, preflight) );
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|