doencode.c

vc环境下的pgp源码

/*___________________________________________________________________________
    doencode.c

    Copyright 1998 by Network Associates Inc.
    All rights reserved.

	PGP 6.5 Command Line 

    uses the PGP SDK to encode messages.

    $Id: doencode.c,v 1.12 1999/05/12 21:01:03 sluu Exp $
____________________________________________________________________________*/
#include <stdio.h>
#include <assert.h>
#include <errno.h>

#include "pgpBase.h"
#include "pgpKeys.h"
#include "pgpErrors.h"
#include "pgpUserInterface.h"
#include "pgpUtilities.h"
#include "pgpEnv.h"
#include "pgpContext.h"

#include "config.h"
#include "usuals.h"
#include "language.h"
#include "pgp.h"
#include "globals.h"
#include "fileio.h"
#include "exitcodes.h"
#include "prototypes.h"

#define RECIP_MAGIC 0x4fd450c0

struct RecipList {
    long magic;
    int size,maxsize;
    char **recips;
    /* a null-terminated array of pointers to strings, all privately
    allocated, specifying the list of recipients */

};


/* count the nubmer of strings in the array. terminates with NULL or
   the first empty string.. */
static int pgpCountStrArray( char **ptr )
{
    int i;
    if(!ptr)
        return 0;
    for(i=0; *ptr && *ptr[0]; ptr++, i++)
        ;
    return i;
}

static PGPError pgpNewRecipList( int maxsize, struct RecipList *reclist )
{
    int i;
    char **recips;

    assert( reclist->magic != RECIP_MAGIC );

    if ((recips= (char **) malloc((maxsize +1) * sizeof(char *))) == NULL)
        return kPGPError_OutOfMemory;
    for(i=0; i<=maxsize; i++)
        recips[i]=NULL;
    reclist->recips = recips;
    reclist->size = 0;
    reclist->maxsize = maxsize;
    reclist->magic = RECIP_MAGIC;
    return kPGPError_NoErr;
}

 /* add a recipient to the list. */
static PGPError pgpAddRecip( struct RecipList *reclist, char *recip )
{
    char *p;
    assert( reclist->magic == RECIP_MAGIC );

    if(reclist->size >= reclist->maxsize)
        return -1;
    if((p = (char *)malloc(strlen( recip ) + 1))==NULL)
        return kPGPError_OutOfMemory;
    strcpy(p,recip);
    reclist->recips[ reclist->size ] = p;
    reclist->size++;
    return kPGPError_NoErr;
}

static PGPError pgpFreeRecipList( struct RecipList *reclist )
{
    int i;
    assert( reclist->magic == RECIP_MAGIC );
    /*return -1;*/
    for(i=0; i< reclist->size; i++)
        free( reclist->recips[ i ] );
    free( reclist->recips );
    reclist->magic = 0;
    return kPGPError_NoErr;
}


/*
   Build the list of recipients, from command line arguments or whatever.
   If necessary, prompt the user.  The caller is responsible to call
   pgpFreeRecipList().
 */

PGPError pgpBuildRecipList( struct pgpmainBones *mainbPtr, struct
        RecipList *reclist )
{
    char mcguffin[256];
    int numr;
    PGPInt32 pri;
    PGPError err;
    char **pp;

    struct pgpfileBones *filebPtr=mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr=mainbPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env;

    numr = pgpCountStrArray( mainbPtr->recipients );

    if (!envbPtr->filterMode && !pgpenvGetInt( env, PGPENV_NOOUT, &pri,
            &err ))

        fprintf(filebPtr->pgpout, LANG(
"\n\nRecipients' public key(s) will be used to encrypt.\n"));

    if ( numr == 0 ) {
        /* no Recipient specified on command line */
        fprintf(filebPtr->pgpout, LANG(
"\nA user ID is required to select the Recipient's public key.\n"));
        fprintf(filebPtr->pgpout, LANG("Enter the Recipient's user ID: "));
        pgpTtyGetString(mcguffin, 255, filebPtr->pgpout);

        if((err = pgpNewRecipList( 1, reclist )) != 0)
            return err;
        err = pgpAddRecip( reclist, mcguffin );
    } else {
        if((err = pgpNewRecipList( numr, reclist )) != 0)
            return err;
        for( pp= mainbPtr->recipients; pp && *pp && **pp; pp++)
            if((err = pgpAddRecip( reclist, *pp )) != 0)
                return err;
    }
    pgpAssertNoErr(err);

    for( pp = reclist->recips; pp && *pp && **pp; pp++ )
        CONVERT_TO_CANONICAL_CHARSET(*pp);
    return kPGPError_NoErr;
}


PGPError enchandler(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 );
    PGPUInt32 need;
    PGPError err;
    PGPInt32 pri;
    PGPInt32 verbose = pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err );
    PGPBoolean compatible = envbPtr->compatible;

    /* 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,
                        __FILE__,__LINE__);

            if(errno == ENOSPC)
                fprintf(filebPtr->pgpout,
                        LANG("Error: No space left on device.\n"));

            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_EntropyEvent:
            /* how much entropy do we need?*/

            need = event->data.entropyData.entropyBitsNeeded;
            if(verbose)
                fprintf( filebPtr->pgpout,
                        LANG("event %d: entropy needed: %d\n"),
                        event->type, need);

            /* usually equals this...*/
            /*need = PGPGlobalRandomPoolGetMinimumEntropy()*/
            /*    - PGPGlobalRandomPoolGetEntropy();*/

#if PGP_UNIX || PGP_WIN32
            err = pgpAcquireEntropy( filebPtr, need );
#else
            err = PGPCollectRandomDataDialog( context, need,
                    PGPOLastOption( context ) );

#endif

            if( !compatible && IsPGPError( err ) ) {
                if(verbose)
                    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;
}

/*
  During encode, if invalid keys are used then a warning is generated
  but it's too late to ask the user. This should be called before all
  that takes place.
 */
PGPError pgpUnionKeysAskInvalid( struct pgpfileBones *filebPtr,
        PGPKeySetRef fromSet, PGPKeySetRef toSet, PGPKeySetRef *resultset )
{
    PGPEnv *env = filebPtr->envbPtr->m_env;
    PGPKeyListRef keylist = NULL;
    PGPKeyIterRef keyiter = NULL;
    PGPKeyRef key;
    PGPError err;
    PGPInt32 pri;
    PGPBoolean batchmode = pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &err );
    PGPBoolean verbose = pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err );
    PGPBoolean quietmode = pgpenvGetInt( env, PGPENV_NOOUT, &pri, &err);
    PGPKeySetRef tmpset;

    err = PGPNewEmptyKeySet( toSet, &tmpset );
    pgpAssertNoErr(err);
    err = PGPUnionKeySets( toSet, tmpset, resultset );
    pgpAssertNoErr(err);
    PGPFreeKeySet( tmpset );

    err = PGPOrderKeySet( fromSet, kPGPAnyOrdering, &keylist );
    if( IsPGPError(err) )
        goto done;

    err = PGPNewKeyIter( keylist, &keyiter );
    if( IsPGPError(err) )
        goto done;

    err = PGPKeyIterRewind( keyiter );
    pgpAssertNoErr(err);

    err = PGPKeyIterNext( keyiter, &key);
    /* if err, there are none.*/

    while( key != NULL )
    {
        PGPInt32 validity;

        if (!quietmode) pgpShowKeyBrief( filebPtr, key );

        err = PGPGetKeyNumber(key, kPGPKeyPropValidity, &validity);
        pgpAssertNoErr(err);

        if(verbose)
            pgpShowKeyValidity( filebPtr, key );

        if( validity < kPGPValidity_Marginal ) {
            char useridstr[ kPGPMaxUserIDSize ];
            PGPBoolean answer;
            err = pgpGetUserIDStringFromKey( key, useridstr );
            pgpAssertNoErr(err);

            fprintf( filebPtr->pgpout, LANG(
"WARNING:  Because this public key is not certified with a trusted\n"));
            fprintf( filebPtr->pgpout, LANG(
"signature, it is not known with high confidence that this public key\n"));
            fprintf( filebPtr->pgpout, LANG(
"actually belongs to: \"%s\".\n"), useridstr );

            /*
               XXX need to find out whether we previously approved using
               the key, and if so don't ask, but print the following
               message...  But you previously approved using this public
               key anyway. Trouble is, I don't know how to do that here.
             */

            if (!(batchmode && quietmode)) fprintf( filebPtr->pgpout, LANG(
    "\nAre you sure you want to use this public key (y/N)?") );

            answer = getyesno( filebPtr, 'N', batchmode );
            if( !answer ) {
                if (!quietmode) fprintf( filebPtr->pgpout,
                        LANG("Ok, skipping userid %s\n"), useridstr );

                goto next;
            }
        }

        {
            PGPKeySetRef myset;
            err = PGPNewSingletonKeySet( key, &myset );
            err = PGPUnionKeySets( myset, *resultset, &tmpset );
            PGPFreeKeySet( *resultset );
            PGPFreeKeySet( myset );
            *resultset = tmpset;
        }
        pgpAssertNoErr(err);
next:
        err = PGPKeyIterNext( keyiter, &key);
        /* if err, there are no more*/
    }
    if( err == kPGPError_EndOfIteration )
        err = kPGPError_NoErr;
done:
    if(keyiter)
        PGPFreeKeyIter(keyiter);
    if(keylist)
        PGPFreeKeyList(keylist);
    return err;
}