textgen.c

安全开发库。含客户端建立ssl连接、签名、证书验证、证书发布和撤销等。编译用到nss

        tmp = SSM_NEW_ARRAY(char, fragLen);
        if (tmp == NULL) {
            goto loser;
        }
        memcpy(tmp, leftBrace+1, fragLen-1);
        tmp[fragLen-1] = '\0';
        rv = SSMTextGen_SubstituteString(cx, tmp, &repl1);
        PR_Free(tmp);
        tmp = NULL;
        if (rv != SSM_SUCCESS) {
            goto loser;        
        }
        rv = SSMTextGen_ProcessKeyword(cx, repl1, &repl2);
        if (rv != SSM_SUCCESS) {
            char ch;
            SSMStatus rv1, rv2;
            /* The text between the braces couldn't be replaced, so
             * insert everything starting with raw up to and including
             * the left brace, then insert repl1 which is what the substring
             * was substituted as, then place the closing right bracket.
             */
            ch = leftBrace[1];
            leftBrace[1] = '\0';
            rv1 = ssmtextgen_add_segment(&segResult, raw);
            leftBrace[1] = ch;
            rv2 = ssmtextgen_add_segment(&segResult, repl1);
            if (rv1 != SSM_SUCCESS || rv2 != SSM_SUCCESS ||
                ssmtextgen_add_segment(&segResult, "}") != SSM_SUCCESS) {
                goto loser;
            }
        } else {
            /* We processed a keyword, so take the string before the left
             * brace, make it the next segment, then make the response
             * from SSMTextGen_ProcessKeyword the segment after that.
             */
            SSMStatus rv1, rv2;

            leftBrace[0] = '\0';
            rv1 = ssmtextgen_add_segment(&segResult, raw);
            rv2 = ssmtextgen_add_segment(&segResult, repl2);
            PR_Free(repl2);
            repl2 = NULL;
            leftBrace[0] = punct_ch[TEXTGEN_PUNCT_LEFTBRACE];
            if (rv1 != SSM_SUCCESS || rv2 != SSM_SUCCESS) {
                goto loser;
            }
        }
        if (repl1 != NULL) {
            PR_Free(repl1);
            repl1 = NULL;
        }
        if (repl2 != NULL) {
            PR_Free(repl2);
            repl2 = NULL;
        }
        raw = &rightBrace[1];
    }
    *result = segResult.result;
    rv = SSM_SUCCESS;
    goto done;
 loser:
    if (rv == SSM_SUCCESS) rv = SSM_FAILURE;

    /* delete/NULL result if we ran into a problem */
    if (*result)
    {
        PR_Free(*result);
        *result = NULL;
    }
 done:
    /* deallocate working strings */
    return rv;
}

/* Given a key and a context, cycle through resource bundles until
   we find a match for the desired key. */
SSMStatus
SSM_FindUTF8StringInBundles(SSMTextGenContext *cx,
                               const char *key, 
                               char **utf8Result)
{
    SSMStatus rv = SSM_FAILURE;
    PRInt32 i;
    size_t bufSize;
    char *utf8;
    
    /*
      If we aren't serving an HTTP request, use the default locale.
    */
    if (cx && cx->m_request && cx->m_request->locale)
        loc = cx->m_request->locale;
    /* REMOVED CALL */;
}

/* Get a UnicodeString from the resource database and expand it. */
SSMStatus
SSM_GetAndExpandText(SSMTextGenContext *cx, 
                     const char *key, 
                     char **result)
{
    char *replText = NULL;
    char *origText=NULL;
    char *tmp = NULL;
    SSMStatus rv = SSM_SUCCESS;

    if (!key || !result)
        goto loser;
    PR_FREEIF(*result);
    *result = NULL; /* in case we fail */

    if (cx != NULL && PL_strcmp(cx->m_keyword, key)) {
        PR_Free(cx->m_keyword);
        cx->m_keyword = PL_strdup(key);
    }

    /* Get the text from the database. */
    SSM_DEBUG("Requesting string <%s> from the text database.\n", key);
    rv = SSM_FindUTF8StringInBundles(cx, key, &origText);
    if (rv != SSM_SUCCESS)
    {
        if (cx != NULL)
            SSM_HTTPReportSpecificError(cx->m_request, 
                                        "SSM_GetAndExpandText: SSM error %d "
                                        "getting property string '%s'.", 
                                        rv, key);
        goto loser;
    }

    /* Expand/replace keywords in the string. */
    rv = SSMTextGen_SubstituteString(cx, origText, &replText);
    /*     SSM_DebugUTF8String("SSM_GetAndExpandText - expanded text",  */
    /*                            replText); */
    if ((rv != SSM_SUCCESS) || (!replText))
        goto loser;
    *result = replText;
    replText = NULL; /* So we don't free it*/
    goto done;
 loser:
    if (rv == SSM_SUCCESS)
        rv = SSM_FAILURE;
    /* ### mwelch Need to attempt to return a blank string in case some
       errors happen (such as: we can't find the string/locale not supported).*/
    if (*result) {
        PR_Free(*result);
        *result = NULL;
    }
 done:
    /* Dispose of intermediate strings if applicable. */
    if (origText)
        PR_Free(origText);
    if (replText)
        PR_Free(replText);

    return rv;
}

/* Get a string from the resource database using a Unicode string
   as key. Then, expand the string. */
SSMStatus
SSM_GetAndExpandTextKeyedByString(SSMTextGenContext *cx,
                                  const char *key, 
                                  char **result)
{
    SSMStatus rv = SSM_SUCCESS;
    char *text=NULL;

    *result = NULL; /* in case we fail */

    /* Use the ascii equivalent of (key) as the actual key. */
    if (!key)
        goto loser;

    /* Now, call SSM_GetAndExpandText above using the ASCII key. */
    rv = SSM_GetAndExpandText(cx, key, &text);
    if (rv != SSM_SUCCESS)
        goto loser;

    *result = text;
    text = NULL;

    goto done;
 loser:
    if (rv == SSM_SUCCESS) 
        rv = SSM_FAILURE;
    if (text != NULL) 
        PR_Free(text);
    *result = NULL;
 done:
    return rv;
}

/* Get a numeric parameter from the properties file. */
SSMStatus
SSM_GetNumber(SSMTextGenContext *cx, char *key, PRInt32 *param)
{
    char *text = NULL;
    SSMStatus rv = SSM_SUCCESS;

    *param = 0; /* in case we fail */

    /* Get expanded text from the database. */
    rv = SSM_GetAndExpandText(cx, key, &text);
    if ((rv != SSM_SUCCESS) || (!text))
        goto loser;

    *param = SSMTextGen_atoi(SSMTextGen_GetLocale(cx), text);

    goto done;
 loser:
    if (rv == SSM_SUCCESS)
        rv = SSM_FAILURE;
 done:
    if (text)
        PR_Free(text);
    return rv;
}

/* 
   Retrieves a string, expands it, then formats it according to the
   _Print method of the target object. 
*/
SSMStatus
SSM_GetUTF8Text(SSMTextGenContext *cx,
                const char *key, 
                char **resultStr)
{
    char *expandedText = NULL, *fmtResult = NULL;
    SSMStatus rv = SSM_SUCCESS;
    SSMResource *targetObj;

    *resultStr = NULL; /* in case we fail */

    /* Get expanded text from the database. */
    rv = SSM_GetAndExpandText(cx, key, &expandedText);
    if ((rv != SSM_SUCCESS) || (!expandedText))
        goto loser;

    targetObj = SSMTextGen_GetTargetObject(cx);
    if (SSMTextGen_StringContainsFormatParams(expandedText))
    {
        if (targetObj != NULL)
            rv = SSM_MessageFormatResource(targetObj, expandedText, 
					   cx->m_request->numParams-2, 
					   &(cx->m_request->paramValues[2]), 
                                           &fmtResult);
        else
        {
            PR_ASSERT(!"No target object for formatting");
            rv = SSM_FAILURE;
        }
    } else {
        fmtResult = expandedText;
    }
    if (rv != SSM_SUCCESS)
        goto loser;

    *resultStr = fmtResult;
             
    if (*resultStr == NULL) {
        goto loser;
    }
    goto done;
 loser:
    if (rv != SSM_SUCCESS) rv = SSM_FAILURE;
    if (*resultStr != NULL) {
        PR_Free(*resultStr);
    }
    *resultStr = NULL;
 done:
    if ((expandedText) && (*resultStr != expandedText))
        PR_Free(expandedText);
    if ((fmtResult) && (*resultStr != fmtResult))
        PR_Free(fmtResult);
    return rv;
}

/* 
   Hello World keyword handler example.
   This handler replaces all instances of the keyword "{hello}"
   with "Hello, World!" in the text being processed. Look for
   "Hello World" in minihttp.c for content handler examples.
*/
SSMStatus
SSM_HelloKeywordHandler(SSMTextGenContext *cx)
{
    SSMStatus rv = SSM_SUCCESS; /* generic rv */

    cx->m_result = PL_strdup("Hello, World");
    /* All done. */
    return rv;
}

SSMStatus
wrap_test(SSMTextGenContext *cx)
{
    SSMStatus rv = SSM_SUCCESS;
    char *p, *pattern, *temp = NULL, *fmt;
    int i;

    pattern = PL_strdup("test(%1$s) ");
    /* Zero out the result. */
    SSMTextGen_UTF8StringClear(&cx->m_result);

    /* Wrap the parameters inside "test()", and concatenate them onto the 
       result. */
    for(i=0;i<SSM_Count(cx->m_params);i++)
    {
        p = (char *) SSM_At(cx->m_params, i);
        temp = PR_smprintf(pattern, p);
        if (temp == NULL) {
            goto loser;
        }
        fmt = PR_smprintf("%s%s", cx->m_result, temp);
        PR_smprintf_free(temp);
        if (fmt == NULL) {
            goto loser;
        }
        PR_Free(cx->m_result);
        cx->m_result = fmt;
    }
    goto done;
 loser:
    if (rv == SSM_SUCCESS)
        rv = SSM_FAILURE;
    SSMTextGen_UTF8StringClear(&cx->m_result);
 done:
    PR_FREEIF(temp);
    return rv;
}

void SSM_InitNLS(char *dataDirectory)
{
    SSMStatus rv = SSM_SUCCESS;

    /* REMOVED CALL */;

    /* Initialize data. */

    /* 
       Create a default locale.
       ### mwelch We really should not use default locales for any UI if
       we can help it. I'm adding this for now, but next week I need to hook
       up the incoming locale in the HTTP request to this code.
    */
    /* REMOVED CALL */;

    /* Initialize hash table which contains keyword handlers. */
    rv = SSM_KeywordHandlerInitialize();
    if (rv != SSM_SUCCESS)
        goto loser;

    /* Create keyword handlers */
    SSM_RegisterKeywordHandler("_certlist", SSM_CertListKeywordHandler);
    SSM_RegisterKeywordHandler("_server_cert_info", 
                               SSM_ServerCertKeywordHandler);
    SSM_RegisterKeywordHandler("view_cert_info", 
                               SSM_ViewCertInfoKeywordHandler);
    SSM_RegisterKeywordHandler("tokenList", SSMTokenUI_KeywordHandler);

    SSM_RegisterKeywordHandler("_client_auth_certList", 
			       SSM_ClientAuthCertListKeywordHandler);
    SSM_RegisterKeywordHandler("_get_current_time", 
                               SSM_CurrentTimeKeywordHandler);
    SSM_RegisterKeywordHandler("_server_cert_domain_info",
                               SSM_ServerAuthDomainNameKeywordHandler);
    SSM_RegisterKeywordHandler("_verify_server_cert",
                               SSM_VerifyServerCertKeywordHandler);

    SSM_RegisterKeywordHandler("_fipsmode", SSM_PKCS11FIPSModeKeywordHandler);
    SSM_RegisterKeywordHandler("_pk11modules",
                               SSM_PKCS11ModulesKeywordHandler);
    SSM_RegisterKeywordHandler("_pk11slots",
                               SSM_PKCS11SlotsKeywordHandler);
    SSM_RegisterKeywordHandler("_signtext_certList",
                    SSM_SignTextCertListKeywordHandler);
    SSM_RegisterKeywordHandler("_ca_cert_info", SSM_CACertKeywordHandler);
    SSM_RegisterKeywordHandler("_ca_policy_info", SSM_CAPolicyKeywordHandler);
    SSM_RegisterKeywordHandler("verify_cert", SSM_VerifyCertKeywordHandler);
    SSM_RegisterKeywordHandler("choose_list", SSM_SelectCertKeywordHandler);
    SSM_RegisterKeywordHandler("edit_cert", SSM_EditCertKeywordHandler);
    SSM_RegisterKeywordHandler("sa_selected_item", SSMSecurityAdvisorContext_sa_selected_item);
    SSM_RegisterKeywordHandler("set_or_reset_password", SSM_ReSetPasswordKeywordHandler);
    SSM_RegisterKeywordHandler("show_result", SSM_ShowFollowupKeywordHandler); 
    SSM_RegisterKeywordHandler("get_pref_list", SSMSecurityAdvisorContext_GetPrefListKeywordHandler);
    SSM_RegisterKeywordHandler("_ocsp_options", 
                               SSM_OCSPOptionsKeywordHandler);
    SSM_RegisterKeywordHandler("_default_ocsp_responder",
                               SSM_OCSPDefaultResponderKeywordHandler);
    SSM_RegisterKeywordHandler("password_lifetime_pref", SSM_PasswordPrefKeywordHandler);
    SSM_RegisterKeywordHandler("delete_cert_help", SSM_DeleteCertHelpKeywordHandler);
    SSM_RegisterKeywordHandler("delete_cert_warning", SSM_DeleteCertWarnKeywordHandler);
    SSM_RegisterKeywordHandler("get_new_cert_url", SSM_ObtainNewCertSite);
    SSM_RegisterKeywordHandler("ldap_server_list", SSM_LDAPServerListKeywordHandler);
#if 0
    SSM_RegisterKeywordHandler("_java_principals", SSM_JavaPrincipalsKeywordHandler);
#endif
#if 0
    SSM_RegisterKeywordHandler("testwrap", wrap_test);
    SSM_RegisterKeywordHandler("hello", SSM_HelloKeywordHandler);
#endif
    SSM_RegisterKeywordHandler("free_target", 
                               SSM_FreeTarget);
    SSM_RegisterKeywordHandler("pkcs12_incompatibility_warning",
                               SSM_WarnPKCS12Incompatibility);
    SSM_RegisterKeywordHandler("pass_var",
                               SSM_PassVariable);
    return;
 loser:
    SSM_DEBUG("NLS initialization failed. UI will be broken.\n");
}

SSMStatus
SSM_PassVariable(SSMTextGenContext *cx)
{
    SSMStatus rv;
    char *variable, *value;

    variable = (char *) SSM_At(cx->m_params, 0);
    rv = SSM_HTTPParamValue(cx->m_request, variable, &value);
    PR_FREEIF(cx->m_result);
    if (rv == SSM_SUCCESS) {
        cx->m_result = PR_smprintf("&%s=%s", variable, value);
    } else {
        cx->m_result = PL_strdup("");
    }
    return SSM_SUCCESS;
}