args.c

vc环境下的pgp源码

                fprintf(filebPtr->pgpout, LANG("\007Group view error. "));
                *perrorLvl = KEYRING_VIEW_ERROR;
            }
            goto out;
        } /* view key ring entries, with groupname match */

    default:
        argError(filebPtr,perrorLvl);
        status=-1;
        goto out;
    }
    status=0;

out:
	if(keySet != kPGPInvalidRef)
		PGPFreeKeySet(keySet);

    PGPFreeFileSpec( pubringSpec );
    PGPFreeData( pubringName );
    return status;
}

int doKeyOpt(struct pgpmainBones *mainbPtr, char keyChar, int *perrorLvl)
{
    PGPContextRef context = mainbPtr->pgpContext;
    char keyfilename[MAX_PATH];
    PGPFileSpecRef keyfilespec;
    char ringfilename[MAX_PATH];
    char origRingFileName[MAX_PATH];
    PGPFileSpecRef ringfilespec = kPGPInvalidRef;
    PGPFileSpecRef secringfilespec = kPGPInvalidRef;
    char *workFileName;
    int status = 0;
    struct pgpargsBones *argsbPtr = mainbPtr->argsbPtr;
    struct pgpargsPBones *argsPrivbPtr = argsbPtr->argsPrivbPtr;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env; PGPInt32  pri; PGPError err;

    PGPFileSpecRef pubringSpec;
    PGPFileSpecRef secringSpec;
    char *pubringName;
    char *secringName;

    origRingFileName[0] = '\0';

    if ((envbPtr->filterMode || pgpenvGetInt( env, PGPENV_BATCHMODE,
            &pri, &err )) && (keyChar == 'g' || keyChar == 'e' ||
            keyChar == 'd' || (keyChar == 'r' && argsbPtr->signFlag))) {
        *perrorLvl = NO_BATCH;
        argError(filebPtr,perrorLvl);
        /* interactive process, no go in batch mode */
        return -1;
    }
    /*
     * 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 = PGPsdkPrefGetFileSpec( context, kPGPsdkPref_PrivateKeyring,
            &secringSpec);

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

    switch (keyChar) {

/*-------------------------------------------------------*/
    case 'g':
        { /* Key generation
             Arguments: bitcount, bitcount
           */
            char keybits[6], ebits[6];
            if (argsPrivbPtr->myArgc > 2)
                strncpy(keybits, argsPrivbPtr->myArgv[2], sizeof(keybits)
                        - 1);
            else
                keybits[0] = '\0';

            if (argsPrivbPtr->myArgc > 3)
                strncpy(ebits, argsPrivbPtr->myArgv[3], sizeof(ebits) - 1);
            else
                ebits[0] = '\0';

            /* If the -u option is given, use that username */

            /* dokeygen writes the keys out to the key rings... */
            status = dokeygen( mainbPtr, keybits, ebits );

            if (status < 0) {
                fprintf(filebPtr->pgpout, LANG("\007Keygen error. "));
                *perrorLvl = KEYGEN_ERROR;
            }
            goto out;
        } /* Key generation */

/*-------------------------------------------------------*/
    case 'c':
        { /* Key checking
             Arguments: userid, ringfilnamee
           */

            if (argsPrivbPtr->myArgc < 3) { /* Default to all user ID's */
                argsPrivbPtr->mcguffin[0] = '\0';
            } else {
                strcpy(argsPrivbPtr->mcguffin, argsPrivbPtr->myArgv[2]);
                if (strcmp(argsPrivbPtr->mcguffin, "*") == 0)
                    argsPrivbPtr->mcguffin[0] = '\0';
            }
            CONVERT_TO_CANONICAL_CHARSET(argsPrivbPtr->mcguffin);

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

            if ((argsPrivbPtr->myArgc < 4 && argsPrivbPtr->myArgc > 2)
                    /* Allow just key file as arg */
                    && (hasExtension(argsPrivbPtr->myArgv[2],
                            filebPtr->PKR_EXTENSION) ||
                            hasExtension(argsPrivbPtr->myArgv[2],
                                    filebPtr->SKR_EXTENSION))) {

                strcpy(ringfilename, argsPrivbPtr->myArgv[2]);
                argsPrivbPtr->mcguffin[0] = '\0';
            }

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

            err = dokeycheck(mainbPtr, argsPrivbPtr->mcguffin,
                    ringfilespec);

            if (IsPGPError(err)) {
                fprintf(filebPtr->pgpout,
                        LANG("\007Keyring check error.\n"));
                *perrorLvl = KEYRING_CHECK_ERROR;
            }
            else {
                err = pgpShowTrustAndValidityList(mainbPtr,
                        argsPrivbPtr->mcguffin, ringfilespec);

                pgpAssertNoErr(err);

                if (argsPrivbPtr->mcguffin[0] != '\0')
                {
                    PGPFreeFileSpec(ringfilespec);
                    goto out;
                    /* checking a single user, dont do maintenance */
                }

            }

            PGPFreeFileSpec(ringfilespec);
            status= (status == -7 ? 0 : status);
            goto out;
        } /* Key check */

/*-------------------------------------------------------*/
    case 'm':
        { /* Maintenance pass
             Arguments: ringfilnamee
           */

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

#ifdef MSDOS
            strlwr(ringfilename);
#endif
            if (!fileExists(ringfilename))
                defaultExtension( filebPtr, ringfilename,
                filebPtr->PKR_EXTENSION );

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

            /* Assume: ringfilename always public*/

            err = doMaintenance(mainbPtr, ringfilespec, ringfilename);

            if (IsPGPError(err)) {
                fprintf(filebPtr->pgpout,
                        LANG("\007Maintenance pass error.\n"));
                *perrorLvl = KEYRING_CHECK_ERROR;
            }

            PGPFreeFileSpec(ringfilespec);
            goto out;
        } /* Maintenance pass */

/*-------------------------------------------------------*/
    case 's':
        /* Key signing
           Arguments: her_id, keyfilename
         */
        {
            char *myName;
            if (argsPrivbPtr->myArgc >= 4)
                strncpy(keyfilename, argsPrivbPtr->myArgv[3],
                        sizeof(keyfilename) - 1);

            else
                strcpy(keyfilename, pubringName);

            if (argsPrivbPtr->myArgc >= 3) {
                strcpy(argsPrivbPtr->mcguffin, argsPrivbPtr->myArgv[2]);
                /* Userid to sign */
            } else {
                fprintf(filebPtr->pgpout, LANG(
"\nA user ID is required to select the public key you want to sign. "));
                if (pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &err ))
                {
                    status=-1;
                    goto out;
                }
                fprintf(filebPtr->pgpout,
                        LANG("\nEnter the public key's user ID: "));
                pgpTtyGetString(argsPrivbPtr->mcguffin, 255,
                        filebPtr->pgpout); /* echo keyboard */

            }

            CONVERT_TO_CANONICAL_CHARSET(argsPrivbPtr->mcguffin);

            myName = (char *)pgpenvGetCString( env, PGPENV_MYNAME, &pri );
            if( myName[0] == '\0' || pri < PGPENV_PRI_CONFIG) {
                fprintf(filebPtr->pgpout, LANG(
"\nA secret key is required to make a signature. "));
                fprintf(filebPtr->pgpout, LANG(
"\nYou specified no user ID to select your secret key,\n"
"so the default user ID and key will be the most recently\n"
"added key on your secret keyring.\n"));
            }

            err = PGPNewFileSpecFromFullPath( context, keyfilename,
                    &keyfilespec );

            pgpAssertNoErr(err);

            err = signKeyInFileSpec(mainbPtr, argsPrivbPtr->mcguffin,
                    keyfilespec);

            PGPFreeFileSpec( keyfilespec );

            if (err) {
                fprintf(filebPtr->pgpout, LANG(
                        "\007Key signature error. "));

                *perrorLvl = KEY_SIGNATURE_ERROR;
            }

            goto out;

        } /* Key signing */

/*-------------------------------------------------------*/
    case 'd':
        { /* disable/revoke key
             Arguments: userid, keyfilnamee
           */

            if (argsPrivbPtr->myArgc >= 4)
                strncpy(keyfilename, argsPrivbPtr->myArgv[3],
                        sizeof(keyfilename) - 1);

            else
                strcpy(keyfilename, pubringName);

            if (argsPrivbPtr->myArgc >= 3) {
                strcpy(argsPrivbPtr->mcguffin, argsPrivbPtr->myArgv[2]);
                /* Userid to sign */

            } else {
                if(argsbPtr->signFlag) {
                    fprintf(filebPtr->pgpout, LANG(
"\nA user ID is required to select the key signature you want to revoke. "));

                } else {
                    fprintf(filebPtr->pgpout, LANG(
"\nA user ID is required to select the key you want to revoke or disable. "));
                }
                fprintf(filebPtr->pgpout, LANG("\nEnter user ID: "));
                pgpTtyGetString(argsPrivbPtr->mcguffin, 255,
                        filebPtr->pgpout); /* echo keyboard */

            }
            CONVERT_TO_CANONICAL_CHARSET(argsPrivbPtr->mcguffin);

            if (argsbPtr->signFlag) { /* Revoke signatures */
                if (revokeSigs(mainbPtr,argsPrivbPtr->mcguffin,
                        keyfilename) < 0) {
                    PGPFreeFileSpec(ringfilespec);
                    fprintf(filebPtr->pgpout, LANG(
                            "\007Key signature revoke error. "));
                    *perrorLvl = KEYSIG_REVOKE_ERROR;
                }
            } else {
                if( pgpLocationIsURL( keyfilename )) {
                    status = disableKeyOnKeyServer(mainbPtr,
                            argsPrivbPtr->mcguffin, keyfilename);

                } else {
                    err = PGPNewFileSpecFromFullPath( context,
                            keyfilename, &keyfilespec);

                    pgpAssertNoErr(err);
                    status = revokeOrDisableKey(mainbPtr,
                            argsPrivbPtr->mcguffin, keyfilespec);

                    PGPFreeFileSpec(keyfilespec);
                }
                if (status < 0)
                    fprintf(filebPtr->pgpout,
                            LANG("\007Key disable or revoke error. "));
                if (status < 0)
                    *perrorLvl = KEY_SIGNATURE_ERROR;
            }
            goto out;
        }   /* Key compromise */

/*-------------------------------------------------------*/
    case 'e':
        {   /*      Key editing
                            Arguments: userid, ringfilnamee
                          */

            if (argsPrivbPtr->myArgc >= 4)
			{
                strncpy(ringfilename, argsPrivbPtr->myArgv[3],
                        sizeof(ringfilename) - 1);
				err = PGPNewFileSpecFromFullPath( context, ringfilename,
                    &ringfilespec);
				pgpAssertNoErr(err);
			}

            else  /* default key ring filename */
                ringfilespec = kPGPInvalidRef;

            if (argsPrivbPtr->myArgc >= 3) {
                strcpy(argsPrivbPtr->mcguffin, argsPrivbPtr->myArgv[2]);
                /* Userid to edit */

            } else {
                fprintf(filebPtr->pgpout, LANG(
"\nA user ID is required to select the key you want to edit. "));

                fprintf(filebPtr->pgpout,
                        LANG("\nEnter the key's user ID: "));

                pgpTtyGetString(argsPrivbPtr->mcguffin, 255,
                        filebPtr->pgpout);  /* echo keyboard */

            }
            CONVERT_TO_CANONICAL_CHARSET(argsPrivbPtr->mcguffin);

            status = doKeyEdit(mainbPtr, argsPrivbPtr->mcguffin,
                    ringfilespec);

            if (status >= 0) {
                status = maintUpdate(ringfilespec, 0);
                if (status == -7)
                    status = 0; /* ignore "not a public keyring" error */