access.c

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

		}

		switch((PGPikeHash) prefStruct->members[1].data)
		{
		case kPGPike_HA_MD5:
			strcat(szText, "MD5, ");
			break;

		case kPGPike_HA_SHA1:
			strcat(szText, "SHA, ");
			break;
		}

		switch((PGPikeCipher) prefStruct->members[2].data)
		{
		case kPGPike_SC_DES_CBC:
			strcat(szText, "DES56, ");
			break;

		case kPGPike_SC_3DES_CBC:
			strcat(szText, "TripleDES, ");
			break;

		case kPGPike_SC_CAST_CBC:
			strcat(szText, "CAST, ");
			break;
		}

		switch((PGPikeGroupID) prefStruct->members[3].data)
		{
		case kPGPike_GR_MODPTwo:
			strcat(szText, "1024");
			break;

		case kPGPike_GR_MODPFive:
			strcat(szText, "1536");
			break;
		}

		InsertItemInTree(IMAGE_ITEM, 0);
	}
	PGPFreePrefArray(prefArray);
	tvis.hParent = hParent;

	LoadItemString(IDS_IPSECPROPOSALS);
	PGPGetPrefArray(pConfig->prefRefNet, kPGPNetPrefIPSecProposalArray, 
		&prefArray);
	PGPGetPrefFlags(pConfig->prefRefNet, kPGPNetPrefIPSecProposalArray, 
		&nFlags);
	strcpy(szText, szFormat);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPNetPrefIPSecProposalArray);
	hParent = tvis.hParent;
	tvis.hParent = hItem;
	
	for (nIndex=0; nIndex<prefArray->numElements; nIndex++)
	{
		szText[0] = 0;
		PGPGetPrefArrayStruct(pConfig->prefRefNet, prefArray, nIndex,
			&prefStruct);

		switch ((PGPipsecAHTransformID) prefStruct->members[4].data)
		{
		case kPGPike_AH_None:
			strcat(szText, "None, ");
			break;

		case kPGPike_AH_MD5:
			strcat(szText, "MD5, ");
			break;

		case kPGPike_AH_SHA:
			strcat(szText, "SHA, ");
			break;
		}

		switch((PGPipsecESPTransformID) prefStruct->members[1].data)
		{
		case kPGPike_ET_NULL:
			strcat(szText, "None, ");
			break;

		case kPGPike_ET_DES:
			strcat(szText, "DES56, ");
			break;

		case kPGPike_ET_3DES:
			strcat(szText, "TripleDES, ");
			break;

		case kPGPike_ET_CAST:
			strcat(szText, "CAST, ");
			break;
		}

		switch((PGPipsecAuthAttribute) prefStruct->members[2].data)
		{
		case kPGPike_AA_HMAC_MD5:
			strcat(szText, "MD5, ");
			break;

		case kPGPike_AA_HMAC_SHA:
			strcat(szText, "SHA, ");
			break;

		}

		switch((PGPipsecIPCOMPTransformID) prefStruct->members[7].data)
		{
		case kPGPike_IC_None:
			strcat(szText, "None");
			break;

		case kPGPike_IC_Deflate:
			strcat(szText, "Deflate");
			break;

		case kPGPike_IC_LZS:
			strcat(szText, "LZS");
			break;
		}

		InsertItemInTree(IMAGE_ITEM, 0);
	}
	PGPFreePrefArray(prefArray);
	tvis.hParent = hParent;

	LoadItemString(IDS_PFSPROPOSAL);
	PGPGetPrefNumber(pConfig->prefRefNet, kPGPnetPrefIPSECGroupID, &nValue);
	PGPGetPrefFlags(pConfig->prefRefNet, kPGPnetPrefIPSECGroupID, &nFlags);
	switch (nValue)
	{
	case kPGPike_GR_None:
		strcpy(szValue, "0");
		break;

	case kPGPike_GR_MODPTwo:
		strcpy(szValue, "1024");
		break;

	case kPGPike_GR_MODPFive:
		strcpy(szValue, "1536");
		break;
	}
	wsprintf(szText, szFormat, szValue);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPnetPrefIPSECGroupID);
	
	UpdateCatagory();
	}
	return;
}


static void sAddHotkeySequence(PGPUInt32 nHotKey, PGPBoolean *pbValue, 
							   char *szValue)
{
	unsigned char uChar = nHotKey & 0xff;
	char szChar[5];

	if (nHotKey & kPGPHotKeyEnabled)
		*pbValue = TRUE;
	else
		*pbValue = FALSE;

	if (nHotKey & kPGPHotKeyCtrlModifier)
		strcat(szValue, "Ctrl + ");
	if (nHotKey & kPGPHotKeyAltModifier)
		strcat(szValue, "Alt + ");
	if (nHotKey & kPGPHotKeyShiftModifier)
		strcat(szValue, "Shift + ");

	if ((uChar >= VK_F1) && (uChar <= VK_F12))
		wsprintf(szChar, "F%d", uChar - VK_F1 + 1);
	else
		wsprintf(szChar, " %c", uChar);

	strcat(szValue, szChar);

	return;
}


static void	sGetKeyUserID(PGPKeyDBRef keyDB, PGPByte *pData,
						  char *szValue, PGPSize nSize)
{
	PGPKeyID keyID;
	PGPKeyDBObjRef key;

	memcpy(keyID.opaqueBytes, pData, sizeof(keyID.opaqueBytes));
	PGPFindKeyByKeyID(keyDB, &keyID, &key);
	PGPclGetPrimaryUserIDName(key, szValue, nSize, &nSize);
	return;
}


static void sInitGUI(HWND hwndDlg, pgpConfigInfo *pConfig)
{
	if (pConfig->bCopyClientPrefs)
		CheckDlgButton(hwndDlg, IDC_INCLUDEOPTIONS, BST_CHECKED);
	else
		CheckDlgButton(hwndDlg, IDC_INCLUDEOPTIONS, BST_UNCHECKED);

	EnableWindow(GetDlgItem(hwndDlg, IDC_SETOPTIONS), pConfig->bCopyClientPrefs);
	EnableWindow(GetDlgItem(hwndDlg, IDC_IMPORTOPTIONS), pConfig->bCopyClientPrefs);
	EnableWindow(GetDlgItem(hwndDlg, IDC_OPTIONSLABEL), 
		pConfig->bCopyClientPrefs);
	EnableWindow(GetDlgItem(hwndDlg, IDC_OPTIONS), pConfig->bCopyClientPrefs);

	if (!(pConfig->bActiveX))
	{
		RECT rcOrig;
		RECT rcList;
		POINT *pOrig = (POINT *) &rcOrig;
		POINT *pList = (POINT *) &rcList;
		LONG lOffset;

		GetWindowRect(GetDlgItem(hwndDlg, IDC_OPTIONSLABEL), &rcOrig);
		GetWindowRect(GetDlgItem(hwndDlg, IDC_OPTIONS), &rcList);
		ScreenToClient(hwndDlg, pOrig);
		ScreenToClient(hwndDlg, pList);
		lOffset = pList->y - pOrig->y;
		GetWindowRect(GetDlgItem(hwndDlg, IDC_OPTIONSPLACE), &rcList);
		ScreenToClient(hwndDlg, pList);
		ShowWindow(GetDlgItem(hwndDlg, IDC_SETOPTIONS), SW_HIDE);
		EnableWindow(GetDlgItem(hwndDlg, IDC_SETOPTIONS), FALSE);
		ShowWindow(GetDlgItem(hwndDlg, IDC_IMPORTOPTIONS), SW_HIDE);
		EnableWindow(GetDlgItem(hwndDlg, IDC_IMPORTOPTIONS), FALSE);
		SetWindowPos(GetDlgItem(hwndDlg, IDC_OPTIONSLABEL), 0, pList->x,
			pList->y, 0, 0, 
			SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_SHOWWINDOW);
		SetWindowPos(GetDlgItem(hwndDlg, IDC_OPTIONS), 0, pList->x,
			pList->y + lOffset, 0, 0, 
			SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_SHOWWINDOW);
	}

	return;
}


static void sSetPrefFlag(pgpConfigInfo *pConfig, PGPUInt32 parentIndex, 
						 PGPUInt32 prefIndex, PGPUInt32 flag)
{
	if (parentIndex == 0)
	{
		if (flag)
			PGPSetPrefFlags(pConfig->prefRef, prefIndex, LOCK_PREF_FLAGS);
		else
			PGPClearPrefFlags(pConfig->prefRef, prefIndex, LOCK_PREF_FLAGS);

		switch (prefIndex)
		{
		case kPGPPrefCacheType:
			prefIndex = kPGPPrefCacheSeconds;
			break;

		case kPGPPrefWordWrapEnable:
			prefIndex = kPGPPrefWordWrapWidth;
			break;

		case kPGPPrefDiskUnmountOnInactivity:
			prefIndex = kPGPPrefDiskAutoUnmountTimeout;
			break;

		case kPGPPrefAutoBackupKeyring:
			if (flag)
			{
				PGPSetPrefFlags(pConfig->prefRef, 
					kPGPPrefAutoBackupToKeyringFolder, LOCK_PREF_FLAGS);
				PGPSetPrefFlags(pConfig->prefRef, 
					kPGPPrefAutoBackupFolder, LOCK_PREF_FLAGS);
			}
			else
			{
				PGPClearPrefFlags(pConfig->prefRef, 
					kPGPPrefAutoBackupToKeyringFolder, LOCK_PREF_FLAGS);
				PGPClearPrefFlags(pConfig->prefRef, 
					kPGPPrefAutoBackupFolder, LOCK_PREF_FLAGS);
			}
			break;

		default:
			return;
		}

		if (flag)
			PGPSetPrefFlags(pConfig->prefRef, prefIndex, LOCK_PREF_FLAGS);
		else
			PGPClearPrefFlags(pConfig->prefRef, prefIndex, LOCK_PREF_FLAGS);
	}
	else
	{
		if (flag)
			PGPSetPrefFlags(pConfig->prefRefNet, prefIndex, LOCK_PREF_FLAGS);
		else
			PGPClearPrefFlags(pConfig->prefRefNet, prefIndex, LOCK_PREF_FLAGS);

		switch (prefIndex)
		{
		case kPGPNetPrefHostArray:
			if (flag)
				pConfig->bCopyNetHosts = TRUE;
			break;

		case kPGPNetPrefEnableIKETimeExpiration:
			prefIndex = kPGPNetPrefIKETimeExpiration;
			break;

		case kPGPNetPrefEnableIKEKByteExpiration:
			prefIndex = kPGPNetPrefIKEKByteExpiration;
			break;

		case kPGPNetPrefEnableIPSECTimeExpiration:
			prefIndex = kPGPNetPrefIPSECTimeExpiration;
			break;

		case kPGPNetPrefEnableIPSECKByteExpiration:
			prefIndex = kPGPNetPrefIPSECKByteExpiration;
			break;

		case kPGPNetPrefAllowCipherNone:
			if (flag)
			{
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowCipherCAST, LOCK_PREF_FLAGS);
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowCipher3DES, LOCK_PREF_FLAGS);
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowCipherDES56, LOCK_PREF_FLAGS);
			}
			else
			{
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowCipherCAST, LOCK_PREF_FLAGS);
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowCipher3DES, LOCK_PREF_FLAGS);
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowCipherDES56, LOCK_PREF_FLAGS);
			}
			return;

		case kPGPNetPrefAllowHashNone:
			if (flag)
			{
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowHashSHA1, LOCK_PREF_FLAGS);
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowHashMD5, LOCK_PREF_FLAGS);
			}
			else
			{
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowHashSHA1, LOCK_PREF_FLAGS);
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowHashMD5, LOCK_PREF_FLAGS);
			}
			return;

		case kPGPNetPrefAllowDH768:
			if (flag)
			{
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowDH1024, LOCK_PREF_FLAGS);
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowDH1536, LOCK_PREF_FLAGS);
			}
			else
			{
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowDH1024, LOCK_PREF_FLAGS);
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAllowDH1536, LOCK_PREF_FLAGS);
			}
			return;

		case kPGPNetPrefAllowCompLZS:
			prefIndex = kPGPNetPrefAllowCompDeflate;
			break;

		case kPGPnetPrefFirewallRuleSet:
			if (flag)
			{
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefFirewallRuleArray, LOCK_PREF_FLAGS);
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefUseLearnMode, LOCK_PREF_FLAGS);
				PGPSetPrefBoolean(pConfig->prefRefNet, 
					kPGPNetPrefUseLearnMode, FALSE);
			}
			else
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefFirewallRuleArray, LOCK_PREF_FLAGS);
			return;

		case kPGPNetPrefUseLearnMode:
			if (!flag)
			{
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPnetPrefFirewallRuleSet, LOCK_PREF_FLAGS);
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefFirewallRuleArray, LOCK_PREF_FLAGS);
			}
			return;

		case kPGPNetPrefAutoBlockAttacks:
			if (flag)
			{
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefBlockUntilRemoved, LOCK_PREF_FLAGS);
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPnetPrefBlockMinutes, LOCK_PREF_FLAGS);
			}
			else
			{
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefBlockUntilRemoved, LOCK_PREF_FLAGS);
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPnetPrefBlockMinutes, LOCK_PREF_FLAGS);
			}
			break;

		case kPGPNetPrefAttackEmailNotify:
			if (flag)
				PGPSetPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAttackNotifyEmail, LOCK_PREF_FLAGS);
			else
				PGPClearPrefFlags(pConfig->prefRefNet, 
					kPGPNetPrefAttackNotifyEmail, LOCK_PREF_FLAGS);
			break;

		default:
			return;
		}

		if (flag)
			PGPSetPrefFlags(pConfig->prefRefNet, prefIndex, LOCK_PREF_FLAGS);
		else
			PG