pgpkeyserverdialogs.cpp

可以实现对邮件的加密解密以及签名

		for(specIndex = 0; specIndex < ServerCount; specIndex++)
		{
			PGPKeyServerSpec	*srcSpec;
			PGPKeyServerSpec	*destSpec;
				
			srcSpec 	= &(InList[specIndex]);
			destSpec 	= &((*pOutList)[specIndex]);

			if( IsntNull( srcSpec->serverName ) )
			{
				destSpec->serverName = pgpAllocCString( context,
											srcSpec->serverName );
				if( IsNull( destSpec->serverName ) )
					err = kPGPError_OutOfMemory;
			}
				
			if( IsntNull( srcSpec->serverDomain ) )
			{
				destSpec->serverDomain = pgpAllocCString( context,
											srcSpec->serverDomain );
				if( IsNull( destSpec->serverDomain ) )
					err = kPGPError_OutOfMemory;
			}
				
			if( IsPGPError( err ) )
				break;
		}
	}
	else
	{
		err = kPGPError_OutOfMemory;
	}
		
	if( IsPGPError( err ) )
	{
		FreeServerList( context,
			*pOutList, 
			ServerCount);

		*pOutList = NULL;
	}

	return( err );
}

UINT WINAPI
KeyServerThread (LPVOID lpvoid) 
{
	KEYGBL		*pkg;
	PGPContextRef context;
	PGPKeySetRef mFailedKeys;
	PGPKeyDBRef mNewKeys = NULL;

	mFailedKeys=NULL;

	pkg=(KEYGBL *)lpvoid;
	context=pkg->context;

	if(pkg->bSearch)
	{
		CPGPSearchKeyServerDialogOptions *options;

		options=(CPGPSearchKeyServerDialogOptions *)pkg->options;

		pkg->serverCount=options->mServerCount;

		// Make copy of servers in case we're orphaned
		pkg->err=CopyServerList(context,
			&(pkg->serverList),
			(PGPKeyServerSpec *)options->mServerList,
			pkg->serverCount);

		if(IsntPGPError(pkg->err))
		{
			pkg->err = PGPSearchKeyServerDialogCommon( context,
				pkg->serverList, pkg->serverCount,
				options->mTLSContext, options->mFilter,
				KeyServerCallbackProc, (PGPUserValue) pkg,
				options->mSearchAllServers, &mNewKeys );

			FreeServerList(context,
				pkg->serverList,
				pkg->serverCount);			
		}

		if(!pkg->bCancel)
			*(options->mNewKeys)=mNewKeys;

	}
	else
	{
		CPGPSendToKeyServerDialogOptions *options;

		options=(CPGPSendToKeyServerDialogOptions *)pkg->options;

		pkg->serverCount=options->mServerCount;

		// Make copy of servers in case we're orphaned
		pkg->err=CopyServerList(context,
			&(pkg->serverList),
			(PGPKeyServerSpec *)options->mServerList,
			pkg->serverCount);

		if(IsntPGPError(pkg->err))
		{
			pkg->err = PGPSendToKeyServerDialogCommon( context,
				pkg->serverList, options->mTLSContext,
				options->mKeysToSend,
				KeyServerCallbackProc, (PGPUserValue) pkg,
				&mFailedKeys );

			FreeServerList(context,
				pkg->serverList,
				pkg->serverCount);			
		}

		if(!pkg->bCancel)
			*(options->mFailedKeys)=mFailedKeys;
	}

	if(pkg->bCancel)
	{
		// If canceled, we have to free it
		CloseHandle (pkg->hSemaphore);
		free(pkg);
	}
	else
	{
		// Kill the window and let the main thread free it
		ReleaseSemaphore(pkg->hSemaphore, 1, NULL);
		SendMessage(pkg->hwndServerProgress,WM_CLOSE,0,0);
	}

	return 0;
}

//	______________________________________________________
//
//  Server progress dialog procedure

BOOL CALLBACK
ServerProgressDlgProc (
		 HWND	hDlg, 
		 UINT	uMsg, 
		 WPARAM wParam,
		 LPARAM lParam) 
{
	KEYGBL		*pkg;

	switch (uMsg) 
	{
		case WM_INITDIALOG:
		{
			UINT	u;
			
			SetWindowLong (hDlg, GWL_USERDATA, lParam);
			pkg=(KEYGBL *)lParam;

			PGPsdkUICreateImageList(&(pkg->hIml));
			pkg->hwndServerProgress=hDlg;

			pkg->iStatusValue = 0;
			pkg->iStatusDirection = 1;

			pkg->hThread=(HANDLE)_beginthreadex (NULL, 0, KeyServerThread, 
				(LPVOID)pkg, 0, &u);

			return TRUE;
		}

		case WM_PAINT :
		{
			PAINTSTRUCT		ps;
			HDC				hdc;
			int				LockIcon;
			int				rst;

			pkg=(KEYGBL *)GetWindowLong (hDlg, GWL_USERDATA);

			// Draw lock for TLS connection
			if(pkg->bSecureConnection)
				LockIcon=IDX_CLOSEDLOCK;
			else
				LockIcon=IDX_OPENLOCK;

			hdc = BeginPaint (hDlg, &ps);

			rst=ImageList_Draw(pkg->hIml,LockIcon,
				hdc,
				8,80,
				ILD_TRANSPARENT);

			EndPaint (hDlg, &ps);

			// Draw star trek progress lights
			DrawStatus (GetDlgItem (hDlg, IDC_PROGRESS), 
				&(pkg->iStatusValue),
				&(pkg->iStatusDirection));
			break;
		}

		case WM_TIMER :
		{
			pkg=(KEYGBL *)GetWindowLong (hDlg, GWL_USERDATA);

			pkg->iStatusValue += pkg->iStatusDirection;
			if (pkg->iStatusValue <= 0) 
			{
				pkg->iStatusValue = 0;
				pkg->iStatusDirection = 1;
			}
			else if (pkg->iStatusValue >= NUMLEDS-1) 
			{
				pkg->iStatusValue = NUMLEDS-1;
				pkg->iStatusDirection = -1;
			}
			InvalidateRect (hDlg, NULL, FALSE);
			break;
		}


		case WM_NOTIFY :
		{
			break;
		}

		case WM_CLOSE:
		{
			pkg=(KEYGBL *)GetWindowLong (hDlg, GWL_USERDATA);

			ImageList_Destroy(pkg->hIml);
			EndDialog(hDlg, 1);
			return TRUE;
		}

		case WM_COMMAND :
		{
			switch(LOWORD (wParam)) 
			{
				case IDCANCEL :
				{
					pkg=(KEYGBL *)GetWindowLong (hDlg, GWL_USERDATA);

					// Do the dirty deed
//					pkg->err=kPGPError_UserAbort;
//					TerminateThread(pkg->hThread,0);

					pkg->bCancel=TRUE;

					if (pkg->mLastKeyServer) 
					{
						PGPError err;

						err = PGPCancelKeyServerCall (pkg->mLastKeyServer);
						PGPsdkUIErrorBox (hDlg, err);
					}

					EndDialog(hDlg, 0);
					break;
				}

			}
			return TRUE;
		}
	}

	return FALSE;
}

	PGPError
pgpSearchKeyServerDialogPlatform(
	PGPContextRef						context,
	CPGPSearchKeyServerDialogOptions 	*options)
{
	PGPError	err;
	KEYGBL		*pkg;
	
	PGPValidatePtr( options );
		
	err=kPGPError_NoErr;

	pkg=(KEYGBL *)malloc(sizeof(KEYGBL));
	if(!pkg)
	{
		err=kPGPError_OutOfMemory;
	}
	else
	{
		memset(pkg,0x00,sizeof(KEYGBL));

		pkg->context=context;
		pkg->options=options;
		pkg->bSearch=TRUE;

		pkg->hSemaphore = CreateSemaphore(NULL, 0, 1, NULL);

		if (!pkg->hSemaphore)
		{
			err=kPGPError_OutOfMemory;
		}
		else
		{
			if (DialogBoxParam (gPGPsdkUILibInst, 
					MAKEINTRESOURCE(IDD_SERVERPROGRESS),
					options->mHwndParent, 
					(DLGPROC)ServerProgressDlgProc, 
					(LPARAM)pkg))
			{
				WaitForSingleObject (pkg->hSemaphore, INFINITE);
				CloseHandle (pkg->hSemaphore);
				CloseHandle (pkg->hThread);
				err=pkg->err;
				free(pkg);
			}
			else
			{
				// Let thread free its own memory after its done
				err=kPGPError_UserAbort;
			}
		}
	}

	return( err );
}

	PGPError
pgpSendToKeyServerDialogPlatform(
	PGPContextRef						context,
	CPGPSendToKeyServerDialogOptions 	*options)
{
	PGPError	err;
	KEYGBL		*pkg;

	PGPValidatePtr( options );
		
	err=kPGPError_NoErr;
	
	pkg=(KEYGBL *)malloc(sizeof(KEYGBL));
	if(!pkg)
	{
		err=kPGPError_OutOfMemory;
	}
	else
	{
		memset(pkg,0x00,sizeof(KEYGBL));

		pkg->context=context;
		pkg->options=options;
		pkg->bSearch=FALSE;

		pkg->hSemaphore = CreateSemaphore(NULL, 0, 1, NULL);

		if (!pkg->hSemaphore)
		{
			err=kPGPError_OutOfMemory;
		}
		else
		{
			if (DialogBoxParam (gPGPsdkUILibInst, 
					MAKEINTRESOURCE(IDD_SERVERPROGRESS),
					options->mHwndParent, 
					(DLGPROC)ServerProgressDlgProc, 
					(LPARAM)pkg))
			{
				WaitForSingleObject (pkg->hSemaphore, INFINITE);
				CloseHandle (pkg->hSemaphore);
				CloseHandle (pkg->hThread);
				err=pkg->err;
				free(pkg);
			}
			else
			{
				// Let thread free its own memory after its done
				err=kPGPError_UserAbort;
			}
		}
	}
	
	return( err );
}