pkkeyio.c

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

	return TRUE;
}


//	_______________________________________________
//
//  Drag selected X.509 out of application onto 
//  desktop or into Explorer.  Uses OLE interface.

static BOOL 
sDragAndDropX509Cert (
		PGPKEYSSTRUCT*	ppks,
		PGPKeyDBObjRef	cert)
{
	BOOL			bOKtoDelete			= FALSE;
	DWORD			dwEffect			= 0;
	LPDATAOBJECT	lpdo;
	LPDROPSOURCE	lpds;
	CHAR			szFile[MAX_PATH];

	sGetX509ExportFileName (cert, szFile, sizeof(szFile), TRUE);

	lpdo = PKCreateDataObject (ppks, szFile);
	lpds = PKCreateDropSource (
			ppks, ppks->hwndMain, ppks->hwndTreeList, TRUE);

	if (lpds) 
	{
		if (lpdo) 
		{
			s_bDraggingOut = TRUE;
			DoDragDrop (lpdo, lpds, 
				DROPEFFECT_COPY|DROPEFFECT_MOVE, &dwEffect); 
			bOKtoDelete = PKOKToDeleteDataObject (lpdo);
			lpdo->lpVtbl->Release(lpdo);
			s_bDraggingOut = FALSE;
		}
		lpds->lpVtbl->Release(lpds);
	}

	if (dwEffect == DROPEFFECT_MOVE) 
	{
		if (bOKtoDelete) 
		{
			if (PKIsDeleteEnabled (ppks)) 
			{
				PKDeleteObject (ppks);
			}
		}
	}

	return TRUE;
}


//	_______________________________________________
//
//  Drag selected key(s) or X.509 cert out of application onto 
//  desktop or into Explorer.  Uses OLE interface.

BOOL 
PKDragAndDrop (
		PGPKEYSSTRUCT*	ppks)
{
	PGPUInt32		uSel, uFocus;
	PGPKeyDBObjRef	obj;

	PGPclKeyListGetSelectionInfo (ppks->hKL, &uFocus, &obj, NULL, &uSel);

	if (uSel == kPGPclKeyList_Key) 
		return sDragAndDropKeys (ppks);

	if (uSel == kPGPclKeyList_Signature)
	{
		if ((uFocus == IDX_X509CERT) ||
			(uFocus == IDX_X509REVCERT) ||
			(uFocus == IDX_X509EXPCERT))
		{
			return sDragAndDropX509Cert (ppks, obj);
		}
	}

	return FALSE;
}


//	_______________________________________________
//
//  Copy key(s) to clipboard

BOOL 
PKCopyKeys (
		PGPKEYSSTRUCT*	ppks,
		HANDLE*			phMem) 
{
	PGPKeySetRef	keysetCopy			= kInvalidPGPKeySetRef;
	PGPError		err					= kPGPError_NoErr;
	BOOL			bRetVal				= FALSE;
	PGPBoolean		bX509cert			= FALSE;
	size_t			slen;
	HANDLE			hMem;
	LPSTR			pMem;
	LPSTR			pMemG;
	CHAR			szComment[256];
	PGPExportFormat	exportformat;

	err = sGetKeysetToExport (ppks, &keysetCopy, &bX509cert, NULL, NULL);
	if (!PGPKeySetRefIsValid (keysetCopy))
		return FALSE;

	slen = 0;
	sGetCommentString (PGPPeekContextMemoryMgr (g_context), 
			szComment, sizeof(szComment));

	// determine export format
	if (bX509cert)
		exportformat = kPGPExportFormat_X509Cert;
	else 
		exportformat = sGetExportFormat (PGPPeekContextMemoryMgr (g_context));

	if (IsntPGPError (PGPclErrorBox (NULL,
		PGPExport (g_context, 
				PGPOExportKeySet (g_context, keysetCopy),
				PGPOAllocatedOutputBuffer (g_context,
						&pMem, 0x40000000, &slen),
				PGPOExportFormat (g_context, exportformat),
				PGPOVersionString (g_context, 
						pgpVersionHeaderString()),
				PGPOCommentString (g_context, szComment),
				bX509cert ?
						PGPOArmorOutput (g_context, TRUE) :
						PGPONullOption (g_context),
				PGPOLastOption (g_context))))) 
	{
		hMem = GlobalAlloc (GMEM_MOVEABLE|GMEM_DDESHARE, slen+1);
		if (hMem) 
		{
			pMemG = GlobalLock (hMem);
			if (pMem) 
			{
				pMem[slen-2] = '\0';
				memcpy (pMemG, pMem, slen+1);
				GlobalUnlock (hMem);
				if (phMem) 
				{
					*phMem = hMem;
					bRetVal = TRUE;
				}
				else 
				{
					if (OpenClipboard (NULL)) 
					{
						EmptyClipboard ();
						SetClipboardData (CF_TEXT, hMem);
						CloseClipboard ();
						bRetVal = TRUE;
					}
				}
				PGPFreeData (pMem);
			}
			else 
				GlobalFree (hMem);
		}
	}

	if (PGPKeySetRefIsValid (keysetCopy))
		PGPFreeKeySet (keysetCopy);

	return bRetVal;
}


//	_______________________________________________
//
//  Paste key(s) from clipboard

BOOL 
PKPasteKeys (
		PGPKEYSSTRUCT*	ppks)
{
	PGPKeyDBRef		keydb		= kInvalidPGPKeyDBRef;
	BOOL			bImport;
	BOOL			bKeys;
	HANDLE			hMem;
	LPSTR			pMem;
	size_t			sLen;
	HDROP			hDrop;

	bImport = FALSE;
	bKeys = FALSE;
	if (OpenClipboard (NULL)) 
	{
		hMem = GetClipboardData (CF_HDROP);
		if (hMem) 
		{
			hDrop = GlobalLock (hMem);
			bImport = PKInputFile (ppks, hDrop);
			GlobalUnlock (hMem);
			CloseClipboard ();
			return bImport;
		}
		hMem = GetClipboardData (CF_TEXT);
		if (hMem) 
		{
			pMem = GlobalLock (hMem);
			if (pMem) 
			{
				PGPInputFormat	format;
				LPSTR			pBegin;

				format = sEvaluateBuffer (pMem, &pBegin);
				sLen = lstrlen (pBegin);

				PGPImport (g_context, &keydb, 
						PGPOInputBuffer (g_context, pBegin, sLen),
						PGPOInputFormat (g_context, format),
						PGPOLastOption (g_context));

				if (PGPKeyDBRefIsValid (keydb)) 
				{
					PGPUInt32	uNumKeys;

					PGPCountKeys (PGPPeekKeyDBRootKeySet (keydb), &uNumKeys);
					if (uNumKeys > 0) 
					{
						bKeys = TRUE;

						if (PGPclImportKeys (g_context, g_tlscontext,
								ppks->hwndMain, 
								PGPPeekKeyDBRootKeySet (keydb), 
								ppks->keydbMain,
								kPGPclDefaultImportFlags) 
							== kPGPError_NoErr) 
						{
							bImport = TRUE;
						}
					}
					PGPFreeKeyDB (keydb);
				}
				GlobalUnlock (hMem);
			}
		}
		if (!bKeys) 
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
					IDS_NOIMPORTKEYSPASTE, MB_OK|MB_ICONINFORMATION);
		}
		CloseClipboard ();
	}

	if (bImport) 
	{
		PKKeyDBModified (ppks, PK_MOD_INDEX_0);
		PGPclKeyListReloadKeys (ppks->hKL, TRUE);
	}
	
	return bImport;
}


//	_______________________________________________
//
//  Drop text key(s)

BOOL 
PKDropKeys (
		PGPKEYSSTRUCT*	ppks,
		BOOL			bKeySet,
		HANDLE			hMem) 
{
	PGPKeyDBRef		keydb;
	PGPKeySetRef	keyset;
	PGPUInt32		numKeys;
	BOOL			bImport;
	BOOL			bKeys;
	LPSTR			pMem;
	size_t			sLen;

	bImport = FALSE;
	bKeys = FALSE;
	if (hMem) 
	{
		pMem = GlobalLock (hMem);
		if (pMem) 
		{
			if (bKeySet)
			{
				pgpCopyMemory (pMem, &keyset, sizeof(keyset));

				PGPCountKeys (keyset, &numKeys);
			
				if (numKeys > 0) 
				{
					bKeys = TRUE;

					if (IsntPGPError (PGPclErrorBox (NULL,
						PGPCopyKeys (keyset, ppks->keydbMain, NULL))))
					{
						PGPCalculateTrust (
								PGPPeekKeyDBRootKeySet (ppks->keydbMain),
								kInvalidPGPKeyDBRef);
						bImport = TRUE;
					}
				}
			}
			else
			{
				PGPInputFormat	format;
				LPSTR			pBegin;

				format = sEvaluateBuffer (pMem, &pBegin);
				sLen = lstrlen (pBegin);

				PGPImport (g_context, &keydb, 
						PGPOInputBuffer (g_context, pBegin, sLen),
						PGPOInputFormat (g_context, format),
						PGPOLastOption (g_context));

				if (PGPKeyDBRefIsValid (keydb))
				{
					keyset = PGPPeekKeyDBRootKeySet (keydb);
					PGPCountKeys (keyset, &numKeys);
				
					if (numKeys > 0) 
					{
						bKeys = TRUE;

						if (s_bDraggingOut) 
						{
							PGPCheckKeyRingSigs (keyset,
									ppks->keydbMain, TRUE, NULL, NULL);

							if (IsntPGPError (PGPclErrorBox (NULL,
								PGPCopyKeys (keyset, ppks->keydbMain, NULL))))
							{
								PGPCalculateTrust (
										PGPPeekKeyDBRootKeySet (ppks->keydbMain),
										kInvalidPGPKeyDBRef);
								bImport = TRUE;
							}
						}
						else 
						{
							if (PGPclImportKeys (g_context, g_tlscontext,
									ppks->hwndMain, keyset, 
									ppks->keydbMain, 0) == kPGPError_NoErr) 
							{
								bImport = TRUE;
							}
						}
					}
					PGPFreeKeyDB (keydb);
				}
			}

			GlobalUnlock (hMem);
		}
		if (!bKeys) 
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
					IDS_NODRAGTEXTKEYS, MB_OK|MB_ICONINFORMATION);
		}
	}

	if (bImport) 
	{
		PKKeyDBModified (ppks, PK_MOD_INDEX_0);
		PGPclKeyListReloadKeys (ppks->hKL, TRUE);
	}
	
	return bImport;
}


//	___________________________________________
//
//  Determine if there is text in the clipboard

BOOL 
PKDataToPaste (VOID) 
{
	if (IsClipboardFormatAvailable (CF_TEXT)) 
		return TRUE;
	if (IsClipboardFormatAvailable (CF_HDROP)) 
		return TRUE;
	return FALSE;
}


//	_______________________________________________
//
//  Send key(s) in email message

static PGPError
sSendKeysViaEmail (
		PGPKEYSSTRUCT*	ppks,
		PGPKeySetRef	keysetToSend)
{
	PGPBoolean		bCompatible		= TRUE;
	PGPPrefRef		prefref			= kInvalidPGPPrefRef;
	HMODULE			hMAPI32			= NULL;
	LPMAPISENDMAIL	pMAPISendMail	= NULL;
	PGPSize			slen			= 0;
	PGPError		err				= kPGPError_NoErr;

	char			szFilePath[MAX_PATH];
	char			szFileName[256];
	char			szSubject[128];
	char			szBody[256];
	MapiMessage		msg;
	MapiFileDesc	file;

	hMAPI32 = LoadLibrary ("mapi32.dll");
	if (IsntNull (hMAPI32))
	{
		pMAPISendMail = 
				(LPMAPISENDMAIL) GetProcAddress (hMAPI32, "MAPISendMail");
	}

	if (IsNull (pMAPISendMail))
		return kPGPError_FeatureNotAvailable;

	GetTempPath (sizeof(szFileName), szFileName);
	GetTempFileName (szFileName, "PGP", 0, szFilePath);
	if (PKExportKeys (ppks, szFilePath))
	{
		ULONG	ret;

		sGetPGPExportName (ppks, szFileName, sizeof(szFileName));

		pgpClearMemory (&file, sizeof(file));
		file.nPosition = -1;
		file.lpszPathName = szFilePath;
		file.lpszFileName = szFileName;

		LoadString (g_hinst, IDS_KEYEMAILSUBJECT, szSubject, sizeof(szSubject));
		LoadString (g_hinst, IDS_KEYEMAILBODY, szBody, sizeof(szBody));

		pgpClearMemory (&msg, sizeof(msg));
		msg.lpszSubject = szSubject;
		msg.lpszNoteText = szBody;
		msg.nFileCount = 1;
		msg.lpFiles = &file;

		ret = pMAPISendMail (0, (ULONG)(ppks->hwndMain), 
				&msg, MAPI_DIALOG|MAPI_LOGON_UI, 0);

		if ((ret == MAPI_E_USER_ABORT) ||
			(ret == SUCCESS_SUCCESS))
		{
			err = kPGPError_NoErr;
		}
		else if (ret == MAPI_E_LOGIN_FAILURE)
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
					IDS_CANNOTLOGINTOEMAIL, MB_OK|MB_ICONEXCLAMATION);
			err = kPGPError_LazyProgrammer;
		}
		else
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
					IDS_CANNOTSENDVIAEMAIL, MB_OK|MB_ICONEXCLAMATION);
			err = kPGPError_LazyProgrammer;
		}

		DeleteFile (szFilePath);
	}

	FreeLibrary(hMAPI32);

	return err;
}


BOOL 
PKSendViaEmail (
		PGPKEYSSTRUCT*	ppks) 
{
	PGPKeySetRef	keysetToSend		= kInvalidPGPKeySetRef;
	PGPError		err					= kPGPError_UnknownError;
	BOOL			bRetVal				= FALSE;
	PGPBoolean		bX509cert			= FALSE;

	err = sGetKeysetToExport (ppks, &keysetToSend, &bX509cert, NULL, NULL);
	if (!PGPKeySetRefIsValid (keysetToSend))
		return FALSE;

	if (!bX509cert)
	{
		err = sSendKeysViaEmail (ppks, keysetToSend);
	}

	if (PGPKeySetRefIsValid (keysetToSend))
		PGPFreeKeySet (keysetToSend);

	return (err == kPGPError_NoErr);
}