keyadd.c

PGP—Pretty Good Privacy

            err = PGPGetKeyUserVal( key, &val );
            pgpAssertNoErr(err);

            if( (validity > kPGPValidity_Invalid) && ! ((PGPInt32)val &
                    kMark_Trust ) ) /* key has not been processed*/

            {
                PGPUserIDRef userid;
                PGPSize scrap;
                char useridstr[ kPGPMaxUserIDSize ];
                err = PGPGetPrimaryUserID( origkey, &userid );
                pgpAssertNoErr(err);
                err = PGPGetUserIDStringBuffer( userid,
                       kPGPUserIDPropName, kPGPMaxUserIDSize, useridstr,
                       &scrap);

                pgpAssertNoErr(err);
                if( pgpGetKeyTrust( origkey ) <= kPGPKeyTrust_Unknown ) {
                    err = pgpShowKeyBrief( filebPtr, key );
                    pgpAssertNoErr(err);
                    err = pgpEditPublicTrustParameter( filebPtr,
                            useridstr, key );

                    if( err ) {
                        pgpShowError( filebPtr, err,__FILE__,__LINE__ );
                        goto done;
                    }
                    PGPPropagateTrust( ringSet );
                    PGPSetKeyUserVal( key, (PGPUserValue)( (PGPInt32)val |
                            kMark_Trust )); /* key has been processed*/

                    endloop = FALSE;
                }
            }
next:
            err = PGPKeyIterNext( keyiter, &key );
            /*if err, no more*/
        }

        if( endloop == TRUE ) break;
    }
done:
    if( keyiter )
        PGPFreeKeyIter( keyiter );
    if( keylist )
        PGPFreeKeyList( keylist );
    return err;
}

PGPError addToWorkingRingSet(struct pgpmainBones *mainbPtr, PGPKeySetRef
        keySet )
{
    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;

    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( mainbPtr->workingRingSet, &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( mainbPtr->workingRingSet, &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 '%s'? (Y/n) "), ringfile );
        fflush( filebPtr->pgpout );
        ans = getyesno(filebPtr, 'y', batchmode);
        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);

        err = pgpShowKeySetUnmarked( filebPtr, keepset, &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"));

    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 ) {
        fprintf( filebPtr->pgpout,
                LANG("No new keys or signatures in keyfile.\n" ) );
        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(keepset != NULL)
        PGPFreeKeySet( keepset );
    if( iter )
        PGPFreeKeyIter( iter );
    if( keylist)
        PGPFreeKeyList( keylist );
    if( origset )
        PGPFreeKeySet( origset );

    if(PGPKeySetNeedsCommit(mainbPtr->workingRingSet))
        PGPCommitKeyRingChanges(mainbPtr->workingRingSet);

    /* 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;
    PGPKeySetRef    keySet = kPGPInvalidRef;
    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;
    }

    /* 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, dechandler, (PGPUserValue) mainbPtr ),
            PGPOLastOption( context )
            );

    if(err) {
        pgpShowError( filebPtr, err,__FILE__,__LINE__ );
        goto done;
    }
    else
    {
        err = PGPAddKeys(mainbPtr->workingRingSet, ringSet);
        if(IsntPGPError(err) && PGPKeySetNeedsCommit(ringSet))
        {
            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

done:
    if(emptyKeySet != kPGPInvalidRef)
    {
        er2 = PGPFreeKeySet(emptyKeySet);
        pgpAssertNoErr(er2);
    }

    if( keySet != kPGPInvalidRef ) {
       er2 = PGPFreeKeySet( keySet );
       pgpAssertNoErr(er2);
    }

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