pgpnetlog.c

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

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

	$Id: pgpNetLog.c,v 1.17 2002/08/06 20:10:25 dallen Exp $
____________________________________________________________________________*/
#include <stdio.h>
#include <string.h>

#include "pgpMemoryMgr.h"
#include "pgpMem.h"
#include "pgpPFLErrors.h"
#include "pgpFileUtilities.h"
#include "pgpEndianConversion.h"
#include "pgpUtilities.h"
#include "pgpPFLPriv.h"
#include "pgpStdFileIOPriv.h"

#if PGP_OSX
#	include "PGPnetDriverComm.h"
#endif

#include "pgpNetLog.h"

#if PGP_WIN32
#include "pgpNetLogUtils.h"
#endif

#if PGP_OSX
#include <sys/types.h>
#include <sys/stat.h>
#endif

typedef struct PGPnetLog	PGPnetLog;

struct PGPnetLog 
{
	PGPMemoryMgrRef	memoryMgr;
	PFLFileSpecRef	logFileSpec;
	PGPIORef		logIO;

	PGPUInt32		recLength;
	PGPUInt32		numRecords;
	PGPUInt32		dataLength;
	PGPUInt32		fileLength;
	PGPUInt32		currentFilePosition;

#if PGP_WIN32 || PGP_OSX
	/* pointer to buffer which we assume will contain the path of folder 
	   for event data files.  May not have been filled in at time of call
	   to PGPnetOpenLog  */
	char*			pszEventDirPath;
#endif
};


#define kPGPNetLogHeaderLength		sizeof(PGPnetLogFileHeader)
#define PGPValidateLog(logRef)		PGPValidateParam(logRef != NULL)

static PGPError sFreeLog(PGPnetLogRef logRef);
static PGPError sIOWriteEvent(PGPIORef fileIO, PGPnetLogEvent* pevent);
static PGPError sIOReadEvent(PGPIORef fileIO, PGPnetLogEvent* pevent);
static PGPError sDeleteOldEventFile(PGPnetLogRef logRef);
static PGPError sCheckForCurrentLogFile(PGPnetLogRef logRef, PGPBoolean	bWriteAccess);

/*____________________________________________________________________________

  Releases memory allocated for the PGPnetLog structure.
  ____________________________________________________________________________*/

static PGPError 
sFreeLog (
		PGPnetLogRef	logRef)
{
	PGPValidateLog (logRef);

	if (logRef)
	{
		if (pflFileSpecIsValid (logRef->logFileSpec))
			PFLFreeFileSpec (logRef->logFileSpec);

		if (PGPIOIsValid (logRef->logIO))
			PGPFreeIO (logRef->logIO);

		PGPFreeData (logRef);
		return kPGPError_NoErr;
	}
	else
		return kPGPError_BadParams;
}

/*____________________________________________________________________________

  Writes a PGPnetLogEvent to the filespec associated with fileIO.
  ____________________________________________________________________________*/

static PGPError 
sIOWriteEvent (
		PGPIORef		fileIO, 
		PGPnetLogEvent* pevent)
{
	PGPError		err = kPGPError_NoErr;
	PGPnetLogEvent	event;

	event.timeOfEvent	= pevent->timeOfEvent;
	event.typeOfEvent	= pevent->typeOfEvent;
	event.ipaddress		= pevent->ipaddress;

	pgpCopyMemory(pevent->eventDataFile, event.eventDataFile, sizeof(event.eventDataFile));
	pgpCopyMemory (pevent->info.buffer, event.info.buffer, sizeof(event.info));

	err = PGPIOWrite(fileIO, sizeof(PGPnetLogEvent), &event);

	return err;
}

/*____________________________________________________________________________

  Reads a PGPnetLogEvent from the filespec associated with fileIO.
  ____________________________________________________________________________*/

static PGPError 
sIOReadEvent (
		PGPIORef		fileIO, 
		PGPnetLogEvent* pevent)
{
	PGPnetLogEvent	event;
	PGPError		err;
	PGPSize			bytesRead;

	PGPValidateIO (fileIO);
	PGPValidatePtr (pevent);

	err = PGPIORead (fileIO, sizeof(PGPnetLogEvent), &event, &bytesRead);

	if (IsntPGPError (err))
	{
		pevent->timeOfEvent = event.timeOfEvent;
		pevent->typeOfEvent = event.typeOfEvent;
		pevent->ipaddress	= event.ipaddress;

		pgpCopyMemory(event.eventDataFile, pevent->eventDataFile, sizeof(event.eventDataFile));
		pgpCopyMemory (event.info.buffer, pevent->info.buffer, sizeof(event.info));
	}
	return err;
}

/*____________________________________________________________________________

  Reads an event from the log, and deletes the file associated with the event.

  If a log event makes reference to additional data (like a packet capture),
  the data is usually saved to disk for later retrieval. When log events are
  about to be overwritten, it's probably a good idea to delete their
  associated files, so that the disk doesn't become cluttered.
  ____________________________________________________________________________*/

static PGPError
sDeleteOldEventFile (
		PGPnetLogRef	logRef)
{
	PGPError		err = kPGPError_NoErr;
	PGPnetLogEvent	previousEvent;
	PGPMemoryMgrRef	memoryMgr;
#if PGP_MACINTOSH
	PFLFileSpecRef	oldEventFileSpec;
	FSSpec			oldEventFileFSSpec;
	OSStatus		macErr;
#elif PGP_WIN32 || PGP_OSX
	PFLFileSpecRef	oldEventFileSpec;
	PGPSize			requestSize = 0;
	char*			oldEventFile = NULL;
	char*			pszEventDir = NULL;
#if PGP_WIN32
	char			szEventDir[MAX_PATH];
#endif /* PGP_WIN32 */
	PGPUInt32		fileLen;
#endif /* PGP_WIN32 || PGP_OSX */

	/*
	Read an event from the log. If it contains valid (non-zero)
	eventDataFile fields, attempt to delete the file specified.
	*/
	err = sIOReadEvent(logRef->logIO, &previousEvent);
	if (IsPGPError(err))
		return err;
	
	memoryMgr = PGPIOGetMemoryMgr(logRef->logIO);
	err = PGPValidateMemoryMgr(memoryMgr);
		
	if (IsPGPError(err))
		return err;

	if (previousEvent.eventDataFile[0])
#if PGP_WIN32 || PGP_OSX
	{	

#if PGP_WIN32
		if (!logRef->pszEventDirPath)
		{
			err = pgpGetEventDirFullPath(szEventDir, sizeof(szEventDir));

			pszEventDir = szEventDir;

			if (IsPGPError(err))
				return err;
		}
#endif /* PGP_WIN32 */

		if (!pszEventDir)
			pszEventDir = logRef->pszEventDirPath;

		fileLen		= strlen(previousEvent.eventDataFile);
		requestSize	= strlen(pszEventDir) + fileLen + 1;

		oldEventFile = (char*) PGPNewData(memoryMgr, 
				requestSize, kPGPMemoryMgrFlags_Clear);

		if (oldEventFile)
		{
			strncpy(oldEventFile, pszEventDir, requestSize);
			strncat(oldEventFile, previousEvent.eventDataFile, fileLen);
			/* Determine if the file exists. If so, attempt to remove it */
			err = PFLNewFileSpecFromFullPath(memoryMgr, oldEventFile, &oldEventFileSpec);
			if (IsntPGPError(err))
			{
				PFLFileSpecDelete(oldEventFileSpec);
				PFLFreeFileSpec(oldEventFileSpec);
			}
			PGPFreeData(oldEventFile);
		}
		else
			return kPGPError_OutOfMemory;
	}
#elif PGP_MACINTOSH		/* Mac stuff */
	{
		if (previousEvent.eventDataFile[0])
		{
			macErr = FindPGPnetLogEventDataFolder(kOnSystemDisk,
												  &oldEventFileFSSpec.vRefNum,
												  &oldEventFileFSSpec.parID);
			/*
			FSMakeFSSpec returning anything other than noErr indicates that the
			file does NOT exist.
			*/
			macErr = FSMakeFSSpec(oldEventFileFSSpec.vRefNum,
								  oldEventFileFSSpec.parID,
								  previousEvent.eventDataFile,
								  &oldEventFileFSSpec);
			if (macErr == noErr)
			{
				err = PFLNewFileSpecFromFSSpec(memoryMgr,
											   &oldEventFileFSSpec,
											   &oldEventFileSpec);
				if (IsntPGPError(err))
					err = PFLFileSpecDelete(oldEventFileSpec);
					
				PFLFreeFileSpec(oldEventFileSpec);
			}
		}
	}
#else		/* Linux stuff */
	{
		/* Nothing to do */
	}
#endif

	return err;
}


PGPError 
PGPnetFlushLogBuffers (
		PGPnetLogRef 	logRef)
{
	PGPValidateLog (logRef);

	if (logRef)
		return PGPIOFlush (logRef->logIO);
	else
		return kPGPError_BadParams;
}



PGPError 
PGPnetClearLogFile (
		PGPnetLogRef 	logRef)
{
	PGPnetLogEvent	event;
	PGPUInt32		u;
	PGPIORef		newIORef;
	PGPError		err = kPGPError_NoErr;

	PGPValidateLog (logRef);

	if (logRef)
	{
		PGPFreeIO(logRef->logIO);
		err = PGPOpenFileSpec(logRef->logFileSpec,
					kPFLFileOpenFlags_ReadWrite,
					(PGPFileIORef*)&newIORef);
		if (IsntPGPError(err))
		{
			/* Free the old PGPIORef, and point logRef->logIO to the new one */
			logRef->logIO = newIORef;
		}

		PGPIOSetPos (logRef->logIO, kPGPNetLogHeaderLength);
		pgpClearMemory (&event, sizeof(PGPnetLogEvent));
		for (u=0; u<logRef->numRecords; u++)
		{
			PGPIOWrite (logRef->logIO, sizeof(PGPnetLogEvent), &event);
		}

		PGPIOSetPos (logRef->logIO, kPGPNetLogHeaderLength);
		logRef->currentFilePosition	= kPGPNetLogHeaderLength;

		return PGPIOFlush (logRef->logIO);
	}
	else
		return kPGPError_BadParams;
}


static PGPError
sCheckForCurrentLogFile (
		PGPnetLogRef	logRef,
		PGPBoolean		bWriteAccess)
{
	PGPBoolean			bFileExists;
	PGPError			err;
	PGPIORef			logIO;
	PGPnetLogFileHeader	header;
	PGPSize				bytesRead;

	/* first check if file exists */
	err = PFLFileSpecExists (logRef->logFileSpec, &bFileExists);
	if (IsntPGPError (err) && !bFileExists)
		err = kPGPError_FileNotFound;

	if (IsPGPError (err))
		return err;

	/* now check if file header corresponds */
	err = PGPOpenFileSpec(	logRef->logFileSpec, 
							kPFLFileOpenFlags_ReadOnly, 
							(PGPFileIORef*)&logIO);

	if (IsntPGPError (err))
	{
		err = PGPIORead (logIO, 
				sizeof(PGPnetLogFileHeader), &header, &bytesRead);

		if (IsntPGPError (err) && (bytesRead != sizeof(PGPnetLogFileHeader)))
			err = kPGPError_CantOpenFile;

		if (IsntPGPError (err))
		{
			if( header.logfileFormatVersion != kPGPnetLogFileFormatVersion)
				err = kPGPError_CantOpenFile;

			if( header.recordLengthBytes != logRef->recLength)
				err = kPGPError_CantOpenFile;

			/* if opening for write access, then the file must have the
			   the expected number of records */
			if (bWriteAccess)
			{
				if( header.fileLengthRecords != logRef->numRecords )
					err = kPGPError_CantOpenFile;
			}
			/* for read access, just use the number of records specified
			   in the header */
			else
			{
				logRef->numRecords = header.fileLengthRecords;
				logRef->dataLength = logRef->numRecords * 
										logRef->recLength;
				logRef->fileLength = logRef->dataLength +
										kPGPNetLogHeaderLength;
			}
		}

		PGPFreeIO (logIO);
	}

	return err;
}


PGPError 
PGPnetOpenLogFile (
		PFLFileSpecRef	logFileSpec, 
		PGPBoolean		bWriteAccess,
		PGPBoolean		bZeroOutFile,
#if PGP_WIN32 || PGP_OSX
		char*			eventfolder,
		PGPUInt32		eventDirLen,
#endif
		PGPnetLogRef*	plogRef)
{
	PGPMemoryMgrRef	memoryMgr	= NULL;
	PGPError		err;
	PGPnetLogEvent	event;

	if (IsntNull (plogRef))
		*plogRef = NULL;

	PGPValidatePtr (plogRef);
	PFLValidateFileSpec (logFileSpec);

	memoryMgr = PFLGetFileSpecMemoryMgr (logFileSpec);
	
	pgpAssert (PGPMemoryMgrRefIsValid (memoryMgr));
	if (!PGPMemoryMgrRefIsValid (memoryMgr))
		return kPGPError_BadParams;

	*plogRef = (PGPnetLogRef) PGPNewData (memoryMgr, 
								sizeof(PGPnetLog), 
								kPGPMemoryMgrFlags_Clear);

	pgpAssert (IsntNull (*plogRef));
	if (IsNull (*plogRef))
		return kPGPError_OutOfMemory;

	(*plogRef)->memoryMgr			= memoryMgr;