pkaddid.c

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

				0, GetParent (hwnd), NULL);

		DestroyMenu (hMC);
		break;
	}

	case WM_DROPFILES :
	{
		CHAR				szFile[MAX_PATH];
		INT					iLen;
		LPBITMAPINFO		lpbmi;
		LPBYTE				pPhoto;
		INT					isize;
		PGPError			err;
		HWND				hwndParent;

		iLen = DragQueryFile ((HDROP)wParam, 0, szFile, sizeof(szFile));
		hwndParent = GetParent (hwnd);

		err = PGPclReadPhotoFromFile (g_context, szFile, &pPhoto, &isize);
		if (IsntPGPError (PGPclErrorBox (hwnd, err))) 
		{
			SetActiveWindow (GetParent (hwndParent));
			if (paps->pPhotoBuffer) 
				PGPFreeData (paps->pPhotoBuffer);
			if (paps->hbitmapPhotoID) 
				DeleteObject (paps->hbitmapPhotoID);
			if (paps->hpalettePhotoID) 
				DeleteObject (paps->hpalettePhotoID);

			paps->pPhotoBuffer = pPhoto;
			paps->iPhotoBufferLength = isize;
			EnableWindow (GetDlgItem (hwndParent, IDOK), TRUE); 

			err = PGPclDIBfromPhoto (g_context, pPhoto, isize, TRUE, &lpbmi);

			if (IsntPGPError (err)) 
			{
				PGPclGetDIBSize (lpbmi, &(paps->iwidthPhotoID),
						&(paps->iheightPhotoID), NULL);

				PGPclDDBfromDIB (lpbmi, 
						&(paps->hbitmapPhotoID),
						&(paps->hpalettePhotoID)); 

				PGPFreeData (lpbmi);

				InvalidateRect (hwndParent, NULL, TRUE);
			}
		} 

		DragFinish ((HDROP)wParam);
		break;
	}

	default :
		return CallWindowProc (paps->wpOrigPhotoIDProc, 
				hwnd, uMsg, wParam, lParam); 
	}
	return TRUE;
} 


//	___________________________________________________
//
//  select BMP file 

static VOID 
sSelectBitmapFile (
		HWND			hwnd,
		PADDPHOTOSTRUCT	paps)
{
	LPBYTE			pPhoto;
	INT				isize;
	CHAR			szFile[MAX_PATH];
	CHAR			szInitDir[MAX_PATH];
	CHAR			szTitle[128];
	CHAR			szFilter[128];
	CHAR*			p;
	PGPError		err;
	OPENFILENAME	ofn;
	LPBITMAPINFO	lpbmi;

	szFile[0] = '\0';

	LoadString (g_hinst, IDS_BITMAPFILTER, szFilter, sizeof(szFilter));
	while (p = strrchr (szFilter, '@')) *p = '\0';

	LoadString (g_hinst, IDS_OPENBITMAPTITLE, szTitle, sizeof(szTitle));
	PGPclGetPath (kPGPclDefaultOpenFolder, szInitDir, sizeof(szInitDir));

	ofn.lStructSize       = sizeof (OPENFILENAME);
	ofn.hwndOwner         = hwnd;
	ofn.hInstance         = (HANDLE)g_hinst;
	ofn.lpstrFilter       = szFilter;
	ofn.lpstrCustomFilter = (LPTSTR)NULL;
	ofn.nMaxCustFilter    = 0L;
	ofn.nFilterIndex      = 1L;
	ofn.lpstrFile         = szFile;
	ofn.nMaxFile          = sizeof (szFile);
	ofn.lpstrFileTitle    = szTitle;
	ofn.nMaxFileTitle     = 0;
	ofn.lpstrInitialDir   = szInitDir;
	ofn.lpstrTitle        = szTitle;
	ofn.Flags			  = OFN_HIDEREADONLY|OFN_NOCHANGEDIR;
	ofn.nFileOffset       = 0;
	ofn.nFileExtension    = 0;
	ofn.lpstrDefExt       = NULL;
	ofn.lCustData         = 0;

	if (!GetOpenFileName (&ofn)) 
		return;

	err = PGPclReadPhotoFromFile (g_context, szFile, &pPhoto, &isize);

	if (IsntPGPError (PGPclErrorBox (hwnd, err))) 
	{
		if (paps->pPhotoBuffer) 
			PGPFreeData (paps->pPhotoBuffer);
		if (paps->hbitmapPhotoID) 
			DeleteObject (paps->hbitmapPhotoID);
		if (paps->hpalettePhotoID) 
			DeleteObject (paps->hpalettePhotoID);

		paps->pPhotoBuffer = pPhoto;
		paps->iPhotoBufferLength = isize;
		EnableWindow (GetDlgItem (hwnd, IDOK), TRUE);

		err = PGPclDIBfromPhoto (g_context, pPhoto, isize, TRUE, &lpbmi);

		if (IsntPGPError (err)) 
		{
			PGPclGetDIBSize (lpbmi, &(paps->iwidthPhotoID),
					&(paps->iheightPhotoID), NULL);

			PGPclDDBfromDIB (lpbmi, 
					&(paps->hbitmapPhotoID),
					&(paps->hpalettePhotoID)); 

			PGPFreeData (lpbmi);

			InvalidateRect (hwnd, NULL, TRUE);
		}
	} 
}


//	___________________________________________________
//
//  Add PhotoID Dialog Message procedure

static BOOL CALLBACK 
sAddPhotoDlgProc (
		HWND	hwnd, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	PADDPHOTOSTRUCT paps;
	LPBITMAPINFO	lpbmi;

	switch(uMsg) {

	case WM_INITDIALOG:
		paps = (PADDPHOTOSTRUCT)lParam;
		SetWindowLong (hwnd, GWL_USERDATA, lParam);

		// subclass photoID control to handle dropping, dragging
		paps->wpOrigPhotoIDProc = 
			(WNDPROC) SetWindowLong(GetDlgItem (hwnd, IDC_PHOTOID), 
						GWL_WNDPROC, (LONG) sPhotoIDSubclassProc); 

		return TRUE;

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

	case WM_DESTROY :
 		paps = (PADDPHOTOSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		SetWindowLong (GetDlgItem(hwnd, IDC_PHOTOID), 
							GWL_WNDPROC, (LONG)paps->wpOrigPhotoIDProc); 
		break;

	case WM_PAINT :
		paps = (PADDPHOTOSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		sPaintPhotoID (hwnd, paps->hbitmapPhotoID, paps->hpalettePhotoID,
				paps->iwidthPhotoID, paps->iheightPhotoID);
		break;

	case WM_PALETTECHANGED :
		if ((HWND)wParam != hwnd) 
		{
			paps = (PADDPHOTOSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			sUpdatePalette (hwnd, paps);
		}
		break;

	case WM_QUERYNEWPALETTE :
		paps = (PADDPHOTOSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		return (sUpdatePalette (hwnd, paps));

	case WM_COMMAND:
		paps = (PADDPHOTOSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		switch(LOWORD (wParam)) {
		case IDOK: 
			EndDialog (hwnd, 1);
			return TRUE;

		case IDCANCEL:
			EndDialog (hwnd, 0);
			return TRUE;

		case IDC_SELECTFILE :
			sSelectBitmapFile (hwnd, paps);
			break;

		case IDM_COPYBITMAP :
			PGPclCopyPhotoToClipboard (g_context, hwnd, 
					paps->pPhotoBuffer, paps->iPhotoBufferLength);
			break;

		case IDM_PASTEBITMAP :
		{
			LPBYTE		pPhoto				= NULL;
			INT			isize				= 0;
			PGPError	err					= kPGPError_UserAbort;
			INT			iLen;
			CHAR		szFile[MAX_PATH];
			HANDLE		hMem;
			HDROP		hDrop;

			if (IsClipboardFormatAvailable (CF_DIB))
			{
				err = PGPclPastePhotoFromClipboard (g_context, 
						hwnd, &pPhoto, &isize);
			}

			if (IsPGPError (err)) 
			{
				if (IsClipboardFormatAvailable (CF_HDROP)) 
				{
					if (OpenClipboard (hwnd)) 
					{ 
						hMem = GetClipboardData (CF_HDROP); 
						if (hMem) 
						{
							hDrop = GlobalLock (hMem);
							iLen = DragQueryFile (hDrop, 
									0, szFile, sizeof(szFile));

							err = PGPclReadPhotoFromFile (
									g_context, szFile, &pPhoto, &isize);

							GlobalUnlock (hMem);
						}
						CloseClipboard ();
					}
				}
			}

			if (IsntPGPError (PGPclErrorBox (hwnd, err)))
			{
				if (paps->pPhotoBuffer) 
					PGPFreeData (paps->pPhotoBuffer);
				if (paps->hbitmapPhotoID) 
					DeleteObject (paps->hbitmapPhotoID);
				if (paps->hpalettePhotoID) 
					DeleteObject (paps->hpalettePhotoID);

				paps->pPhotoBuffer = pPhoto;
				paps->iPhotoBufferLength = isize;
				EnableWindow (GetDlgItem (hwnd, IDOK), TRUE);

				err = PGPclDIBfromPhoto (g_context, 
						pPhoto, isize, TRUE, &lpbmi);

				if (IsntPGPError (err)) 
				{
					PGPclGetDIBSize (lpbmi, &(paps->iwidthPhotoID),
							&(paps->iheightPhotoID), NULL);

					PGPclDDBfromDIB (lpbmi, 
							&(paps->hbitmapPhotoID),
							&(paps->hpalettePhotoID)); 

					PGPFreeData (lpbmi);

					InvalidateRect (hwnd, NULL, TRUE);
				}
			} 
			break;
		}
		}
		return TRUE;
	}
	return FALSE;
}


//	___________________________________________________
//
//  Add Photo UserID to key
//	This routine is called when the user chooses to add
//	a PhotoID to an existing secret key.

BOOL 
PKAddPhotoToKey (
		PGPKEYSSTRUCT*	ppks) 
{
	PGPPrefRef		prefref			= kInvalidPGPPrefRef;
	PGPByte*		pPasskey		= NULL;
	BOOL			bRetVal			= TRUE;
	PGPError		err;
	PGPKeyDBObjRef	key;
	PGPSize			sizePasskey;
	ADDPHOTOSTRUCT	aps;
	CHAR			sz[256];
	HCURSOR			hcursorOld;

	// initialize struct
	aps.ppks = ppks;
	aps.pPhotoBuffer = NULL;
	aps.hbitmapPhotoID = NULL;
	aps.hpalettePhotoID = NULL;

	if (IsPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		return FALSE;

	PGPGetPrefBoolean (prefref, 
			kPGPPrefKeyServerSyncOnAdd, &(aps.bSyncWithServer));

	// get selected key
	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &key, NULL, NULL);

	// check if there is a pre-existing photoid
	if (PKExistingPhotoID (key)) 
	{
		PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO,
				IDS_PHOTOIDALREADYEXISTS, MB_OK|MB_ICONINFORMATION);
		return FALSE;
	}

	// get new photoid from user
	if (DialogBoxParam (g_hinst, MAKEINTRESOURCE (IDD_NEWPHOTOID), 
					ppks->hwndMain, sAddPhotoDlgProc, (LPARAM)&aps)) 
	{
		// get valid passphrase
		LoadString (g_hinst, IDS_SELKEYPASSPHRASE, sz, sizeof(sz)); 
		err = PGPclGetKeyPhrase (g_context, g_tlscontext,
				ppks->hwndMain, sz, ppks->keydbMain, key,
				NULL, &pPasskey, &sizePasskey);
		PGPclErrorBox (ppks->hwndMain, err);

		// now we have a valid passphrase, if required
		if (IsntPGPError (err)) 
		{
			// update from server
			if (aps.bSyncWithServer) 
			{
				if (!PKGetFromServerInternal (ppks, FALSE, FALSE, FALSE)) 
				{
					if (PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
							IDS_QUERYCONTINUEADDING, 	
							MB_YESNO|MB_ICONINFORMATION) == IDNO) 
					{
						bRetVal = FALSE;
					}
				}
			}
		
			if (bRetVal) 
			{
				// make sure we have enough entropy
				PGPclRandom (g_context, ppks->hwndMain, 0);

				hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
				if (pPasskey) 
				{
					err = PGPAddAttributeUserID (key,
							kPGPAttribute_Image,
							aps.pPhotoBuffer,
							aps.iPhotoBufferLength,
							PGPOPasskeyBuffer (g_context, 
								pPasskey, sizePasskey),
							PGPOLastOption (g_context));
				}
				else 
				{
					err = PGPAddAttributeUserID (key,
							kPGPAttribute_Image,
							aps.pPhotoBuffer,
							aps.iPhotoBufferLength,
							PGPOLastOption (g_context));
				}
				SetCursor (hcursorOld);
						
				if (IsntPGPError (PGPclErrorBox (ppks->hwndMain, err))) 
				{
					PKKeyDBModified (ppks, PK_MOD_INDEX_0);
					PGPclKeyListUpdateTree (ppks->hKL, 
							kPGPclKeyListUpdateObject, key, FALSE);
					PGPclKeyListSetTree (ppks->hKL,
							kPGPclSelectSpecifiedOnly, key);

					// send to server
					if (aps.bSyncWithServer) 
						PKSendToServer (ppks, kPGPclDefaultServer);
				}
				else 
					bRetVal = FALSE;
			}
		}
		else 
			bRetVal = FALSE;
	}
	else 
		bRetVal = FALSE;

	// free passkey
	if (pPasskey) 
	{
		PGPclFreePasskey (pPasskey, sizePasskey);
		pPasskey = NULL;
	}

	// free photoID objects
	if (aps.hbitmapPhotoID)
		DeleteObject (aps.hbitmapPhotoID);
	if (aps.hpalettePhotoID) 
		DeleteObject (aps.hpalettePhotoID);
	if (aps.pPhotoBuffer) 
		PGPFreeData (aps.pPhotoBuffer);

	return bRetVal;
}