pgpnetlogutils.c

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

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

	$Id: pgpNetLogUtils.c,v 1.4 2002/08/06 20:10:28 dallen Exp $
____________________________________________________________________________*/

#include <windows.h>

#include <stdio.h>

#ifndef CSIDL_COMMON_APPDATA
#define CSIDL_COMMON_APPDATA	0x0023
#endif
#ifndef CSIDL_FLAG_CREATE
#define CSIDL_FLAG_CREATE		0x8000
#endif

#include "pgpNetLogUtils.h"

// Definition for SHGetFolderPath
typedef HRESULT (_stdcall *SHGetFolderPathProc)
					(HWND, int, HANDLE, DWORD, LPTSTR);

PGPError
pgpGetApplicationDataPath(
	char*		pathBuf,
	PGPUInt32	bufferSize)
{
	char		appDataPath[MAX_PATH + 1];		/* Additional byte for '\\' if needed */
	char		pgpAppDataPath[MAX_PATH + 1];
	PGPUInt32	appDataPathLen = 0;
	PGPUInt32	pgpAppDataPathLen = 0;
	HMODULE		hmod = NULL;
	SHGetFolderPathProc fpSHGetFolderPath = NULL;

	hmod = LoadLibrary("SHFOLDER.DLL");

	if (hmod == NULL)
		return kPGPError_Win32DllOpFailed;
	else
	{
		fpSHGetFolderPath = (SHGetFolderPathProc)
								GetProcAddress(hmod, "SHGetFolderPathA");

		if (fpSHGetFolderPath == NULL)
		{
			FreeLibrary(hmod);
			hmod = NULL;
		}
	}

	if (hmod != NULL)
	{	
		if (!SUCCEEDED(fpSHGetFolderPath(
			NULL, CSIDL_COMMON_APPDATA|CSIDL_FLAG_CREATE, NULL, 0, appDataPath)) ||
			(appDataPath[0] == 0))
		{
			/*
			If we can't call SHGetFolderPath(), we attempt to get
			the install directory from the registry.
			*/
			FreeLibrary(hmod);
			hmod = NULL;
			fpSHGetFolderPath = NULL;
		}
		else
		{
			appDataPathLen		= strlen(appDataPath);
			pgpAppDataPathLen	= strlen(PGP_RELATIVEPATHNAME);
			
			if (appDataPath[appDataPathLen - 1] != '\\')
			{
				strcat(appDataPath, "\\");
				++appDataPathLen;
			}
			
			if (bufferSize < (appDataPathLen + pgpAppDataPathLen + 1))
			{
				FreeLibrary(hmod);
				return kPGPError_BufferTooSmall;
			}
			else
			{
				strncpy(pathBuf, appDataPath, appDataPathLen + 1);
				strncat(pathBuf, PGP_RELATIVEPATHNAME, pgpAppDataPathLen);
			}
		}
	}

	if (hmod == NULL)
	{
		HKEY hKey;
		LRESULT lResult;
		DWORD dwValueType;
		DWORD dwSize;

		lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, PGP_REGISTRYKEY, 0, 
					KEY_READ, &hKey);

		if (lResult == ERROR_SUCCESS)
		{
			dwSize = _MAX_PATH;
			lResult = RegQueryValueEx(hKey, PGP_INSTALLPATHVALUE, 0, 
						&dwValueType, (BYTE *) pgpAppDataPath, &dwSize);
			RegCloseKey(hKey);
			
			if (lResult != ERROR_SUCCESS)
				return kPGPError_Win32DllOpFailed;
		}
		else
			return kPGPError_Win32DllOpFailed;
		
		pgpAppDataPathLen	= strlen(pgpAppDataPath);

		if (pgpAppDataPath[pgpAppDataPathLen - 1] != '\\')
		{
			strcat(pgpAppDataPath, "\\");
			++pgpAppDataPathLen;
		}

		if (bufferSize < (pgpAppDataPathLen - 1))
		{
			FreeLibrary(hmod);
			return kPGPError_BufferTooSmall;
		}
		else
			strncpy(pathBuf, pgpAppDataPath, pgpAppDataPathLen + 1);
	}

	if (hmod != NULL)
		FreeLibrary(hmod);

	return kPGPError_NoErr;
}

PGPError
pgpGetLogFileFullPath(char *szFile, PGPUInt32 uLen)
{
	PGPError		err = kPGPError_NoErr;
	PGPUInt32		pathLen;
	PGPUInt32		logFileLen;

	err = pgpGetApplicationDataPath(szFile, uLen);
	if (IsPGPError(err))
		return err;

	pathLen = strlen(szFile);
	logFileLen = strlen(PGP_NETLOGFILENAME);

	if (uLen < (pathLen + logFileLen + 1))
		return kPGPError_BufferTooSmall;

	strncat(szFile, PGP_NETLOGFILENAME, logFileLen);

	return err;
}

PGPError
pgpGetEventDirFullPath(char* inPathBuf, PGPUInt32 inBufferSize)
{
	PGPError		err = kPGPError_NoErr;
	PGPUInt32		pathLen;
	PGPUInt32		eventDirLen;
	char*			ch = 0;

	err = pgpGetApplicationDataPath(inPathBuf, inBufferSize);
	if (IsPGPError(err))
		return err;

	pathLen = strlen(inPathBuf);
	eventDirLen = strlen(PGP_NETEVENTDATAFOLDER);

	if (inBufferSize < (pathLen + eventDirLen + 1))
		return kPGPError_BufferTooSmall;

	strncat(inPathBuf, PGP_NETEVENTDATAFOLDER, eventDirLen);

	return err;
}

PGPError
pgpNetNewPacketFileSpec(
	PGPMemoryMgrRef inMemoryMgr,
	PFLFileSpecRef* inSpec,
	char*			outFilename,
	PGPUInt32		inBufferSize)
{
	PGPError		err = kPGPError_NoErr;
	char*			packetFullPath = 0;
	char*			uniqueFilename = 0;
	char*			previousEnvString = 0;
	char*			ourEnvString = 0;
	char			dirnameBuf[MAX_PATH];
	PGPUInt32		dirnameLen = 0;
	PGPUInt32		requestSize;
	PGPUInt32		fileNameLen;
	PGPUInt32		fileExtLen;

	if (!outFilename)
		return kPGPError_BadParams;

	*outFilename = '\0';

	err = PGPValidateMemoryMgr(inMemoryMgr);
	if (IsPGPError(err))
		return err;

	if (!inSpec)
		return kPGPError_BadParams;
	
	*inSpec = 0;

	if (!inBufferSize)
		return kPGPError_BufferTooSmall;

	err = pgpGetEventDirFullPath(dirnameBuf, sizeof(dirnameBuf));
	if (IsPGPError(err))
		return err;

	dirnameLen = strlen(dirnameBuf);

	if (!CreateDirectory(dirnameBuf, NULL))
	{
		if (GetLastError() != ERROR_ALREADY_EXISTS)
			return kPGPError_FileOpFailed;
	}
		
	/*
	_tempnam looks at the value of 'TMP' before using the specified directory.
	To make sure that our packet filename is unique to the saved packet directory,
	we set 'TMP' to be our packet directory.
	*/

	requestSize = strlen("TMP=") + dirnameLen + 1;
	ourEnvString = (char*) PGPNewData(inMemoryMgr, requestSize, 0);
	if (ourEnvString)
	{
		previousEnvString = getenv("TMP");
		sprintf(ourEnvString, "TMP=%s", dirnameBuf);
		ourEnvString[requestSize - 1] = '\0';
		_putenv(ourEnvString);
		PGPFreeData(ourEnvString);
	}
	else
		return kPGPError_OutOfMemory;

	uniqueFilename = _tempnam(dirnameBuf, kPGPnetPacketFileName);

	if (previousEnvString)
		_putenv(previousEnvString);	/* Restore the env var. */
	else
		_putenv("TMP=");

	if (!uniqueFilename)
		return kPGPError_OutOfMemory;

	requestSize = strlen(uniqueFilename) + strlen(kPGPnetPacketFileExt) + 1;
	packetFullPath = (char*) PGPNewData(inMemoryMgr, requestSize, 0);

	if (!packetFullPath)
		return kPGPError_OutOfMemory;
			
	fileNameLen = strlen(uniqueFilename);
	fileExtLen = strlen(kPGPnetPacketFileExt);

	strcpy(packetFullPath, uniqueFilename);
	strncat(packetFullPath + fileNameLen, kPGPnetPacketFileExt, fileExtLen);

	free(uniqueFilename);

	fileNameLen = strlen(strrchr(packetFullPath, '\\') + 1);
		
	if (inBufferSize < (fileNameLen + 1))
	{
		PGPFreeData(packetFullPath);
		return kPGPError_BufferTooSmall;
	}

	strncpy(outFilename, strrchr(packetFullPath, '\\') + 1, inBufferSize);

	err = PFLNewFileSpecFromFullPath(inMemoryMgr, packetFullPath, inSpec);
	if (IsPGPError(err))
		*inSpec = 0;

	PGPFreeData(packetFullPath);

	return err;
}