pgpfileref.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	$Id: pgpFileRef.c,v 1.19 2002/10/29 05:25:27 jeffc Exp $
____________________________________________________________________________*/

#include "pgpConfig.h"
#include "pgpPFLPriv.h"

#if HAVE_UNISTD_H
#include <unistd.h>
#endif

#if HAVE_PATHS_H
#include <paths.h>
#endif

#if PGP_UNIX || PGP_WIN32
#include <sys/types.h>
#include <sys/stat.h>
#if HAVE_FCNTL_H
#include <fcntl.h>
#endif
#endif

#if __MWERKS__
#define HAVE_SHARE_H	0
#elif PGP_WIN32
#define HAVE_SHARE_H	1
#else
#define HAVE_SHARE_H	0
#endif

#if PGP_WIN32
#include <windows.h>
#include <io.h>
#if HAVE_SHARE_H
#include <share.h>
#endif
#endif

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

#if PGP_MACINTOSH
#include <unix.h>
#include <Errors.h>
#include <Folders.h>
#include <Script.h>
#endif

#include "pgpFileRef.h"
#include "pgpFileNames.h"
#include "pgpFileUtilities.h"
#include "pgpErrors.h"
#include "pgpTypes.h"
#include "pgpDebug.h"
#include "pgpMem.h"
#include "pgpContext.h"

#include "pgpFileSpec.h"


#if PGP_MACINTOSH

#include "MacFiles.h"
#include "MacStrings.h"
#include "pgpMacFile.h"
#include "pgpMacUtils.h"

#elif PGP_OSX

#include <CoreServices/CoreServices.h>

#include "PGPMacOSCompatibility.h"
#include "pgpMacFile.h"
#include "pgpMacUtils.h"
#include <sys/param.h>
#include <sys/mount.h>

#endif


#if !defined(_PATH_TMP) && PGP_UNIX && HAVE_MKSTEMP
#define _PATH_TMP	"/tmp/"
#endif

#if HAVE_MKSTEMP && defined(sparc)
extern int	mkstemp (char *__template);
#endif

#define pgpaPGPFileTypeValid(fileType)								\
		pgpaAssert(fileType > kPGPFileTypeNone						\
				&& fileType < kPGPFileTypeNumTypes)

/* These must be kept in sync with the PGPFileType decl in pgpFileRef.h */

#if PGP_UNIX	/* [ */

static struct UnixFileTypeEntry
{
	mode_t	mask;	/* umask value for permissions */
} sUnixFileTypeTable[kPGPFileTypeNumTypes] = {
	{ 0 },		/* kPGPFileTypeNone */
	{ 0077 },	/* kPGPFileTypePrefs */
	{ 0077 },	/* kPGPFileTypePubRing */
	{ 0077 },	/* kPGPFileTypePrivRing */
	{ 0077 },	/* kPGPFileTypeDetachedSig */
	{ 0077 },	/* kPGPFileTypeRandomSeed */
	{ 0077 },	/* kPGPFileTypeArmorFile */
	{ 0077 },	/* kPGPFileTypeEncryptedData */
	{ 0077 },	/* kPGPFileTypeGroups */
	{ 0077 },	/* kPGPFileTypeDecryptedText */
	{ 0077 },	/* kPGPFileTypeDecryptedBin */
	{ 0077 },	/* kPGPFileTypeSignedData */
	{ 0077 }	/* kPGPFileTypeExported509Keys */
};

#endif	/* ] PGP_UNIX */




	PGPMemoryMgrRef
pgpGetFileRefMemoryMgr( PFLConstFileSpecRef fileRef )
{
	return( 
		PFLGetFileSpecMemoryMgr( (PFLConstFileSpecRef)fileRef ) );
}



/*
 * pgpGetFileRefName returns a string allocated with pgpContextMemAlloc(),
 * which the caller is responsible for freeing.
 */
	char *
pgpGetFileRefName( PFLConstFileSpecRef	fileRef)
{
	char *	name	= NULL;
	PGPError	err	= kPGPError_NoErr;
	
	err	= PFLGetFileSpecName( fileRef, &name );
	
	return( name );
}


	PGPError
pgpSetFileRefName(
	PFLFileSpecRef	fileRef,
	char const *	newName)
{
	return( PFLSetFileSpecName( fileRef, newName ) );
}

	uchar *
pgpExportFileRef(
	PFLConstFileSpecRef		fileRef,
	size_t *				size)
{
	PGPError	err	= kPGPError_NoErr;
	PGPByte *	data	= NULL;
	PGPSize		dataSize;
	
	err	= PFLExportFileSpec( fileRef, &data, &dataSize );
	*size	= dataSize;
	
	return( data );
}

	PGPError
pgpImportFileRef(
	PGPContextRef		context,
	uchar const *		buffer,
	size_t				size,
	PFLFileSpecRef *		outRef )
{
	PGPError	err	= kPGPError_NoErr;
	
	err	= PFLImportFileSpec( PGPPeekContextMemoryMgr( context ),
				buffer, size, outRef );
	
	return( err );
}


#if PGP_MACINTOSH	/* [ */

	PGPError
pgpCalcFileSize(
	PFLConstFileSpecRef	fileRef,
	PGPFileOpenFlags	flags,
	PGPFileOffset *		fileSize)
{
	return pgpMacCalcFileSize(fileRef, flags, fileSize);
}

	PGPError
pgpCreateFile(
	PFLConstFileSpecRef	fileRef,
	PGPFileType			fileType)
{
	PGPError	err = kPGPError_NoErr;
	FSSpec		spec;
	OSErr		macErr;
	
	PFLValidateFileSpec( fileRef );
	
	err	= PFLGetFSSpecFromFileSpec(fileRef, &spec);
	if ( IsntPGPError( err ) )
	{
		macErr = FSpCreate( &spec,
					pgpGetMacFileCreatorFromPGPFileType( fileType ),
					pgpGetMacFileTypeFromPGPFileType( fileType ),
					smSystemScript );
		if (macErr != noErr)
			err = pgpErrorFromMacError(macErr, kPGPError_CantOpenFile);
	}
	return err;
}


	FILE *
pgpStdIOOpenTempFile(
	PGPContextRef		context,
	PFLFileSpecRef *	tempFileRef,
	PGPError *			errorCode)
{
	FSSpec		spec;
	FILE *		stdIOFile = NULL;
	PGPError	err = kPGPError_NoErr;
	OSErr		macErr;
	long		i;
	
	pgpa(pgpaAddrValid(tempFileRef, PFLFileSpecRef));
	
	*tempFileRef = NULL;
	if ((macErr = FindFolder(kOnSystemDisk, kTemporaryFolderType,
								kCreateFolder, &spec.vRefNum,
								&spec.parID)) != noErr)
		goto macError;
	
	for (i = 0; ; i++)
	{
		pgpFormatPStr(spec.name, sizeof(spec.name), 0, "PGP Temp %d", i);
		macErr = FSpCreate( &spec, '????', 'BINA', smSystemScript );
		if (macErr == noErr)
			break;
		else if (macErr != dupFNErr)
			goto macError;
	}
	
	err	= PFLNewFileSpecFromFSSpec( PGPPeekContextMemoryMgr( context ),
		&spec, tempFileRef );
	if ( IsErr( err ) )
		goto error;
	
	*errorCode	= pgpFileRefStdIOOpen(*tempFileRef, kPGPFileOpenStdUpdateFlags,
						kPGPFileTypeDecryptedBin, &stdIOFile);
	return( stdIOFile );
	
macError:
	err = pgpErrorFromMacError(macErr, kPGPError_CantOpenFile);
error:
	if (*tempFileRef != NULL)
	{
		PFLFreeFileSpec(*tempFileRef);
		*tempFileRef = NULL;
	}
	if (errorCode != NULL)
	{
		pgpAssertAddrValid(errorCode, PGPError);
		*errorCode = err;
	}
	return NULL;
}

#else	/* ] PGP_MACINTOSH [ */

	PGPError
pgpCalcFileSize(
	PFLConstFileSpecRef		fileRef,
	PGPFileOpenFlags		flags,
	PGPFileOffset *			fileSize)
{
	PGPError		err = kPGPError_NoErr;
#if PGP_OSX
	if (flags & (kPGPFileOpenForceLocalEncode | kPGPFileOpenMaybeLocalEncode)) {
		err = pgpMacCalcFileSize(fileRef, flags, fileSize);
	} else {
#endif
		char *			fullPath = NULL;
#if PGP_WIN32
		struct _stati64		statBuf;
#elif PGP_UNIX
#if HAVE_64BIT_FILES
		struct stat64		statBuf;
#else
		struct stat			statBuf;
#endif /* HAVE_64BIT_FILES */
#endif /* PGP_UNIX */
		
		PFLValidateFileSpec( fileRef );
		PGPValidatePtr( fileSize );
		
		(void)flags;	/* Avoid warning */
		*fileSize = 0;	/* In case there's an error */
		
		err = PFLGetFullPathFromFileSpec(fileRef, &fullPath);
		if ( IsntPGPError( err ) )
		{
			/* XXX Maybe make this more portable.  Does this work on MSDOS? */
#if PGP_WIN32
			if (_stati64(fullPath, &statBuf) != 0)
#elif PGP_UNIX
#if HAVE_64BIT_FILES
			if (stat64(fullPath, &statBuf) != 0)
#else
			if (stat(fullPath, &statBuf) != 0)
#endif /* HAVE_64BIT_FILES */
#endif /* PGP_UNIX */
				err = kPGPError_CantOpenFile;
			else if ((S_IFMT & statBuf.st_mode) == S_IFREG)
				*fileSize = statBuf.st_size;
			/* XXX Maybe return a special err if it's not a regular file */
		}
		
			
		PGPFreeData( fullPath );
		
#if PGP_OSX
	}
#endif
	return err;
}


	PGPError
pgpCreateFile(
	PFLConstFileSpecRef		fileRef,
	PGPFileType			fileType)
{
	PGPError	err = kPGPError_NoErr;
	char *		fullPath = NULL;
	
	PFLValidateFileSpec( fileRef );
	(void)fileType;
	
	err = PFLGetFullPathFromFileSpec(fileRef, &fullPath);
	if ( IsntPGPError( err ) )
	{
#if PGP_UNIX	/* [ */
		int			fileDes;
		
		/*
		 * XXX Beware that calling this routine could be a security flaw,
		 *     because there is a window between creating and opening
		 *     the file, in between which the file might have been moved
		 *     out of the way, thus possibly having you open a new file
		 *     with the wrong permissions.
		 */
#if HAVE_64BIT_FILES
		fileDes = open64(fullPath,
						O_WRONLY | O_CREAT | O_EXCL,
						0666 & ~sUnixFileTypeTable[fileType].mask);
#else
		fileDes = open(fullPath,
						O_WRONLY | O_CREAT | O_EXCL,
						0666 & ~sUnixFileTypeTable[fileType].mask);
#endif
		if (fileDes > 0) {
			close(fileDes);
#if PGP_OSX
/*			pgpOSXSetFileCreatorAndType(fullPath, pgpGetMacFileCreatorFromPGPFileType(fileType),
				pgpGetMacFileTypeFromPGPFileType(fileType));*/
#endif
		} else {
			err = kPGPError_CantOpenFile;	/* XXX Use better error */
		}
#else	/* ] PGP_UNIX [ */
		FILE *		stdIOFile;
		
		stdIOFile = fopen(fullPath, "ab+");
		if (stdIOFile != NULL)
			fclose(stdIOFile);
		else
			err = kPGPError_CantOpenFile;	/* XXX Use better error */
#endif	/* ] PGP_UNIX */
	}
	PGPFreeData( fullPath);
	return err;
}




	FILE *
pgpStdIOOpenTempFile(
	PGPContextRef		context,
	PFLFileSpecRef *	tempFileRef,
	PGPError *			errorCode)
{
	PGPError	err = kPGPError_NoErr;
	FILE *		stdIOFile = NULL;
	
	pgpa(pgpaAddrValid(tempFileRef, PFLFileSpecRef));
	
	*tempFileRef = NULL;

#if PGP_WIN32								/* [ */

	{
		char		*fileName;

		fileName = tempnam( "", "pgpt" );
		if( IsNull( fileName ) )
			goto fileError;

		if (IsPGPError(err = PFLNewFileSpecFromFullPath(
			PGPPeekContextMemoryMgr( context ), fileName, tempFileRef)))
		{
			free( fileName );
			err = kPGPError_OutOfMemory;
			goto error;
		}

		free( fileName );

		/* XXX Perhaps check for an error and retry if necessary */
		*errorCode = pgpFileRefStdIOOpen(*tempFileRef,
				kPGPFileOpenStdUpdateFlags,
				kPGPFileTypeDecryptedBin, &stdIOFile);
	}


#elif defined(_PATH_TMP) && HAVE_MKSTEMP	/* ] [ */

	{
		int			fd = -1;
		char		*fileName;
		char		*tmpdir;
		PGPUInt32	tmpdirlen;

		tmpdir = getenv("TMP");
		if( IsNull( tmpdir ) )
			tmpdir = (char *)_PATH_TMP;
		tmpdirlen = strlen(tmpdir);
		fileName = pgpContextMemAlloc( context, tmpdirlen + 20, 0 );
		if( IsNull( fileName ) )
			goto fileError;
		strcpy(fileName, tmpdir);
		if( fileName[tmpdirlen-1] != '/' )
		{
			fileName[tmpdirlen] = '/';
			fileName[tmpdirlen+1] = '\0';
		}
		strcat(fileName, "ptmpXXXXXX");
		if ((fd = mkstemp(fileName)) == -1 ||
				(stdIOFile = fdopen(fd, "w+b")) == NULL)
		{
			pgpContextMemFree( context, fileName );
			if (fd != -1)
				close(fd);
			goto fileError;
		}
		err	= PFLNewFileSpecFromFullPath( PGPPeekContextMemoryMgr( context ),
				fileName, tempFileRef);
		pgpContextMemFree( context, fileName );
		if (IsPGPError( err ))
			goto error;
	}

#else	/* ] defined(_PATH_TMP) && HAVE_MKSTEMP [ */
	
	{
		char		fileName[L_tmpnam];

		if (tmpnam(fileName) != fileName)
			goto fileError;

		if (IsPGPError(err = PFLNewFileSpecFromFullPath(
			PGPPeekContextMemoryMgr( context ), fileName, tempFileRef)))
		{
			err = kPGPError_OutOfMemory;
			goto error;
		}

		/* XXX Perhaps check for an error and retry if necessary */
		*errorCode = pgpFileRefStdIOOpen(*tempFileRef,
				kPGPFileOpenStdUpdateFlags,
				kPGPFileTypeDecryptedBin, &stdIOFile);
	}

#endif	/* ] defined(_PATH_TMP) && HAVE_MKSTEMP */