searchproc.c

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

				LeaveCriticalSection(keyserverLock);
			}

		}
	}
	PGPKeyServerDisposeThreadStorage(previousStorage);

	PGPKeyServerCleanup();

	return error;
}

DWORD WINAPI SearchThreadRoutine (LPVOID lpvoid)
{
	PSEARCHTHREADSTRUCT psts = (PSEARCHTHREADSTRUCT) lpvoid;
	SEARCHRESULT result;
	PGPKeySetRef keyset	= kInvalidPGPKeySetRef;
	HWND hwnd = psts->hwnd;
	HWND hwndLocation = NULL;
	HWND hwndSearch = NULL;
	HWND hwndStop = NULL;
	HWND hwndPending = NULL;
	long flags = 0;
	BOOL bPending = FALSE;
	PGPError error = kPGPError_NoErr;

	hwndLocation = GetDlgItem(hwnd, IDC_LOCATION);
	hwndSearch = GetDlgItem(hwnd, IDC_SEARCH);
	hwndStop = GetDlgItem(hwnd, IDC_STOP);
	hwndPending = GetDlgItem(hwnd, IDC_PENDING);

	bPending = Button_GetCheck(hwndPending);

	error = PerformSearch(	hwndLocation,
							psts,
							bPending,
							&flags,
							&keyset);

	memset(&result, 0x00, sizeof(result));

	if( IsntPGPError(error) ||
		(error == kPGPError_ServerPartialSearchResults))
	{
		result.pData = keyset;
		result.flags = flags;
		result.error = error;

		memcpy(&(result.keyserver),
			&(psts->keyserverEntry),
			sizeof(PGPKeyServerEntry));

		if(bPending)
		{
			result.flags |= FLAG_AREA_PENDING;
		}
	}
	else
	{
		result.pData = NULL;
		result.flags = 0;
		result.error = error;
	}

	result.nmhdr.hwndFrom = hwnd;
	result.nmhdr.idFrom = IDD_SEARCH;
	result.nmhdr.code = SEARCH_DISPLAY_KEYSET;

	SendMessage(GetParent(hwnd),
				WM_NOTIFY,
				(WPARAM)hwnd,
				(LPARAM)&result);

	if ( PGPFilterRefIsValid (psts->filter) )
	{
		PGPFreeFilter ( psts->filter );
		psts->filter = kInvalidPGPFilterRef;
	}

	psts->threadHandle = NULL;

	EnableWindow(hwndStop, FALSE);
	ShowWindow(hwndStop, SW_HIDE);
	ShowWindow(hwndSearch, SW_SHOW);
	EnableWindow(hwndSearch, TRUE);

	return 0;
}

//	____________________________________
//
//  translate keyserver state to string index

static INT
sTranslateKSMessage (INT iKSmessage)
{
	switch (iKSmessage) {
	case kPGPKeyServerState_Opening :
								return IDS_SEARCH_MESSAGE_CONNECTING;
	case kPGPKeyServerState_Querying:
								return IDS_SEARCH_MESSAGE_QUERYING;
	case kPGPKeyServerState_ReceivingResults :
								return IDS_SEARCH_MESSAGE_RECEIVING;
	case kPGPKeyServerState_ProcessingResults :
								return IDS_SEARCH_MESSAGE_PROCESSING;
	case kPGPKeyServerState_Uploading :
								return IDS_SEARCH_MESSAGE_SENDING;
	case kPGPKeyServerState_Deleting :
								return IDS_SEARCH_MESSAGE_DELETING;
	case kPGPKeyServerState_Disabling :
								return IDS_SEARCH_MESSAGE_DISABLING;
	case kPGPKeyServerState_Closing	:
								return IDS_SEARCH_MESSAGE_CLOSING;

	default :
//	case kPGPKeyServerState_TLSUnableToSecureConnection :
//	case kPGPKeyServerState_TLSConnectionSecured :
		return IDS_SEARCH_MESSAGE_BASE;
	}
}


PGPError SearchEventHandler(PGPContextRef context,
							PGPEvent *event,
							PGPUserValue userValue)
{
	PGPError error = kPGPError_NoErr;
	PSEARCHTHREADSTRUCT psts;

	psts = (PSEARCHTHREADSTRUCT) userValue;

	switch(event->type)
	{
		case kPGPEvent_ErrorEvent:
		{
			PGPEventErrorData data = event->data.errorData;

			if(data.error == kPGPError_UserAbort)
			{
				psts->bCancel = TRUE;
				return kPGPError_NoErr;
			}

			break;
		}

		case kPGPEvent_KeyServerEvent:
		{
			PGPEventKeyServerData data = event->data.keyServerData;
			SEARCHPROGRESS progress;
			int index;

			memset(&progress, 0x00, sizeof(progress));

			progress.nmhdr.hwndFrom = psts->hwnd;
			progress.nmhdr.idFrom = IDD_SEARCH;
			progress.nmhdr.code = SEARCH_PROGRESS;
			progress.step = SEARCH_PROGRESS_INFINITE; // data.soFar;//
			progress.total = SEARCH_PROGRESS_INFINITE;// data.total;//

			if(!psts->bCancel)
			{
				index = data.state;
			}
			else
			{
				index = IDS_SEARCH_MESSAGE_CANCEL;
				progress.step = 0;
				progress.total = 0;
			}

			index = sTranslateKSMessage (index);
			LoadString(	g_hinst,
						index,
						progress.message,
						sizeof(progress.message));


			SendMessage(GetParent(psts->hwnd),
						WM_NOTIFY,
						(WPARAM)psts->hwnd,
						(LPARAM)&progress);

			break;
		}

		case kPGPEvent_KeyServerTLSEvent:
		{
			PGPEventKeyServerTLSData data = event->data.keyServerTLSData;

			SEARCHSECURE secure;

			memset(&secure, 0x00, sizeof(secure));

			secure.nmhdr.hwndFrom = psts->hwnd;
			secure.nmhdr.idFrom = IDD_SEARCH;
			secure.nmhdr.code = SEARCH_SECURE_STATUS;
			secure.secure = FALSE;

			if(data.state == kPGPKeyServerState_TLSConnectionSecured)
			{

				PGPtlsSessionRef	tls =
									event->data.keyServerTLSData.tlsSession;

				PGPInt32			remoteKeyAlg;
				PGPKeyID			keyID,
									expectedID;
				PGPError			error;

				error =
					PGPtlsGetRemoteAuthenticatedKey( tls,
										&secure.keyAuth, NULL );
				if( IsPGPError( error ) )
					break;

				error =
					PGPtlsGetNegotiatedCipherSuite( tls,
										&secure.tlsCipher );
				if( IsPGPError( error ) )
					break;

				PGPGetKeyServerURL(&(psts->keyserverEntry),
												secure.szServerName);

				error = PGPGetKeyID( secure.keyAuth, &keyID );
				if( IsPGPError( error ) )
					break;

				error = PGPGetKeyDBObjNumericProperty( secure.keyAuth,
						kPGPKeyProperty_AlgorithmID, &remoteKeyAlg );
				if( IsPGPError( error ) )
					break;

				// check if we already have an auth key from this server
				if( psts->keyserverEntry.authAlg !=
					kPGPPublicKeyAlgorithm_Invalid )
				{
					error = PGPNewKeyIDFromString(
								psts->keyserverEntry.authKeyIDString,
								kPGPPublicKeyAlgorithm_Invalid,
								&expectedID );

					if( IsPGPError( error ) )
						break;

					if( PGPCompareKeyIDs( &expectedID, &keyID ) )
					{
						error = PGPclConfirmRemoteAuthentication (
												g_context,
												psts->hwnd,
												secure.szServerName,
												secure.keyAuth,
												secure.tlsCipher,
												psts->keydbMain,
												kPGPclAuthUnexpectedKey);
						// if user approve
						if(IsntPGPError(error))
						{
							NMHDR nmhdr;

							error = PGPGetKeyIDString( &keyID,
									kPGPKeyIDString_Full,
									psts->keyserverEntry.authKeyIDString );

							if( IsPGPError( error ) )
								break;

							psts->keyserverEntry.authAlg =
								(PGPPublicKeyAlgorithm) remoteKeyAlg;

							PGPclSyncKeyserverPrefs(g_context,
												&(psts->keyserverEntry));

							secure.secure = TRUE;

							nmhdr.hwndFrom = psts->hwnd;
							nmhdr.idFrom = IDD_SEARCH;
							nmhdr.code = REFRESH_KEYSERVER_LIST;

							SendMessage(psts->hwnd,
								WM_NOTIFY,
								(WPARAM)psts->hwnd,
								(LPARAM)&nmhdr);
						}
					}
					else
					{
						error = PGPclConfirmRemoteAuthentication (
												g_context,
												psts->hwnd,
												secure.szServerName,
												secure.keyAuth,
												secure.tlsCipher,
												psts->keydbMain,
												kPGPclAuthExpectedKey);
						// if user approve
						if(IsntPGPError(error))
						{
							secure.secure = TRUE;
						}
					}
				}
				// this is the first time we're talking to this server
				else
				{

					error = PGPclConfirmRemoteAuthentication (
											g_context,
											psts->hwnd,
											secure.szServerName,
											secure.keyAuth,
											secure.tlsCipher,
											psts->keydbMain,
											kPGPclAuthNewKey);
					// if user approve
					if(IsntPGPError(error))
					{
						NMHDR nmhdr;

						error = PGPGetKeyIDString( &keyID,
									kPGPKeyIDString_Full,
									psts->keyserverEntry.authKeyIDString );

						if( IsPGPError( error ) )
							break;

						psts->keyserverEntry.authAlg =
							(PGPPublicKeyAlgorithm) remoteKeyAlg;


						PGPclSyncKeyserverPrefs(g_context,
												&(psts->keyserverEntry));

						secure.secure = TRUE;

						nmhdr.hwndFrom = psts->hwnd;
						nmhdr.idFrom = IDD_SEARCH;
						nmhdr.code = REFRESH_KEYSERVER_LIST;

						SendMessage(psts->hwnd,
							WM_NOTIFY,
							(WPARAM)psts->hwnd,
							(LPARAM)&nmhdr);
					}
				}

				if (secure.secure != TRUE)
				{
					SEARCHABORT abort;

					psts->bCancel = TRUE;

					memset(&abort, 0x00, sizeof(abort));

					abort.nmhdr.hwndFrom = psts->hwnd;
					abort.nmhdr.idFrom = IDD_SEARCH;
					abort.nmhdr.code = SEARCH_ABORT;
					abort.error = kPGPError_UserAbort;

					SendMessage(GetParent(psts->hwnd),
							WM_NOTIFY,
							(WPARAM)psts->hwnd,
							(LPARAM)&abort);
				}

			}
			else if(data.state ==
						kPGPKeyServerState_TLSUnableToSecureConnection)
			{
				secure.secure = FALSE;
			}

			SendMessage(GetParent(psts->hwnd),
						WM_NOTIFY,
						(WPARAM)psts->hwnd,
						(LPARAM)&secure);

			break;
		}

		case kPGPEvent_FinalEvent:
		{
			break;
		}
	}


	if( psts->bCancel )
	{
		error = kPGPError_UserAbort;
	}

	return error;
}

void GrabUserIdStrings(HWND hwnd,
					   char** string,
					   int* length)
{
	PCHOICE	choice				= NULL;
	HWND	hwndEdit			= NULL;
	HWND	hwndAttribute		= NULL;
	int		AttributeSelection	= 0;
	int		userIdSelection		= 0;

	*string = NULL;
	*length = 0;

	hwndAttribute	= GetDlgItem(hwnd, IDC_ATTRIBUTE);
	hwndEdit		= GetDlgItem(hwnd, IDC_SPECIFIER_EDIT);

	AttributeSelection	= ComboBox_GetCurSel(hwndAttribute);

	if(AttributeSelection == 0) // User Id
	{
		*length = UTF8EditGetTextLength(hwndEdit) + 1;
		
		*string = (char*)malloc(*length);

		if( *string )
		{
			UTF8EditGetText(hwndEdit,
							*string,
							*length);
		}
	}

	// now iterate the children if there are any
	choice = FirstChoice(hwnd);

	while( choice )
	{
		hwndAttribute	= GetDlgItem(choice->hwnd, IDC_ATTRIBUTE);
		hwndEdit		= GetDlgItem(choice->hwnd, IDC_SPECIFIER_EDIT);

		AttributeSelection	= ComboBox_GetCurSel(hwndAttribute);

		if(AttributeSelection == 0) // User Id
		{
			int tempLength = 0;

			tempLength = *length + UTF8EditGetTextLength(hwndEdit) + 1;

			if(!(*string))
			{
				*string = (char*)malloc(tempLength);
			}
			else
			{
				*string = (char*)realloc(*string, tempLength);
			}

			if( *string )
			{
				if(*length)
				{
					*(*string + *length - 1) = 0x20; // add space
				}

				UTF8EditGetText(hwndEdit,
								*string + *length,
								tempLength);

				*length = tempLength;
			}
		}

		choice = NextChoice(hwnd, choice);
	}
}