args.c

vc环境下的pgp源码

/*____________________________________________________________________________
    args.c

    Copyright(C) 1998,1999 Network Associates, Inc.
    All rights reserved.

	PGP 6.5 Command Line 

    Based on PGP262 main module

    $Id: args.c,v 1.20.6.2 1999/06/14 19:41:46 sluu Exp $
____________________________________________________________________________*/


#include <stdio.h>
#include <assert.h>
#include <string.h>
#if PGP_WIN32
#include <io.h>
#endif
#if PGP_UNIX
#include <unistd.h>
#endif

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

#include "pgpSDKPrefs.h"
#include "pgpEnv.h"
#include "pgpKeys.h"
#include "pgpPFLErrors.h"
#include "pgpUtilities.h"

static struct pgpargsBones _argsBones;

struct pgpargsPBones {

     /* thse used to be auto variables local to main()...*/
     int myArgc;
     char **myArgv;

     char mcguffin[256]; /* userid search tag */

     PGPBoolean cFlag;
     PGPBoolean uFlag; /* Did I get myName from -u? */

     char *inputFileName;
     char **mcguffins;
     char *workFileName, *tempf;

     char cipherFile[MAX_PATH+1];

     PGPByte ctb;
};

static struct pgpargsPBones argsPriv;

void initArgsPBonesbPtr(struct pgpmainBones *mainbPtr) 
{

     struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
     struct pgpargsPBones *argsPrivbPtr=&argsPriv;
     mainbPtr->argsbPtr->argsPrivbPtr = argsPrivbPtr;
     assert(filebPtr);

  /* private...*/

     argsPrivbPtr->myArgc = 2;

     argsPrivbPtr->cFlag = FALSE;
     argsPrivbPtr->uFlag = FALSE; /* Did I get myName from -u? */

     argsPrivbPtr->inputFileName = NULL;
}

void initArgsBones(struct pgpmainBones *mainbPtr) 
{

     struct pgpargsBones *argsbPtr=&_argsBones;
     mainbPtr->argsbPtr=argsbPtr;

     argsbPtr->encryptFlag = FALSE; /* -e */
     argsbPtr->decryptOnlyFlag = FALSE; /* -d */
     argsbPtr->signFlag = FALSE;    /* -s */
     argsbPtr->keyFlag = FALSE;     /* -k */
     argsbPtr->conventionalFlag = FALSE; /* -c */
     argsbPtr->armorFlag = FALSE;   /* -a */
     argsbPtr->stripSigFlag = FALSE; /* -b */
     argsbPtr->wipeFlag = FALSE;    /* -w */

     argsbPtr->preserveFileName = FALSE;
     argsbPtr->outputFileName = NULL;
     argsbPtr->keyChar = '\0';

     /*mainbPtr->deArmorOnly = FALSE;*/
     argsbPtr->envbPtr=mainbPtr->envbPtr;

     initArgsPBonesbPtr(mainbPtr);
}

void usage(struct pgpfileBones *filebPtr, int *errorLvl);

static void buildHelpFileName(struct pgpfileBones *filebPtr, char
        *helpFileName, char const *extra );

/*
 * The following 2 stub functions are required to
 * interface to the old methods
 */

static int maintUpdate(PGPFileSpecRef ringfilespec, 
					   struct newkey const *nkeys)
{ 
	/* 
	 *No "maintenance pass req'd.  The SDK takes care of this
	 */

	return 0; 
}

static int cryptRandWriteFile(char const *name, 
							  struct IdeaCfbContext *cfb,
							  unsigned bytes) 
{ 
	return -1;	/* not supported in 6.5 */
}

/* comes here if user made a boo-boo. */
void userError(struct pgpfileBones *filebPtr, int *perrorLvl)
{
    fprintf(filebPtr->pgpout, LANG("\nFor a usage summary, type:  pgp -h\n"));
    fprintf(filebPtr->pgpout,
            LANG("For more detailed help, consult the PGP User's Guide.\n"));
    if(!*perrorLvl)
        *perrorLvl = 127;
}

static void argError(struct pgpfileBones *filebPtr, int *perrorLvl)
{
    fprintf(filebPtr->pgpout, LANG("\nInvalid arguments.\n"));
    *perrorLvl = BAD_ARG_ERROR;
}


/* look for a keyring whose name matches the argument.
   return TRUE if found. */
PGPBoolean tryRingFileExtensions ( struct pgpfileBones *filebPtr, char
        *ringfilename )
{
    char tryFileName[MAX_PATH+1];
    strncpy(tryFileName, ringfilename, MAX_PATH);
    tryFileName[MAX_PATH] = '\0';

    if (!fileExists(tryFileName)) {
        defaultExtension( filebPtr, tryFileName, filebPtr->PKR_EXTENSION );
        if (!fileExists(tryFileName)) {
            dropExtension( filebPtr, tryFileName );
            defaultExtension( filebPtr, tryFileName,
                    filebPtr->SKR_EXTENSION );

            if (!fileExists(tryFileName)) {
                return FALSE;
            }
        }
    }

    /* If we are here we have found a legit file. */
    strcpy ( ringfilename, tryFileName);
    return TRUE;
}



int doGroupOpt(struct pgpmainBones *mainbPtr, char groupChar, int *perrorLvl)
{
    struct pgpargsBones *argsbPtr = mainbPtr->argsbPtr;
    struct pgpargsPBones *argsPrivbPtr = argsbPtr->argsPrivbPtr;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    PGPContextRef context = mainbPtr->pgpContext;
    char ringfilename[MAX_PATH];
    char origRingFileName[MAX_PATH];
    PGPFileSpecRef ringfilespec;
    int status;
    PGPError err;
    PGPFileSpecRef pubringSpec;
    char *pubringName;
    PGPKeySetRef keySet = kPGPInvalidRef;

    /*
     * If we're not doing anything that uses stdout, produce output there,
     * in case user wants to redirect it.
     */
    if (!envbPtr->filterMode)
        filebPtr->pgpout = stdout;

    err = PGPsdkPrefGetFileSpec( context, kPGPsdkPref_PublicKeyring,
            &pubringSpec);

    pgpAssertNoErr(err);
    err = PGPGetFullPathFromFileSpec( pubringSpec, &pubringName );
    pgpAssertNoErr(err);

    switch (groupChar) {

    case 'a':
        { /*
             Add a group or keys to a group
             Arguments: groupname [ userids... ]
           */
            char *groupname;

            if (argsPrivbPtr->myArgc < 3 && !envbPtr->filterMode) {
                argError(filebPtr,perrorLvl);
                status=-1;
                goto out;
            }

            groupname = argsPrivbPtr->myArgv[2];

            if (argsPrivbPtr->myArgc >= 4) {
                strcpy(ringfilename, argsPrivbPtr->myArgv[
                        argsPrivbPtr->myArgc - 1 ]);

                if( tryRingFileExtensions( filebPtr, ringfilename ) )
                    argsPrivbPtr->myArgv[ argsPrivbPtr->myArgc - 1 ]=0;
                else
                    strcpy(ringfilename, pubringName);
            } else /* default key ring filename */
                strcpy(ringfilename, pubringName);
#ifdef MSDOS
            strlwr(ringfilename);
#endif
            err = PGPNewFileSpecFromFullPath( context, ringfilename,
                    &ringfilespec);

            pgpAssertNoErr(err);

            err = PGPOpenKeyRing( context, kPGPKeyRingOpenFlags_Mutable,
                    ringfilespec, &keySet);

            pgpAssertNoErr(err);
            mainbPtr->workingRingSet = keySet;


            status = addToGroup(mainbPtr, groupname,
                    &argsPrivbPtr->myArgv[3], ringfilespec);

            if (status < 0) {
                fprintf(filebPtr->pgpout, LANG("\007Group add error. "));
                *perrorLvl = KEYRING_ADD_ERROR;
            }

            /* mainbPtr->workingRingSet is autofreed elsewhere.*/

            if( pubringSpec != ringfilespec) {
                PGPFreeFileSpec(ringfilespec);
            }
            goto out;
        }

/*-------------------------------------------------------*/
    case 'r':
        { /*
             Remove a group or remove keys from a group
             Arguments: groupname [ userids... ]
           */
            char *groupname;

            if (argsPrivbPtr->myArgc < 3 && !envbPtr->filterMode) {
                argError(filebPtr,perrorLvl);
                status=-1;
                goto out;
            }

            groupname = argsPrivbPtr->myArgv[2];

            if (argsPrivbPtr->myArgc >= 4) {
                strcpy(ringfilename,
                        argsPrivbPtr->myArgv[ argsPrivbPtr->myArgc - 1 ]);

                if( tryRingFileExtensions( filebPtr, ringfilename ) )
                    argsPrivbPtr->myArgv[ argsPrivbPtr->myArgc - 1 ]=0;
                else
                    strcpy(ringfilename, pubringName);
            } else /* default key ring filename */
                strcpy(ringfilename, pubringName);

#ifdef MSDOS
            strlwr(ringfilename);
#endif
            err = PGPNewFileSpecFromFullPath( context, ringfilename,
                    &ringfilespec);

            pgpAssertNoErr(err);

            err = PGPOpenKeyRing( context, kPGPKeyRingOpenFlags_Mutable,
                    ringfilespec, &keySet);
            pgpAssertNoErr(err);

            mainbPtr->workingRingSet = keySet;
            status = removeFromGroup(mainbPtr, groupname,
                    &argsPrivbPtr->myArgv[3], ringfilespec);

            if (status < 0) {
                fprintf(filebPtr->pgpout, LANG("\007Group add error. "));
                *perrorLvl = KEYRING_ADD_ERROR;
            }

            /* mainbPtr->workingRingSet is autofreed elsewhere.*/

            if( pubringSpec != ringfilespec) {
                PGPFreeFileSpec(ringfilespec);
            }
            goto out;

        }  /* Remove keys from a group or remove a group
              Arguments: groupname [ userids... ] [ ringfilename ]
            */

/*-------------------------------------------------------*/
    case 'v':
    case 'V': /* -gvv */
        { /* View group entries, with group name match
             Arguments: groupname [ ringfilename ]
           */

            if (argsPrivbPtr->myArgc < 4) /* default key ring filename */
                strcpy(ringfilename, pubringName);
            else
                strcpy(ringfilename, argsPrivbPtr->myArgv[3]);

            if (argsPrivbPtr->myArgc > 2) {
                strcpy(argsPrivbPtr->mcguffin, argsPrivbPtr->myArgv[2]);
                if (strcmp(argsPrivbPtr->mcguffin, "*") == 0)
                    argsPrivbPtr->mcguffin[0] = '\0';
            } else {
                *argsPrivbPtr->mcguffin = '\0';
            }

            if ((argsPrivbPtr->myArgc == 3) &&
                    ( hasExtension(argsPrivbPtr->myArgv[2],
                                   filebPtr->PKR_EXTENSION) ||
                      hasExtension(argsPrivbPtr->myArgv[2],
                              filebPtr->SKR_EXTENSION)) ) {
                strcpy(ringfilename, argsPrivbPtr->myArgv[2]);
                argsPrivbPtr->mcguffin[0] = '\0';
            }
            CONVERT_TO_CANONICAL_CHARSET(argsPrivbPtr->mcguffin);

#ifdef MSDOS
            strlwr(ringfilename);
#endif
            strcpy(origRingFileName, ringfilename);
            tryRingFileExtensions ( filebPtr, ringfilename );

            err = PGPNewFileSpecFromFullPath( context, ringfilename,
                    &ringfilespec);

            pgpAssertNoErr(err);

            /* If a second 'v' (groupChar = V), show keys too */
            status = viewGroups(mainbPtr, argsPrivbPtr->mcguffin,
                    ringfilespec, origRingFileName,
                    (PGPBoolean) (groupChar == 'V') );

            PGPFreeFileSpec(ringfilespec);

            if( status < 0 ) {