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; }