kmtree.c

vc环境下的pgp源码

	tlI.hItem = hItem;
	tlI.mask = TLIF_TEXT | TLIF_IMAGE | TLIF_STATE | TLIF_PARAM;
	tlI.stateMask = TLIS_BOLD | TLIS_ITALICS;
	tlI.stateMask |= uState;
	tlI.state = uState;
	tlI.pszText = szText;
	tlI.cchTextMax = lstrlen (szText);
	tlI.iImage = iImage;
	tlI.iSelectedImage = iImage;
	tlI.lParam = lParam;

	// Insert the data into the tree.
	if (bReInsertExisting || !hItem) {
		tlIns.item = tlI;
		tlIns.hInsertAfter = hInsAfter;
		tlIns.hParent = hParent;
		return (TreeList_InsertItem (pKM->hWndTree, &tlIns));
	}
	else {
		TreeList_SetItem (pKM->hWndTree, &tlI);
		return hItem;
	}
}


//	_______________________________________________
//
//  Construct string representation of number of key bits

VOID 
KMGetKeyBitsString (
		PGPKeySetRef	KeySet, 
		PGPKeyRef		Key, 
		LPSTR			sz, 
		UINT			u) 
{
	UINT uAlg;
	UINT uKeyBits, uSubKeyBits;
	PGPSubKeyRef SubKey;
	PGPKeyListRef KeyList;
	PGPKeyIterRef KeyIter;
	PGPError err;
	CHAR szbuf[32];

	PGPGetKeyNumber (Key, kPGPKeyPropAlgID, &uAlg);
	switch (uAlg) {
	case kPGPPublicKeyAlgorithm_RSA :
		PGPGetKeyNumber (Key, kPGPKeyPropBits, &uKeyBits);
		wsprintf (szbuf, "%i", uKeyBits);
		lstrcpyn (sz, szbuf, u);
		break;

	case kPGPPublicKeyAlgorithm_DSA :
		// key key bits
		err = PGPGetKeyNumber (Key, kPGPKeyPropBits, &uKeyBits);
		wsprintf (szbuf, "%i", uKeyBits);

		// now try to get subkey bits
		PGPOrderKeySet (KeySet, kPGPAnyOrdering, &KeyList);
		PGPNewKeyIter (KeyList, &KeyIter);
		PGPKeyIterSeek (KeyIter, Key);
		PGPKeyIterNextSubKey (KeyIter, &SubKey);
		if (SubKey) {
			PGPGetSubKeyNumber (SubKey, kPGPKeyPropBits, &uSubKeyBits);
			wsprintf (szbuf, "%i/%i", uSubKeyBits, uKeyBits);
		}
		PGPFreeKeyIter (KeyIter);
		PGPFreeKeyList (KeyList);

		lstrcpyn (sz, szbuf, u);
		break;

	default :
		LoadString (g_hInst, IDS_UNKNOWN, sz, u);
		break;
	}
}


//	_______________________________________________
//
//  Set list data for a key

static VOID 
sFillDescription (INT idx, INT iVal, LPSTR sz, INT iLen) 
{

	INT		ids				= 0;
	BOOL	bSig			= FALSE;
	CHAR	szTemp[128];

	switch (idx) {
	case IDX_RSAPUBKEY :	ids = IDS_RSAPUBKEY;		break;
	case IDX_DSAPUBKEY :	ids = IDS_DSAPUBKEY;		break;
	case IDX_RSASECKEY :	ids = IDS_RSASECKEY;		break;
	case IDX_DSASECKEY :	ids = IDS_DSASECKEY;		break;

	case IDX_RSAPUBDISKEY : ids = IDS_RSAPUBDISKEY;		break;
	case IDX_RSAPUBREVKEY : ids = IDS_RSAPUBREVKEY;		break;
	case IDX_RSAPUBEXPKEY : ids = IDS_RSAPUBEXPKEY;		break;

	case IDX_RSASECDISKEY : ids = IDS_RSASECDISKEY;		break;
	case IDX_RSASECREVKEY : ids = IDS_RSASECREVKEY;		break;
	case IDX_RSASECEXPKEY : ids = IDS_RSASECEXPKEY;		break;
	case IDX_RSASECSHRKEY : ids = IDS_RSASECSHRKEY;		break;

	case IDX_DSAPUBDISKEY : ids = IDS_DSAPUBDISKEY;		break;
	case IDX_DSAPUBREVKEY : ids = IDS_DSAPUBREVKEY;		break;
	case IDX_DSAPUBEXPKEY : ids = IDS_DSAPUBEXPKEY;		break;

	case IDX_DSASECDISKEY : ids = IDS_DSASECDISKEY;		break;
	case IDX_DSASECREVKEY : ids = IDS_DSASECREVKEY;		break;
	case IDX_DSASECEXPKEY : ids = IDS_DSASECEXPKEY;		break;
	case IDX_DSASECSHRKEY : ids = IDS_DSASECSHRKEY;		break;

	case IDX_RSAUSERID :	ids = IDS_RSAUSERID;		break;
	case IDX_DSAUSERID :	ids = IDS_DSAUSERID;		break;
	case IDX_PHOTOUSERID :	ids = IDS_PHOTOUSERID;		break;
	case IDX_INVALIDUSERID :ids = IDS_UNKNOWNFORMAT;	break;

	case IDX_CERT :		
		ids = IDS_CERT;	
		bSig = TRUE;
		break;

	case IDX_REVCERT :		
		ids = IDS_REVCERT;			
		bSig = TRUE;
		break;

	case IDX_EXPCERT :		
		ids = IDS_EXPCERT;			
		bSig = TRUE;
		break;

	case IDX_BADCERT :		
		ids = IDS_BADCERT;			
		bSig = TRUE;
		break;

	case IDX_EXPORTCERT :	
		ids = IDS_EXPORTCERT;		
		bSig = TRUE;
		break;

	case IDX_TRUSTEDCERT :		
		ids = IDS_EXPORTMETACERT;	
		bSig = TRUE;
		break;

	case IDX_METACERT:
		ids = IDS_METACERT;			
		bSig = TRUE;
		break;

	case IDX_X509CERT :
		ids = IDS_X509CERT;
		bSig = FALSE;
		break;

	case IDX_X509EXPCERT :
		ids = IDS_X509EXPCERT;
		bSig = FALSE;
		break;

	case IDX_X509REVCERT :
		ids = IDS_X509REVCERT;
		bSig = FALSE;
		break;

	default :				
		ids = IDS_UNKNOWNFORMAT;			
		break;
	}

	sz[0] = '\0';

	if (bSig) {
		switch (iVal) {
		case kPGPPublicKeyAlgorithm_RSA :
			LoadString (g_hInst, IDS_RSA, sz, iLen);
			break;

		case kPGPPublicKeyAlgorithm_DSA :
			LoadString (g_hInst, IDS_DSS, sz, iLen);
			break;

		default :
			LoadString (g_hInst, IDS_UNKNOWN, sz, iLen);
			break;
		}
		lstrcat (sz, " ");
	}

	LoadString (g_hInst, ids, szTemp, sizeof(szTemp));
	lstrcat (sz, szTemp);
}


//	_______________________________________________
//
//  Set list data for a key

static HTLITEM 
sSetKeyData (
		PKEYMAN		pKM, 
		HTLITEM		hItem, 
		PGPKeyRef	Key, 
		INT			idx) 
{ 
	TL_LISTITEM tlL;
	INT iField, iCol;
	Boolean bAxiomatic;

	CHAR szText [128];
	INT iValue;
	PGPTime time;
	UINT u;

	tlL.pszText = szText;
	tlL.hItem = hItem;
	tlL.stateMask = TLIS_VISIBLE;

	for (iCol=1; iCol<NUMBERFIELDS; iCol++) {
		iField = pKM->wColumnField[iCol];
		if (iField) {
			switch (iField) {
			case KMI_VALIDITY :
				PGPGetPrimaryUserIDValidity (Key, &iValue);
				iValue = KMConvertFromPGPValidity (iValue);
				PGPGetKeyBoolean (Key, kPGPKeyPropIsAxiomatic, &bAxiomatic);
				if (bAxiomatic) iValue = 
						KMConvertFromPGPValidity (kPGPValidity_Complete)+1;
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_DATAVALUE | TLIF_STATE;
				if (pKM->ulOptionFlags & KMF_NOVICEMODE) {
					if (iValue > KM_VALIDITY_COMPLETE)
						tlL.lDataValue = IDX_AXIOMATIC;
					else if (iValue >= pKM->iValidityThreshold) 
						tlL.lDataValue = IDX_VALID;
					else tlL.lDataValue = IDX_INVALID;
				}
				else tlL.lDataValue = iValue;
				break;

			case KMI_SIZE :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				KMGetKeyBitsString (pKM->KeySetDisp, 
										Key, szText, sizeof(szText));
				break;

			case KMI_DESCRIPTION :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				sFillDescription (idx, 0, szText, sizeof(szText));
				break;

			case KMI_KEYID :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				KMGetKeyIDFromKey (Key, szText, sizeof(szText));
				break;
				
			case KMI_TRUST :
				PGPGetKeyNumber (Key, kPGPKeyPropTrust, &iValue);
				iValue = KMConvertFromPGPTrust (iValue);
				PGPGetKeyBoolean (Key, kPGPKeyPropIsAxiomatic, &bAxiomatic);
				if (bAxiomatic) 
					iValue = KMConvertFromPGPTrust (kPGPKeyTrust_Ultimate)+1;
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_DATAVALUE | TLIF_STATE;
				tlL.lDataValue = iValue;
				break;

			case KMI_CREATION :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				PGPGetKeyTime (Key, kPGPKeyPropCreation, &time);
				KMConvertTimeToString (time, szText, sizeof(szText));
				break;
				
			case KMI_EXPIRATION :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				PGPGetKeyTime (Key, kPGPKeyPropExpiration, &time);
				if (time != kPGPExpirationTime_Never) 
					KMConvertTimeToString (time, szText, sizeof (szText));
				else 
					LoadString (g_hInst, IDS_NEVER, szText, sizeof (szText));
				break;
				
			case KMI_ADK :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_DATAVALUE | TLIF_STATE;
				PGPCountAdditionalRecipientRequests (Key, &u);
				if (u > 0) 
					tlL.lDataValue = IDX_ADK;
				else
					tlL.lDataValue = IDX_NOADK;
				break;
			}
			tlL.iSubItem = iCol;
			hItem = (HTLITEM) TreeList_SetListItem (pKM->hWndTree, 
													&tlL, FALSE);
		}
	}

	return (hItem);
}


//	_______________________________________________
//
//  Set treelist list data for a userID

static HTLITEM 
sSetIDData (
		PKEYMAN			pKM, 
		HTLITEM			hItem, 
		PGPUserIDRef	UserID, 
		INT				idx) 
{
	TL_LISTITEM tlL;
	CHAR szText [128];
	INT iField, iCol;
	INT iValue;

	tlL.pszText = szText;
	tlL.hItem = hItem;
	tlL.stateMask = TLIS_VISIBLE;

	for (iCol=1; iCol<NUMBERFIELDS; iCol++) {
		iField = pKM->wColumnField[iCol];
		if (iField) {
			switch (iField) {
			case KMI_VALIDITY :
				PGPGetUserIDNumber (UserID, kPGPUserIDPropValidity, &iValue);
				iValue = KMConvertFromPGPValidity (iValue);
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_DATAVALUE | TLIF_STATE;
				if (pKM->ulOptionFlags & KMF_NOVICEMODE) {
					if (iValue >= pKM->iValidityThreshold) 
						tlL.lDataValue = IDX_VALID;
					else tlL.lDataValue = IDX_INVALID;
				}
				else tlL.lDataValue = iValue;
				break;

			case KMI_SIZE :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;

			case KMI_DESCRIPTION :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				sFillDescription (idx, 0, szText, sizeof(szText));
				break;

			case KMI_KEYID :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;
				
			case KMI_TRUST :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;

			case KMI_CREATION :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;
				
			case KMI_EXPIRATION :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;
				
			case KMI_ADK :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;
			}
			tlL.iSubItem = iCol;
			hItem = (HTLITEM) TreeList_SetListItem (pKM->hWndTree, 
													&tlL, FALSE);
		}
	}
	return (hItem);
}


//	_______________________________________________
//
//  Set treelist list data for a certification

static HTLITEM 
sSetCertData (
			 PKEYMAN	pKM, 
			 HTLITEM	hItem, 
			 PGPSigRef	Cert, 
			 INT		idx) 
{
	TL_LISTITEM tlL;
	CHAR		szText [128];
	INT			iField, iCol;
	PGPTime		time;
	INT			iAlg;

	tlL.pszText = szText;
	tlL.hItem = hItem;
	tlL.stateMask = TLIS_VISIBLE;

	for (iCol=1; iCol<NUMBERFIELDS; iCol++) {
		iField = pKM->wColumnField[iCol];
		if (iField) {
			switch (iField) {
			case KMI_VALIDITY :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;

			case KMI_SIZE :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;

			case KMI_DESCRIPTION :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				PGPGetSigNumber (Cert, kPGPSigPropAlgID, &iAlg);
				sFillDescription (idx, iAlg, szText, sizeof(szText));
				break;

			case KMI_KEYID :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				KMGetKeyIDFromCert (Cert, szText, sizeof(szText));
				break;
				
			case KMI_TRUST :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;

			case KMI_CREATION :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				PGPGetSigTime (Cert, kPGPSigPropCreation, &time);
				KMConvertTimeToString (time, szText, sizeof(szText));
				break;
				
			case KMI_EXPIRATION :
				tlL.state = TLIS_VISIBLE;
				tlL.mask = TLIF_TEXT | TLIF_STATE;
				PGPGetSigTime (Cert, kPGPSigPropExpiration, &time);
				if (time != kPGPExpirationTime_Never) 
					KMConvertTimeToString (time, szText, sizeof (szText));
				else 
					LoadString (g_hInst, IDS_NEVER, szText, sizeof (szText));
				break;
				
			case KMI_ADK :
				tlL.state = 0;
				tlL.mask = TLIF_STATE;
				break;
			}
			tlL.iSubItem = iCol;
			hItem = (HTLITEM) TreeList_SetListItem (pKM->hWndTree, 
													&tlL, FALSE);
		}
	}
	return (hItem);
}


//	_______________________________________________
//
//  Reload a single key

static HTLITEM 
sReloadKey (
		PKEYMAN			pKM, 
		PGPKeyIterRef	KeyIter, 
		PGPKeyRef		Key, 
		BOOL			bReInsertExisting, 
		BOOL			bForceNewAlloc, 
		BOOL			bExpandNew, 
		BOOL			bFirstCall, 
		HTLITEM			hTPrev) 
{
	HTLITEM hTKey, hTUID, hTCert;
	TL_TREEITEM tli;
	INT idx;
	CHAR sz[kPGPMaxUserIDSize +1];
	CHAR sz2[64];
	CHAR szID[32];
	UINT uState;
	BOOL bItalics, bNew, bX509;
	PGPUserIDRef UserID;
	PGPSigRef Cert;
	PGPKeyRef CertKey;
	PGPSize size;
	PGPError err;
	static BOOL bNewKeyExpanded;

	uState = 0;
	bNew = FALSE;
	if (bFirstCall) bNewKeyExpanded = FALSE;

	KMGetKeyUserVal (pKM, Key, (long*)&hTKey);
	if (!hTKey) {
		bNew = TRUE;
	}

	// determine icon and italics
	idx = KMDetermineKeyIcon (pKM, Key, &bItalics);
	if (bItalics) uState |= TLIS_ITALICS;

	// get primary userid name string
	KMGetKeyName (Key, sz, sizeof(sz));

	// insert key item into tree and save pointer to tree item
	if (!hTKey && bExpandNew) uState |= TLIS_SELECTED;
	if (bForceNewAlloc) hTKey = NULL;
	hTKey = sSetOneItem (pKM, bReInsertExisting, hTKey, NULL, sz, hTPrev, 
						idx, uState, (LPARAM)Key);
	KMSetKeyUserVal (pKM, Key, (long)hTKey);

	// if a reinsertion, then we're done
	if (bReInsertExisting) 
		return hTKey;

	sSetKeyData (pKM, hTKey, Key, idx);

	// iterate through userids
	PGPKeyIterNextUserID (KeyIter, &UserID);
	while (UserID) {
		uState = 0;
		KMGetUserIDUserVal (pKM, UserID, (long*)&hTUID);
		if (!hTUID) bNew = TRUE;

		// get and set treelist tree data for this userid
		KMGetUserIDName (UserID, sz, sizeof(sz));
		if (bForceNewAlloc) hTUID = NULL;
		idx = KMDetermineUserIDIcon (Key, UserID, &bItalics);
		if (bItalics) uState |= TLIS_ITALICS;

		hTUID = sSetOneItem (pKM, FALSE, hTUID, hTKey, sz, 
							(HTLITEM)TLI_LAST, idx, uState, (LPARAM)UserID);
		KMSetUserIDUserVal (pKM, UserID, (long)hTUID);

		// get and set treelist list data for this userid
		sSetIDData (pKM, hTUID, UserID, idx);
		
		// iterate through certifications
		PGPKeyIterNextUIDSig (KeyIter, &Cert);
		while (Cert) {
			uState = 0;
			KMGetCertUserVal (pKM, Cert, (long*)&hTCert);
			if (!hTCert) bNew = TRUE;

			// get and set treelist tree data for this cert
			err = PGPGetSigCertifierKey (Cert, pKM->KeySetDisp, &CertKey);
			if (err == kPGPError_ItemNotFound) {
				err = kPGPError_NoErr;
				CertKey = NULL;
			}

			if (!CertKey && (pKM->KeySetDisp != pKM->KeySetMain)) {
				err = PGPGetSigCertifierKey (Cert, pKM->KeySetMain, &CertKey);
			}
			if (err == kPGPError_ItemNotFound) {
				err = kPGPError_NoErr;
				CertKey = NULL;
			}

			PGPclErrorBox (NULL, err);