access.c

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

	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefAutoBackupToKeyringFolder, 
		&bValue);
	if (bValue)
		LoadString(g_hInstance, IDS_KEYRINGFOLDER, szValue, sizeof(szValue));
	else
		PGPGetPrefStringBuffer(pConfig->prefRef, kPGPPrefAutoBackupFolder, 
			sizeof(szValue), szValue);
		
	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefAutoBackupKeyring, 
		&bValue);
	if (!bValue)
		strcpy(szValue, "");
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefAutoBackupKeyring, &nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse, szValue);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefAutoBackupKeyring);

	LoadItemString(IDS_SMARTCARD);
	PGPGetPrefStringBuffer(pConfig->prefRef, kPGPPrefPKCS11DrvFile, 
	    sizeof(szValue), szValue);
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefPKCS11DrvFile, &nFlags);
	nValue = strlen(szValue);
	LoadString(g_hInstance, IDS_CUSTOM, szTemp, sizeof(szTemp));
	if (nValue == 0)
		LoadString(g_hInstance, IDS_NONE, szTemp, sizeof(szTemp));
	if (nValue >= 9)
	{
		if (!stricmp(&(szValue[nValue-9]), "SLBck.dll"))
			LoadString(g_hInstance, IDS_SCHLUMBERGER, szTemp, sizeof(szTemp));
	}
	if (nValue >= 11)
	{
		if (!stricmp(&(szValue[nValue-11]), "PK2priv.dll"))
			LoadString(g_hInstance, IDS_GEMPLUS, szTemp, sizeof(szTemp));
		if (!stricmp(&(szValue[nValue-11]), "DKck232.dll"))
			LoadString(g_hInstance, IDS_RAINBOW, szTemp, sizeof(szTemp));
	}
	if (nValue >= 12)
	{
		if (!stricmp(&(szValue[nValue-12]), "eTpkcs11.dll"))
			LoadString(g_hInstance, IDS_ALADDIN, szTemp, sizeof(szTemp));
	}
	wsprintf(szText, szFormat, szTemp);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefPKCS11DrvFile);

	UpdateCatagory();
	}

	if (PGPclIsComponentInstalled(kPGPclPGPdisk)) {

	tvis.hParent = NULL;
	LoadString(g_hInstance, IDS_PGPDISK, szText, sizeof(szText));
	InsertItemInTree(IMAGE_UNCHECK, 0);
	tvis.hParent = hItem;

	LoadItemString(IDS_ALLOWFORCEUNMOUNT);
	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefDiskAllowForcibleUnmounts, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefDiskAllowForcibleUnmounts, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefDiskAllowForcibleUnmounts);

	LoadItemString(IDS_ASKUNMOUNT);
	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefDiskAlwaysForceUnmounts, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefDiskAlwaysForceUnmounts, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefDiskAlwaysForceUnmounts);

	LoadItemString(IDS_AUTOUNMOUNT);
	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefDiskUnmountOnInactivity, 
		&bValue);
	PGPGetPrefNumber(pConfig->prefRef, kPGPPrefDiskAutoUnmountTimeout, 
		&nValue);
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefDiskUnmountOnInactivity, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse, nValue);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefDiskUnmountOnInactivity);

	LoadItemString(IDS_SLEEPUNMOUNT);
	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefDiskAutoUnmountOnSleep, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefDiskAutoUnmountOnSleep, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefDiskAutoUnmountOnSleep);

	LoadItemString(IDS_PREVENTSLEEP);
	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefDiskNoSleepIfFailAU, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefDiskNoSleepIfFailAU, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefDiskNoSleepIfFailAU);

/*	LoadItemString(IDS_VIEWCONTENTS);
	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefDiskBrowseAfterMount, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefDiskBrowseAfterMount, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefDiskBrowseAfterMount);*/

	LoadItemString(IDS_WARNDELETE);
	PGPGetPrefBoolean(pConfig->prefRef, kPGPPrefDiskWarnOnDeletion, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRef, kPGPPrefDiskWarnOnDeletion, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPPrefDiskWarnOnDeletion);

	UpdateCatagory();
	}

	if (PGPclIsComponentInstalled (kPGPclPFIDS)) {

	tvis.hParent = NULL;
	LoadString(g_hInstance, IDS_NETFIREWALL, szText, sizeof(szText));
	InsertItemInTree(IMAGE_UNCHECK, 1);
	tvis.hParent = hItem;

	LoadItemString(IDS_PGPNET);
	PGPGetPrefBoolean(pConfig->prefRefNet, kPGPNetPrefEnablePGPnet, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRefNet, kPGPNetPrefEnablePGPnet, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPNetPrefEnablePGPnet);

	LoadItemString(IDS_PGPFIRE);
	PGPGetPrefBoolean(pConfig->prefRefNet, kPGPNetPrefEnableFirewall, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRefNet, kPGPNetPrefEnableFirewall, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPNetPrefEnableFirewall);

	LoadItemString(IDS_LEARNMODE);
	PGPGetPrefBoolean(pConfig->prefRefNet, kPGPNetPrefUseLearnMode, 
		&bValue);
	PGPGetPrefFlags(pConfig->prefRefNet, kPGPNetPrefUseLearnMode, 
		&nFlags);
	wsprintf(szText, szFormat, bValue ? szTrue : szFalse);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPNetPrefUseLearnMode);

	LoadItemString(IDS_PROTECTIONLEVEL);
	PGPGetPrefFlags(pConfig->prefRefNet, kPGPnetPrefFirewallRuleSet, &nFlags);
	PGPGetPrefNumber(pConfig->prefRefNet, kPGPnetPrefFirewallRuleSet, &nValue);
	
	switch (nValue)
	{
	case kPGPNetFirewallRuleSet_Custom:
		LoadString(g_hInstance, IDS_FIREWALLCUSTOM, szValue, sizeof(szValue));
		break;
		
	case kPGPNetFirewallRuleSet_Minimal:
		LoadString(g_hInstance, IDS_FIREWALLMINIMAL, szValue, sizeof(szValue));
		break;
		
	case kPGPNetFirewallRuleSet_ClientMedium:
		LoadString(g_hInstance, IDS_CLIENTMEDIUM, szValue, sizeof(szValue));
		break;
		
	case kPGPNetFirewallRuleSet_ClientHigh:
		LoadString(g_hInstance, IDS_CLIENTHIGH, szValue, sizeof(szValue));
		break;
		
	case kPGPNetFirewallRuleSet_ServerMedium:
		LoadString(g_hInstance, IDS_SERVERMEDIUM, szValue, sizeof(szValue));
		break;
		
	case kPGPNetFirewallRuleSet_ServerHigh:
		LoadString(g_hInstance, IDS_SERVERHIGH, szValue, sizeof(szValue));
		break;
		
	case kPGPNetFirewallRuleSet_LearnStarter:
		LoadString(g_hInstance, IDS_LEARNSTARTER, szValue, sizeof(szValue));
		break;
	}

	wsprintf(szText, szFormat, szValue);
	InsertItemInTree(PREFFLAGS_DISABLEGUI, kPGPnetPrefFirewallRuleSet);
	hParent = tvis.hParent;
	tvis.hParent = hItem;

	PGPGetNetFirewallRuleSet(pConfig->prefRefNet, &pRule, &nNumRules);
	for (nIndex=0; nIndex<nNumRules; nIndex++)
	{
		if (strlen(pRule[nIndex].description) > 0)
		{
			strcpy(szText, pRule[nIndex].description);
			InsertItemInTree(IMAGE_ITEM, 0);
			continue;
		}

		if (pRule[nIndex].active)
			LoadItemString(IDS_ACTIVE);
		else
			LoadItemString(IDS_INACTIVE);

		strcpy(szText, szFormat);

		if (!strlen(pRule[nIndex].appPath))
			LoadItemString(IDS_ANYAPPLICATION);
		else
		{
			char *szPtr;

			szPtr = sGetFileDescription(pConfig->memoryMgr, 
						pRule[nIndex].appPath);

			strcpy(szFormat, szPtr);
			PGPFreeData(szPtr);
		}

		strcat(szText, ", ");
		strcat(szText, szFormat);

		if (pRule[nIndex].permit)
			LoadItemString(IDS_PERMIT);
		else
			LoadItemString(IDS_DENY);

		strcat(szText, ", ");
		strcat(szText, szFormat);

		if (pRule[nIndex].matchIntrusion)
		{
			LoadItemString(IDS_ISINTRUSION);
			strcat(szText, ", ");
			strcat(szText, szFormat);
		}

		switch (pRule[nIndex].direction)
		{
		case 0:
			LoadItemString(IDS_BOTHDIRECTIONS);
			break;

		case 1:
			LoadItemString(IDS_INBOUND);
			break;

		case 2:
			LoadItemString(IDS_OUTBOUND);
			break;
		}

		strcat(szText, ", ");
		strcat(szText, szFormat);
		strcat(szText, ", ");

		switch (pRule[nIndex].ipProtocol)
		{
		case kPGPnetIPProtocol_ICMP:
			strcat(szText, "ICMP");
			break;

		case kPGPnetIPProtocol_IGMP:
			strcat(szText, "IGMP");
			break;

		case kPGPnetIPProtocol_TCP:
			strcat(szText, "TCP");
			break;

		case kPGPnetIPProtocol_UDP:
			strcat(szText, "UDP");
			break;

		case kPGPnetIPProtocol_ESP:
			strcat(szText, "ESP");
			break;

		case kPGPnetIPProtocol_AH:
			strcat(szText, "AH");
			break;
		}

		strcat(szText, ", ");

		switch (pRule[nIndex].remoteAddrType)
		{
		case kPGPnetAddrType_Host:
			nValue = pRule[nIndex].remoteIPAddrStart;
			
			wsprintf(szFormat, "%d.%d.%d.%d", nValue & 0xff,
				(nValue >> 8) & 0xff, (nValue >> 16) & 0xff,
				(nValue >> 24) & 0xff);
			break;

		case kPGPnetAddrType_Subnet:
			nValue =	pRule[nIndex].remoteIPAddrStart &
						pRule[nIndex].remoteIPMaskEnd;

			wsprintf(szFormat, "%d.%d.%d.%d", nValue & 0xff,
				(nValue >> 8) & 0xff, (nValue >> 16) & 0xff,
				(nValue >> 24) & 0xff);
			strcat(szText, szFormat);

			nValue = 0;
			while (pRule[nIndex].remoteIPMaskEnd & 0x1)
			{
				nValue++;
				pRule[nIndex].remoteIPMaskEnd >>= 1;
			}
			wsprintf(szFormat, "/%d", nValue);
			break;

		case kPGPnetAddrType_LocalSubnet:
			LoadItemString(IDS_LOCALSUBNET);
			break;

		case kPGPnetAddrType_Range:
			nValue = pRule[nIndex].remoteIPAddrStart;
			
			wsprintf(szFormat, "%d.%d.%d.%d", nValue & 0xff,
				(nValue >> 8) & 0xff, (nValue >> 16) & 0xff,
				(nValue >> 24) & 0xff);

			nValue = pRule[nIndex].remoteIPMaskEnd;
			
			wsprintf(szFormat, " - %d.%d.%d.%d", nValue & 0xff,
				(nValue >> 8) & 0xff, (nValue >> 16) & 0xff,
				(nValue >> 24) & 0xff);
			break;

		case kPGPnetAddrType_Any:
			LoadItemString(IDS_ANYADDRESS);
			break;
		}

		strcat(szText, szFormat);
		strcat(szText, ", ");
		LoadItemString(IDS_REMOTETYPES);
		strcat(szText, szFormat);

		switch (pRule[nIndex].remoteServiceType)
		{
		case kPGPnetIPServiceType_Single:
		case kPGPnetIPServiceType_Range:
		case kPGPnetIPServiceType_List:
			for (nPort=0; nPort<pRule[nIndex].numRemoteServices; nPort++)
			{
				switch (pRule[nIndex].ipProtocol)
				{
				case kPGPnetIPProtocol_ICMP:
					PGPGetICMPTypeString(pRule[nIndex].remoteService[nPort],
						sizeof(szFormat), szFormat);
					break;

				case kPGPnetIPProtocol_IGMP:
				case kPGPnetIPProtocol_ESP:
				case kPGPnetIPProtocol_AH:
					szFormat[0] = 0;
					break;

				case kPGPnetIPProtocol_TCP:
				case kPGPnetIPProtocol_UDP:
					PGPGetTCPServiceString(pRule[nIndex].remoteService[nPort],
						sizeof(szFormat), szFormat);
					break;
				}

				if (pRule[nIndex].remoteServiceType == 
					kPGPnetIPServiceType_Range)
				{
					if (nPort == 0)
						strcat(szText, " ");

					wsprintf(szFormat, "%d", 
						pRule[nIndex].remoteService[nPort]);

					strcat(szText, szFormat);

					if (nPort == 0)
						strcat(szText, "-");
				}
				else
				{
					strcat(szText, " ");
					strcat(szText, szFormat);
				}
			}
			break;

		case kPGPnetIPServiceType_Any:
			strcat(szText, " ");
			LoadItemString(IDS_ANYTYPE);
			strcat(szText, szFormat);
			break;
		}

		strcat(szText, ", ");
		LoadItemString(IDS_LOCALTYPES);
		strcat(szText, szFormat);

		switch (pRule[nIndex].localServiceType)
		{
		case kPGPnetIPServiceType_Single:
		case kPGPnetIPServiceType_Range:
		case kPGPnetIPServiceType_List:
			for (nPort=0; nPort<pRule[nIndex].numLocalServices; nPort++)
			{
				switch (pRule[nIndex].ipProtocol)
				{
				case kPGPnetIPProtocol_ICMP:
					PGPGetICMPTypeString(pRule[nIndex].localService[nPort],
						sizeof(szFormat), szFormat);
					break;

				case kPGPnetIPProtocol_IGMP:
				case kPGPnetIPProtocol_ESP:
				case kPGPnetIPProtocol_AH:
					szFormat[0] = 0;
					break;

				case kPGPnetIPProtocol_TCP:
				case kPGPnetIPProtocol_UDP:
					PGPGetTCPServiceString(pRule[nIndex].localService[nPort],
						sizeof(szFormat), szFormat);
					break;
				}

				if (pRule[nIndex].localServiceType == 
					kPGPnetIPServiceType_Range)
				{
					if (nPort == 0)
						strcat(szText, " ");

					wsprintf(szFormat, "%d", 
						pRule[nIndex].localService[nPort]);

					strcat(szText, szFormat);

					if (nPort == 0)
						strcat(szText, "-");
				}
				else