clavlist.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 1,349 行 · 第 1/3 页

	PGPAttributeValue*	pAV;

	for (pAV=pavls->pAVListStart; pAV<pavls->pAVListEnd; pAV++)
	{
		if ((pAV->attribute >= kPGPAVAttributeFirstPointer) &&
			(pAV->attribute <= kPGPAVAttributeLastPointer))
		{
			if (pAV->value.pointervalue == NULL)
				return FALSE;
		}
	}

	return TRUE;
}


//	_____________________________________________________
//
//  context menu for AVlist listview

static VOID
sAVlistContextMenu (
		HWND			hwnd,
		PAVLISTSTRUCT	pavls,
		HWND			hwndList,
		INT				iX,
		INT				iY)
{
	HMENU	hMC;
	HMENU	hMenuTrackPopup;

	if ((iX == 0xFFFF) && (iY == 0xFFFF))
	{
		POINT	pt;
		pt.x = 0;
		pt.y = 0;

		MapWindowPoints (hwndList, NULL, &pt, 1);
		iX = pt.x;
		iY = pt.y;
	}

	hMC = LoadMenu (g_hInst, MAKEINTRESOURCE (IDR_MENUAVLIST));
	if (pavls->selectedpair)
	{
		EnableMenuItem (hMC, IDC_EDITAV, MF_BYCOMMAND|MF_ENABLED);
		EnableMenuItem (hMC, IDC_REMOVEAV, MF_BYCOMMAND|MF_ENABLED);
	}

	hMenuTrackPopup = GetSubMenu (hMC, 0);

	TrackPopupMenu (hMenuTrackPopup, TPM_LEFTALIGN | TPM_RIGHTBUTTON,
					iX, iY, 0, hwnd, NULL);

	DestroyMenu (hMC);
}


//	___________________________________________________
//
//	AV list dialog procedure

static BOOL CALLBACK
sAVListDlgProc (
		HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	PAVLISTSTRUCT		pavls;

	switch (uMsg) {

	case WM_INITDIALOG :
		SetWindowLong (hwnd, GWL_USERDATA, lParam);
		pavls = (PAVLISTSTRUCT)lParam;

		sInitAVListControls (hwnd, pavls);
		sLoadAVList (hwnd, pavls);

		// initialize request type controls
		if (pavls->uRequestType == kPGPPrefCertRequestCRS)
			CheckRadioButton (hwnd, IDC_CRS, IDC_PKCS10, IDC_CRS);
		else
			CheckRadioButton (hwnd, IDC_CRS, IDC_PKCS10, IDC_PKCS10);

		if (!pavls->bRequestGUI)
		{
			EnableWindow (GetDlgItem (hwnd, IDC_REQUESTTEXT), FALSE);
			EnableWindow (GetDlgItem (hwnd, IDC_CRS), FALSE);
			EnableWindow (GetDlgItem (hwnd, IDC_PKCS10), FALSE);
		}

		if (pavls->bHideCancel)
		{
			EnableWindow (GetDlgItem (hwnd, IDCANCEL), FALSE);
			ShowWindow (GetDlgItem (hwnd, IDCANCEL), SW_HIDE);
		}

		return TRUE;

	case WM_HELP :
		return PGPclHtmlHelp (hwnd, uMsg, wParam, lParam, 
				(char*)kPGPclHelpFile, aAVlistIds);

	case WM_CONTEXTMENU :
		pavls = (PAVLISTSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		if ((HWND)wParam == GetDlgItem (hwnd, IDC_AVLIST))
		{
			sAVlistContextMenu (hwnd, pavls, (HWND)wParam, 
					(SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
		}
		else
		{
			return PGPclHtmlHelp (hwnd, uMsg, wParam, lParam, 
					(char*)kPGPclHelpFile, aAVlistIds);
		}
		break;

	case WM_DRAWITEM :
		sDrawItem ((LPDRAWITEMSTRUCT)lParam);
		break;

	case WM_NOTIFY :
	{
		LPNMHDR pnmhdr = (LPNMHDR)lParam;
		pavls = (PAVLISTSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

		if (pnmhdr->idFrom == IDC_AVLIST)
		{
			switch (pnmhdr->code) {
			case LVN_ITEMCHANGED :
			{
				NM_LISTVIEW* pnmlv = (NM_LISTVIEW*)lParam;

				if (pnmlv->iItem >= 0)
				{
					BOOL bEnable = FALSE;

					if (pnmlv->uNewState & LVIS_SELECTED)
					{
						pavls->selectedpair =
									(PGPAttributeValue*)pnmlv->lParam;
						bEnable = TRUE;
					}
					else
					{
						pavls->selectedpair = NULL;
					}
					EnableWindow (GetDlgItem (hwnd, IDC_EDITAV), bEnable);
					EnableWindow (GetDlgItem (hwnd, IDC_REMOVEAV), bEnable);
				}
				break;
			}

			case NM_DBLCLK :
				if (DialogBoxParam (g_hInst, MAKEINTRESOURCE(IDD_AVPAIR),
							hwnd, sAVPairDlgProc, (LPARAM)pavls))
				{
					sLoadAVList (hwnd, pavls);
				}
				break;
			}
		}
		break;
	}

	case WM_COMMAND :
		pavls = (PAVLISTSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

		switch (LOWORD(wParam)) {

		case IDCANCEL :
			EndDialog (hwnd, 0);
			break;

		case IDOK :
			if (sAllAttributesHaveValues (hwnd, pavls))
			{
				if (IsDlgButtonChecked (hwnd, IDC_CRS) == BST_CHECKED)
					pavls->uRequestType = kPGPPrefCertRequestCRS;
				else
					pavls->uRequestType = kPGPPrefCertRequestPKCS10;

				EndDialog (hwnd, 1);
			}
			else
			{
				PGPclMessageBox (hwnd, IDS_CAPTIONINFO,
						IDS_MISSINGATTRIBUTEVALUE, MB_OK|MB_ICONINFORMATION);
			}
			break;

		case IDC_NEWAV :
			pavls->selectedpair = NULL;
			EnableWindow (GetDlgItem (hwnd, IDC_EDITAV), FALSE);
			EnableWindow (GetDlgItem (hwnd, IDC_REMOVEAV), FALSE);
			if (DialogBoxParam (g_hInst, MAKEINTRESOURCE(IDD_AVPAIR),
						hwnd, sAVPairDlgProc, (LPARAM)pavls))
			{
				sLoadAVList (hwnd, pavls);
			}
			break;

		case IDC_EDITAV :
			if (DialogBoxParam (g_hInst, MAKEINTRESOURCE(IDD_AVPAIR),
						hwnd, sAVPairDlgProc, (LPARAM)pavls))
			{
				sLoadAVList (hwnd, pavls);
			}
			break;

		case IDC_REMOVEAV :
			sRemoveSelectedAVPair (pavls);
			pavls->selectedpair = NULL;
			EnableWindow (GetDlgItem (hwnd, IDC_EDITAV), FALSE);
			EnableWindow (GetDlgItem (hwnd, IDC_REMOVEAV), FALSE);
			sLoadAVList (hwnd, pavls);
			break;

		}
		return TRUE;
	}
	return FALSE;
}


//	___________________________________________________
//
//	fill the AV list from the user dialog

static PGPError
sGetAVPairsFromUser (
	HWND				hwnd,
	PGPContextRef		context,
	PGPKeyServerClass	serverclass,
	PGPUInt32*			puRequestType,
	PGPBoolean			bRequestGUI,
	PGPBoolean			bHideCancel,
	PGPAttributeValue*	pAVListStart,
	PGPAttributeValue**	ppAVList)
{
	AVLISTSTRUCT	avls;

	avls.context		= context;
	avls.selectedpair	= NULL;
	avls.serverclass	= serverclass;
	avls.uRequestType	= *puRequestType;
	avls.bRequestGUI	= bRequestGUI;
	avls.bHideCancel	= bHideCancel;
	avls.pAVListStart	= pAVListStart;
	avls.pAVListEnd		= *ppAVList;

	if (DialogBoxParam (g_hInst, MAKEINTRESOURCE(IDD_AVLIST), hwnd,
						sAVListDlgProc, (LPARAM)&avls))
	{
		*puRequestType = avls.uRequestType;
		*ppAVList = avls.pAVListEnd;
		return kPGPError_NoErr;
	}
	else
	{
		*ppAVList = avls.pAVListEnd;
		return kPGPError_UserAbort;
	}
}


//	___________________________________________________
//
//	fill the AV list from the prefs file

static PGPError
sGetAVPairsFromPrefs (
	PGPContextRef		context,
	PGPPrefRef			prefref,
	PGPAttributeValue**	ppAVcur)
{
	PGPError			err;
	PGPSize				size;
	PGPByte*			data;
	PGPUInt32			numAVs;
	PGPAttributeValue*	pAVlist;
	PGPUInt32			u;

	err = PGPGetPrefData (prefref, kPGPPrefExtraAVPairs, &size, &data);
	if (IsntPGPError (err))
	{
		err = PGPclDataToAVPairs (PGPPeekContextMemoryMgr (context),
					data, size, &pAVlist, &numAVs);
		PGPFreeData (data);

		for (u=0; u<numAVs; u++)
		{
			(*ppAVcur)->attribute			= pAVlist[u].attribute;
			(*ppAVcur)->size				= pAVlist[u].size;
			(*ppAVcur)->value.pointervalue	= pAVlist[u].value.pointervalue;
			++(*ppAVcur);
		}

		PGPFreeData (pAVlist);
	}
	return err;
}


//	___________________________________________________
//
//	Get CA cert request AV list either from prefs or from user

PGPError PGPclExport
PGPclGetCACertRequestAVList (
		HWND					hwnd,
		PGPContextRef			context,
		PGPBoolean				bAdminCaller,
		PGPKeyDBObjRef			userid,
		PGPKeyServerClass		serverclass,
		PGPUInt32*				puRequestType,
		PGPAttributeValue**		ppAVlist,
		PGPUInt32*				pNumAVs)
{
	PGPUInt32			numAVs				= 0;
	PGPPrefRef			prefref				= kInvalidPGPPrefRef;
	PGPBoolean			bRequestGUIEnabled	= TRUE;

	PGPSize				size;
	PGPAttributeValue*	pAVcur;
	PGPError			err;
	PGPAttributeValue	tempAVlist[MAX_AV];

	pAVcur = &tempAVlist[0];
	*puRequestType = kPGPPrefCertRequestCRS;

	err = sCreateCommonAVPairs (context, serverclass, userid, &pAVcur);

	if(PGPlnEnterprise())
	{
		if (!bAdminCaller)
		{
			PGPUInt32	u;

			err = PGPclPeekClientLibPrefRefs (&prefref, NULL); CKERR;
			PGPGetPrefNumber (prefref, kPGPPrefCertRequestType, puRequestType);

			if (IsntPGPError (
					PGPGetPrefFlags (prefref, kPGPPrefCertRequestType, &u)))
			{
				if (u & kPGPPrefFlags_DisableGUI)
					bRequestGUIEnabled = FALSE;
			}

			err = sGetAVPairsFromPrefs (context, prefref, &pAVcur);
		}
	}

	if ((!PGPlnEnterprise())||(IsPGPError (err) || bAdminCaller))
	{
		if (IsntNull (*ppAVlist) &&
			IsntNull (pNumAVs) &&
			(*pNumAVs > 0))
		{
			size = *pNumAVs * sizeof(PGPAttributeValue);
			pgpCopyMemory (*ppAVlist, tempAVlist, size);
			pAVcur = &tempAVlist[*pNumAVs];
		}
		else
		{
			err = sCreateDefaultAVPairs (
					context, serverclass, &pAVcur); CKERR;
		}
		err = sGetAVPairsFromUser (
				hwnd, context, serverclass, puRequestType,
				bRequestGUIEnabled, FALSE, tempAVlist, &pAVcur);
	}

done:
	if (IsntPGPError (err))
	{
		// if userid is passed in, this is a real request and we
		// should append any class-specific pairs
		if (PGPKeyDBObjRefIsValid (userid))
			err = sAppendClassAVPairs (context, hwnd, serverclass, &pAVcur);
	}

	numAVs = pAVcur - &tempAVlist[0];

	if (IsntPGPError (err))
	{
		size = numAVs * sizeof(PGPAttributeValue);

		if (IsntNull (*ppAVlist))
			PGPFreeData (*ppAVlist);

		*ppAVlist = PGPNewData (
				PGPPeekContextMemoryMgr (context), size, 0);

		if (*ppAVlist)
		{
			pgpCopyMemory (tempAVlist, *ppAVlist, size);
			*pNumAVs = numAVs;
		}
		else
			err = kPGPError_OutOfMemory;
	}

	if (IsPGPError (err))
	{
		PGPUInt32	u;

		for (u=0; u<numAVs; u++)
		{
			if (tempAVlist[u].value.pointervalue)
				PGPFreeData (tempAVlist[u].value.pointervalue);
		}
	}

	return err;
}


//	___________________________________________________
//
//	Free the CA cert request AV list returned by PGPclGetCACertRequestAVList

PGPError PGPclExport
PGPclFreeCACertRequestAVList (
		PGPAttributeValue*		pAVlist,
		PGPUInt32				NumAVs)
{
	PGPUInt32		u;

	if (pAVlist)
	{
		for (u=0; u<NumAVs; u++)
		{
			if ((pAVlist[u].attribute >= kPGPAVAttributeFirstPointer) &&
				(pAVlist[u].attribute < kPGPAVAttributeFirstBoolean))
			{
				if (pAVlist[u].value.pointervalue)
					PGPFreeData (pAVlist[u].value.pointervalue);
			}
		}

		PGPFreeData (pAVlist);
	}

	return kPGPError_NoErr;
}