PGPError
AddEvents(
PGPContextRef context,
PGPEvent *event,
PGPUserValue userValue
)
{
MYSTATE *s;
(void) context;
s = (MYSTATE *)userValue;
if(SCGetProgressCancel(s->hPrgDlg))
return kPGPError_UserAbort;
switch( event->type )
{
case kPGPEvent_NullEvent:
{ PGPEventNullData *d = &event->data.nullData;
if(d->bytesTotal!=0)
{
return SCSetProgressBar(s->hPrgDlg,
(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_AnalyzeEvent:
{ PGPEventAnalyzeData *d = &event->data.analyzeData;
if(d->sectionType!=kPGPAnalyze_Key)
return kPGPError_SkipSection;
s->FoundPGPData=TRUE;
}
break;
default:
break;
}
return kPGPError_NoErr;
}
PluginError PerformTranslation(
short trans_id,
char* in_file,
char* out_file,
char** addresses,
emsMIMEtypeP in_mime,
emsMIMEtypeP* out_mime
)
{
PluginError pluginReturn = EMSR_UNKNOWN_FAIL;
BOOL bSign = FALSE;
PGPError error = 0;
PGPSize mimeBodyOffset = 0;
char szExe[256];
char szDll[256];
assert(in_file);
assert(out_file);
LoadString(g_hinst, IDS_EXE, szExe, sizeof(szExe));
LoadString(g_hinst, IDS_DLL, szDll, sizeof(szDll));
switch( trans_id )
{
case kEncryptTranslatorID:
case kSignTranslatorID:
case kEncryptAndSignTranslatorID:
{
char** RecipientList = NULL;
unsigned long numRecipients = 0;
PGPOptionListRef pgpOptions = NULL;
PGPOptionListRef signOptions = NULL;
char mimeSeparator[kPGPMimeSeparatorSize];
PRECIPIENTDIALOGSTRUCT prds = NULL;
// allocate a recipient dialog structure
prds = (PRECIPIENTDIALOGSTRUCT)
calloc(sizeof(RECIPIENTDIALOGSTRUCT), 1);
if(prds)
{
char szTitle[256] = {0x00}; // title for recipient dialog
UINT recipientReturn = FALSE; // recipient dialog result
error = PGPsdkLoadDefaultPrefs(g_pgpContext);
if (IsPGPError(error))
{
PGPclEncDecErrorBox(g_hwndEudoraMainWindow, error);
return EMSR_UNKNOWN_FAIL;
}
error = PGPOpenDefaultKeyRings(g_pgpContext,
(PGPKeyRingOpenFlags)0,
&(prds->OriginalKeySetRef));
if (IsPGPError(error))
{
PGPclEncDecErrorBox(g_hwndEudoraMainWindow, error);
return EMSR_UNKNOWN_FAIL;
}
if ((trans_id == kEncryptTranslatorID) ||
(trans_id == kEncryptAndSignTranslatorID))
{
if(addresses) // do we have addresses to pass along
{
numRecipients = CreateRecipientList(addresses,
&RecipientList);
}
LoadString(GetModuleHandle("PGPplugin.dll"),
IDS_TITLE_RECIPIENTDIALOG, szTitle, sizeof(szTitle));
prds->Context = g_pgpContext;
prds->tlsContext = g_tlsContext;
prds->Version = CurrentPGPrecipVersion;
prds->hwndParent = g_hwndEudoraMainWindow;
prds->szTitle = szTitle;
prds->dwOptions = PGPCL_ASCIIARMOR;
prds->dwDisableFlags = PGPCL_DISABLE_WIPEORIG |
PGPCL_DISABLE_ASCIIARMOR |
PGPCL_DISABLE_SDA;
prds->dwNumRecipients = numRecipients;
prds->szRecipientArray = RecipientList;
/* Disable FYEO if there's an attachment or HTML */
if (in_mime && !match_mime_type(in_mime, "text", "plain"))
prds->dwDisableFlags |= PGPCL_DISABLE_FYEO;
// If shift is pressed, force the dialog to pop.
if (GetAsyncKeyState( VK_CONTROL) & 0x8000)
prds->dwDisableFlags|=PGPCL_DISABLE_AUTOMODE;
// See who we wish to encrypt this to
recipientReturn = PGPclRecipientDialog( prds );
if (prds->AddedKeys != NULL)
{
PGPUInt32 numKeys;
PGPCountKeys(prds->AddedKeys, &numKeys);
if (numKeys > 0)
PGPclQueryAddKeys(g_pgpContext, g_tlsContext,
g_hwndEudoraMainWindow, prds->AddedKeys,
NULL);
PGPFreeKeySet(prds->AddedKeys);
prds->AddedKeys = NULL;
}
if (!recipientReturn)
{
if (RecipientList)
FreeRecipientList(RecipientList, numRecipients);
if (prds->SelectedKeySetRef != NULL)
PGPFreeKeySet(prds->SelectedKeySetRef);
PGPFreeKeySet(prds->OriginalKeySetRef);
free(prds);
return EMSR_UNKNOWN_FAIL;
}
}
if( IsntPGPError(error) )
{
error = PGPBuildOptionList(g_pgpContext, &pgpOptions,
PGPOOutputLineEndType(g_pgpContext,
kPGPLineEnd_CRLF),
PGPOPGPMIMEEncoding(g_pgpContext,
TRUE,
&mimeBodyOffset,
mimeSeparator),
PGPOLastOption(g_pgpContext) );
}
if(IsntPGPError( error))
{
error = EncryptSignFile(g_hinst, g_hwndEudoraMainWindow,
g_pgpContext, g_tlsContext, szExe,
szDll, in_file, prds, pgpOptions,
&signOptions, out_file,
((trans_id ==
kSignTranslatorID) ? FALSE : TRUE ),
((trans_id ==
kEncryptTranslatorID) ? FALSE : TRUE ),
FALSE);
PGPFreeOptionList(pgpOptions);
PGPFreeOptionList(signOptions);
}
else
{
PGPclEncDecErrorBox (NULL, error);
}
if (RecipientList)
FreeRecipientList(RecipientList, numRecipients);
if (prds->SelectedKeySetRef != NULL)
PGPFreeKeySet(prds->SelectedKeySetRef);
PGPFreeKeySet(prds->OriginalKeySetRef);
free(prds);
if( IsntPGPError(error) )
{
if( out_mime )
{
pluginReturn = BuildEncryptedPGPMIMEType(
out_mime,
mimeSeparator );
if(EMSR_OK == pluginReturn)
{
pluginReturn = AddMIMEParam(*out_mime,
"PGPFormat",
"PGPMIME-encrypted" );
}
}
}
}
break;
}
case kDecryptTranslatorID:
case kVerifyTranslatorID:
{
char *szTempFile = NULL;
BOOL bFYEO = FALSE;
void *pOutput = NULL;
PGPSize outSize = 0;
error = DecryptVerifyFile(g_hinst, g_hwndEudoraMainWindow,
g_pgpContext, g_tlsContext, szExe, szDll, in_file,
TRUE, FALSE, &szTempFile, &pOutput, &outSize, &bFYEO);
if( IsntPGPError(error) )
{
if ((bFYEO)||(GetSecureViewerPref((void *)g_pgpContext)))
TempestViewer((void *)g_pgpContext,NULL,pOutput,outSize,
bFYEO);
CopyFile(szTempFile, out_file, FALSE);
DeleteFile(szTempFile);
if( out_mime )
{
ParseFileForMIMEType( out_file, out_mime );
}
if ((bFYEO)||(GetSecureViewerPref((void *)g_pgpContext)))
pluginReturn = EMSR_UNKNOWN_FAIL;
else
pluginReturn = EMSR_OK;
}
if (szTempFile != NULL)
PGPFreeData(szTempFile);
if (pOutput != NULL)
PGPFreeData(pOutput);
break;
}
}
return pluginReturn;
}
BOOL
EncryptSignRichEditText(char** ppBuffer,
long* pLength,
BOOL bEncrypt,
BOOL bSign,
char** pAddresses,
long NumAddresses,
char* pAttachments,
char** ppOutAttachments)
{
BOOL ReturnValue = FALSE;
void* pOutput = NULL;
long outSize = 0;
PGPError error = kPGPError_NoErr;
PGPOptionListRef userOptions = NULL;
PGPclRecipientDialogStruct *prds = NULL;
char szExe[256];
char szDll[256];
LoadString(g_hinst, IDS_EXE, szExe, sizeof(szExe));
LoadString(g_hinst, IDS_DLL, szDll, sizeof(szDll));
// allocate a recipient dialog structure
prds = (PGPclRecipientDialogStruct *)
calloc(sizeof(PGPclRecipientDialogStruct), 1);
if (!prds)
{
PGPclErrorBox(g_hwndEudoraMainWindow, kPGPError_OutOfMemory);
return FALSE;
}
error = PGPclOpenDefaultKeyrings(g_pgpContext,
kPGPOpenKeyDBFileOptions_Mutable, &(prds->keydbOriginal));
if (IsPGPError(error))
error = PGPclOpenDefaultKeyrings(g_pgpContext,
kPGPOpenKeyDBFileOptions_None, &(prds->keydbOriginal));
if (IsPGPError(error))
{
char szTitle[255];
char szBuffer[1024];
LoadString(g_hinst, IDS_DLL, szTitle, 254);
LoadString(g_hinst, IDS_Q_NOKEYRINGS, szBuffer, 1023);
if (MessageBox(g_hwndEudoraMainWindow, szBuffer, szTitle, MB_YESNO))
{
char szPath[MAX_PATH];
PGPclGetPath(kPGPclPGPkeysExeFile, szPath, MAX_PATH-1);
PGPclExecute(szPath, SW_SHOW);
}
return S_FALSE;
}
if(prds && bEncrypt)
{
char szTitle[256] = {0x00}; // title for recipient dialog
UINT recipientReturn = FALSE; // recipient dialog result
LoadString(GetModuleHandle("PGPplugin.dll"),
IDS_TITLE_RECIPIENTDIALOG, szTitle, sizeof(szTitle));
if( IsntPGPError(error) )
{
prds->context = g_pgpContext;
prds->tlsContext = g_tlsContext;
prds->Version = kPGPCurrentRecipVersion;
prds->hwndParent = g_hwndEudoraMainWindow;
prds->szTitle = szTitle;
prds->dwOptions = kPGPclASCIIArmor;
prds->dwDisableFlags = kPGPclDisableWipeOriginal |
kPGPclDisableASCIIArmor |
kPGPclDisableSelfDecryptingArchive |
kPGPclDisableInputIsText;
prds->dwNumRecipients = NumAddresses;
prds->szRecipientArray = pAddresses;
// If shift is pressed, force the dialog to pop.
if (GetAsyncKeyState( VK_CONTROL) & 0x8000)
prds->dwDisableFlags |= kPGPclDisableAutoMode;
// See who we wish to encrypt this to
recipientReturn = PGPclRecipientDialog( prds );
}
if (prds->keydbAdded != NULL)
{
PGPUInt32 numKeys;
PGPKeySetRef keySet;
PGPNewKeySet(prds->keydbAdded, &keySet);
PGPCountKeys(keySet, &numKeys);
if (numKeys > 0)
PGPclImportKeys(g_pgpContext, g_tlsContext, prds->hwndParent,
keySet, prds->keydbOriginal,
kPGPclNoDialogForValidSingletons);
PGPFreeKeySet(keySet);
PGPFreeKeyDB(prds->keydbAdded);
prds->keydbAdded = NULL;
}
if (!recipientReturn)
{
if (prds->keydbSelected != NULL)
PGPFreeKeyDB(prds->keydbSelected);
PGPFreeKeyDB(prds->keydbOriginal);
free(prds);
return FALSE;
}
}
if( IsntPGPError(error) )
{
error = EncryptSignBuffer(g_hinst, g_hwndEudoraMainWindow,
g_pgpContext, g_tlsContext, szExe, szDll,
*ppBuffer, *pLength, prds, NULL, &userOptions, &pOutput,
&outSize, bEncrypt, bSign, FALSE, FALSE);
}
else
{
PGPclEncDecErrorBox(g_hwndEudoraMainWindow, error);
}
*pLength = outSize;
if( IsntPGPError(error) )
{
if( pOutput )
{
*ppBuffer = (char*)HeapReAlloc( GetProcessHeap(),
HEAP_ZERO_MEMORY,
*ppBuffer,
*pLength + 1);
if(*ppBuffer)
{
ReturnValue = TRUE;
memcpy(*ppBuffer, (char*)pOutput, *pLength);
*(*ppBuffer + *pLength) = 0x00; // NULL terminate the string
memset(pOutput, 0x00, *pLength);
}
else
{
error = kPGPError_OutOfMemory;
}
PGPFreeData(pOutput);
}
}
// are there attachments?
if(IsntPGPError(error) && pAttachments && *pAttachments)
{
error = EncryptAttachments( pAttachments,
ppOutAttachments,
prds,
userOptions,
bEncrypt,
bSign);
}
if(userOptions != NULL)
{
PGPFreeOptionList(userOptions);
}
if (prds)
{
if (prds->keydbSelected != NULL)
PGPFreeKeyDB(prds->keydbSelected);
PGPFreeKeyDB(prds->keydbOriginal);
free(prds);
}
return ReturnValue;
}
