gmops.c

vc环境下的pgp源码

//
//  add selected items to focused group

BOOL 
GMAddSelectedToFocused (PGROUPMAN pGM) 
{
	PGPGroupID		groupidDest;
	TL_TREEITEM		tli;
	ADDSTRUCT		as;

	tli.hItem = GMFocusedItem (pGM);
	tli.mask = TLIF_IMAGE|TLIF_PARAM;
	TreeList_GetItem (pGM->hWndTree, &tli);

	// if selected item is a group then get the groupid
	if (tli.iImage == IDX_GROUP) {
		groupidDest = HIWORD(tli.lParam);
		if (!groupidDest) groupidDest = LOWORD(tli.lParam);
	}

	// otherwise it's a key, get the parent groupid
	else {
		groupidDest = HIWORD(tli.lParam);
	}

	if (groupidDest) {
		as.lpfnCallback = sAddSingleObject;
		as.pGM = pGM;
		as.groupidDest = groupidDest;
		as.bAdded = FALSE;

		TreeList_IterateSelected (pGM->hWndTree, &as);
	}
	
	if (as.bAdded) {
		GMSortGroupSet (pGM);
		GMCommitGroupChanges (pGM, TRUE);
		GMLoadGroupsIntoTree (pGM, FALSE, TRUE, FALSE);
		InvalidateRect (pGM->hWndTree, NULL, TRUE);
		UpdateWindow (pGM->hWndTree);
	}

	return TRUE;
}

//	_______________________________________________
//
//  add keys to selected group

BOOL 
GMAddKeysToGroup (
		PGROUPMAN		pGM, 
		PGPKeySetRef	keyset) 
{
	PGPKeyListRef	keylist;
	PGPKeyIterRef	keyiter;
	PGPKeyRef		key;
	PGPGroupID		groupid;
	PGPGroupItem	groupitem;
	TL_TREEITEM		tli;

	tli.hItem = GMFocusedItem (pGM);
	tli.mask = TLIF_IMAGE|TLIF_PARAM;
	TreeList_GetItem (pGM->hWndTree, &tli);

	// if selected item is a group then get the groupid
	if (tli.iImage == IDX_GROUP) {
		groupid = HIWORD(tli.lParam);
		if (!groupid) groupid = LOWORD(tli.lParam);
	}

	// otherwise it's a key, get the parent groupid
	else {
		groupid = HIWORD(tli.lParam);
	}

	if (groupid) {
		PGPOrderKeySet (keyset, kPGPAnyOrdering, &keylist);
		PGPNewKeyIter (keylist, &keyiter);

		PGPKeyIterNext (keyiter, &key);

		while (key) {
			groupitem.type = kPGPGroupItem_KeyID;
			groupitem.userValue = 0;
			PGPGetKeyNumber (key, kPGPKeyPropAlgID, 
									&groupitem.u.key.algorithm);
			PGPGetKeyIDFromKey (key, &groupitem.u.key.keyID);

			PGPAddItemToGroup (pGM->groupsetMain, &groupitem, groupid);

			PGPKeyIterNext (keyiter, &key);
		}
	
		PGPFreeKeyIter (keyiter);
		PGPFreeKeyList (keylist);
	}
	
	return TRUE;
}

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

BOOL 
GMDropKeys (
		PGROUPMAN	pGM, 
		HANDLE		hMem) 
{
	PGPKeySetRef	keyset;
	PGPError		err;
	BOOL			bAdded;
	LPSTR			pMem;
	size_t			sLen;

	bAdded = FALSE;
	if (hMem) {
		pMem = GlobalLock (hMem);
		if (pMem) {
			sLen = lstrlen (pMem);
			err =PGPImportKeySet (pGM->context, &keyset, 
							PGPOInputBuffer (pGM->context, pMem, sLen),
							PGPOLastOption (pGM->context));
			if (IsntPGPError (PGPclErrorBox (NULL, err) && 
					PGPRefIsValid (keyset))) {
				PGPUInt32	numKeys;
				PGPCountKeys (keyset, &numKeys);
				
				if (numKeys > 0) {
					GMAddKeysToGroup (pGM, keyset);

					TreeList_Select (pGM->hWndTree, NULL, TRUE);
					GMSetFocus (pGM, NULL, FALSE);

					bAdded = TRUE;
				}

				PGPFreeKeySet (keyset);
			}
			GlobalUnlock (hMem);
		}
	}

	if (bAdded) {
		GMSortGroupSet (pGM);
		GMCommitGroupChanges (pGM, TRUE);
		GMLoadGroupsIntoTree (pGM, FALSE, TRUE, FALSE);
		InvalidateRect (pGM->hWndTree, NULL, TRUE);
		UpdateWindow (pGM->hWndTree);
	}
	
	return bAdded;
}

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

BOOL 
GMPasteKeys (PGROUPMAN pGM) 
{
	BOOL			bAdded;
	HANDLE			hMem;

	bAdded = FALSE;

	if (OpenClipboard (NULL)) {
		hMem = GetClipboardData (CF_TEXT);
		if (hMem) {
			bAdded = GMDropKeys (pGM, hMem);
		}
		CloseClipboard ();
	}

	if (!bAdded) {
		PGPgmMessageBox (pGM->hWndParent, IDS_CAPTION, 
					IDS_NOPASTEKEYS, MB_OK|MB_ICONEXCLAMATION);

	}

	return bAdded;
}

//----------------------------------------------------|
//  Locate (ie. select) a single object
//	routine called as a callback function from the TreeList control to 
//	delete a single item.
//
//	lptli	= pointer to TreeList item to delete

static BOOL CALLBACK 
sLocateSingleObject (
		TL_TREEITEM*	lptli, 
		LPARAM			lParam) 
{
	LOCATESTRUCT*	pls			= (LOCATESTRUCT*)lParam;
	PGPKeyRef		key;
	PGPUInt32		index;
	PGPGroupID		id;
	PGPGroupItem	groupitem;
	PGPError		err;

	switch (lptli->iImage) {

	// is it a group ?
	case IDX_GROUP :
		return TRUE;

	// otherwise it's a key 
	default:
		id = HIWORD(lptli->lParam);
		index = LOWORD(lptli->lParam);
		if (id) {
			PGPGetIndGroupItem (pls->pGM->groupsetMain, 
											id, index, &groupitem);

			err = PGPGetKeyByKeyID (pls->pGM->keysetMain,
						&groupitem.u.key.keyID, 
						groupitem.u.key.algorithm, &key);

			if (IsntPGPError (err)) {
				PGPkmSelectKey (pls->pGM->hKM, key, pls->bFirst);
				pls->bFirst = FALSE;
			}

			return TRUE;
		}
	}

	return FALSE;
}

//	___________________________________________________
//
//	select keys in main keys window

BOOL  
GMLocateKeys (PGROUPMAN pGM)
{
	LOCATESTRUCT	ls;

	ls.lpfnCallback = sLocateSingleObject;
	ls.pGM = pGM;
	ls.bFirst = TRUE;

	pGM->bLocatingKeys = TRUE;
	TreeList_IterateSelected (pGM->hWndTree, &ls);
	pGM->bLocatingKeys = FALSE;

	return TRUE;
}


//	_______________________________________________
//
//  Import groups from group file
//
//	hDrop	== NULL	=> prompt user for file name
//			!= NULL => hDrop is a handle passed in from 
//						the WM_DROPFILE message
//

BOOL 
GMImportGroups (
		PGROUPMAN	pGM, 
		HDROP		hDrop) 
{
	PGPGroupSetRef	groupset			= NULL;
	OPENFILENAME	OpenFileName;
	CHAR			szFile[MAX_PATH];
	CHAR			szFilter[256];
	CHAR			szTitle[64];
	CHAR*			p;
	INT				iIndex;
	BOOL			bImport;
	PGPFileSpecRef	filespec;
	PGPError		err;

	// file was dropped
	if (hDrop) {
		iIndex = 0;
		bImport = FALSE;
		while (DragQueryFile (hDrop, iIndex, szFile, sizeof(szFile))) {
			PGPNewFileSpecFromFullPath (pGM->context, szFile, &filespec);
			if (filespec) {
				groupset = NULL;
				err = PGPNewGroupSetFromFile (pGM->context, 
												filespec, &groupset);
				if (IsntPGPError (err)) {
					err = PGPMergeGroupSets (groupset, pGM->groupsetMain);
					if (IsntPGPError (err)) bImport = TRUE;
				}
				if (groupset)
					PGPFreeGroupSet (groupset);
				PGPFreeFileSpec (filespec);
			}
			iIndex++;
		}
		if (!bImport) {
			PGPgmMessageBox (pGM->hWndParent, IDS_CAPTION, 
							IDS_NOIMPORTGROUPS, MB_OK|MB_ICONEXCLAMATION);
		}
	}

	// file wasn't dropped, prompt user for file name
	else {
		lstrcpy (szFile, "");
		LoadString (g_hInst, IDS_GROUPIMPORTFILTER, 
									szFilter, sizeof(szFilter));
		while (p = strrchr (szFilter, '@')) *p = '\0';
		LoadString (g_hInst, IDS_GROUPIMPORTCAPTION, 
									szTitle, sizeof(szTitle));
		OpenFileName.lStructSize       = sizeof (OPENFILENAME);
		OpenFileName.hwndOwner         = pGM->hWndParent;
		OpenFileName.hInstance         = (HANDLE)g_hInst;
		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   = NULL;
		OpenFileName.lpstrTitle        = szTitle;
		OpenFileName.Flags			   = OFN_HIDEREADONLY|OFN_NOCHANGEDIR;
		OpenFileName.nFileOffset       = 0;
		OpenFileName.nFileExtension    = 0;
		OpenFileName.lpstrDefExt       = "";
		OpenFileName.lCustData         = 0;

		bImport = FALSE;
		if (GetOpenFileName (&OpenFileName)) {
			PGPNewFileSpecFromFullPath (pGM->context, szFile, &filespec);
			if (filespec) {
				groupset = NULL;
				err = PGPNewGroupSetFromFile (pGM->context, 
												filespec, &groupset);
				if (IsntPGPError (err)) {
					err = PGPMergeGroupSets (groupset, pGM->groupsetMain);
					if (IsntPGPError (err)) bImport = TRUE;
				}
				if (groupset)
					PGPFreeGroupSet (groupset);
				PGPFreeFileSpec (filespec);
			}
			if (!bImport) {
				PGPgmMessageBox (pGM->hWndParent, IDS_CAPTION, 
							IDS_NOIMPORTGROUPS, MB_OK|MB_ICONEXCLAMATION);
			}
		}
	}

	if (bImport) {
		GMSortGroupSet (pGM);
		GMCommitGroupChanges (pGM, TRUE);
		GMLoadGroupsIntoTree (pGM, FALSE, TRUE, FALSE);
		InvalidateRect (pGM->hWndTree, NULL, TRUE);
		UpdateWindow (pGM->hWndTree);
	}

	return bImport;
}