clkspref.c

vc环境下的pgp源码

	// count number of servers
	iServerCount = 0;
	hTServer = TreeList_GetFirstItem (pkssThis->hWndTree);
	while (hTServer) {
		++iServerCount;
		tlI.hItem = hTServer;
		tlI.mask = TLIF_NEXTHANDLE;
		TreeList_GetItem (pkssThis->hWndTree, &tlI);
		hTServer = tlI.hItem;
	}

	hTServer = TreeList_GetFirstItem (pkssThis->hWndTree);
	while (hTServer) {
		// get server structure
		tlI.hItem = hTServer;
		tlI.mask = TLIF_PARAM | TLIF_NEXTHANDLE;
		TreeList_GetItem (pkssThis->hWndTree, &tlI);

		pkss = (PKEYSERVERSTRUCT)(tlI.lParam);

		if (pkss != (PKEYSERVERSTRUCT)pkssThis->pOrigStruct) {
			if (!lstrcmpi (pkss->szServer, pkssThis->szServer)) {
				if (pkss->iType == pkssThis->iType) {
					if (pkss->iPort == pkssThis->iPort) {
						return TRUE;
					}
				}
			}
		}

		// step to next server
		hTServer = tlI.hItem;
	}

	return FALSE;
}

//	_____________________________________________________
//
//  find out if there are any domain-less servers among those
//  which are not selected.

static BOOL
sIsThisTheOnlyWorldServer (HWND hWndTree)
{
	HTLITEM				hTServer;
	TL_TREEITEM			tlI;
	PKEYSERVERSTRUCT	pkss;

	// is the selected server a "world" server?
	tlI.hItem = hTSelected;
	tlI.mask = TLIF_PARAM;
	TreeList_GetItem (hWndTree, &tlI);
	pkss = (PKEYSERVERSTRUCT)tlI.lParam;

	// if server has a domain, then it's not a "world" server.
	if (pkss->szDomain[0]) 
		return FALSE;

	// interate through tree
	hTServer = TreeList_GetFirstItem (hWndTree);
	while (hTServer) {

		if (hTServer != hTSelected) {
			// get keyserver structure
			tlI.hItem = hTServer;
			tlI.mask = TLIF_PARAM;
			TreeList_GetItem (hWndTree, &tlI);

			pkss = (PKEYSERVERSTRUCT)tlI.lParam;

			// if this server doesn't have a domain, then the
			// selected server isn't the last "world" server
			if (pkss->szDomain[0] == 0)
				return FALSE;
		}

		// get next server
		tlI.hItem = hTServer;
		tlI.mask = TLIF_NEXTHANDLE;
		TreeList_GetItem (hWndTree, &tlI);

		hTServer = tlI.hItem;
	}
	
	// didn't find any other "world" servers
	return TRUE;
}

//	___________________________________________
//
//  New/Edit Keyserver Dialog Message procedure

static BOOL CALLBACK 
sEditServerDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	PKEYSERVERSTRUCT	pkss;
	CHAR				sz[256];
	LPSTR				p;
	INT					i, iSelected;

	switch (uMsg) {

	case WM_INITDIALOG :
		SetWindowLong (hDlg, GWL_USERDATA, lParam);
		pkss = (PKEYSERVERSTRUCT)lParam;
		if (pkss->bEdit) {
			LoadString (g_hInst, IDS_EDITSERVERTITLE, sz, sizeof(sz));
			SetWindowText (hDlg, sz);
		}

		// load protocol combo box
		LoadString (g_hInst, IDS_LDAP, sz, sizeof(sz));
		i = SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_ADDSTRING, 
								0, (LPARAM)sz);
		SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 
								i, (LPARAM)kPGPKeyServerType_LDAP);
		if (pkss->iType == kPGPKeyServerType_LDAP) iSelected = i;
		
		LoadString (g_hInst, IDS_LDAPS, sz, sizeof(sz));
		i = SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_ADDSTRING, 
								0, (LPARAM)sz);
		SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 
								i, (LPARAM)kPGPKeyServerType_LDAPS);
		if (pkss->iType == kPGPKeyServerType_LDAPS) iSelected = i;
		
		LoadString (g_hInst, IDS_HTTP, sz, sizeof(sz));
		i = SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_ADDSTRING, 
								0, (LPARAM)sz);
		SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 
								i, (LPARAM)kPGPKeyServerType_HTTP);
		if (pkss->iType == kPGPKeyServerType_HTTP) iSelected = i;

		// initialize protocol combo box
		SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_SETCURSEL, iSelected, 0);

		// initialize server name
		SetDlgItemText (hDlg, IDC_SERVERNAME, pkss->szServer);

		// initialize port number
		if (pkss->iPort != 0)
			SetDlgItemInt (hDlg, IDC_PORT, pkss->iPort, FALSE);


		// initialize authentication key name
		SetDlgItemText (hDlg, IDC_SERVERKEY, pkss->szUserIDAuth);

		// initialize domain buttons
		if (pkss->szDomain[0]) {
			CheckRadioButton (hDlg, IDC_ANYDOMAIN, IDC_SPECIFIEDDOMAIN,
								IDC_SPECIFIEDDOMAIN);
			SetDlgItemText (hDlg, IDC_DOMAIN, pkss->szDomain);
		}
		else {
			CheckRadioButton (hDlg, IDC_ANYDOMAIN, IDC_SPECIFIEDDOMAIN,
								IDC_ANYDOMAIN);
			SetDlgItemText (hDlg, IDC_DOMAIN, "");
			EnableWindow (GetDlgItem (hDlg, IDC_DOMAIN), FALSE);
		}

		// initialize checkboxes
		if (pkss->bListed) 
			CheckDlgButton (hDlg, IDC_LISTED, BST_CHECKED);
		else
			CheckDlgButton (hDlg, IDC_LISTED, BST_UNCHECKED);
			
		SetFocus (GetDlgItem (hDlg, IDC_SERVERNAME));
		return TRUE;

	case WM_HELP: 
	    WinHelp (((LPHELPINFO) lParam)->hItemHandle, g_szHelpFile, 
	        HELP_WM_HELP, (DWORD) (LPSTR) aIds); 
	    break; 

	case WM_CONTEXTMENU: 
		WinHelp ((HWND) wParam, g_szHelpFile, HELP_CONTEXTMENU, 
		    (DWORD) (LPVOID) aIds); 
		break; 

	case WM_COMMAND :
		switch(LOWORD (wParam)) {

		case IDC_ANYDOMAIN :
			EnableWindow (GetDlgItem (hDlg, IDC_DOMAIN), FALSE);
			break;

		case IDC_SPECIFIEDDOMAIN :
			pkss = (PKEYSERVERSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			if ((pkss->bEdit) &&
				(sIsThisTheOnlyWorldServer (pkss->hWndTree))) 
			{
				PGPclMessageBox (hDlg, IDS_PROPCAPTION, 
					IDS_MUSTHAVEDEFAULTSERVER, MB_OK|MB_ICONEXCLAMATION);
				CheckRadioButton (hDlg, IDC_ANYDOMAIN, IDC_SPECIFIEDDOMAIN,
									IDC_ANYDOMAIN);
			}
			else 
				EnableWindow (GetDlgItem (hDlg, IDC_DOMAIN), TRUE);
			break;

		case IDOK :
			pkss = (PKEYSERVERSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
				
			// get protocol
			iSelected = 
				SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_GETCURSEL, 0, 0);
			pkss->iType = 
				SendDlgItemMessage (hDlg, IDC_PROTOCOL, CB_GETITEMDATA, 
										iSelected, 0);

			// get server name
			if (!GetDlgItemText (hDlg, IDC_SERVERNAME, sz, sizeof (sz))) {
				PGPclMessageBox (hDlg, IDS_PROPCAPTION, IDS_NOSERVERNAME,
					MB_OK|MB_ICONEXCLAMATION);
				SetFocus (GetDlgItem (hDlg, IDC_SERVERNAME));
				return TRUE;
			}
			else {
				// make sure user didn't type in prefix
				p = strstr (sz, "//");
				if (!p) p = strstr (sz, "\\\\");
				if (p) p += 2;
				else p = &sz[0];
				lstrcpy (pkss->szServer, p);
			}

			// get port number
			pkss->iPort = GetDlgItemInt (hDlg, IDC_PORT, NULL, FALSE);

			// get domain name
			if (IsDlgButtonChecked (hDlg, IDC_SPECIFIEDDOMAIN)) {
				GetDlgItemText (hDlg, IDC_DOMAIN, pkss->szDomain, 
									sizeof (pkss->szDomain));
			}
			else 
				pkss->szDomain[0] = '\0';

			// get checkbox states			
			if (IsDlgButtonChecked (hDlg, IDC_LISTED) == BST_CHECKED) 
				pkss->bListed = TRUE;
			else 
				pkss->bListed = FALSE;

			if (sIsThisServerAlreadyInList (pkss)) {
				PGPclMessageBox (hDlg, IDS_PROPCAPTION, IDS_DUPLICATESERVER,
					MB_OK|MB_ICONEXCLAMATION);
				SetFocus (GetDlgItem (hDlg, IDC_SERVERNAME));
				return TRUE;
			}

			EndDialog (hDlg, 1);
			break;

		case IDCANCEL:
			EndDialog (hDlg, 0);
			break;
		}
		return TRUE;
	}
	return FALSE;
}

//	_____________________________________________________
//
//  set all text to non-bold

static VOID
sRemoveAllRoots (HWND hWndTree) 
{
	HTLITEM				hTServer;
	TL_TREEITEM			tlI;
	PKEYSERVERSTRUCT	pkss;

	// interate through tree
	hTServer = TreeList_GetFirstItem (hWndTree);
	while (hTServer) {
		// get current state
		tlI.hItem = hTServer;
		tlI.mask = TLIF_STATE | TLIF_PARAM;
		TreeList_GetItem (hWndTree, &tlI);

		// make non-root
		pkss = (PKEYSERVERSTRUCT)tlI.lParam;
		pkss->bRoot = FALSE;

		// remove "bold" property
		tlI.state &= ~TLIS_BOLD;
		tlI.stateMask = TLIS_BOLD;
		TreeList_SetItem (hWndTree, &tlI);

		// get next item
		tlI.hItem = hTServer;
		tlI.mask = TLIF_NEXTHANDLE;
		TreeList_GetItem (hWndTree, &tlI);

		hTServer = tlI.hItem;
	}
}

//	_____________________________________________________
//
//  create new keyserver and add to treelist

INT
CLNewKeyserver (HWND hWndParent, HWND hWndTree)
{
	PKEYSERVERSTRUCT pkss;

	pkss = (PKEYSERVERSTRUCT)clAlloc (sizeof(KEYSERVERSTRUCT));
	if (!pkss) return 1;

	pkss->hWndTree = hWndTree;
	pkss->bEdit = FALSE;

	pkss->szServer[0] = '\0';
	pkss->iPort = 0;
	pkss->iType = kPGPKeyServerType_LDAP;
	LoadString (g_hInst, IDS_UNKNOWNKEY, pkss->szUserIDAuth, 
					sizeof(pkss->szUserIDAuth));
	pkss->szDomain[0] = '\0';
	pkss->bListed = TRUE;
	pkss->bRoot = FALSE;
	pkss->authAlg = kPGPPublicKeyAlgorithm_Invalid;
	pkss->pOrigStruct = NULL;

	if (!DialogBoxParam (g_hInst, MAKEINTRESOURCE(IDD_NEWSERVER), hWndParent, 
				sEditServerDlgProc, (LPARAM)pkss)) {
		clFree (pkss);
		SetFocus (hWndTree);
		return 0;
	}

	sSetOneKSItem (hWndTree, pkss); 
	InvalidateRect (hWndTree, NULL, TRUE);

	++uNumberOfServers;

	EnableWindow (GetDlgItem (hWndParent, IDC_REMOVEKEYSERVER), 
						FALSE);
	EnableWindow (GetDlgItem (hWndParent, IDC_EDITKEYSERVER),
						FALSE);
	EnableWindow (GetDlgItem (hWndParent, IDC_SETASROOT),
						FALSE);

	return 0;
}

//	_____________________________________________________
//
//  edit existing keyserver params

VOID
CLEditKeyserver (HWND hWndParent, HWND hWndTree)
{
	TL_TREEITEM			tlI;
	TL_LISTITEM			tlL;
	KEYSERVERSTRUCT		kss;
	PKEYSERVERSTRUCT	pkss;
	CHAR				sz[256];

	// get server struct
	tlI.hItem = hTSelected;
	tlI.mask = TLIF_PARAM;
	TreeList_GetItem (hWndTree, &tlI);

	pkss = (PKEYSERVERSTRUCT)tlI.lParam;
	memcpy (&kss, pkss, sizeof(KEYSERVERSTRUCT));
	kss.bEdit = TRUE;
	kss.pOrigStruct = (VOID*)pkss;

	if (DialogBoxParam (g_hInst, MAKEINTRESOURCE(IDD_NEWSERVER), hWndParent, 
		sEditServerDlgProc, (LPARAM)&kss)) {

		memcpy (pkss, &kss, sizeof(KEYSERVERSTRUCT));

		sURLfromInfo (pkss->iType, pkss->szServer, pkss->iPort, sz);
		pkss->authAlg = kPGPPublicKeyAlgorithm_Invalid;

		// insert new server text into treelist
		tlI.hItem = hTSelected;
		tlI.mask = TLIF_TEXT | TLIF_STATE;
		tlI.stateMask = TLIS_BOLD;
		if (pkss->bRoot) 
			tlI.state = TLIS_BOLD;
		else
			tlI.state = 0;
		tlI.cchTextMax = lstrlen (sz);
		tlI.pszText = sz;
		TreeList_SetItem (hWndTree, &tlI);

		// set new domain text
		tlL.hItem = hTSelected;
		tlL.mask = TLIF_TEXT;
		tlL.iSubItem = 1;
		tlL.cchTextMax = lstrlen (pkss->szDomain);
		if (tlL.cchTextMax)
			tlL.pszText = pkss->szDomain;
		else