config.c

vc环境下的pgp源码

    return ERROR;
}

/* Extract a token from a buffer */

static int extractToken( char *buffer, int *endIndex, int *length )
{
    int index = 0, tokenStart;
    char ch;

    /* Skip whitespace */
    for( ch = buffer[ index ]; ch && ( ch == ' ' || ch == '\t' );
            ch = buffer[ index ] )
        index++;
    tokenStart = index;

    /* Find end of setting */
    while( index < LINEBUF_SIZE && ( ch = buffer[ index ] ) != '\0'
            && ch != ' ' && ch != '\t' )
        index++;
    *endIndex += index;
    *length = index - tokenStart;

    /* Return start position of token in buffer */
    return tokenStart;
}

/* Get a string constant */

static int getaString( char *buffer, int *endIndex )
{
    PGPBoolean noQuote = FALSE;
    int stringIndex = 0, bufferIndex = 1;
    char ch = *buffer;

    /* Skip whitespace */
    while( ch && ( ch == ' ' || ch == '\t' ) )
        ch = buffer[ bufferIndex++ ];

    /* Check for non-string */
    if( ch != '\"' )
    {
        *endIndex += bufferIndex;

        /* Check for special case of null string */
        if( !ch )
        {
            *str = '\0';
            return OK;
        }

        /* Use nasty non-rigorous string format */
        noQuote = TRUE;
    }

    /* Get first char of string */
    if( !noQuote )
        ch = buffer[ bufferIndex++ ];

    /* Get string into string */
    while( ch && ch != '\"' )
    {
        /* Exit on '#' if using non-rigorous format */
        if( noQuote && ch == '#' )
            break;

        str[ stringIndex++ ] = ch;
        ch = buffer[ bufferIndex++ ];
    }

    /* If using the non-rigorous format, stomp trailing spaces */
    if( noQuote )
        while( stringIndex > 0 && str[ stringIndex - 1 ] == ' ' )
            stringIndex--;

    str[ stringIndex++ ] = '\0';
    *endIndex += bufferIndex;

    /* Check for missing string terminator */
    if( ch != '\"' && !noQuote )
    {
        if( line )
            fprintf( stderr,
                    LANG("%s: unterminated string in line %d\n"),
                    errtag, line );
        else
            fprintf( stderr,
                    LANG("unterminated string: '\"%s'\n"), str );
        hasError = TRUE;
        errCount++;
        return ERROR;
    }

    return OK;
}

/* Get an assignment to an intrinsic */

static int getAssignment( char *buffer, int *endIndex, INPUT_TYPE
        settingType )
{
    int settingIndex = 0;
	unsigned int length;
    long longval;
    char *p;

    buffer += extractToken( buffer, endIndex, &length );

    /* Check for an assignment operator */
    if( *buffer != '=' )
    {
        if( line )
            fprintf( stderr, LANG("%s: expected '=' in line %d\n"),
                    errtag, line );
        else
            fprintf( stderr,
                    LANG("%s: expected '=' after \"%s\"\n"),
                    errtag, optstr);
        hasError = TRUE;
        errCount++;
        return ERROR;
    }
    buffer++; /* Skip '=' */

    buffer += extractToken( buffer, endIndex, &length );

    switch( settingType )
    {
        case BOOLE:
            /* Check for known intrinsic - really more general
               than just checking for TRUE or FALSE */
            settingIndex = lookup( buffer, length, settings,
                    NO_SETTINGS );
            if( settingIndex == ERROR )
            {
                hasError = TRUE;
                errCount++;
                return ERROR;
            }

            value = ( settingIndex == 0 ) ? FALSE : TRUE;
            break;

        case STRING:
            /* Get a string */
            getaString( buffer, &length );
            break;

        case NUMERIC:
            longval = strtol(buffer, &p, 0);
            if (p == buffer+length &&
                    longval <= INT_MAX && longval >= INT_MIN) {
                value = (int)longval;
                break;
            }
            if( line )
                fprintf( stderr,
                        LANG("%s: numeric argument expected in line %d\n"),
                        errtag, line );
            else
                fprintf( stderr,
                        LANG("%s: numeric argument required for \"%s\"\n"),
                        errtag, optstr);
            hasError = TRUE;
            errCount++;
            return ERROR;
    }

    return settingIndex;
}

/* Process an assignment */

static void processAssignment( struct pgpenvBones *envbPtr, int
        intrinsicIndex, PGPInt32 pri )
/* pri is either PGPENV_PRI_SYSCONF, PGPENV_PRI_CONFIG, or
   PGPENV_PRI_CMDLINE*/
{
    PGPEnv *env = envbPtr->m_env;
    PGPContextRef context = pgpenvGetContext( env );

    PGPError err;
    if( !hasError )
        switch( intrinsicIndex )
        {
            case ARMOR:
                pgpenvSetInt( env, PGPENV_ARMOR,  value, pri );
                break;

            case ARMORLINES:
                pgpenvSetInt( env, PGPENV_ARMORLINES,  value, pri );
                break;

            case BAKRING:
                pgpenvSetString( env, PGPENV_BAKRING, str, pri );
                break;

            case BATCHMODE:
                pgpenvSetInt( env, PGPENV_BATCHMODE,  value, pri );
                break;

            case CERT_DEPTH:
                if( value < MIN_CERT_DEPTH )
                    value = MIN_CERT_DEPTH;
                if( value > MAX_CERT_DEPTH )
                    value = MAX_CERT_DEPTH;
                pgpenvSetInt( env, PGPENV_CERTDEPTH,  value, pri );
                break;

            case CHARSET:
                pgpenvSetString( env, PGPENV_CHARSET, str, pri );
                break;

            case CLEAR:
                pgpenvSetInt( env, PGPENV_CLEARSIG,  value, pri );
                break;

            case COMPATIBLE:
                envbPtr->compatible = value;
                break;

            case COMMENT:
                pgpenvSetString( env, PGPENV_COMMENT, str, pri );
                break;

            case COMPLETES_NEEDED:
                pgpenvSetInt( env, PGPENV_COMPLETES,  value, pri );
                /* Keep within range */
                if( pgpenvGetInt( env, PGPENV_COMPLETES, &pri, &err )
                        < MIN_COMPLETE )
                    pgpenvSetInt( env, PGPENV_COMPLETES,  MIN_COMPLETE,
                            pri );

                if( pgpenvGetInt( env, PGPENV_COMPLETES, &pri, &err )
                        > MAX_COMPLETE )
                    pgpenvSetInt( env, PGPENV_COMPLETES,  MAX_COMPLETE,
                            pri );

                break;

            case COMPRESS:
                pgpenvSetInt( env, PGPENV_COMPRESS,  value, pri );
                break;

            case FASTKEYGEN:
                pgpenvSetInt( env, PGPENV_FASTKEYGEN,  value, pri );
                break;

            case FORCE:
                pgpenvSetInt( env, PGPENV_FORCE,  value, pri );
                break;

            case INTERACTIVE:
                envbPtr->interactiveAdd = value;
                break;

            case KEEPBINARY:
                /*envbPtr->keepctx = value;*/
                break;

            case KEYSERVER_URL:
                strcpy( envbPtr->keyserverURL, str );
                break;

            case LANGUAGE:
                pgpenvSetString( env, PGPENV_LANGUAGE, str, pri );
                break;


            case MAKERANDOM:
                envbPtr->makeRandom = value;
                break;

            case MARGINALS_NEEDED:
                pgpenvSetInt( env, PGPENV_MARGINALS,  value, pri );
                /* Keep within range */
                if( pgpenvGetInt( env, PGPENV_MARGINALS, &pri, &err )
                        < MIN_MARGINALS )

                    pgpenvSetInt( env, PGPENV_MARGINALS,  MIN_MARGINALS,
                            pri );

                break;

            case MYNAME:
                pgpenvSetString( env, PGPENV_MYNAME, str, pri );
                break;

            case NOMANUAL:
                envbPtr->noManual = value;
                break;

            case PAGER:
                strcpy( envbPtr->pager, str );
                break;

            case PASSTHROUGH:
                envbPtr->passThrough = value;
                break;

            case PGP_MIME:
                pgpenvSetInt( env, PGPENV_PGPMIME,  value, pri );
                break;

            case PGP_MIMEPARSE:
                pgpenvSetInt( env, PGPENV_PGPMIMEPARSEBODY,  value, pri );
                break;

            case PUBRING:
                pgpenvSetString( env, PGPENV_PUBRINGnolongerused, str, pri );
                /*
                   what should we do now?  if priority
                   is config or higher we should set
                   the preferences.
                 */

                if( pri >= PGPENV_PRI_CONFIG )
                {
                    PGPFileSpecRef pubfilespec;
                    char pubring[MAX_PATH+1];
                    strcpy(pubring,str);
                    /*force_extension( pubring, ".pkr", filebPtr);*/
                    err = PGPNewFileSpecFromFullPath( context, pubring,
                            &pubfilespec );

                    pgpAssertNoErr(err);
                    err = PGPsdkPrefSetFileSpec( context,
                            kPGPsdkPref_PublicKeyring, pubfilespec);

                    pgpAssertNoErr(err);
                    PGPFreeFileSpec( pubfilespec );
                }