args.c

PGP—Pretty Good Privacy

            mainbPtr->separateSignature = argsbPtr->stripSigFlag = TRUE;
            break;
        case 'c':
            argsbPtr->encryptFlag = argsbPtr->conventionalFlag = TRUE;
            argsPrivbPtr->cFlag = TRUE;
            break;
        case 'd':
            argsbPtr->decryptOnlyFlag = TRUE;
            break;
        case 'e':
            argsbPtr->encryptFlag = TRUE;
            break;
        case 'f':
            envbPtr->filterMode = TRUE;
            break;
        case 'g':
            argsbPtr->groupFlag = TRUE;
            break;
        case '?':
        case 'h':
            usage(filebPtr,perrorLvl);
            return -1;
            break;
#ifdef VMS
        case 'i':
            /*pgpenvSetInt( env, PGPENV_TEXTMODE,  MODE_LOCAL,
              PGPENV_PRI_CMDLINE );*/
            /* hmm... can't do*/
            break;
#endif    /* VMS */
        case 'k':
            argsbPtr->keyFlag = TRUE;
            break;
        case 'l':
            pgpenvSetInt( env, PGPENV_VERBOSE,  TRUE, PGPENV_PRI_CMDLINE );
            break;
        case 'm':
            envbPtr->moreFlag = TRUE;
            break;
        case 'n':
                /* XXX placeholder to specify new something */
            break;
        case 'p':
            argsbPtr->preserveFileName = TRUE;
            break;
        case 'o':
            argsbPtr->outputFileName = optarg;
            break;
        case 's':
            argsbPtr->signFlag = TRUE;
            break;
        case 't':
            pgpenvSetInt( env, PGPENV_TEXTMODE,  TRUE, PGPENV_PRI_CMDLINE );
            break;
        case 'u':
            {
                char *myName = (char *)malloc( strlen(optarg)+1);
                if(myName == NULL) {
                    fprintf(stderr, LANG("\n\007Out of memory.\n"));
                    *perrorLvl=OUT_OF_MEM;
                    return -1;
                }
                strcpy( myName, optarg );
                CONVERT_TO_CANONICAL_CHARSET(myName);
                pgpenvSetString( env, PGPENV_MYNAME, myName,
                        PGPENV_PRI_CMDLINE );

                argsPrivbPtr->uFlag = TRUE;
                free(myName);
            }
            break;
        case 'w':
            argsbPtr->wipeFlag = TRUE;
            break;
        case 'z':
            /* "-zpassword" or "-z password" */
            break;
        case '+':
            /* '+' special option: does not require - */
            if (processConfigLine( envbPtr, optarg, PGPENV_PRI_CMDLINE) == 0)
                break;
            fprintf(stderr, "\n");
            /* fallthrough */
        default:
            argError(filebPtr,perrorLvl);
            return -1;
        }
    }
    argsPrivbPtr->myArgv[argsPrivbPtr->myArgc] = NULL;
    /* Just to make it NULL terminated */

    return 0;
}

void pgpPrintOutfileName( struct pgpmainBones *mainbPtr) {
  /* Called only after DoEncrypt now. Could be modified to include
     filename options created by DoDecrypt. */

    struct pgpargsBones *argsbPtr = mainbPtr->argsbPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPEnv *env = envbPtr->m_env;
    PGPInt32 pri;
    PGPError err;
    PGPBoolean encrypted = argsbPtr->encryptFlag;
    PGPBoolean sig = argsbPtr->signFlag;
    PGPBoolean quietmode = pgpenvGetInt( env, PGPENV_NOOUT, &pri, &err);
    PGPBoolean textmode = pgpenvGetInt( env, PGPENV_TEXTMODE, &pri, &err);
    PGPBoolean armorout = pgpenvGetInt( env, PGPENV_ARMOR, &pri, &err);
    PGPBoolean clearsig = pgpenvGetInt( env, PGPENV_CLEARSIG, &pri, &err)
                && textmode && armorout && !argsbPtr->stripSigFlag  &&
                !encrypted;

         /* clear-sign only makes sense if file is text and armor is on */

    if (quietmode) return;

           if (armorout) {

               if (clearsig)
                fprintf(filebPtr->pgpout,
                        LANG("\nClear signature file: %s\n"),
                        argsbPtr->outputFileName);

               else
                fprintf(filebPtr->pgpout,
                        LANG("\nTransport armor file: %s\n"),
                        argsbPtr->outputFileName);

               /*check also if >1 transport armor fileS */
           }
           else {

                if (encrypted)
                    fprintf(filebPtr->pgpout,
                    LANG("\nCiphertext file: %s\n"),
                    argsbPtr->outputFileName);

                else if (sig)
                    fprintf(filebPtr->pgpout,
                    LANG("\nSignature file: %s\n"),
                    argsbPtr->outputFileName);

           }
}


int pgpProcessArgs( struct pgpmainBones *mainbPtr, int *perrorLvl)
{
    struct pgpargsBones *argsbPtr = mainbPtr->argsbPtr;
    struct pgpargsPBones *argsPrivbPtr = argsbPtr->argsPrivbPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPEnv *env = envbPtr->m_env;
    PGPInt32 pri;
    PGPError err;
    int status;
    PGPBoolean quietmode = pgpenvGetInt( env, PGPENV_NOOUT, &pri, &err);

    /* -db means break off signature certificate into separate file */
    if (argsbPtr->decryptOnlyFlag && argsbPtr->stripSigFlag)
        argsbPtr->decryptOnlyFlag = FALSE;

    if (argsbPtr->decryptOnlyFlag && argsbPtr->armorFlag)
        mainbPtr->decryptMode = mainbPtr->deArmorOnly = TRUE;

    if (argsbPtr->outputFileName != NULL)
        argsbPtr->preserveFileName = FALSE;

    if (!argsbPtr->signFlag && !argsbPtr->encryptFlag &&
            !argsbPtr->conventionalFlag && !argsbPtr->armorFlag) {

        if (argsbPtr->wipeFlag) { /* wipe only */
            if (argsPrivbPtr->myArgc != 3) {
                argError(filebPtr,perrorLvl); /* need one argument */
                return -1;
            }
            if (wipefile(filebPtr, argsPrivbPtr->myArgv[2]) == 0 &&
                    remove(argsPrivbPtr->myArgv[2]) == 0) {

                if (!quietmode) {
                    fprintf(filebPtr->pgpout,
                        LANG("\nFile %s wiped and deleted. "),
                        argsPrivbPtr->myArgv[2]);

                    fprintf(filebPtr->pgpout, "\n");
                }
                *perrorLvl=EXIT_OK;
                return 0;
            }
            *perrorLvl=UNKNOWN_FILE_ERROR;
            return -1;
        }
        /* decrypt if none of the -s -e -c -a -w options are specified */
        mainbPtr->decryptMode = TRUE;
    }
    if (argsPrivbPtr->myArgc == 2) { /* no arguments */
#ifdef PGP_UNIX
        if (!envbPtr->filterMode && !isatty(fileno(stdin))) {
            /* piping to pgp without arguments and no -f:
             * switch to filter mode but don't write output to stdout
             * if it's a tty, use the preserved filename */
            if (!envbPtr->moreFlag)
                filebPtr->pgpout = stderr;
            envbPtr->filterMode = TRUE;
            if (isatty(fileno(stdout)) && !envbPtr->moreFlag)
                argsbPtr->preserveFileName = TRUE;
        }
#endif
        if (!envbPtr->filterMode) {
            char *p;
            if (pgpenvGetInt( env, PGPENV_NOOUT, &pri, &err )) {
                pgpenvSetInt( env, PGPENV_NOOUT,  FALSE, PGPENV_PRI_FORCE );
            }               if (strcmp((p = LANG("@translator@")),
                                "@translator@"))

                            fprintf(filebPtr->pgpout, p);
                    fprintf(filebPtr->pgpout,
                            LANG("\nFor a usage summary, type:  pgp -h\n"));
                    *perrorLvl=BAD_ARG_ERROR;
                    return -1;
        }
    } else {
        if (envbPtr->filterMode) {
            mainbPtr->recipients = &argsPrivbPtr->myArgv[2];
        } else {
            argsPrivbPtr->inputFileName = argsPrivbPtr->myArgv[2];
            mainbPtr->recipients = &argsPrivbPtr->myArgv[3];
        }
    }

    if (envbPtr->filterMode) {
        argsPrivbPtr->inputFileName = "stdin";
    } else if (envbPtr->makeRandom > 0) { /* Create the input file */
        /*
         * +makerandom=<bytes>: Create an input file consisting of <bytes>
         * cryptographically strong random bytes, before applying the
         * encryption options of PGP.  This is an advanced option, so
         * assume the user knows what he's doing and don't bother about
         * overwriting questions.  E.g.
         * pgp +makerandom=24 foofile
         * Create "foofile" with 24 random bytes in it.
         * pgp +makerandom=24 -ea foofile recipient
         * The same, but also encrypt it to "recipient", creating
         * foofile.asc as well.
         * This feature was created to allow PGP to create and send keys
         * around for other applications to use.
         */
        status = cryptRandWriteFile(argsPrivbPtr->inputFileName,
                (struct IdeaCfbContext *)0, (unsigned)envbPtr->makeRandom);

        if (status < 0) {
            fprintf( stderr, LANG("Error writing file \"%s\"\n"),
                    argsPrivbPtr->inputFileName );

            *perrorLvl = INVALID_FILE_ERROR;
            return -1;
        }
        if (!quietmode) {
            fprintf(filebPtr->pgpout,
                LANG("File %s created containing %d random bytes.\n"),
                argsPrivbPtr->inputFileName, envbPtr->makeRandom);
        }

        /* If we aren't encrypting, don't bother trying to decrypt this! */
        if (mainbPtr->decryptMode) {
            *perrorLvl = EXIT_OK;
            return 0;
        }

        /* This is obviously NOT a text file */
        pgpenvSetInt( env, PGPENV_TEXTMODE,  FALSE, PGPENV_PRI_FORCE );
    } else {
        if (mainbPtr->decryptMode && noExtension( filebPtr,
                argsPrivbPtr->inputFileName )) {
            strcpy(argsPrivbPtr->cipherFile, argsPrivbPtr->inputFileName);
            forceExtension( filebPtr, argsPrivbPtr->cipherFile,
                    filebPtr->ASC_EXTENSION );

            if (fileExists(argsPrivbPtr->cipherFile)) {
                argsPrivbPtr->inputFileName = argsPrivbPtr->cipherFile;
            } else {
                forceExtension( filebPtr, argsPrivbPtr->cipherFile,
                        filebPtr->PGP_EXTENSION );
                if (fileExists(argsPrivbPtr->cipherFile)) {
                    argsPrivbPtr->inputFileName = argsPrivbPtr->cipherFile;
                } else {
                    forceExtension( filebPtr, argsPrivbPtr->cipherFile,
                            filebPtr->SIG_EXTENSION );
                    if (fileExists(argsPrivbPtr->cipherFile))
                        argsPrivbPtr->inputFileName =
                            argsPrivbPtr->cipherFile;

                }
            }
        }
        if (!fileExists(argsPrivbPtr->inputFileName)) {
            fprintf(filebPtr->pgpout,
                    LANG("\007File [%s] does not exist.\n"),
                    argsPrivbPtr->inputFileName);

            *perrorLvl = FILE_NOT_FOUND_ERROR;
            userError(filebPtr,perrorLvl);
            return -1;
        }
    }

    if (strlen(argsPrivbPtr->inputFileName) >= (unsigned) MAX_PATH - 4) {
        fprintf(filebPtr->pgpout,
                LANG("\007Invalid filename: [%s] too long\n"),
                argsPrivbPtr->inputFileName);

        *perrorLvl = INVALID_FILE_ERROR;
        userError(filebPtr,perrorLvl);
        return -1;
    }
    strcpy(mainbPtr->plainfilename, argsPrivbPtr->inputFileName);

    if (envbPtr->filterMode) {
        setOutDir( filebPtr, NULL ); /* NULL means use tmpdir */
    } else {
        if (argsbPtr->outputFileName)
            setOutDir( filebPtr, argsbPtr->outputFileName );
        else
            setOutDir( filebPtr, argsPrivbPtr->inputFileName );
    }

    if (envbPtr->filterMode) {
        if((argsPrivbPtr->workFileName = tempFile( filebPtr, TMP_WIPE |
                TMP_TMPDIR, perrorLvl))==NULL && *perrorLvl != 0)

            return -1;
        readPhantomInput(filebPtr, argsPrivbPtr->workFileName );
    } else {
        argsPrivbPtr->workFileName = argsPrivbPtr->inputFileName;
    }

    /* -- start scanning the input file -------------------------------- */


    getHeaderInfoFromFile(argsPrivbPtr->workFileName, &argsPrivbPtr->ctb, 1);

    if (mainbPtr->decryptMode) {
        PGPUInt32 count;

        /* -- pgpDoDecode is responsible for everything:
           loop while part of the file remains unprocessed,
           0. scan for each lexical section
           1. de armor if needed
           2. decrypt if needed
           ask for pass phrase if needed and keep it for the next ciphertext
           3. check signature
           4. if text mode, convert from canonical text to local format.

           complexities...
           1. may have a sequence of armor texts.
           2. may want to de-armor but not decrypt
           3. may be armored but not encrypted.
           4. may be signed but not encrypted.
           5. may be armored and signed but not encrypted.
           6. may want to output the clear-signed message after de-armor.
           7. may want to output the clear-signed message after decryption.
           8. may want to output the signature detached from the cleartext
           after decryption.
           Q. what to do in filter mode if multiple armor texts appear?
           it seems that the new PGP versions place it inline into the text.
         */

        err = pgpDoDecode( mainbPtr, argsPrivbPtr->workFileName, perrorLvl );
        if( IsPGPError(err ) )
        {
           /* XXX clean up tempfiles??*/
           *perrorLvl = DECR_ERROR;
           return -1;
        }

        /*