encryptsign.c

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

					mimeOptions,
					PGPOLastOption(context));

		if (IsPGPError(err))
		{
			DisplayErrorCode(__FILE__, __LINE__, szModule, err, FALSE, hwnd);
			goto EncryptSignError;
		}

		err = PGPBuildOptionList(context, &encryptOptions,
				PGPOLastOption(context));

		if (IsPGPError(err))
		{
			DisplayErrorCode(__FILE__, __LINE__, szModule, err, FALSE, hwnd);
			goto EncryptSignError;
		}

		if (GetCommentString(memoryMgr, szComment, 254))
		{
			err = PGPBuildOptionList(context, &tempOptions,
					options,
					PGPOCommentString(context, szComment),
					PGPOLastOption(context));
			
			if (IsPGPError(err))
			{
				DisplayErrorCode(__FILE__, __LINE__, szModule, err, FALSE, hwnd);
				goto EncryptSignError;
			}

			PGPFreeOptionList(options);
			options = tempOptions;
		}

		if (bEncrypt)
		{
			if (prds->dwOptions & kPGPclASCIIArmor)
				err = PGPBuildOptionList(context, &tempOptions,
						options,
						PGPOArmorOutput(context, TRUE),
						PGPOLastOption(context));
			else
				err = PGPBuildOptionList(context, &tempOptions,
						options,
						PGPOArmorOutput(context, FALSE),
						PGPOLastOption(context));
				
			if (IsPGPError(err))
			{
				DisplayErrorCode(__FILE__, __LINE__, szModule, err, FALSE, hwnd);
				goto EncryptSignError;
			}
			
			PGPFreeOptionList(options);
			options = tempOptions;
				
			if (*pSignOptions == NULL)
			{
				if (prds->dwOptions & kPGPclPassOnly)
				{
					if (!bGotConvPass)
					{
						char szPrompt[256];
						
						LoadString(hInst, IDS_CONVPASSPHRASE, szPrompt, 
							sizeof(szPrompt));
						
						err = PGPclGetConventionalPhrase(context, hwnd, 
								szPrompt, &szConvPass);
						
						if (err == kPGPError_UserAbort)
							goto EncryptSignError;
						
						nConvPassLen = strlen(szConvPass);
						bGotConvPass = TRUE;
					}
					
					if (!GetPreferredAlgorithm(memoryMgr, &prefAlg))
						goto EncryptSignError;
					
					err = PGPBuildOptionList(context, &tempOptions,
							encryptOptions,
							PGPOConventionalEncrypt(context,
								PGPOPassphraseBuffer(context,
									szConvPass, 
									nConvPassLen),
								PGPOLastOption(context)),
							PGPOCipherAlgorithm(context, prefAlg),
							PGPOLastOption(context));
					
					if (IsPGPError(err))
					{
						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err, FALSE, hwnd);
						goto EncryptSignError;
					}
				}
				else
				{
					if (!GetAllowedAlgorithms(memoryMgr, allowedAlgs, 
						&nNumAlgs))
						goto EncryptSignError;

					PGPNewKeySet(prds->keydbSelected, &recipKeySet);
					
					err = PGPBuildOptionList(context, &tempOptions,
							encryptOptions,
							PGPOPreferredAlgorithms(context,
								allowedAlgs, nNumAlgs ),
							PGPOEncryptToKeySet(context, recipKeySet),
							PGPOFailBelowValidity(context, 
								kPGPValidity_Unknown),
							PGPOWarnBelowValidity(context, 
								kPGPValidity_Unknown),
							PGPOLastOption(context));
					
					if (IsPGPError(err))
					{
						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err, FALSE, hwnd);
						goto EncryptSignError;
					}
				}
				
				PGPFreeOptionList(encryptOptions);
				encryptOptions = tempOptions;
			}
		}
		
		if (bSign)
		{
			if (*pSignOptions == NULL)
			{
				char szPrompt[256];

				if (bGotPassphrase)
					LoadString(hInst, IDS_PASSPHRASEREENTER, szPrompt, 
						sizeof(szPrompt));
				else
					LoadString(hInst, IDS_PASSPHRASEPROMPT, szPrompt, 
						sizeof(szPrompt));
				
				err = PGPclGetCachedSigningPhrase(context, tlsContext, hwnd, 
						szPrompt, bGotPassphrase, &szPassphrase, 
						prds->keydbOriginal, &signKey, NULL, 
						prds->dwFlags, &pPasskey, &nPasskeyLength, 
						&addedKeys, NULL);
				
				if (addedKeys != NULL)
				{
					PGPUInt32 numKeys;
					PGPKeySetRef addedKeySet;

					PGPNewKeySet(addedKeys, &addedKeySet);
					PGPCountKeys(addedKeySet, &numKeys);
					if (numKeys > 0)
						PGPclImportKeys(context, tlsContext, hwnd, 
							addedKeySet, prds->keydbOriginal, 
							kPGPclNoDialogForValidSingletons);

					PGPFreeKeySet(addedKeySet);
					PGPFreeKeyDB(addedKeys);
					addedKeys = NULL;
				}

				if (IsPGPError(err))
				{
					if (err != kPGPError_UserAbort)
						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err, FALSE, hwnd);
					goto EncryptSignError;
				}
				
				bGotPassphrase = TRUE;
				if (szPassphrase != NULL)
				{
					nPassphraseLen = strlen(szPassphrase);
				
					err = PGPBuildOptionList(context, pSignOptions,
							PGPOSignWithKey(context, 
								signKey, 
								PGPOPassphraseBuffer(context,
									szPassphrase, 
									nPassphraseLen),
								PGPOLastOption(context)),
							PGPOLastOption(context));
				}
				else if (pPasskey != NULL)
				{
					err = PGPBuildOptionList(context, pSignOptions,
							PGPOSignWithKey(context, 
								signKey, 
								PGPOPasskeyBuffer(context,
									pPasskey, 
									nPasskeyLength),
								PGPOLastOption(context)),
							PGPOLastOption(context));
				}
				else
				{
					err = PGPBuildOptionList(context, pSignOptions,
							PGPOSignWithKey(context, 
								signKey, 
								PGPOLastOption(context)),
							PGPOLastOption(context));
				}
				
				if (IsPGPError(err))
				{
					if (err != kPGPError_UserAbort)
						DisplayErrorCode(__FILE__, __LINE__, szModule, 
							err, FALSE, hwnd);
					goto EncryptSignError;
				}
			}

			err = PGPBuildOptionList(context, &tempOptions,
					options,
					PGPOClearSign(context, 
						(PGPBoolean) (!bEncrypt && !bBinary && !bHTML)),
					PGPOLastOption(context));
			
			if (IsPGPError(err))
			{
				if (err != kPGPError_UserAbort)
					DisplayErrorCode(__FILE__, __LINE__, szModule, 
						err, FALSE, hwnd);
				goto EncryptSignError;
			}

			PGPFreeOptionList(options);
			options = tempOptions;
		}
		
		if (bEncrypt && !bSign)
			LoadString(hInst, IDS_WORKINGENCRYPT, szWorkingTitle, 
				sizeof(szWorkingTitle));
		else if (!bEncrypt && bSign)
			LoadString(hInst, IDS_WORKINGSIGN, szWorkingTitle, 
				sizeof(szWorkingTitle));
		else
			LoadString(hInst, IDS_WORKINGENCRYPTSIGN, szWorkingTitle, 
				sizeof(szWorkingTitle));

		hwndWorking = WorkingDlgProcThread(GetModuleHandle(szModule), 
						hInst, hwnd, szWorkingTitle, "");

		if (*pSignOptions == NULL)
			PGPBuildOptionList(context, pSignOptions, 
				PGPOLastOption(context));

		bTextDocument = !bBinary || 
						((prds->dwOptions & kPGPclInputIsText)
							== kPGPclInputIsText);

		err = PGPEncode(context,
				ioOptions,
				PGPOEventHandler(context, EncodeEventHandler, hwndWorking),
				options,
				encryptOptions,
				*pSignOptions,
				PGPOSendNullEvents(context, 100),
				PGPODataIsASCII(context, (PGPBoolean) bTextDocument),
				PGPOVersionString(context, pgpVersionHeaderString()),
				PGPOAskUserForEntropy(context, TRUE),
				PGPOForYourEyesOnly(context,
					(PGPBoolean)((prds->dwOptions & kPGPclSecureViewer)
									== kPGPclSecureViewer)),
				PGPOLastOption(context));

		WorkingCallback(hwndWorking, -1, -1);

		if (options != NULL)
		{
			PGPFreeOptionList(options);
			options = NULL;
		}

		if (err == kPGPError_BadPassphrase)
		{
			if (encryptOptions != NULL)
			{
				PGPFreeOptionList(encryptOptions);
				encryptOptions = NULL;
			}

			PGPFreeOptionList(*pSignOptions);
			*pSignOptions = NULL;
		}
	}

	if (IsPGPError(err) && (err != kPGPError_UserAbort))
	{
		DisplayErrorCode(__FILE__, __LINE__, szModule, err, FALSE, hwnd);
		goto EncryptSignError;
	}

	if (IsntPGPError(err))
	{
		if (*pSignOptions == NULL)
			PGPBuildOptionList(context, pSignOptions, 
				PGPOLastOption(context));

		PGPBuildOptionList(context, &tempOptions, 
			*pSignOptions,
			encryptOptions,
			PGPOLastOption(context));

		PGPFreeOptionList(*pSignOptions);
		PGPFreeOptionList(encryptOptions);
		*pSignOptions = tempOptions;
		encryptOptions = NULL;
	}

EncryptSignError:

	if (szPassphrase != NULL)
	{
		PGPclFreeCachedPhrase(szPassphrase);
		szPassphrase = NULL;
	}

	if (pPasskey != NULL)
	{
		PGPFreeData(pPasskey);
		pPasskey = NULL;
	}

	if (szConvPass != NULL)
	{
		PGPclFreePhrase(szConvPass);
		szConvPass = NULL;
	}

	if (encryptOptions != NULL)
		PGPFreeOptionList(encryptOptions);

	if (options != NULL)
		PGPFreeOptionList(options);

	return err;
}


PGPError EncodeEventHandler(PGPContextRef context, 
							PGPEvent *event, 
							PGPUserValue userValue)
{
	HWND			hwnd			= NULL;
	PGPError		err				= kPGPError_NoErr;

	pgpAssert(context != NULL);
	pgpAssert(event != NULL);

	hwnd = (HWND) userValue;

	switch (event->type)
	{
	case kPGPEvent_EntropyEvent:
		err = PGPclRandom(context, hwnd, 
				event->data.entropyData.entropyBitsNeeded);
		break;

	case kPGPEvent_NullEvent:
		{	
			PGPEventNullData *d = &event->data.nullData;
			BOOL bCancel;

			bCancel = WorkingCallback (	(HWND)userValue, 
										(unsigned long)d->bytesWritten, 
										(unsigned long)d->bytesTotal) ;

			if(bCancel)
			{
				return kPGPError_UserAbort;
			}
		}
		break;
	}

	return err;
}


void DisplayErrorCode(char *szFile, int nLine, char *szModule, int nCode,
					  BOOL bKeyrings, HWND hParentWnd)
{
	char szErrorMsg[255];

	if (bKeyrings)
		PGPclErrorToString(nCode, szErrorMsg, 254, NULL);
	else
		PGPclEncDecErrorToString(nCode, szErrorMsg, 254);

#ifdef _DEBUG
	_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_WNDW);
	_CrtDbgReport(_CRT_ERROR, szFile, nLine, szModule, szErrorMsg);
#endif

	MessageBox(hParentWnd, szErrorMsg, szModule, MB_ICONEXCLAMATION);
	return;
}


/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/