scutils.c

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

	strcpy(szPath,"");

	PGPclGetPath (kPGPclInstallFolder,szPath,MAX_PATH);
}

char *PGPscJustFile(char *filename)
{
	char *p;

	p = strrchr(filename, '\\');

	if(p!=0)
		return (p+1);
	else
		return filename;
}

BOOL PGPscGetValidityDrawPrefs(void *PGPsc,
						  BOOL *pbInputBool)
{
	PGPBoolean  bDisplayMarginal=FALSE;
	PGPPrefRef	prefRef;
	PGPError err;

	err=PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	bDisplayMarginal=FALSE;

	if(IsntPGPError(err))
	{
		PGPGetPrefBoolean (prefRef,
			kPGPPrefDisplayMarginalValidity, &bDisplayMarginal);
	}

	*pbInputBool=FALSE;

	if(bDisplayMarginal)
		*pbInputBool=TRUE;

	return TRUE;
}

BOOL PGPscGetMarginalInvalidPref(void *PGPsc,
							BOOL *pbInputBool)
{
	PGPBoolean  bMarginalInvalid;
	PGPPrefRef	prefRef;
	PGPError err;

	err=PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	bMarginalInvalid=FALSE;

	if(IsntPGPError(err))
	{
		PGPGetPrefBoolean (prefRef,
			kPGPPrefMarginalIsInvalid, &bMarginalInvalid);
	}

	*pbInputBool=FALSE;

	if(bMarginalInvalid)
		*pbInputBool=TRUE;
		
	return TRUE;
}

BOOL PGPscGetWipeOnDeletePrefs(void *PGPsc,
		BOOL *pbWipeOnDelete, BOOL *pbWipeProgress,DWORD *pdwPasses)
{
	PGPBoolean pgpbWipeOnDelete,pgpbWipeProgress;
	DWORD pgpdwPasses;
	PGPPrefRef	prefRef;
	PGPError err;

	pgpbWipeOnDelete=pgpbWipeProgress=FALSE;
	pgpdwPasses=1;

	err=PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	if(IsntPGPError(err))
	{
		PGPGetPrefBoolean (prefRef,
			kPGPPrefAutoWipeOnDelete, &pgpbWipeOnDelete);
		pgpbWipeProgress=FALSE;
//		PGPGetPrefBoolean (prefRef,
//			kPGPPrefShowWipeProgress, &pgpbWipeProgress);
		PGPGetPrefNumber (prefRef,
			kPGPPrefFileWipePasses, 
			(PGPUInt32*)&pgpdwPasses);
	}

	*pbWipeOnDelete=(BOOL)pgpbWipeOnDelete;
	*pbWipeProgress=(BOOL)pgpbWipeProgress;
	*pdwPasses=pgpdwPasses;

	return TRUE;
}

// This creates a filelist entry for files or directories,
// and also does the callback/cancel test
UINT FileListFromFile(FILELIST **filelist,char *filename,BOOL IsDirectory,
					  ADDFILELISTCALLBACK UserProc,void *pUserValue)
{
	FILELIST *Current;
	BOOL UserCancel;

	Current=(FILELIST *)malloc(sizeof(FILELIST));

	if(Current!=NULL)
	{
		memset(Current,0x00,sizeof(FILELIST));

		Current->name=(char *)malloc(strlen(filename)+1);

		if(Current->name==NULL)
		{
			free(Current);
			Current=NULL;
		}
		else
		{
			strcpy(Current->name,filename);
			Current->next=*filelist;
			Current->IsDirectory=IsDirectory;
			*filelist=Current;
		}
	}

	// Do the callback, if we've successfully made a filelist
	if((UserProc!=NULL)&&(Current!=NULL))
	{
		UserCancel=(UserProc)(Current,pUserValue);

		if(UserCancel)
		{
			return FALSE;
		}
	}

	return TRUE;
}

UINT FileListFromDirectory(FILELIST **filelist,char *directory,
						   ADDFILELISTCALLBACK UserProc,void *pUserValue)
{
	HANDLE hFindFile;
	WIN32_FIND_DATAW FindFileDataW;
	WIN32_FIND_DATAA FindFileDataA;
	BOOL RetVal=FALSE;
	BOOL KeepGoing;
	char *search;
	char *filename;
	char *name;
	LPWSTR wide;
	int widelen;
	int namelen;
	int retval;
	BOOL IsNT=FALSE;
	DWORD dwFileAttributes;
	OSVERSIONINFO osid;

	hFindFile=INVALID_HANDLE_VALUE;

	memset(&osid,0x00,sizeof(OSVERSIONINFO));

	osid.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
	GetVersionEx (&osid);   
	IsNT=(osid.dwPlatformId == VER_PLATFORM_WIN32_NT);

	if(directory[strlen(directory)-1]!='\\')
		strcat(directory,"\\");

	if(IsNT)
	{
		search=(char *)malloc(25+strlen(directory)); // 25 for prepend plus *.*

		if(search==NULL)
		{
			;
		}
		else
		{
			if(!strncmp(directory,"\\\\",2))
			{
				// Build network search path with UNC prepend
				strcpy(search,"\\\\?\\UNC\\");
				strcat(search,&(directory[2]));
				strcat(search,"*.*");
			}
			else
			{
				// Build local drive search path
				strcpy(search,"\\\\?\\");
				strcat(search,directory);
				strcat(search,"*.*");
			}

			widelen=MultiByteToWideChar(_getmbcp(), 0, search, -1, 0,0);

			wide=(LPWSTR)malloc(widelen*sizeof(WCHAR));

			if(wide==NULL)
			{
				;
			}
			else
			{
				memset(wide,0x00,widelen*sizeof(WCHAR));

				retval=MultiByteToWideChar(_getmbcp(), 0, search,
					-1, wide,widelen);

				hFindFile=FindFirstFileW(wide,&FindFileDataW);
			
				free(wide);
			}
			memset(search,0x00,sizeof(search));
			free(search);
		}
	}
	else	
	{
		int bufsize;
		char shrtpath[MAX_PATH+1];

		bufsize=strlen(directory)+strlen("*.*")+1;

		GetShortPathName(directory,shrtpath,MAX_PATH);

		strcat(shrtpath,"*.*");

		hFindFile=FindFirstFileA(shrtpath,&FindFileDataA);

		memset(shrtpath,0x00,MAX_PATH);
	}

	if(hFindFile!=INVALID_HANDLE_VALUE)
	{
		RetVal=TRUE;

		while(RetVal==TRUE)
		{
			if(IsNT)
			{
				namelen=WideCharToMultiByte(_getmbcp(), 0, FindFileDataW.cFileName,
					-1, 0,0,NULL,NULL);
				namelen++; // If we need to add directory slash

				name=(char *)malloc(namelen);
				memset(name,0x00,namelen);

				WideCharToMultiByte(_getmbcp(), 0, FindFileDataW.cFileName,
					-1, name,namelen,NULL,NULL);

				filename=(char *)malloc(strlen(directory)+namelen+1);

				strcpy(filename,directory);
				strcat(filename,name);

				dwFileAttributes=FindFileDataW.dwFileAttributes;
			}
			else
			{
				namelen=strlen(FindFileDataA.cFileName);
				namelen++;

				name=(char *)malloc(namelen);
				strcpy(name,FindFileDataA.cFileName);

				filename=(char *)malloc(strlen(directory)+namelen+1);
				strcpy(filename,directory);
				strcat(filename,name);

				dwFileAttributes=FindFileDataA.dwFileAttributes;
			}
	
			if((dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
				!=FILE_ATTRIBUTE_DIRECTORY)
			{
				FileListFromFile(filelist,filename,FALSE,
					UserProc,pUserValue);
			}
			else
			{
				if((strcmp(name,"."))&&
					(strcmp(name,"..")))
				{
					KeepGoing=FileListFromFile(filelist,filename,TRUE,
						UserProc,pUserValue);
					if(!KeepGoing)
					{
						FindClose(hFindFile);
						return FALSE;
					}

					KeepGoing=FileListFromDirectory(filelist,filename,UserProc,pUserValue);

					if(!KeepGoing)
					{
						FindClose(hFindFile);
						return FALSE;
					}
				}
			}

			memset(name,0x00,strlen(name));
			free(name);
			memset(filename,0x00,strlen(filename));
			free(filename);

			if(IsNT)
			{
				RetVal=FindNextFileW(hFindFile,&FindFileDataW);
			}
			else
			{
				RetVal=FindNextFileA(hFindFile,&FindFileDataA);
			}
		}

		FindClose(hFindFile);
	}

	return TRUE;
} 

BOOL PGPscAddToFileList(FILELIST **filelist,char *filename,
						ADDFILELISTCALLBACK UserProc,void *pUserValue)
{
	DWORD dwFileAttributes;
	UINT RetVal;

	dwFileAttributes=GetFileAttributes(filename);

	if(dwFileAttributes==0xFFFFFFFF)
		return TRUE;

	if((dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
		==FILE_ATTRIBUTE_DIRECTORY)
	{
		RetVal=FileListFromFile(filelist,filename,TRUE,
			UserProc,pUserValue);

		if(!RetVal)
			return FALSE;

		RetVal=FileListFromDirectory(filelist,filename,UserProc,pUserValue);
	}
	else
	{
		RetVal=FileListFromFile(filelist,filename,FALSE,
			UserProc,pUserValue);
	}

	return RetVal;
}

BOOL PGPscFreeFileList(FILELIST *FileList)
{
	FILELIST *FreeAtLast;

	while(FileList!=0)
	{
		FreeAtLast=FileList;
		FileList=FileList->next;
		memset(FreeAtLast->name,0x00,strlen(FreeAtLast->name));
		free(FreeAtLast->name);
		memset(FreeAtLast,0x00,sizeof(FILELIST));
		free(FreeAtLast);
	}

	return TRUE;
}

FILELIST *PGPscHDropToFileList(HDROP hDrop)
{
	char szFile[5000+1];
	int NumFiles,i,ReturnCode;
	FILELIST *ListHead;

	NumFiles=DragQueryFile(hDrop,0xFFFFFFFF,NULL,0);
	ListHead=0;
	ReturnCode=TRUE;

	if(NumFiles==0)
		return 0;

	for(i=0;i<NumFiles && ReturnCode == TRUE;i++)
	{
		DragQueryFile(hDrop,i,szFile,5000);
		PGPscAddToFileList(&ListHead,szFile,NULL,NULL);
	}

	return ListHead;
}

FILELIST *PGPscCmdLineToFileList(char *szCmdLine)
{
	char *szNext,*szNow;
	FILELIST *ListHead;
	HANDLE hFindFile;
	WIN32_FIND_DATAA FindFileDataA;
	char szLongName[MAX_PATH+1];
	char *name;
	char *path;

	szNext=szCmdLine;
	ListHead=0;

	while(szNext!=NULL)
	{
		szNow=szNext;
			
		szNext=strstr(szNext," ");
		
		if(szNext!=NULL)
		{
			szNext=strstr(szNext,":\\");

			if(szNext!=NULL)
			{
				szNext=szNext-2;
				if(szNext>szCmdLine)
				{
					*szNext=0;
					szNext++;
				}
				else
				{
					szNext=NULL;
				}
			}
		}
		
		strcpy(szLongName,szNow);

		hFindFile=FindFirstFileA(szNow,&FindFileDataA);

		if(hFindFile!=NULL)
		{
			name=strrchr(szNow,'\\');

			if(name!=NULL)
			{
				path=szNow;
				*name=0;
				name++;

				strcpy(szLongName,path);
				strcat(szLongName,"\\");
				strcat(szLongName,FindFileDataA.cFileName);
			}
			else
			{	
				strcpy(szLongName,FindFileDataA.cFileName);
			}

			CloseHandle(hFindFile);
		}

		PGPscAddToFileList(&ListHead,szLongName,NULL,NULL);
	}

	return ListHead;
}

UINT PGPscQueryCacheSecsRemaining (void)
{
// There is no longer a local cache

//	UINT SignCacheSecs;
//	UINT DecCacheSecs;

//	SignCacheSecs=PGPclQuerySigningCacheSecsRemaining();
//	DecCacheSecs=PGPclQueryDecryptionCacheSecsRemaining ();

//	if(SignCacheSecs>DecCacheSecs)
//		return SignCacheSecs;

//	return DecCacheSecs;

	return 0;
}

BOOL PGPscPreferences(HWND hwnd,void *PGPsc,void *PGPtls)
{
	PGPContextRef context;
	PGPtlsContextRef tls;

	context=(PGPContextRef)PGPsc;
	tls=(PGPtlsContextRef)PGPtls;

	PGPclPreferences(context,hwnd, kPGPclGeneralPrefs, NULL);

	return TRUE;
}

BOOL PGPscAbout (HWND hwnd,void *PGPsc)
{
	PGPContextRef context;

	context=(PGPContextRef)PGPsc;

	PGPclHelpAbout (context,hwnd,NULL,NULL,NULL);

	return TRUE;
}

BOOL PGPscDoLaunchKeys(HWND hwnd)
{  
	char PGPkeys[MAX_PATH];
	char StrRes[500];
	
	PGPscPGPpath(PGPkeys);

// Since Windows can't handle tray launched from CD
	SetCurrentDirectory(PGPkeys);

	strcat(PGPkeys,"PGPkeys.exe");
 
	if(!PGPclExecute(PGPkeys, SW_SHOW))
	{ 
		LoadString (g_hinst, IDS_CANTOPENPGPKEYS, StrRes, sizeof(StrRes));

		MessageBox(hwnd,PGPkeys,
			StrRes,
			MB_OK|MB_ICONSTOP|MB_SETFOREGROUND);

		return FALSE;
	}

	return TRUE;
}

BOOL PGPscDoLaunchNet(HWND hwnd)
{  
	char PGPnet[MAX_PATH];
	int error;
	char StrRes[500];
	
	PGPscPGPpath(PGPnet);

// Since Windows can't handle tray launched from CD
	SetCurrentDirectory(PGPnet);

	strcat(PGPnet,"PGPnet.exe");
	error=WinExec(PGPnet, SW_SHOW);
 
	if(error<=31)
	{ 
		LoadString (g_hinst, IDS_CANTOPENPGPNET, StrRes, sizeof(StrRes));

		MessageBox(hwnd,PGPnet,
			StrRes,
			MB_OK|MB_ICONSTOP|MB_SETFOREGROUND);

		return FALSE;
	}

	return TRUE;
}

BOOL PGPscDoLaunchTools(HWND hwnd)