pgpfilespecmac.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1997 Network Associates Inc. and affiliated companies.
	All rights reserved.
	

	$Id: pgpFileSpecMac.c,v 1.30 1999/05/24 20:24:32 heller Exp $
____________________________________________________________________________*/

#if PGP_MACINTOSH	/* [ */

#include <Aliases.h>
#include <Errors.h>
#include <Folders.h>
#include <Script.h>

#include "pgpPFLConfig.h"

#include <string.h>
#include <stdio.h>
#include <FSp_fopen.h>

#include "pgpDebug.h"
#include "pgpPFLErrors.h"
#include "MacFiles.h"
#include "MacStrings.h"
#include "pgpMem.h"

#include "pgpMemoryMgr.h"

#define PGP_USE_FILE_SPEC_PRIV
#include "PGPFileSpecPriv.h"
#include "PGPFileSpecMacPriv.h"


typedef struct MyData
{
	PGPBoolean		specIsValid;	
	FSSpec			spec;
	
	PFLFileSpecMacMetaInfo	metaInfo;

} MyData;

struct PFLDirectoryIter
{
	PGPMemoryMgrRef	memoryMgr;
	short			vRefNum;
	long			parID;
	long			dirIndex;
};

#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=mac68k
#endif

typedef struct
{
	Str31			name;
	PGPUInt32		aliasDataSize;	/* Alias to parent folder of file spec */
	PGPByte			aliasData[1];
	
} ExportedFileSpec;

#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=reset
#endif


#define GetMyData( ref )	( (MyData *)(ref)->data )

static PGPError	sExportProc( PFLConstFileSpecRef ref,
					PGPByte **data, PGPSize *dataSize );
static PGPError	sImportProc( PFLFileSpecRef ref,
					PGPByte const *data, PGPSize dataSize );
static PGPError	sGetNameProc( PFLConstFileSpecRef ref, char name[ 256 ] );
static PGPError	sSetNameProc( PFLFileSpecRef ref, char const *name );
static PGPError	sSetMetaInfoProc( PFLFileSpecRef ref, void const *info );
static PGPError	sExistsProc( PFLFileSpecRef ref, PGPBoolean *exists);
static PGPError	sCreateProc( PFLFileSpecRef ref );
static PGPError	sDeleteProc( PFLConstFileSpecRef ref );
static PGPError	sRenameProc( PFLFileSpecRef ref, const char *newName);
static PGPError	sGetMaxNameLengthProc( PFLConstFileSpecRef ref,
					PGPSize * maxNameLength);
static PGPError	sParentDirProc( PFLConstFileSpecRef fileFromDir,
					PFLFileSpecRef *outParent );
static PGPError	sComposeProc( PFLConstFileSpecRef parent, char const *name,
					PFLFileSpecRef *outRef );


static const PGPFileSpecVTBL	sVTBL =
{
	sExportProc,
	sImportProc,
	sGetNameProc,
	sSetNameProc,
	
	sSetMetaInfoProc,
	sExistsProc,
	sCreateProc,
	sDeleteProc,
	sRenameProc,
	sGetMaxNameLengthProc,
	sParentDirProc,
	sComposeProc
};
	
	
	PGPFileSpecVTBL const *
GetFileSpecVTBLMac()
{
	return( &sVTBL );
}

	static PGPError
GetSpec(
	PFLConstFileSpecRef	ref,
	FSSpec				*fileSpec,
	CInfoPBRec			*fileInfo)
{
	MyData 		*myData;
	PGPError	err = kPGPError_NoErr;
	
	PGPValidateParam( ref->type == kPFLFileSpecMacType );

	myData = GetMyData( ref );
	if( myData->specIsValid )
	{
		*fileSpec = myData->spec;
		
		if( fileInfo != NULL )
		{
			OSStatus	macErr;
			
			macErr = FSpGetCatInfo( fileSpec, fileInfo );
			if ( macErr == fnfErr )
			{
				err	= kPGPError_FileNotFound;
			}
			else if( macErr != noErr )
			{
				err	= kPGPError_FileOpFailed;
			}
		}	
	}
	else
	{
		err = kPGPError_FileNotFound;
	}
	
	return( err );
}

	PGPError
pgpPlatformGetFileInfo(
	PFLConstFileSpecRef	ref,
	PFLFileInfo *		outInfo )
{
	PGPError	err = kPGPError_NoErr;
	FSSpec		spec;
	CInfoPBRec	cpb;
	
	PGPValidateParam( ref->type == kPFLFileSpecMacType );

	err = GetSpec( ref, &spec, &cpb );
	if( IsntPGPError( err ) )
	{
		time_t			nowStdTime = time( NULL );
		unsigned long	nowMacTime;
			
		if( cpbIsFolder( &cpb ) )
		{
			outInfo->flags 		= kPGPFileInfo_IsDirectory;
			outInfo->dataLength = 0;
		}
		else
		{
			outInfo->flags 		= kPGPFileInfo_IsPlainFile;
			outInfo->dataLength = cpbDataForkSize( &cpb );
		}
		
		GetDateTime( &nowMacTime );
		
		outInfo->modificationTime = (time_t)(cpbModificationDate( &cpb )
							+ ((unsigned long)nowStdTime - nowMacTime));
	}
	
	return err;
}

	PGPError
pgpPlatformLockFILE(
	FILE *				file,
	PFLFileOpenFlags	flags )
{
	/* Nothing to do, normal file locking should be enough */

	(void)file;		/* Avoid warnings */
	(void)flags;

	return kPGPError_NoErr;
}

	PGPError
pgpPlatformNewDirectoryIter(
	PFLConstFileSpecRef		parentDir,
	PFLDirectoryIterRef *	outIter )
{
	PGPMemoryMgrRef			memoryMgr	= parentDir->memoryMgr;
	PGPError				err		= kPGPError_NoErr;
	FSSpec					spec;
	PFLDirectoryIterRef		newIter	= NULL;
	CInfoPBRec				cpb;

	*outIter = NULL;
	PGPValidateParam( parentDir->type == kPFLFileSpecMacType );
	PGPValidateMemoryMgr( memoryMgr );

	err = GetSpec( parentDir, &spec, &cpb );
	if( IsntPGPError( err ) )
	{
		newIter = (PFLDirectoryIterRef)PGPNewData( memoryMgr,
											sizeof( *newIter ), 0 );
		if ( IsntNull( newIter ) )
		{
			pgpAssert( cpbIsFolder( &cpb ) );

			newIter->memoryMgr	= memoryMgr;
			newIter->vRefNum	= spec.vRefNum;
			newIter->parID		= cpb.dirInfo.ioDrDirID;
			newIter->dirIndex	= 1;
		}
		else
		{
			err = kPGPError_OutOfMemory;
		}
	}
	
	if ( IsntPGPError( err ) )
		*outIter = newIter;
	else if ( IsntNull( newIter ) )
		PGPFreeData( newIter );

	return err;
}

	PGPError
pgpPlatformNextFileInDirectory(
	PFLDirectoryIterRef		iter,
	PFLFileSpecRef *		outRef )
{
	PGPError		err = kPGPError_NoErr;
	FSSpec			spec;
	HFileInfo		pb;

	*outRef = NULL;
	
	pb.ioNamePtr = spec.name;
	pb.ioVRefNum = iter->vRefNum;
	pb.ioDirID = iter->parID;
	pb.ioFDirIndex = iter->dirIndex;
	if ( PBGetCatInfoSync( (CInfoPBPtr)&pb ) != noErr )
	{
		if ( pb.ioResult == fnfErr )
			err	= kPGPError_EndOfIteration;
		else
			err	= kPGPError_FileOpFailed;
	}
	else
	{
		spec.vRefNum = iter->vRefNum;
		spec.parID = iter->parID;
		err = PFLNewFileSpecFromFSSpec( iter->memoryMgr, &spec, outRef );
	}
	
	if ( IsntPGPError( err ) )
		iter->dirIndex++;

	return err;
}

	PGPError
pgpPlatformFreeDirectoryIter(
	PFLDirectoryIterRef		iter )
{
	PGPValidatePtr( iter );

	PGPFreeData( iter );
	return kPGPError_NoErr;
}

	static PGPError
sExportProc(
	PFLConstFileSpecRef		ref,
	PGPByte **				dataOut,
	PGPSize *				dataSizeOut )
{
	MyData *			myData;
	PGPError			err				= kPGPError_NoErr;
	AliasHandle			alias			= NULL;
	void				*aliasData		= NULL;
	PGPUInt32			aliasDataSize	= 0;
	PGPByte *			data 			= NULL;
	PGPUInt32			dataSize		= 0;
	
	myData = GetMyData( ref );
	
	if( myData->specIsValid )
	{
		CInfoPBRec	cpb;
		FSSpec		parFolderSpec;
		
		parFolderSpec = myData->spec;
		
		pgpClearMemory( &cpb, sizeof( cpb ) );
		
		cpb.dirInfo.ioVRefNum	= parFolderSpec.vRefNum;
		cpb.dirInfo.ioDrDirID	= parFolderSpec.parID;
		cpb.dirInfo.ioNamePtr	= parFolderSpec.name;
		cpb.dirInfo.ioFDirIndex	= -1;
		
		if( PBGetCatInfoSync( &cpb ) == noErr )
		{
			parFolderSpec.parID	= cpb.dirInfo.ioDrParID;

			if( NewAlias( NULL, &parFolderSpec, &alias ) == noErr )
			{
				HLock( (Handle) alias );
				
				aliasData		= *alias;
				aliasDataSize 	= GetHandleSize( (Handle) alias );
			}
		}
	}
	
	dataSize = sizeof( ExportedFileSpec ) + aliasDataSize;
	
	data = (PGPByte *) PGPNewData( ref->memoryMgr, dataSize, 0 );
	if ( IsntNull( data ) )
	{
		ExportedFileSpec	*exportedData = (ExportedFileSpec *) data;
		
		exportedData->aliasDataSize	= aliasDataSize;
		
		CopyPString( myData->spec.name, exportedData->name );
		
		if( aliasData != NULL )
			pgpCopyMemory( aliasData, &exportedData->aliasData[0], aliasDataSize );
	}
	else
	{
		err	= kPGPError_OutOfMemory;
	}
	
	if( alias != NULL )
		DisposeHandle( (Handle) alias );
		
	*dataOut		= data;
	*dataSizeOut	= dataSize;
	
	return( err );
}

	static PGPError
sImportProc(
	PFLFileSpecRef		ref,
	PGPByte const *		data,
	PGPSize				dataSize )
{
	const ExportedFileSpec *	exportedData;
	MyData *					newData	= NULL;
	PGPError					err	= kPGPError_NoErr;

	(void) dataSize;
	
	exportedData	= (const ExportedFileSpec *)data;
	newData			= GetMyData( ref );
	
	err	= PGPReallocData( ref->memoryMgr,
			&newData, sizeof( *newData ), 0 );
	if ( IsntPGPError( err ) )
	{
		MyData *		myData	= (MyData *)newData;
		
		ref->data		= (PGPByte *)newData;
		ref->dataSize	= sizeof( *newData );
		
		myData->specIsValid 	= FALSE;
		
		CopyPString( exportedData->name, myData->spec.name );
		
		if( exportedData->aliasDataSize != 0 )
		{
			AliasHandle	alias;
			
			if( PtrToHand( &exportedData->aliasData[0], (Handle *) &alias,
						exportedData->aliasDataSize ) == noErr )
			{
				FSSpec	spec;
				short	aliasCount = 1;
				Boolean	needsUpdate;
				
				if( MatchAlias( NULL, kARMNoUI | kARMSearch,
						alias, &aliasCount, &spec, &needsUpdate, NULL, NULL ) == noErr )
				{
					CInfoPBRec	cpb;
					
					if( FSpGetCatInfo( &spec, &cpb ) == noErr )
					{
						myData->specIsValid = TRUE;
					
						myData->spec.vRefNum 	= spec.vRefNum;
						myData->spec.parID 		= cpb.dirInfo.ioDrDirID;
					}
				}
				
				DisposeHandle( (Handle) alias );
			}
		}
	}