keyremove.c

vc环境下的pgp源码

			}
			sprintf(secringfilename, "%s%s", szTemp, "secring.skr");
		}
		else
		{
			strcpy(secringfilename, szTemp);
			if(dropFilename(szTemp))
			{
				err = -1;
				goto done;
			}
			sprintf(pubringfilename, "%s%s", szTemp, "pubring.pkr");
		}

		if(!fileExists(pubringfilename) || !fileExists(secringfilename))
		{
			err = -1;
			goto done;
		}

		err = PGPNewFileSpecFromFullPath(context, secringfilename, &secRingFileSpec);
		if(IsPGPError(err))
			goto done;

		err = PGPNewFileSpecFromFullPath(context, pubringfilename, &pubRingFileSpec);
		if(IsPGPError(err))
			goto done;

		err = PGPOpenKeyRingPair(context, kPGPKeyRingOpenFlags_Mutable, pubRingFileSpec,
									secRingFileSpec, &ringSet);
	}
	if(IsPGPError(err))
		goto done;


#if 0
    PGPGetFullPathFromFileSpec( ringFileSpec, &ringFile );

    fprintf( filebPtr->pgpout,
            LANG("\nRemoving from key ring: '%s', userid \"%s\".\n"),
            ringFile, useridstr );
#endif 0

    mainbPtr->workingRingSet = ringSet;
    err = pgpGetMatchingKeySet(mainbPtr, useridstr, 0, &keysToRemove );
    if(IsPGPError(err))
		goto done;

    err = pgpUserChooseAndRemoveKeys( mainbPtr, keysToRemove);

    if( PGPKeySetNeedsCommit( ringSet ) && IsntPGPError(err)) {
        err = PGPCommitKeyRingChanges( ringSet );
    }

done:
	if(keysToRemove != kPGPInvalidRef)
		PGPFreeKeySet(keysToRemove);
	if(secRingFileSpec != kPGPInvalidRef)
		PGPFreeFileSpec(secRingFileSpec);
	if(pubRingFileSpec != kPGPInvalidRef)
		PGPFreeFileSpec(pubRingFileSpec);
	if(ringSet != kPGPInvalidRef)
		PGPFreeKeySet(ringSet);
    mainbPtr->workingRingSet = NULL;

	if( IsntPGPError(err))
        return 0;
    else
        return -1;
}


PGPError srvhandler(PGPContextRef context, struct PGPEvent *event,
        PGPUserValue userValue)
{
    struct pgpmainBones *mainbPtr = (struct pgpmainBones *)userValue;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    PGPEnv *env = pgpContextGetEnvironment( context );
    PGPError err;
    PGPInt32 pri;
    PGPInt32 verbose = pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err );
    PGPJobRef job = event->job;

    /* get the event type*/
    switch ( event->type ) {
        case kPGPEvent_FinalEvent:
            if(verbose)
                fprintf( filebPtr->pgpout, LANG("event %d: final\n"),
                        event->type);
            err = kPGPError_NoErr;
            /* tear down anything we need to here*/
            break;

        case kPGPEvent_InitialEvent:
            if(verbose)
                fprintf( filebPtr->pgpout, LANG("\nevent %d: initial\n"),
                        event->type);
            err = kPGPError_NoErr;
            /* set up whatever we need to here*/
            break;

        case kPGPEvent_ErrorEvent:
            if(verbose)
                fprintf( filebPtr->pgpout, LANG("event %d: error %d\n"),
                        event->type,event->data.errorData.error);
            pgpShowError( filebPtr, event->data.errorData.error, 0,0);
            err = kPGPError_NoErr;
            break;

        case kPGPEvent_WarningEvent:
            if(verbose)
                fprintf( filebPtr->pgpout, LANG("event %d: warning %d\n"),
                        event->type,event->data.warningData.warning);
            if( event->data.warningData.warning == kPGPError_KeyInvalid )
            {
                /*PGPKeySetRef warnset = event->data.warningData.warningArg;*/
            }
            break;

        case kPGPEvent_KeyServerEvent:       /* Key Server progress */
            if(verbose)
                fprintf( filebPtr->pgpout,
                        LANG("event %d: progress, state=%d\n"),
                        event->type, event->data.keyServerData.state);

            err = kPGPError_NoErr;
            break;

        case kPGPEvent_KeyServerSignEvent:     /* Key Server passphrase */
            {
                PGPKeyRef	sigkey;
                char *passphrase = NULL;
                /*PGPKeyServerRef keyServer =
                    event->data.keyServerSignData.keyServerRef;*/
                if(verbose)
				    fprintf( filebPtr->pgpout,
                            LANG("event %d: keyserver wants signature\n"),
                            event->type);
				err = pgpGetSigningKey(mainbPtr, &sigkey);

                if( IsntPGPError(err) ) {
                    PGPBoolean mine;
                    err = pgpRewindPassphrase( envbPtr->passwds );
                    pgpAssertNoErr(err);
                    err = pgpGetValidPassphrase( mainbPtr, sigkey,
                            &passphrase, &mine );
                    if( IsntPGPError(err) ) {
                        err = PGPAddJobOptions(job,
                                PGPOSignWithKey(context, sigkey,
                                        PGPOPassphrase(context, passphrase),
                                        PGPOLastOption( context )),
                                PGPOClearSign( context, TRUE ),
                                PGPOLastOption( context));
                        pgpAssertNoErr(err);
                    }
                    if(mine) {
                        PGPFreeData(passphrase);
                        pgpRemoveFromPointerList(mainbPtr->leaks,passphrase);
                    }
                }
                if( IsPGPError(err) )
                    pgpShowError(filebPtr, err, __FILE__,__LINE__);
            }
            break;

        default:
            /* ignore the event...*/
            if(verbose)
                fprintf( filebPtr->pgpout, LANG("event %d: unknown\n"),
                        event->type);
            err = kPGPError_NoErr;
    }
    return err;
}

int removeFromKeyServer(struct pgpmainBones *mainbPtr, char *useridstr,
        char *keyServerURL)
{
    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = filebPtr->envbPtr;
    PGPEnv * env = envbPtr->m_env;
    PGPtlsContextRef          tlsContext = kInvalidPGPtlsContextRef;
    PGPtlsSessionRef        tlsSession = kInvalidPGPtlsSessionRef;
    PGPKeyServerType          type;
    PGPError err,er2;
    PGPInt32 pri;
    PGPKeySetRef ringSet = NULL;
    /*int status;*/

    err = PGPOpenDefaultKeyRings( context, 0, &ringSet );
    if( IsPGPError(err) ) {
        fprintf(filebPtr->pgpout,
                LANG("\nCan't open default key ring file\n"));
        return -1;
    }
    mainbPtr->workingRingSet=ringSet;

    err = PGPKeyServerInit();
    pgpAssertNoErr(err);

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

    err = PGPSetKeyServerEventHandler( mainbPtr->workingKeyServer,
            srvhandler, (PGPUserValue)mainbPtr);

    pgpAssertNoErr(err);

	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);
            }
        }
        goto done;
    } else {
        PGPKeySetRef keysToRemove=NULL;
        err = pgpGetMatchingKeySet(mainbPtr, useridstr, 0, &keysToRemove );
        pgpAssertNoErr(err);

        err = pgpUserChooseAndRemoveKeys( mainbPtr, keysToRemove);

        if( IsPGPError(err) ) {
            if( err == kPGPError_EndOfIteration ) {
                fprintf( filebPtr->pgpout,
                        LANG("\nKey not found on key server '%s'.\n"),
                        keyServerURL );
            } else if (!envbPtr->compatible)
                pgpShowError(filebPtr, err, __FILE__,__LINE__);
        }
        if( PGPKeySetNeedsCommit( keysToRemove ) ) {
            err = PGPCommitKeyRingChanges( keysToRemove );
            if( IsPGPError(err))
                pgpShowError(filebPtr,err,0,0);
        }
        if(keysToRemove)
            PGPFreeKeySet(keysToRemove);
    }

    er2 = PGPKeyServerClose( mainbPtr->workingKeyServer );
    pgpAssertNoErr(er2);
done:

    if(tlsSession != kInvalidPGPtlsSessionRef)
        PGPFreeTLSSession(tlsSession);
    if(tlsContext != kInvalidPGPtlsContextRef)
        PGPFreeTLSContext(tlsContext);
    if(mainbPtr->workingKeyServer != kPGPInvalidRef)
        PGPFreeKeyServer( mainbPtr->workingKeyServer );
    mainbPtr->workingKeyServer = NULL;

    er2 = PGPKeyServerCleanup();
    pgpAssertNoErr(er2);

    if( ringSet ) {
        PGPFreeKeySet( ringSet );
        mainbPtr->workingRingSet = NULL;
    }

    return IsPGPError(err) ? -1 : 0;
}


PGPError countSigsOnKey( PGPKeyIterRef keyiter, PGPUInt32 *nsigs) {

    PGPUserIDRef userid;
    PGPSigRef sig;
    PGPError err;

    (*nsigs) = 0;

    err = PGPKeyIterRewindUserID( keyiter );
    pgpAssertNoErr(err);
    err = PGPKeyIterNextUserID( keyiter, &userid );
    pgpAssertNoErr(err);

    /* for all userids of key */
    while( userid ) {

        err = PGPKeyIterRewindUIDSig( keyiter );
        pgpAssertNoErr(err);
        err = PGPKeyIterNextUIDSig( keyiter, &sig );
        /*if err, there are none.*/

        /* for all sigs of all userids of all keys */
        while( sig != NULL ) {

            (*nsigs)++;

            err = PGPKeyIterNextUIDSig( keyiter, &sig );
            /*if err, there are no more.*/
        }
        err = PGPKeyIterNextUserID(keyiter,&userid);
        /*if err, there are no more.*/
    }

    return kPGPError_NoErr;

} /* countSigsOnKey */


PGPError revokeSigs( struct pgpmainBones* mainbPtr, char* mcguffin,