pkkeyio.c

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

//
//  Compute name of export file

static VOID 
sGetX509ExportFileName (
		PGPKeyDBObjRef	cert,
		LPSTR			sz, 
		UINT			uLen,
		BOOL			bIncludeExtension) 
{
	CHAR			szDefExt[8];
	INT				i;

	PGPclGetPrimaryUserIDName (PGPPeekKeyDBObjKey (cert), sz, uLen, &i);

	i = strcspn (sz, "\\/:*?\"<>|");

	// truncate really long userids
	if (i > (MAX_PATH/2))
		i = MAX_PATH/2;

	sz[i--] = '\0';

	while ((i >= 0) && (sz[i] == ' '))
	{
		sz[i--] = '\0';
	}

	if (sz[0] == '\0') 
		LoadString (g_hinst, IDS_DROPFILENAME, sz, uLen);

	if (bIncludeExtension)
	{
		lstrcat (sz, ".");
		LoadString (g_hinst, 
				IDS_DEFX509EXPORTEXTENSION, szDefExt, sizeof(szDefExt));
		lstrcat (sz, szDefExt);
	}
}


//	___________________________
//
//  Compute name of export file

static VOID 
sGetPGPExportName (
		PGPKEYSSTRUCT*	ppks,
		LPSTR			sz, 
		UINT			uLen) 
{
	CHAR			szDefExt[8];
	PGPKeyDBObjRef	key;
	INT				i;
	PGPBoolean		bMultiple;

	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &key, &bMultiple, NULL);
	if (!bMultiple) 
	{
		PGPclGetPrimaryUserIDName (key, sz, uLen, &i);

		i = strcspn (sz, "\\/:*?\"<>|");

		// truncate really long userids
		if (i > (MAX_PATH/2))
			i = MAX_PATH/2;

		sz[i--] = '\0';

		while ((i >= 0) && (sz[i] == ' '))
		{
			sz[i--] = '\0';
		}

		if (sz[0] == '\0') 
			LoadString (g_hinst, IDS_DROPFILENAME, sz, uLen);
	}
	else 
		LoadString (g_hinst, IDS_DROPFILENAME, sz, uLen);

	lstrcat (sz, ".");
	LoadString (g_hinst, IDS_DEFEXPORTEXTENSION, szDefExt, sizeof(szDefExt));
	lstrcat (sz, szDefExt);
}


//----------------------------------------------------|
// Export Private Key dialog message procedure

static BOOL CALLBACK 
sExportPrivKeyDlgProc (
		HWND	hwnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	OPENFILENAME*			pofn;
	PEXPORTPRIVKEYSTRUCT	pepks;

	switch (uMsg) {

	case WM_INITDIALOG :
		pofn = (OPENFILENAME*)lParam;
		SetWindowLong (hwnd, GWL_USERDATA, pofn->lCustData);
		pepks = (PEXPORTPRIVKEYSTRUCT)pofn->lCustData;

		if (!pepks->bEnableExportPrivKeys) 
			EnableWindow (GetDlgItem (hwnd, IDC_EXPORTPRIVATEKEYS), FALSE);
		if (!pepks->bEnableCompatible) 
			EnableWindow (GetDlgItem (hwnd, IDC_INCLUDEEXTENSIONS), FALSE);

		pepks->bExportPrivKeys = FALSE;
		if (!pepks->bCompatible)
			CheckDlgButton (hwnd, IDC_INCLUDEEXTENSIONS, BST_CHECKED);
		break;

	case WM_HELP :
		return PGPclHtmlHelp (hwnd, uMsg, wParam, lParam, 
				(char*)kPGPclHelpFile, aExportKeyIds);

	case WM_COMMAND:

		switch (LOWORD(wParam)) {
		case IDC_EXPORTPRIVATEKEYS :
			pepks = (PEXPORTPRIVKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

			if (IsDlgButtonChecked (hwnd, IDC_EXPORTPRIVATEKEYS) == BST_CHECKED)
			{
				pepks->bExportPrivKeys = TRUE;
				if (pepks->bX509)
				{
					CHAR	sz[8];
					LoadString (g_hinst, 
							IDS_PKCS12EXPORTEXTENSION, sz, sizeof(sz));
					SendMessage (GetParent (hwnd), CDM_SETDEFEXT, 0, (LPARAM)sz);
				}
			}
			else 
			{
				pepks->bExportPrivKeys = FALSE;
				if (pepks->bX509)
				{
					CHAR	sz[8];
					LoadString (g_hinst, 
							IDS_DEFX509EXPORTEXTENSION, sz, sizeof(sz));
					SendMessage (GetParent (hwnd), CDM_SETDEFEXT, 0, (LPARAM)sz);
				}
			}
			return TRUE;

		case IDC_INCLUDEEXTENSIONS :
			pepks = (PEXPORTPRIVKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			if (IsDlgButtonChecked (hwnd, IDC_INCLUDEEXTENSIONS) == BST_CHECKED)
				pepks->bCompatible = FALSE;
			else 
				pepks->bCompatible = TRUE;
			return TRUE;

		}
		return FALSE;
	}
	return FALSE;
}


//	_______________________________________________
//
//  construct keyset to export

static PGPError 
sGetKeysetToExport (
		PGPKEYSSTRUCT*	ppks,
		PGPKeySetRef*	pkeyset,
		PGPBoolean*		pbX509cert,
		PGPBoolean*		pbX509onDSS,
		PGPKeyDBObjRef*	pcert) 
{
	PGPKeyDBObjRef		obj			= kInvalidPGPKeyDBObjRef;
	PGPUInt32			uSel		= 0;
	PGPError			err;

	if (pbX509onDSS)
		*pbX509onDSS = FALSE;

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

	if (uSel == kPGPclKeyList_Key)
	{
		*pbX509cert = FALSE;
		err = PGPclKeyListGetSelectedKeys (ppks->hKL, pkeyset);
	}
	else if (uSel == kPGPclKeyList_Signature)
	{
		PGPKeyDBObjRef key;

		*pbX509cert = TRUE;
		key = PGPPeekKeyDBObjKey (obj);
		err = PGPNewOneKeySet (key, pkeyset); 

		if (pbX509onDSS)
		{
			PGPUInt32	uAlg;

			PGPGetKeyDBObjNumericProperty (key, 
					kPGPKeyProperty_AlgorithmID, &uAlg);

			if (uAlg == kPGPPublicKeyAlgorithm_DSA)
				*pbX509onDSS = TRUE;
		}
	}
	else
		err = kPGPError_BadParams;

	if (IsntNull (pcert))
		*pcert = obj;

	return err;
}


//	_______________________________________________
//
//  Export key to text file

BOOL 
PKExportKeys (
		PGPKEYSSTRUCT*	ppks,
		LPSTR			pszFile) 
{
	PGPKeySetRef		keysetExport		= kInvalidPGPKeySetRef;
	PGPPrefRef			prefref				= kInvalidPGPPrefRef;
	PGPError			err					= kPGPError_NoErr;
	PGPKeyDBObjRef		cert				= kInvalidPGPKeyDBObjRef;
	PGPUInt32			uSel				= 0;
	PGPBoolean			bX509onDSSKey		= FALSE;

	OPENFILENAME		OpenFileName;
	EXPORTPRIVKEYSTRUCT	epks;
	CHAR				szFile[MAX_PATH];
	CHAR				szInitDir[MAX_PATH];
	CHAR				szDefExt[8];
	CHAR				szFilter[256];
	CHAR				szTitle[64];
	CHAR*				p;
	BOOL				bRetVal;

	sGetKeysetToExport (ppks, 
			&keysetExport, &epks.bX509, &bX509onDSSKey, &cert);

	if (!PGPKeySetRefIsValid (keysetExport))
		return FALSE;

	epks.bEnableCompatible = !epks.bX509;

	if (pszFile) 
	{
		if (IsntPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		{
			PGPGetPrefBoolean (prefref, 
					kPGPPrefExportKeysCompatible, &epks.bCompatible);

			bRetVal = sExportKeys (ppks, keysetExport, 
					PGPPeekKeyDBObjKey (cert), pszFile, 
					FALSE, epks.bX509, epks.bCompatible);
		}
	}
	else 
	{
		OpenFileName.lStructSize       = sizeof (OPENFILENAME);
		OpenFileName.hwndOwner         = ppks->hwndMain;
		OpenFileName.hInstance         = (HANDLE)g_hinst;
		PGPclGetPath (kPGPclDefaultSaveAsFolder, szInitDir, sizeof(szInitDir));

		if (epks.bX509)
		{
			LoadString (g_hinst, 
					IDS_X509EXPORTCAPTION, szTitle, sizeof(szTitle));
			LoadString (g_hinst, 
					IDS_EXPORTFILTERX509, szFilter, sizeof(szFilter));

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

			LoadString (g_hinst, IDS_DEFX509EXPORTEXTENSION, szDefExt, 
					sizeof(szDefExt));
		}
		else
		{
			LoadString (g_hinst, 
					IDS_EXPORTCAPTION, szTitle, sizeof(szTitle));
			LoadString (g_hinst, 
					IDS_EXPORTFILTER, szFilter, sizeof(szFilter));

			LoadString (g_hinst, IDS_DEFEXPORTEXTENSION, szDefExt, 
					sizeof(szDefExt));

			sGetPGPExportName (ppks, szFile, sizeof (szFile));
		}

		while (p = strrchr (szFilter, '@')) *p = '\0';
		OpenFileName.lpstrFilter	   = szFilter;
		OpenFileName.lpstrCustomFilter = (LPTSTR)NULL;
		OpenFileName.nMaxCustFilter    = 0L;
		OpenFileName.nFilterIndex      = 1L;
		OpenFileName.lpstrFile         = szFile;
		OpenFileName.nMaxFile          = sizeof (szFile);
		OpenFileName.lpstrFileTitle    = NULL;
		OpenFileName.nMaxFileTitle     = 0;
		OpenFileName.lpstrInitialDir   = szInitDir;
		OpenFileName.lpstrTitle        = szTitle;
		OpenFileName.Flags			   = OFN_EXPLORER|
										 OFN_ENABLETEMPLATE|
										 OFN_ENABLEHOOK|
										 OFN_HIDEREADONLY|
										 OFN_OVERWRITEPROMPT|
										 OFN_NOREADONLYRETURN|
										 OFN_NOCHANGEDIR;
		OpenFileName.nFileOffset       = 0;
		OpenFileName.nFileExtension    = 0;
		OpenFileName.lpstrDefExt       = szDefExt;

		OpenFileName.lCustData         = (DWORD)&epks;
		OpenFileName.lpfnHook          = sExportPrivKeyDlgProc; 
		OpenFileName.lpTemplateName    = 
					MAKEINTRESOURCE (IDD_EXPORTDLGEXTENSIONS);

		if (bX509onDSSKey)
			epks.bEnableExportPrivKeys = FALSE;
		else
		{
			epks.bEnableExportPrivKeys = 
					PKCheckForNonTokenSecretKeys (keysetExport);
		}

		if (IsntPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		{
			PGPGetPrefBoolean (prefref, kPGPPrefExportKeysCompatible, 
					&epks.bCompatible);

			if (GetSaveFileName (&OpenFileName)) 
			{
				bRetVal = sExportKeys (ppks, keysetExport, 
						PGPPeekKeyDBObjKey (cert), szFile, 
						epks.bExportPrivKeys, epks.bX509, epks.bCompatible);
			}
		}
	}

	if (PGPKeySetRefIsValid (keysetExport)) 
		PGPFreeKeySet (keysetExport);

	return TRUE;
}


//	_______________________________________________
//
//	called by OLE when DropTarget asks for data

PVOID 
PKDropKeysGetData (
		PGPKEYSSTRUCT*	ppks,
		BOOL			bKeyset,
		UINT*			puLen)
{
	PGPKeySetRef	keysetDrop		= kInvalidPGPKeySetRef;
	PGPError		err				= kPGPError_NoErr;
	DWORD			dwEffect		= 0;
	BOOL			bOKtoDelete		= FALSE;
	PGPSize			slen			= 0;
	PVOID			pExport			= NULL;
	LPSTR			pszExport		= NULL;
	PGPBoolean		bX509cert		= FALSE;

	CHAR			szComment[256];
	HCURSOR			hcursorOld;
	PGPExportFormat exportformat;

	hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));

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

	if (bKeyset)
	{
		pExport = PGPNewData (PGPPeekContextMemoryMgr (g_context), 
				sizeof(PGPKeySetRef), 0);
		memcpy (pExport, &keysetDrop, sizeof(PGPKeySetRef));
		*puLen = sizeof(PGPKeySetRef);
		return pExport;
	}

	// get comment string
	slen = 0;
	sGetCommentString (PGPPeekContextMemoryMgr (g_context), 
			szComment, sizeof(szComment));

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

	// export to buffer
	if (IsntPGPError (PGPclErrorBox (NULL,
		PGPExport (g_context,
				PGPOExportKeySet (g_context, keysetDrop),
				PGPOAllocatedOutputBuffer (g_context,
						&pszExport, 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))))) 
	{
		if (pszExport) 
			pszExport[slen-2] = '\0';
	}

	if (PGPKeySetRefIsValid (keysetDrop))
		PGPFreeKeySet (keysetDrop);

	SetCursor (hcursorOld);

	*puLen = slen-2;
	return pszExport;		
}


//	_______________________________________________
//
//	called by OLE when DropTarget releases data

VOID 
PKDropKeysFreeData (
		BOOL	bKeySet,
		PVOID	p) 
{
	PGPKeySetRef	keyset;

	if (IsntNull (p))
	{
		if (bKeySet)
		{
			memcpy (&keyset, p, sizeof(PGPKeySetRef));
			if (PGPKeySetRefIsValid (keyset))
				PGPFreeKeySet (keyset);
		}

		PGPFreeData (p);
	}
}


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

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

	sGetPGPExportName (ppks, szFile, sizeof(szFile));

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

	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);
			}
		}
	}