args.c

vc环境下的pgp源码

                if (status < 0)
                    fprintf(filebPtr->pgpout,
                            LANG("\007Maintenance pass error. "));

            }
            if (status < 0) {
                fprintf(filebPtr->pgpout, LANG("\007Keyring edit error. "));
                *perrorLvl = KEYRING_EDIT_ERROR;
            }
            PGPFreeFileSpec(ringfilespec);
            goto out;
        }   /* Key edit */

/*-------------------------------------------------------*/
    case 'a':
        {   /*      Add key to key ring
                            Arguments: keyfilename, ringfilename
                          */

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

            if (!envbPtr->filterMode) { /* Get the keyfilename from args */
                strncpy(keyfilename, argsPrivbPtr->myArgv[2],
                        sizeof(keyfilename) - 1);

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

                if (!fileExists(keyfilename)) {
                    fprintf(filebPtr->pgpout,
                            LANG("\n\007Key file '%s' does not exist.\n"),
                            keyfilename);
                    *perrorLvl = NONEXIST_KEY_ERROR;
                    status=-1;
                    goto out;
                }
                workFileName = keyfilename;

            } else {
                if((workFileName = tempFile(filebPtr, TMP_WIPE |
                        TMP_TMPDIR, perrorLvl)) == NULL && *perrorLvl != 0)
                    return -1;
                readPhantomInput(filebPtr, workFileName );
            }

            if (argsPrivbPtr->myArgc < (envbPtr->filterMode ? 3 : 4))
            { /* default key ring filename */

                PGPByte ctb;
                getHeaderInfoFromFile(workFileName, &ctb, 1);
                if (ctb == CTB_CERT_SECKEY)
                    strcpy(ringfilename, secringName);
                else
                    strcpy(ringfilename, pubringName);
            } else {
                strncpy(ringfilename,
                        argsPrivbPtr->myArgv[(envbPtr->filterMode ?
                                2 : 3)], sizeof(ringfilename) - 1);

                strcpy(origRingFileName, ringfilename);

                tryRingFileExtensions ( filebPtr, ringfilename );
            }

#ifdef MSDOS
            strlwr(ringfilename);
#endif

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

            status = addToKeyring(mainbPtr, workFileName, ringfilespec,
                    origRingFileName);

            if (envbPtr->filterMode)
                rmTemp( filebPtr, workFileName );

            if (status < 0) {
                fprintf(filebPtr->pgpout, LANG("\007Keyring add error. "));
                *perrorLvl = KEYRING_ADD_ERROR;
            }
            PGPFreeFileSpec(ringfilespec);
            goto out;
        }   /* Add key to key ring */

/*-------------------------------------------------------*/
    case 'x':
        {   /* Extract key from key ring
               Arguments: argsPrivbPtr->mcguffin,
               keyfilename, ringfilnamee
             */

            PGPBoolean  bTargetIsURL = FALSE;

            if (argsPrivbPtr->myArgc >= (envbPtr->filterMode ? 4 : 5))
                /* default key ring filename */
                strncpy(ringfilename,
                argsPrivbPtr->myArgv[(envbPtr->filterMode ? 3 : 4)],
                        sizeof(ringfilename) - 1);
            else
                strcpy(ringfilename, pubringName);

            if (argsPrivbPtr->myArgc >= (envbPtr->filterMode ? 2 : 3)) {
                if (argsPrivbPtr->myArgv[2])
                    /* Userid to extract */
                    strcpy(argsPrivbPtr->mcguffin, argsPrivbPtr->myArgv[2]);
                else
                    strcpy(argsPrivbPtr->mcguffin, "");
            } else {
                fprintf(filebPtr->pgpout,
LANG("\nA user ID is required to select the key you want to extract. "));
                if (pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &err ))
                    /* not interactive, userid must be on command line */
                {
                    status=-1;
                    goto out;
                }
                fprintf(filebPtr->pgpout,
                        LANG("\nEnter the key's user ID: "));

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

            }
            CONVERT_TO_CANONICAL_CHARSET(argsPrivbPtr->mcguffin);

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

                else
                    keyfilename[0] = '\0';

                workFileName = keyfilename;
            } else {
                if((workFileName = tempFile(filebPtr, TMP_WIPE |
                        TMP_TMPDIR, perrorLvl))==NULL && *perrorLvl != 0)
                {
                    status=-1;
                    goto out;
                }
            }

#ifdef MSDOS
            strlwr(workFileName);
            strlwr(ringfilename);
#endif
            if( pgpLocationIsURL( ringfilename ) ) {
                status = extractFromKeyServer(mainbPtr,
                        argsPrivbPtr->mcguffin, workFileName,
                        ringfilename, (PGPBoolean)(envbPtr->filterMode ?
                                FALSE : pgpenvGetInt( env, PGPENV_ARMOR, &pri,
                                        &err )));

            } else {
                strcpy(origRingFileName, ringfilename);

                tryRingFileExtensions ( filebPtr, ringfilename );

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

                pgpAssertNoErr(err);
                status = extractFromKeyring(mainbPtr,
                        argsPrivbPtr->mcguffin, workFileName,
                        ringfilespec, origRingFileName,
                        (PGPBoolean)(envbPtr->filterMode ? FALSE :
                         pgpenvGetInt( env, PGPENV_ARMOR, &pri,
                                 &err )));

                PGPFreeFileSpec(ringfilespec);
            }

            if (status < 0) {
                if(status == kPGPError_ItemNotFound) {
                    status=0;
                    goto out;
                }
                fprintf(filebPtr->pgpout,
                        LANG("\007Keyring extract error. "));

                *perrorLvl = KEYRING_EXTRACT_ERROR;
                if (envbPtr->filterMode)
                    rmTemp(filebPtr, workFileName );
                goto out;
            }
            if (envbPtr->filterMode && !status) {
                    if (writePhantomOutput( filebPtr, workFileName ) < 0) {
                        *perrorLvl = UNKNOWN_FILE_ERROR;
                        status=-1;
                        goto out;
                    }
                rmTemp( filebPtr, workFileName );
            }

            bTargetIsURL = pgpLocationIsURL( workFileName);
            if ( pgpenvGetInt( env, PGPENV_ARMOR, &pri, &err ) && !bTargetIsURL)
                fprintf(filebPtr->pgpout,
                        LANG("\nTransport armor file: %s\n"), workFileName);
            fprintf(filebPtr->pgpout,
                LANG("\nKey extracted to %s '%s'.\n"), bTargetIsURL ? "keyserver" : "file" ,workFileName);
            status=0;
            goto out;
        }   /* Extract key from key ring */

/*-------------------------------------------------------*/
    case 'r':
        { /*      Remove keys or selected key signatures from userid keys
Arguments: userid, ringfilename
           */
            if (argsPrivbPtr->myArgc >= 4)
                strcpy(ringfilename, argsPrivbPtr->myArgv[3]);
			else
				strcpy(ringfilename, pubringName);

            if (argsPrivbPtr->myArgc >= 3) {
                strcpy(argsPrivbPtr->mcguffin,
                        argsPrivbPtr->myArgv[2]); /* Userid to work on */
            } 
			else 
			{
				/* print usage message */
                if (argsbPtr->signFlag) 
				{
                    fprintf(filebPtr->pgpout,
						LANG("\nA user ID is required to select the public key you want to\n\
						remove certifying signatures from. "));
                }
				else
				{
                    fprintf(filebPtr->pgpout, LANG(
						"\nA user ID is required to select the key you want to remove. "));
                }
                if (pgpenvGetInt( env, PGPENV_BATCHMODE,
                        &pri, &err ))
                    /* not interactive, userid must be on command line */

                {
                    status=-1;
                    goto out;
                }
                fprintf(filebPtr->pgpout,
                        LANG("\nEnter the key's user ID: "));
                pgpTtyGetString(argsPrivbPtr->mcguffin,
                        255, filebPtr->pgpout);  /* echo keyboard */

            }
            CONVERT_TO_CANONICAL_CHARSET(argsPrivbPtr->mcguffin);

			/* check to see if keyring or keyserver */
            if( pgpLocationIsURL( ringfilename )) {

                if (argsbPtr->signFlag) 
				{
					/* Remove signatures */
                    fprintf(filebPtr->pgpout,
                    LANG("\nRemoving signatures from keyserver is NOT supported.\n"));
                    *perrorLvl = KEYSIG_REMOVE_ERROR;
                    status = -1;
                    goto out;

                } 
				else
				{ 
					/* Remove from keyserver */
                    if (removeFromKeyServer(mainbPtr, 
								argsPrivbPtr->mcguffin, ringfilename) < 0) 
					{
                        fprintf(filebPtr->pgpout,
                                LANG("\007Keyring remove error. "));
                        *perrorLvl = KEYRING_REMOVE_ERROR;
                        status=-1;
                        goto out;
                    }
                }
                status=0;
                goto out;
            }
			else	/* operate on keyring */
			{
#ifdef MSDOS
                strlwr(ringfilename);
#endif
                strcpy(origRingFileName, ringfilename);
                tryRingFileExtensions ( filebPtr, ringfilename );

                if (argsbPtr->signFlag)
				{ /* Remove signatures */
                    if ( removeSigs( mainbPtr,
                            argsPrivbPtr->mcguffin, ringfilename,
                            origRingFileName) < 0) 
					{

                        PGPFreeFileSpec(ringfilespec);
                        fprintf(filebPtr->pgpout,
                                LANG("\007Key signature remove error. "));
                        *perrorLvl = KEYSIG_REMOVE_ERROR;
                        status=-1;
                        goto out;
                    }
                } 
				else
				{  /* Remove keyring */
                    if ( removeFromKeyring( mainbPtr,
                            argsPrivbPtr->mcguffin, 
							argsPrivbPtr->myArgc >= 4 ? ringfilename : NULL,
							origRingFileName))
					{
                        fprintf(filebPtr->pgpout,
                                LANG("\007\nKeyring remove error. "));
                        *perrorLvl = KEYRING_REMOVE_ERROR;
                        status=-1;
                        goto out;
                    }
                }
                status=0;
                goto out;

            }

        }   /* remove key signatures from userid */

/*-------------------------------------------------------*/
    case 'v':
    case 'V':   /* -kvv */
        {   /* View or remove key ring entries,
                            with userid match
                            Arguments: userid, 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);

            if( pgpLocationIsURL( ringfilename )) {
                status = viewKeyServer( mainbPtr, argsPrivbPtr->mcguffin,
                        ringfilename,
                        (keyChar == 'V' ? kShow_Sigs | kShow_Subkeys : 0)
                        | (argsPrivbPtr->cFlag ? kShow_Hashes : 0)
                        /*| (verbose ? kShow_Subkeys : 0)*/
                                      );
            } else {
#ifdef MSDOS
                strlwr(ringfilename);
#endif

                strcpy(origRingFileName, ringfilename);