scevents.c

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

/*__________________________________________________________________________
 Copyright (C) 2002 PGP Corporation
 All rights reserved.
 
 $Id: SCevents.c,v 1.10 2002/10/12 22:19:12 wjb Exp $
__________________________________________________________________________*/
#include "precomp.h"
#include "pgpUnicodeWin32.h"

void MakeHeaderFooter(OUTBUFFLIST **obl,
					  OUTBUFFLIST **headobl,
					  OUTBUFFLIST **footobl)
{
	OUTBUFFLIST *lastobl,*indexobl,*prevobl;
				
	prevobl=lastobl=0;
	indexobl=*obl;

	while(indexobl!=0)
	{
		prevobl=lastobl;
		lastobl=indexobl;
		indexobl=indexobl->next;
	}

	// Trim off last entry
	if(prevobl==0)
	{
		*obl=0;
	}
	else
	{
		prevobl->next=0;
	}

	// Create header
	*headobl=PGPscMakeOutBuffItem(obl);

	// Add back in entry
	(*headobl)->next=lastobl;

	// Creater footer
	*footobl=PGPscMakeOutBuffItem(obl);
}

/* Generic event handler */
PGPError
myEvents(
	PGPContextRef context,
	PGPEvent *event,
	PGPUserValue userValue
	)
{
	MYSTATE *s;
	(void) context;

	s = (MYSTATE *)userValue;

	if(PGPscProgressGetCancel(s->hwndWorking))
	{	
		s->bVerEncrypted=FALSE;
		return kPGPError_UserAbort;
	}

	switch( event->type ) 
	{
	case kPGPEvent_NullEvent:
		{	PGPEventNullData *d = &event->data.nullData;

			if(d->bytesTotal!=0)
			{
				return PGPscProgressSetBar(s->hwndWorking,
					(DWORD)(d->bytesWritten*100/d->bytesTotal),FALSE);
			}
		}
		break;
	case kPGPEvent_ErrorEvent:
		{	PGPEventErrorData *d = &event->data.errorData;

			if((d->error!=kPGPError_BadPassphrase)&&
				(d->error!=kPGPError_UserAbort))
				PGPclEncDecErrorBox (s->hwndWorking,d->error); 
		}
		break;
	case kPGPEvent_WarningEvent:
		{	PGPEventWarningData *d = &event->data.warningData;

		}
		break;
	case kPGPEvent_EntropyEvent:
		{	PGPEventEntropyData *d = &event->data.entropyData;
			PGPError err;

			err=PGPclRandom(context, s->hwndWorking, 
				d->entropyBitsNeeded);

			if(err==kPGPError_UserAbort)
			{
				s->bVerEncrypted=FALSE;
				return kPGPError_UserAbort;
			}
		}
		break;
	case kPGPEvent_PassphraseEvent:
		{
			PGPEventPassphraseData *d = &event->data.passphraseData;
			BOOL UserCancel;
			char DecryptPrompt[40];
			char StrRes[500];
			char szPassTitle[100];

			if(s->PassKey)
			{
				memset(s->PassKey,0x00,s->PassKeyLen);
				PGPFreeData(s->PassKey);
				s->PassKey=NULL;
				s->PassKeyLen=0;
			}

			// Don't cache conventional passphrases
			if(d->fConventional)
			{
				PGPError PhraseErr;

				if(s->PassCount & 0x01)
				{
					char*		passphraseNonUTF8	= NULL;
					PGPSize		size;
					PGPUInt32	uLen;

					// try a non-UTF8 version of same phrase
					size = strlen( s->PassPhrase );
					passphraseNonUTF8 = (char*) PGPNewSecureData(
							PGPPeekContextMemoryMgr( context ), 
							size +1, 0 );

					if (passphraseNonUTF8)
					{
						pgpUTF8StringToLocal( kPGPUnicodeFlag_Secure, 
								0, s->PassPhrase, size, 
								passphraseNonUTF8, size, &uLen );
						passphraseNonUTF8[uLen] = '\0';

						PGPclFreeCachedPhrase (s->PassPhrase);
						s->PassPhrase = passphraseNonUTF8;
					}

					UserCancel = FALSE;
				}
				else
				{
					// If multiple passphrase events, clear previous
					if(s->PassPhrase)
					{
						PGPclFreeCachedPhrase (s->PassPhrase);
						s->PassPhrase=NULL;
					}

					if(s->PassCount > 0)
					{
						LoadString(g_hinst, IDS_WRONG_PHRASE, 
								DecryptPrompt, sizeof(DecryptPrompt));
					}
					else 
					{
						LoadString(g_hinst, IDS_ENTER_PHRASE, 
								DecryptPrompt, sizeof(DecryptPrompt));
						LoadString (g_hinst, IDS_DECRYPTIONCOLON, 
								StrRes, sizeof(StrRes));
						lstrcat (DecryptPrompt, StrRes);
					}

					PhraseErr=PGPclGetPhrase (context,
						s->KeyDB,
						s->hwndWorking,
						DecryptPrompt,
						&(s->PassPhrase), 
						NULL,
						NULL, 
						0,
						NULL,
						NULL,
						kPGPclDecryption,
						NULL,NULL,
						0,0,s->tlsContext,NULL,NULL);

					UserCancel=IsPGPError(PhraseErr);
				}

				s->PassCount++;
			}
			else
			// Go through caching otherwise
			{
				BOOL ForceEntry = FALSE;
				char PhraseTitle[256];

				// If multiple passphrase events, clear previous
				if(s->PassPhrase)
				{
					PGPclFreeCachedPhrase (s->PassPhrase);
					s->PassPhrase=NULL;
				}

				LoadString (g_hinst, IDS_ENTERPASSPHRASE, StrRes, sizeof(StrRes));
				strcpy(szPassTitle,s->szAppName);
				strcat(szPassTitle,StrRes);

				LoadString (g_hinst, IDS_PRIVATEKEYCOLON, StrRes, sizeof(StrRes));
				strcpy(DecryptPrompt,StrRes);

				if(s->PassPhrase)
				{
					PGPclFreeCachedPhrase(s->PassPhrase);
					s->PassPhrase = NULL;
				}

				if(s->PassCount > 0)
				{
					LoadString(g_hinst, IDS_WRONG_PHRASE, PhraseTitle, sizeof(PhraseTitle));
					ForceEntry = TRUE;
				}
				else 
				{
					LoadString(g_hinst, IDS_ENTER_PHRASE, PhraseTitle, sizeof(PhraseTitle));
					lstrcat (PhraseTitle, DecryptPrompt);
				}

				UserCancel=(PGPclGetCachedDecryptionPhrase (s->context,
					s->tlsContext,
					s->KeyDB,
					s->hwndWorking, 
					PhraseTitle, 
					ForceEntry,
					&(s->PassPhrase),
					s->RecipientKeySet,
					s->RecipientKeyIDArray,
					s->dwKeyIDCount,
					&(s->PassKey),
					&(s->PassKeyLen),
					&(s->AddedKeyDB),
					szPassTitle)!= kPGPError_NoErr);

				s->PassCount++;
			}
			
			if(UserCancel)
			{
				s->bVerEncrypted=FALSE;
				return kPGPError_UserAbort;
			}
	
			// Use passphrase first if available
			if(s->PassPhrase)
			{
				PGPAddJobOptions( event->job, 
					PGPOPassphraseBuffer(context,
						s->PassPhrase, strlen(s->PassPhrase) ),
					PGPOLastOption(context));
			}
			else if(s->PassKey)
			{
				PGPAddJobOptions( event->job, 
					PGPOPasskeyBuffer(context,
						s->PassKey,s->PassKeyLen),
					PGPOLastOption(context));
			}
		}
		break;
	case kPGPEvent_SignatureEvent:
		{	PGPEventSignatureData *d = &event->data.signatureData;
			OUTBUFFLIST *headobl,*footobl;
			BOOL bSigEvent;

			bSigEvent=FALSE;

			if ((d->signingKey == NULL) &&
				SyncOnVerify(PGPPeekContextMemoryMgr(context)))
			{
				PGPBoolean bGotKeys;

				// From Synch on Verify
				if(s->keydbLookup)
				{
					PGPFreeKeyDB(s->keydbLookup);
					s->keydbLookup=NULL;
				}

				PGPclLookupUnknownSigner(context, 
					s->KeyDB,s->tlsContext, 
					s->hwndWorking, event, 
					d->signingKeyID, &bGotKeys,
					&(s->keydbLookup));

				if (bGotKeys)
					return kPGPError_NoErr;
			}

			// Ugly I know, but we need footers and PGPlog for
			// ICQ -wjb
			if(s->szAppName!=NULL)
			{
				if(!strcmp(s->szAppName,"PGPicq"))
				{
					bSigEvent=TRUE;
					strcpy((char *)s->verifyName,s->szAppName);
				}
			}

			if(s->Operation!=MS_DECRYPTCLIPBOARD)
			{
				bSigEvent=TRUE;
			}

			if(bSigEvent)
			{
				SigEvent(s->hwndWorking,context,d,(char *)s->verifyName);
			}

			if(s->Operation==MS_DECRYPTCLIPBOARD)
			{
				MakeHeaderFooter(&(s->obl),
					  &headobl,
					  &footobl);

				CreateVerificationBlock(g_hinst, context, d,
					s->bVerEncrypted,
					&(headobl->pBuff),
					&(footobl->pBuff));

				if(s->bVerEncrypted)
					headobl->dwType=OBL_LOCK;

				// We don't want another header footer made.
				s->bVerEncrypted=FALSE;

				if(d->verified)
					headobl->dwType|=OBL_SIG;

				footobl->dwType=OBL_END;

				headobl->dwBuffSize=strlen(headobl->pBuff);
				footobl->dwBuffSize=strlen(footobl->pBuff);
			}
		}
		break;
	case kPGPEvent_RecipientsEvent:
		{
			PGPEventRecipientsData *d = &event->data.recipientsData;
			PGPUInt32 i,memamt;
			
			// Save recipient key set for passphrase dialog
			PGPIncKeySetRefCount(d->recipientSet);
			s->RecipientKeySet=d->recipientSet;

			// Save unknown keyids
			if(d->keyCount>0)
			{
				s->dwKeyIDCount=d->keyCount;
				memamt=s->dwKeyIDCount*sizeof(PGPKeyID);
				s->RecipientKeyIDArray=(PGPKeyID *)malloc(memamt);
				memset(s->RecipientKeyIDArray,0x00,memamt);

				for(i=0;i<s->dwKeyIDCount;i++)
				{
					s->RecipientKeyIDArray[i]=d->keyIDArray[i];
				}
			}
		}
		break;
	case kPGPEvent_AnalyzeEvent:
		{	PGPEventAnalyzeData *d = &event->data.analyzeData;

			s->bVerEncrypted = (d->sectionType == kPGPAnalyze_Encrypted);

			if(d->sectionType==kPGPAnalyze_Unknown)
			{
				// If its tray, we want to keep it
				if(s->Operation!=MS_DECRYPTCLIPBOARD)
					return kPGPError_SkipSection;
			}
			else
			{
				s->FoundPGPData=TRUE;
			}
		}
		break;
	case kPGPEvent_DetachedSignatureEvent:
		{
			int UserCancel;

			UserCancel=GetOriginalFileRef(s->hwndWorking,context,
				s->fileName,(char *)s->verifyName,
				&(s->fileRef),s->hwndWorking);

			if(UserCancel)
			{
				s->bVerEncrypted=FALSE;
				return kPGPError_UserAbort;
			}

			PGPAddJobOptions(event->job,
				PGPODetachedSig(context,
					PGPOInputFile(context,s->fileRef),
					PGPOLastOption(context)),
				PGPOLastOption(context));
		}
		break;
	case kPGPEvent_OutputEvent:
		{	PGPEventOutputData *d = &event->data.outputData;
			int UserCancel;
			char inname[MAX_PATH];
			char guessName[MAX_PATH];
			char *suggestedName;
			BOOL Force;
			char StrRes[500];
			PGPBoolean FYEO;
			OUTBUFFLIST *nobl;
			int len;

			FYEO=d->forYourEyesOnly;

			// Since we need an output event to get eyes data,
			// even buffers need to be assigned...
			if((s->Operation==MS_DECRYPTCLIPBOARD)||(FYEO))
			{
				nobl=PGPscMakeOutBuffItem(&(s->obl));

				nobl->FYEO=FYEO;

				PGPAddJobOptions(event->job,
					PGPOAllocatedOutputBuffer(context,&(nobl->pBuff), 
						MAX_PGPSize ,&(nobl->dwBuffSize)),
					PGPOLastOption(context));
				break;
			}

			if(d->suggestedName!=0)
			{
				suggestedName=d->suggestedName;
				Force=FALSE;
			}
			else 
			{
				char *p;

				strcpy(guessName,PGPscJustFile(s->fileName));

				p = strrchr(guessName, '.');

				if(p!=0)
					*p=0;

				suggestedName=guessName;
				Force=FALSE; // Let guess be OK too.
			}

			strcpy(inname,s->fileName);

			AlterDecryptedFileName(inname,suggestedName);

			// Double check if DLLs coming through the pipe
			len=strlen(inname);
			if(len>=4)
			{
				if((!stricmp(&(inname[len-4]),".dll"))||
					(!stricmp(&(inname[len-4]),".vxd"))||
					(!stricmp(&(inname[len-4]),".sys")))
					Force=TRUE;
			}

			LoadString (g_hinst, IDS_ENTEROUTPUTFILENAME, StrRes, sizeof(StrRes));

			UserCancel=SaveOutputFile(context,
				s->hwndWorking, 
				StrRes,
				inname,
				&(s->fileRef),
				Force);

			if(UserCancel)
			{
				s->bVerEncrypted=FALSE;
				return kPGPError_UserAbort;
			}

			PGPAddJobOptions(event->job,
				PGPOOutputFile(context,s->fileRef),
				PGPOLastOption(context));
		}
		break;
	case kPGPEvent_BeginLexEvent:
		{	PGPEventBeginLexData *d = &event->data.beginLexData;
			s->sectionCount = d->sectionNumber;
		}
		break;
	case kPGPEvent_EndLexEvent:
		{	PGPEventEndLexData *d = &event->data.endLexData;

			if((s->Operation==MS_DECRYPTCLIPBOARD)&&
				(s->bVerEncrypted))
			{
				OUTBUFFLIST *headobl,*footobl;

				MakeHeaderFooter(&(s->obl),
					&headobl,
					&footobl);

				headobl->dwType=OBL_LOCK;
				footobl->dwType=OBL_END;
			}
		}
		break;
		
	default:
		break;
	}
				
	return kPGPError_NoErr;
}

/*__Editor_settings____

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