PGPError PGPclExport
PGPclUpdateKeySetFromServer (
PGPContextRef context,
PGPtlsContextRef tlsContext,
HWND hwndParent,
PGPKeySetRef keysetToUpdate,
UINT uServer,
PGPKeySetRef keysetMain,
PGPKeySetRef* pkeysetResult)
{
PGPError err = kPGPError_NoErr;
PGPKeySetRef keysetCollect = kInvalidPGPKeySetRef;
PGPOptionListRef optionSearch = kInvalidPGPOptionListRef;
PGPKeyListRef keylist = kInvalidPGPKeyListRef;
PGPKeyIterRef keyiter = kInvalidPGPKeyIterRef;
PGPKeySetRef keyset = kInvalidPGPKeySetRef;
PGPKeyID keyid;
// initialize return keyset
PGPValidatePtr (pkeysetResult);
*pkeysetResult = kInvalidPGPKeySetRef;
if (uServer == PGPCL_USERIDBASEDSERVER) {
PGPKeyRef key = kInvalidPGPKeyRef;
CHAR szUserID[kPGPMaxUserIDSize+1];
PGPSize size;
err = PGPNewKeySet (context, &keysetCollect); CKERR;
err = PGPOrderKeySet (keysetToUpdate,
kPGPAnyOrdering, &keylist); CKERR;
err = PGPNewKeyIter (keylist, &keyiter); CKERR;
while ( IsntPGPError (err) &&
IsntPGPError (PGPKeyIterNext (keyiter, &key)) &&
PGPKeyRefIsValid (key))
{
err = PGPGetPrimaryUserIDNameBuffer (key, kPGPMaxUserIDSize,
szUserID, &size); CKERR;
err = PGPGetKeyIDFromKey (key, &keyid); CKERR;
optionSearch = PGPOUIKeyServerSearchKeyIDList (context,
1, &keyid);
if (PGPOptionListRefIsValid (optionSearch)) {
err = sQueryServerInternal (hwndParent,
context,
tlsContext,
optionSearch,
uServer,
szUserID,
keysetMain,
&keyset);
if (IsPGPError (PGPclErrorBox (hwndParent, err)))
err = kPGPError_NoErr;
if (IsntPGPError (err))
{
if (PGPKeySetRefIsValid (keyset))
{
err = PGPAddKeys (keyset, keysetCollect);
if (IsntPGPError (PGPclErrorBox (hwndParent, err)))
{
err = PGPCommitKeyRingChanges (keysetCollect);
PGPclErrorBox (hwndParent, err);
}
}
}
if (PGPKeySetRefIsValid (keyset))
{
PGPFreeKeySet (keyset);
keyset = kInvalidPGPKeySetRef;
}
}
}
if (PGPKeySetRefIsValid (keysetCollect))
{
*pkeysetResult = keysetCollect;
keysetCollect = kInvalidPGPKeySetRef;
}
}
else {
optionSearch = PGPOUIKeyServerSearchKeySet (context, keysetToUpdate);
if (PGPOptionListRefIsValid (optionSearch)) {
err = sQueryServerInternal (hwndParent,
context,
tlsContext,
optionSearch,
uServer,
"",
keysetMain,
&keysetCollect);
if (IsntPGPError (err))
{
*pkeysetResult = keysetCollect;
keysetCollect = kInvalidPGPKeySetRef;
}
}
}
done :
if (PGPKeyListRefIsValid (keylist))
PGPFreeKeyList (keylist);
if (PGPKeyIterRefIsValid (keyiter))
PGPFreeKeyIter (keyiter);
if (PGPKeySetRefIsValid (keyset))
PGPFreeKeySet (keyset);
if (PGPKeySetRefIsValid (keysetCollect))
PGPFreeKeySet (keysetCollect);
return err;
}
void AddSelectedKeys(HWND hWnd,
int nListCtrl,
PGPContextRef pgpContext,
PGPKeySetRef *pKeySet)
{
int nIndex;
LV_ITEM lviKey;
HWND hList;
PGPKeyRef newKey;
PGPKeySetRef userKeySet;
PGPKeySetRef newKeySet;
PGPKeyID newKeyID;
PGPError err;
PGPPublicKeyAlgorithm newKeyAlg;
if(IsPGPError(err = PGPOpenDefaultKeyRings(pgpContext,
(PGPKeyRingOpenFlags) 0, &userKeySet)))
{
MessageBox(NULL, "PGPOpenDefaultKeyRings error", "debug", MB_OK);
return;
}
hList = GetDlgItem(hWnd, nListCtrl);
if (*pKeySet != NULL)
PGPFreeKeySet(*pKeySet);
*pKeySet = NULL;
nIndex = ListView_GetNextItem(hList, -1, LVNI_SELECTED);
if (nIndex != -1)
PGPNewKeySet(pgpContext, pKeySet);
while (nIndex > -1)
{
lviKey.mask = LVIF_PARAM | LVIF_IMAGE;
lviKey.iItem = nIndex;
lviKey.iSubItem = 0;
ListView_GetItem(hList, &lviKey);
PGPGetKeyIDFromString((char *) lviKey.lParam, &newKeyID);
switch (lviKey.iImage)
{
case IDX_RSAPUBKEY:
newKeyAlg = kPGPPublicKeyAlgorithm_RSA;
break;
case IDX_DSAPUBKEY:
newKeyAlg = kPGPPublicKeyAlgorithm_DSA;
break;
default:
pgpDebugMsg("Image index isn't RSA or DSA!");
}
err = PGPGetKeyByKeyID(userKeySet, &newKeyID, newKeyAlg, &newKey);
if ((newKey != NULL) && (IsntPGPError(err)))
{
PGPNewSingletonKeySet(newKey, &newKeySet);
PGPAddKeys( newKeySet, *pKeySet);
PGPFreeKeySet(newKeySet);
}
nIndex = ListView_GetNextItem(hList,
nIndex, LVNI_SELECTED);
}
PGPFreeKeySet(userKeySet);
return;
}
BOOL
KMAddRevoker (PKEYMAN pKM)
{
PGPKeySetRef keysetToChoose = kInvalidPGPKeySetRef;
PGPKeySetRef keysetToRemove = kInvalidPGPKeySetRef;
PGPKeySetRef keysetThisKey = kInvalidPGPKeySetRef;
PGPKeySetRef keysetSelected = kInvalidPGPKeySetRef;
PGPFilterRef filterRSA = kInvalidPGPFilterRef;
PGPError err = kPGPError_NoErr;
PGPByte* pbyte = NULL;
BOOL bRet = FALSE;
PGPUInt32 uCount = 0;
PGPBoolean bSyncWithServer = FALSE;
PGPPrefRef prefref;
PGPSize size;
PGPKeyRef key;
CHAR szPrompt[256];
key = (PGPKeyRef)KMFocusedObject (pKM);
PGPclOpenClientPrefs (PGPGetContextMemoryMgr (pKM->Context), &prefref);
PGPGetPrefBoolean (prefref, kPGPPrefKeyServerSyncOnAdd,
&bSyncWithServer);
PGPclCloseClientPrefs (prefref, FALSE);
err = PGPNewKeySet (pKM->Context, &keysetToChoose); CKERR;
err = PGPAddKeys (pKM->KeySetMain, keysetToChoose); CKERR;
err = PGPCommitKeyRingChanges (keysetToChoose); CKERR;
err = PGPNewKeyEncryptAlgorithmFilter (pKM->Context,
kPGPPublicKeyAlgorithm_RSA, &filterRSA); CKERR;
err = PGPFilterKeySet (pKM->KeySetMain,
filterRSA, &keysetToRemove); CKERR;
err = PGPCommitKeyRingChanges (keysetToRemove); CKERR;
err = PGPRemoveKeys (keysetToRemove, keysetToChoose); CKERR;
err = PGPCommitKeyRingChanges (keysetToChoose); CKERR;
err = PGPCountKeys (keysetToChoose, &uCount); CKERR;
if (uCount <= 1) {
KMMessageBox (pKM->hWndParent, IDS_PGP, IDS_NOTENOUGHKEYSTOADDREVOKER,
MB_OK|MB_ICONINFORMATION);
goto done;
}
err = PGPFreeKeySet (keysetToRemove); CKERR;
err = PGPNewSingletonKeySet (key, &keysetToRemove); CKERR;
err = PGPRemoveKeys (keysetToRemove, keysetToChoose); CKERR;
err = PGPCommitKeyRingChanges (keysetToChoose); CKERR;
LoadString (g_hInst, IDS_ADDREVOKERPROMPT, szPrompt, sizeof(szPrompt));
err = PGPclSelectKeys (pKM->Context, pKM->tlsContext,
pKM->hWndParent, szPrompt,
keysetToChoose, pKM->KeySetMain, &keysetSelected);
if (IsntPGPError (err) && PGPKeySetRefIsValid (keysetSelected))
{
if (KMMessageBox (pKM->hWndParent, IDS_CAPTION,
IDS_ADDREVOKERCONFIRM, MB_YESNO|MB_ICONEXCLAMATION) == IDYES)
{
err = KMGetKeyPhrase (pKM->Context, pKM->tlsContext,
pKM->hWndParent, NULL,
pKM->KeySetMain, key,
NULL, &pbyte, &size); CKERR;
// update from server
if (IsntPGPError (err) && bSyncWithServer) {
if (!KMGetFromServerInternal (pKM, FALSE, FALSE, FALSE)) {
if (KMMessageBox (pKM->hWndParent, IDS_CAPTION,
IDS_QUERYCONTINUEADDING,
MB_YESNO|MB_ICONEXCLAMATION) == IDNO)
{
err = kPGPError_UserAbort;
}
}
}
if (IsntPGPError (err)) {
err = PGPAddKeyOptions (key,
PGPORevocationKeySet (pKM->Context, keysetSelected),
pbyte ?
PGPOPasskeyBuffer (pKM->Context, pbyte, size) :
PGPONullOption (pKM->Context),
PGPOLastOption (pKM->Context)); CKERR;
}
}
else
err = kPGPError_UserAbort;
}
// send to server
if (IsntPGPError (err) && bSyncWithServer) {
KMSendToServer (pKM, PGPCL_DEFAULTSERVER);
}
if (IsntPGPError (err)) {
KMCommitKeyRingChanges (pKM);
bRet = TRUE;
if (bSyncWithServer) {
KMMessageBox (pKM->hWndParent, IDS_PGP, IDS_ADDEDSENTREVOKERS,
MB_OK|MB_ICONINFORMATION);
}
else {
KMMessageBox (pKM->hWndParent, IDS_PGP, IDS_ADDEDREVOKERS,
MB_OK|MB_ICONINFORMATION);
}
}
done :
if (NULL!=(int) (pbyte))
KMFreePasskey (pbyte, size);
if (PGPKeySetRefIsValid (keysetToChoose))
PGPFreeKeySet (keysetToChoose);
if (PGPKeySetRefIsValid (keysetToRemove))
PGPFreeKeySet (keysetToRemove);
if (PGPKeySetRefIsValid (keysetThisKey))
PGPFreeKeySet (keysetThisKey);
if (PGPKeySetRefIsValid (keysetSelected))
PGPFreeKeySet (keysetSelected);
if (PGPFilterRefIsValid (filterRSA))
PGPFreeFilter (filterRSA);
PGPclErrorBox (pKM->hWndParent, err);
return bRet;
}
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;
}
PGPError addToWorkingRingSet(struct pgpmainBones *mainbPtr, PGPKeySetRef
keySet, PGPBoolean bAddToDefault )
{
PGPContextRef context = mainbPtr->pgpContext;
PGPEnv *env = pgpContextGetEnvironment( context );
struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
PGPKeyIterRef iter = NULL;
PGPError err;
PGPKeyRef key = 0;
PGPKeyRef origkey = 0;
PGPKeyID keyid;
int copying = 0;
int newkeys = 0, newsigs = 0, newuids = 0, newrvks = 0;
PGPKeyListRef keylist = 0;
char* ringfile = "";
PGPInt32 pri;
PGPInt32 verbose = pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err );
PGPInt32 interactive = envbPtr->interactiveAdd;
PGPBoolean batchmode = pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &err );
PGPKeySetRef keepset = NULL, origset = NULL;
PGPBoolean ans;
PGPKeySetRef defKeySet = kPGPInvalidRef;
err = PGPOpenDefaultKeyRings(context, kPGPKeyRingOpenFlags_Mutable, &defKeySet);
if(IsPGPError(err))
goto done;
if(bAddToDefault)
mainbPtr->workingRingSet = defKeySet;
pgpAssertAddrValid( mainbPtr, struct pgpmainBones );
pgpAssertAddrValid( mainbPtr->workingRingSet, PGPKeySetRef );
err = PGPNewEmptyKeySet( mainbPtr->workingRingSet, &origset );
pgpAssertNoErr(err);
err = PGPOrderKeySet( keySet, kPGPAnyOrdering, &keylist );
pgpAssertNoErr(err);
err = PGPNewKeyIter( keylist, &iter );
pgpAssertNoErr(err);
if(verbose)
fprintf(filebPtr->pgpout,
LANG("\nPASS 1.. find the existing keys\n"));
err = PGPKeyIterRewind( iter );
pgpAssertNoErr(err);
err = PGPKeyIterNext( iter, &key);
if( err ) {
fprintf( filebPtr->pgpout,LANG("Could not read key from keyfile."));
goto done;
}
while( key ) {
err = PGPGetKeyIDFromKey( key, &keyid );
pgpAssertNoErr(err);
err = PGPGetKeyByKeyID( defKeySet, &keyid,
kPGPPublicKeyAlgorithm_Invalid,
&origkey );
if(err == 0 )
err = pgpAddKeyToKeySet( origkey, origset );
err = PGPKeyIterNext( iter, &key );
}
if(verbose)
fprintf(filebPtr->pgpout,
LANG("\nPASS 2.. ask whether to add the new keys\n"));
err = PGPKeyIterRewind( iter );
pgpAssertNoErr(err);
err = PGPKeyIterNext( iter, &key);
if( err ) {
fprintf( filebPtr->pgpout,LANG("Could not read key from keyfile."));
goto done;
}
while( key ) {
PGPBoolean isnew;
err = PGPGetKeyIDFromKey( key, &keyid );
pgpAssertNoErr(err);
err = PGPGetKeyByKeyID( defKeySet, &keyid,
kPGPPublicKeyAlgorithm_Invalid,
&origkey );
/* Copy if all criteria are met */
copying = 0;
isnew = FALSE;
if(err == 0 ) {
copying = 1;
} else {
/* is a new key*/
err = pgpShowKeyListFormat( filebPtr,
mainbPtr->workingRingSet, iter, key, kShow_Sigs |
kShow_Checks );
if( interactive ) {
fprintf( filebPtr->pgpout, LANG(
"\nDo you want to add this key to keyring '%s' (y/N)? "), ringfile);
copying = getyesno(filebPtr,'n', batchmode ) ? 1 : 0;
} else
copying = 1;
if(copying) {
isnew=TRUE;
newkeys++;
}
}
if( copying ) {
if(keepset == NULL) {
err = PGPNewKeySet( context, &keepset );
pgpAssertNoErr(err);
}
err = pgpAddKeyToKeySet( key, keepset );
if(IsPGPError(err)) {
pgpShowError(filebPtr, err,__FILE__,__LINE__);
}
if( isnew && !batchmode ) {
/* This is not efficient, because it loops on
keepset, so avoid calling it in batchmode. */
err = pgpMarkKeyInSet( keepset, key );
}
}
err = PGPKeyIterNext( iter, &key );
if( err != 0 || key == 0 ) {
break;
}
}
if(err == kPGPError_EndOfIteration)
err = 0;
if( newkeys > 0 && !interactive ) {
fprintf( filebPtr->pgpout, LANG("\nkeyfile contains %d new keys. "),
newkeys);
fprintf( filebPtr->pgpout, LANG(
"Add these keys to keyring ? (Y/n) "));
fflush( filebPtr->pgpout );
ans = getyesno(filebPtr, 'y', batchmode);
/* add a newline to make it easier to read */
fprintf(filebPtr->pgpout, "\n");
fflush(filebPtr->pgpout);
if(!ans)
goto done;
}
if(verbose)
fprintf(filebPtr->pgpout, LANG(
"\nPASS 3.. show the new userids and new sigs\n"));
{
PGPSize keys,uids,sigs,rvks;
err = pgpMarkKeySet( origset );
pgpAssertNoErr(err);
err = PGPAddKeys( origset, keepset );
pgpAssertNoErr(err);
/*
* mark default key set to determine which keys are
* being added in, need to do this because mainbPtr->workingRingSet
* might be a in memory key set
*/
err = pgpMarkKeySet( defKeySet );
pgpAssertNoErr(err);
err = PGPAddKeys( keepset, defKeySet );
pgpAssertNoErr(err);
err = pgpShowKeySetUnmarked( filebPtr, defKeySet, &keys, &uids,
&sigs, &rvks );
pgpAssertNoErr(err);
/*newkeys += keys;*/
newuids += uids;
newsigs += sigs;
newrvks += rvks;
}
if(verbose)
fprintf(filebPtr->pgpout,
LANG("\nPASS 4... add them to the keyring\n"));
if(!bAddToDefault)
{
err = PGPAddKeys( keepset, mainbPtr->workingRingSet );
pgpAssertNoErr(err);
}
/* For now AddKeys should be more or less the same as mergekeys */
/* User feedback */
if( newsigs == 0 && newkeys == 0 && newuids == 0 && newrvks == 0 ) {
goto done;
}
/* Check signatures */
PGPCheckKeyRingSigs( keepset, mainbPtr->workingRingSet, 0, NULL, NULL );
if( err ) {
if( verbose ) {
fprintf(filebPtr->pgpout, LANG(
"addToWorkingRingSet: pgpDoCheckKeySet() returned %d\n"), err);
}
goto done;
}
/* More user feedback */
fprintf(filebPtr->pgpout, LANG("\nKeyfile contains:\n"));
if (newkeys)
fprintf(filebPtr->pgpout, LANG("%4d new key(s)\n"), newkeys);
if (newsigs)
fprintf(filebPtr->pgpout, LANG("%4d new signatures(s)\n"), newsigs);
if (newuids)
fprintf(filebPtr->pgpout, LANG("%4d new user ID(s)\n"), newuids);
if (newrvks)
fprintf(filebPtr->pgpout, LANG("%4d new revocation(s)\n"), newrvks);
err = PGPPropagateTrust( mainbPtr->workingRingSet );
pgpAssertNoErr(err);
/* mainbPtr->workingRingSet = ringSet;*/
/* mainbPtr->workingGroupSet = NULL;*/
err = pgpProcessUncertifiedKeys( mainbPtr, keepset );
if( IsPGPError(err)) {
if(err == kPGPError_UserAbort)
err = kPGPError_NoErr;
goto done;
}
err = pgpProcessUntrustedKeys( mainbPtr, keepset,
mainbPtr->workingRingSet );
done:
if(PGPKeySetNeedsCommit(mainbPtr->workingRingSet))
PGPCommitKeyRingChanges(mainbPtr->workingRingSet);
if(defKeySet != kPGPInvalidRef)
PGPFreeKeySet(defKeySet);
if(keepset != NULL)
PGPFreeKeySet( keepset );
if( iter )
PGPFreeKeyIter( iter );
if( keylist)
PGPFreeKeyList( keylist );
if( origset )
PGPFreeKeySet( origset );
/* The event handler will call addToRingSetFinish( ringSet ); before
this is done */
return err;
}
int addToKeyring(struct pgpmainBones *mainbPtr, char* keyfile,
PGPFileSpecRef ringFileSpec, char *origRingFileName )
{
PGPContextRef context = mainbPtr->pgpContext;
struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
PGPFileSpecRef keyFileSpec = kPGPInvalidRef;
PGPKeySetRef ringSet = kPGPInvalidRef;
#ifdef NOTPREFERREDMETHOD
PGPKeySetRef keySet = kPGPInvalidRef;
#endif /* NOTPREFERREDMETHOD */
PGPKeySetRef emptyKeySet = kPGPInvalidRef;
PGPError err,er2;
char *ringfile = NULL;
PGPEnv *env = mainbPtr->envbPtr->m_env;
PGPInt32 pri;
PGPBoolean compatible = mainbPtr->envbPtr->compatible;
err = PGPGetFullPathFromFileSpec( ringFileSpec, &ringfile );
pgpAssertNoErr(err);
/* Manually open the input file, gives us an early out if it is
missing */
err = PGPNewFileSpecFromFullPath(context, keyfile, &keyFileSpec);
if(err) {
pgpShowError( filebPtr, err, __FILE__,__LINE__);
goto done;
}
/* add the keys to a in memory key set, then
do one add operation at end to the target key set */
err = PGPNewKeySet(context, &emptyKeySet);
if(IsPGPError(err))
goto done;
mainbPtr->workingRingSet = emptyKeySet;
/* Get or create target keySet. Must be both public and secret
keyrings, in case the input contains new secret keys. */
err = pgpOpenKeyringsFromPubringSpec( mainbPtr, ringFileSpec, &ringSet,
kPGPKeyRingOpenFlags_Mutable);
if(err) {
/* XXX The error msg context here may differ from 262 */
fprintf(filebPtr->pgpout, ringFileSpec ? LANG(
"\nKey ring file '%s' cannot be created.\n")
: LANG("Default ring file cannot be created"),
origRingFileName);
goto done;
}
/*
* mark key set so that we know what was added
*/
err = pgpMarkKeySet(ringSet);
pgpAssertNoErr(err);
/* Allow eventhandler in dodecode.c to do the remaining work */
fprintf(filebPtr->pgpout,LANG("\nLooking for new keys...\n"));
err = PGPDecode(
context,
PGPOInputFile( context, keyFileSpec ),
PGPOKeySetRef( context, ringSet ),
PGPOSendEventIfKeyFound( context, TRUE ),
PGPOEventHandler( context, addHandler, (PGPUserValue) mainbPtr ),
PGPOLastOption( context )
);
if(err) {
pgpShowError( filebPtr, err,__FILE__,__LINE__ );
goto done;
}
else
{
/* count number of keys before add */
PGPUInt32 countBefore = 0;
err = PGPCountKeys(ringSet, &countBefore);
pgpAssertNoErr(err);
err = PGPAddKeys(mainbPtr->workingRingSet, ringSet);
if(IsntPGPError(err) && PGPKeySetNeedsCommit(ringSet))
{
/*
* show what was added
*/
PGPUInt32 keys = 0;
PGPSize dummy,uids,sigs,rvks;
err = PGPCountKeys(ringSet, &keys);
pgpAssertNoErr(err);
keys -= countBefore;
fprintf(filebPtr->pgpout,
LANG("\n\nSummary of changes : \n"));
err = pgpShowKeySetUnmarked( filebPtr, ringSet, &dummy, &uids,
&sigs, &rvks );
pgpAssertNoErr(err);
if(keys || uids || sigs || rvks)
{
fprintf(filebPtr->pgpout, LANG("\nAdded :\n"));
if (keys)
fprintf(filebPtr->pgpout,
LANG("%4d new key(s)\n"), keys);
if (sigs)
fprintf(filebPtr->pgpout,
LANG("%4d new signatures(s)\n"), sigs);
if (uids)
fprintf(filebPtr->pgpout,
LANG("%4d new user ID(s)\n"), uids);
if (rvks)
fprintf(filebPtr->pgpout,
LANG("%4d new revocation(s)\n"), rvks);
}
else
{
fprintf(filebPtr->pgpout,
LANG("No new keys found."));
}
PGPCommitKeyRingChanges(ringSet);
}
}
#ifdef NOTPREFERREDMETHOD
/* Rather than calling this here, we call it from the callback
Copy all keys from keySet which aren't in ringSet already */
err = addToWorkingRingSet( mainbPtr, keySet );
#endif /* NOTPREFERREDMETHOD */
done:
if(emptyKeySet != kPGPInvalidRef)
{
er2 = PGPFreeKeySet(emptyKeySet);
pgpAssertNoErr(er2);
}
#ifdef NOTPREFERREDMETHOD
if( keySet != kPGPInvalidRef ) {
er2 = PGPFreeKeySet( keySet );
pgpAssertNoErr(er2);
}
#endif /* NOTPREFERREDMETHOD */
if( ringSet != kPGPInvalidRef ) {
er2 = PGPFreeKeySet( ringSet );
pgpAssertNoErr(er2);
mainbPtr->workingRingSet = NULL;
}
if( keyFileSpec != kPGPInvalidRef ) {
er2 = PGPFreeFileSpec(keyFileSpec);
pgpAssertNoErr(er2);
}
if(!compatible && IsPGPError(err) &&
pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &er2 ) ) {
pgpShowError(filebPtr, err,__FILE__,__LINE__);
}
if(ringfile)
PGPFreeData(ringfile);
return err ? -1 : 0;
}
