keyview.c

PGP—Pretty Good Privacy

            kstr, schar, showFlags );

	if(defaultKey == kPGPInvalidRef && !bNoDefaultKey)
	{
		err = PGPGetDefaultPrivateKey(keyringset, &defaultKey);
		if(IsPGPError(err))
		{
			bNoDefaultKey = TRUE;
			defaultKey = kPGPInvalidRef;
		}
	}
	if(defaultKey != kPGPInvalidRef)
	{
		if(!PGPCompareKeys(defaultKey, key, kPGPValidityOrdering))
		{
			/* this is the default key */
			fprintf(filebPtr->pgpout, "*** DEFAULT SIGNING KEY ***\n");
            fprintf( filebPtr->pgpout, "     %-*s %-*s            ",
                    bitsLength,"",keyIDLength,"");
		}
	}


    /* now list all userids associated with the key. */
    err = PGPKeyIterRewindUserID( iterContext );
    pgpAssertNoErr(err);
    err = PGPKeyIterNextUserID( iterContext, &userid);
    pgpAssertNoErr(err);

    if( userid ) {
        int before=0;
        while( userid ) {
            err = PGPGetUserIDStringBuffer( userid, kPGPUserIDPropName,
                    256, useridstr, &actual );

            if( err == kPGPError_InvalidProperty ) {
                /* the userid field was empty? rare, but possible.*/
                useridstr[0]='\0';
            } else
                pgpAssertNoErr(err);

            fprintf( filebPtr->pgpout, "%s\n", useridstr);

            if( (showFlags & kShow_Hashes) && !before ) {
                pgpShowKeyFingerprint( filebPtr, key );
                before++;
            }

            if( showFlags & kShow_Sigs ) {
                PGPSigRef sig;
                err = PGPKeyIterRewindUIDSig( iterContext );
                pgpAssertNoErr(err);
                err = PGPKeyIterNextUIDSig( iterContext, &sig );
                /*if error, there are no sig's*/
                while( sig ) {

                    err = pgpShowKeySig( filebPtr, keyringset, sig,
                            showFlags );

                    pgpAssertNoErr(err);

                    err = PGPKeyIterNextUIDSig( iterContext, &sig );
                    /*if error, no more userids.*/
                }
            }

            err = PGPKeyIterNextUserID( iterContext, &userid);
            /*if err, no more userids for this key*/
            if(userid)
                fprintf( filebPtr->pgpout, "     %-*s %-*s            ",
                        bitsLength,"",keyIDLength,"");
        }
    }
    if( err == kPGPError_EndOfIteration )
        err = 0;
    return err;
}

PGPError viewKeySet(struct pgpmainBones *mainbPtr, PGPKeySetRef keyset,
        PGPFlags showFlags )
{
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPKeyListRef keylist = NULL;
    PGPKeyIterRef keyiter = NULL;
    PGPKeyRef key = NULL;
    PGPError err;
    PGPSize keyIDLength,bitsLength;
    PGPBoolean compatible = mainbPtr->envbPtr->compatible;
    int keycount = 0;

    err = PGPOrderKeySet( keyset, kPGPUserIDOrdering, &keylist );
    pgpAssertNoErr(err);
    err = PGPNewKeyIter( keylist, &keyiter );
    pgpAssertNoErr(err);
    err = PGPKeyIterRewind( keyiter );
    pgpAssertNoErr(err);

    keyIDLength = ( compatible ? 8 : 10 );
    bitsLength = ( compatible ? 4 : 9 );

    if(!compatible)
        fprintf(filebPtr->pgpout,
                LANG("\nType %-*s %-*s Date       User ID\n"),
                bitsLength,LANG("bits"),keyIDLength, LANG("keyID"));
    else
        fprintf(filebPtr->pgpout,
                LANG("\nType %-*s/%-*s Date       User ID\n"),
                bitsLength,LANG("bits"),keyIDLength, LANG("keyID"));

    err = PGPKeyIterNext( keyiter, &key);
    /*if error, no keys found.*/
    while( key != NULL )
    {
        keycount++;

        err = pgpShowKeyListFormat( filebPtr, mainbPtr->workingRingSet,
                keyiter, key, showFlags );

        pgpAssertNoErr(err);

        err = PGPKeyIterNext( keyiter, &key);
        /*if err, no more keys*/
    }
    if(err == kPGPError_EndOfIteration)
        err = kPGPError_NoErr;
    fprintf( filebPtr->pgpout, LANG("%d matching key%s found.\n"),
            keycount, keycount != 1 ? "s" : "" );

    if(keyiter)
        PGPFreeKeyIter( keyiter );
    if(keylist)
        PGPFreeKeyList( keylist );
    return err;
}

int viewKeyring(struct pgpmainBones *mainbPtr, char *mcguffin,
PGPFileSpecRef ringfilespec, char *origRingFileName, PGPFlags showFlags )
{
    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env;
    PGPKeyRingOpenFlags openflags = 0;
    PGPKeySetRef keyringset = NULL;
    PGPKeySetRef keyset = NULL;
    PGPError err;
    char *ringfile = NULL;
    PGPInt32 pri;
    PGPBoolean quietmode = pgpenvGetInt( env, PGPENV_NOOUT, &pri, &err);

    if(ringfilespec) {
        err = PGPGetFullPathFromFileSpec( ringfilespec, &ringfile );
        pgpAssertNoErr(err);

        err = PGPOpenKeyRing( context, openflags, ringfilespec,
                &keyringset );

        if( IsPGPError(err) ) {
            fprintf(filebPtr->pgpout,
                    LANG("\nCan't open key ring file '%s'\n"),
                    origRingFileName);
            goto done;
        } else
            if (!quietmode) fprintf(filebPtr->pgpout,
                LANG("\nKey ring: '%s'"), ringfile);
    } else {
        err = PGPOpenDefaultKeyRings( context, openflags, &keyringset );
        if( IsPGPError(err) ) {
            fprintf(filebPtr->pgpout,
                    LANG("\nCan't open default key ring file\n"));
            goto done;
        }
    }

    if((mcguffin && mcguffin[0] != '\0') && !quietmode)
        fprintf(filebPtr->pgpout, LANG(", looking for user ID \"%s\"."),
                mcguffin);

    mainbPtr->workingRingSet=keyringset;

    err = pgpGetMatchingKeySet( mainbPtr, mcguffin, 0, &keyset);
    if( IsPGPError(err) )
        pgpShowError( filebPtr, err, 0,0); /*__FILE__,__LINE__);*/
    else
        err = viewKeySet(mainbPtr, keyset, showFlags );

done:
    if(keyset)
        PGPFreeKeySet(keyset);
    if(keyringset) {
        PGPFreeKeySet( keyringset );
        mainbPtr->workingRingSet = NULL;
    }
    if(ringfile)
        PGPFreeData(ringfile);
    return err == kPGPError_NoErr ? 0 : -1;
}

int viewKeyServer(struct pgpmainBones *mainbPtr, char *mcguffin, char
        *keyServerURL, PGPFlags showFlags )

{
    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env;
    PGPtlsContextRef tlsContext = kInvalidPGPtlsContextRef;
    PGPtlsSessionRef tlsSession = kInvalidPGPtlsSessionRef;
    PGPKeyServerType type;

    PGPError err, er2;
    int status;
    PGPInt32 pri;
    PGPBoolean quietmode = pgpenvGetInt( env, PGPENV_NOOUT, &pri, &err);

    err = PGPKeyServerInit();
    pgpAssertNoErr(err);

    err = PGPNewKeyServerFromURL( context, keyServerURL,
            kPGPKeyServerAccessType_Default,
            kPGPKeyServerKeySpace_Default,
            &mainbPtr->workingKeyServer );
    if( IsPGPError(err) )
        pgpShowError(filebPtr, err,__FILE__,__LINE__);

	if(IsPGPError(err = PGPGetKeyServerType(mainbPtr->workingKeyServer, &type)))
	{
        err = 1;
		goto done;
	}

	if (type == kPGPKeyServerType_LDAPS) {
		if(IsPGPError(err = PGPNewTLSContext(context, &tlsContext)))
		{
            err = 1;
			goto done;
		}

		if(IsPGPError(err = PGPNewTLSSession(tlsContext, &tlsSession)))
		{
            err = 1;
			goto done;
		}
	}

    err = PGPKeyServerOpen( mainbPtr->workingKeyServer, tlsSession );
    if( IsPGPError(err) )  {
        if (!envbPtr->compatible) {
            if (pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &er2 )) {
                pgpShowError( filebPtr, err, __FILE__,__LINE__);
            }
            else {
                 pgpShowError( filebPtr, err, 0, 0);
            }
        }
        status = -1;
        goto done;
    } else {
        if (!quietmode) fprintf(filebPtr->pgpout,
            pgpLocationIsURL( keyServerURL ) ? 
            LANG("\nKey server: '%s'") :
            LANG("\nKey ring: '%s'"), keyServerURL);
        status = viewKeyring( mainbPtr, mcguffin, NULL, keyServerURL,
                showFlags );
    }

    err = PGPKeyServerClose( mainbPtr->workingKeyServer );
    pgpAssertNoErr(err);
done:
    if(tlsSession != kInvalidPGPtlsSessionRef)
        PGPFreeTLSSession(tlsSession);
    if(tlsContext != kInvalidPGPtlsContextRef)
        PGPFreeTLSContext(tlsContext);
    if(mainbPtr->workingKeyServer != kPGPInvalidRef)
        PGPFreeKeyServer( mainbPtr->workingKeyServer );
    mainbPtr->workingKeyServer = NULL;

    err = PGPKeyServerCleanup();
    pgpAssertNoErr(err);

    return status;
}

/*
  Called by -kc and -km, this function prints a keyring's stats:
   KeyID         Trust         Validity         User ID
 */
PGPError pgpShowKeySetTrustAndValidity( struct pgpfileBones *filebPtr,
        PGPKeySetRef ringSet, PGPKeySetRef keyset )
{
    PGPError err;
    PGPKeyListRef keylist = NULL;
    PGPKeyIterRef keyiter = NULL;
    PGPKeyRef key = NULL;

    PGPSize keyIDLength;
    PGPSize trustLength = 9;
    PGPSize validityLength = 9;
    PGPBoolean compatible = filebPtr->envbPtr->compatible;

    keyIDLength = ( compatible ? 8 : 10 );

    err = PGPOrderKeySet( keyset, kPGPAnyOrdering, &keylist );
    /* iterate thru and print interesting info */

    err = PGPNewKeyIter( keylist, &keyiter );
    pgpAssertNoErr(err);
    err = PGPKeyIterRewind( keyiter );
    pgpAssertNoErr(err);

    fprintf( filebPtr->pgpout, LANG("\n  %-*s %-*s %-*s %s\n"),
            keyIDLength, LANG("KeyID"), trustLength, LANG("Trust"),
            validityLength, LANG("Validity"), LANG("User ID") );

    err = PGPKeyIterNext( keyiter, &key);
    /*if error, no keys found.*/

    while( key != NULL )
    {
        err = pgpShowKeyTrustAndValidity( filebPtr, ringSet, keyiter,
                key, FALSE );
        pgpAssertNoErr(err);

        err = PGPKeyIterNext( keyiter, &key);
        /*if err, no more keys*/
    }
    if( err == kPGPError_EndOfIteration )
        err = kPGPError_NoErr;

    if( keyiter )
        PGPFreeKeyIter( keyiter );
    if( keylist )
        PGPFreeKeyList( keylist );
    return err;
}

PGPError pgpShowTrustAndValidityList(struct pgpmainBones *mainbPtr,
        char *useridStr, PGPFileSpecRef ringFileSpec)
{
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPError err;
    PGPKeySetRef ringSet;

    PGPKeySetRef keysToCheck;

    err = pgpOpenKeyringsFromPubringSpec( mainbPtr, ringFileSpec, &ringSet , 0);
    if( IsPGPError(err) )
        return -1;

    mainbPtr->workingRingSet=ringSet;
    err = pgpGetMatchingKeySet(mainbPtr, useridStr, kMatch_NotKeyServer,
            &keysToCheck );
    pgpAssertNoErr(err);

    err = pgpShowKeySetTrustAndValidity( filebPtr, ringSet, keysToCheck );
    pgpAssertNoErr(err);

    PGPFreeKeySet( keysToCheck );
    PGPFreeKeySet( ringSet );
    mainbPtr->workingRingSet = NULL;

    return kPGPError_NoErr;
}