prompter.cpp

subversion-1.4.3-1.tar.gz 配置svn的源码

                m_maySave = false;
        }
        else
        {
            m_answer = "";
            m_maySave = false;
        }
        return m_answer.c_str();
    }
}
int Prompter::askTrust(const char *question, bool maySave)
{
    if(m_version2)
    {
        static jmethodID mid = 0;
        JNIEnv *env = JNIUtil::getEnv();
        if(mid == 0)
        {
            jclass clazz = env->FindClass(JAVA_PACKAGE"/PromptUserPassword2");
            if(JNIUtil::isJavaExceptionThrown())
            {
                return -1;
            }
            mid = env->GetMethodID(clazz, "askTrustSSLServer", 
                                   "(Ljava/lang/String;Z)I");
            if(JNIUtil::isJavaExceptionThrown() || mid == 0)
            {
                return -1;
            }
            env->DeleteLocalRef(clazz);
            if(JNIUtil::isJavaExceptionThrown())
            {
                return -1;
            }
        }
        jstring jquestion = JNIUtil::makeJString(question);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return -1;
        }
        jint ret = env->CallIntMethod(m_prompter, mid, jquestion, 
                                      maySave ? JNI_TRUE : JNI_FALSE);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return -1;
        }
        env->DeleteLocalRef(jquestion);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return -1;
        }
        return ret;
    }
    else
    {
        std::string q = question;
        if(maySave)
        {
            q += _("(R)eject, accept (t)emporarily or accept (p)ermanently?");
        }
        else
        {
            q += _("(R)eject or accept (t)emporarily?");
        }
        const char *answer = askQuestion(NULL, q.c_str(), true, false);
        if(*answer == 't' || *answer == 'T')
        {
            return 
              org_tigris_subversion_javahl_PromptUserPassword2_AcceptTemporary;
        }
        else if(maySave && (*answer == 'p' || *answer == 'P'))
        {
            return 
             org_tigris_subversion_javahl_PromptUserPassword2_AcceptPermanently;
        }
        else
            return org_tigris_subversion_javahl_PromptUserPassword2_Reject;
    }
    return -1;
}

bool Prompter::prompt(const char *realm, const char *pi_username, bool maySave)
{
    JNIEnv *env = JNIUtil::getEnv();
    if(m_version3)
    {
        static jmethodID mid = 0;
        static jmethodID mid2 = 0;
        if(mid == 0)
        {
            jclass clazz = env->FindClass(JAVA_PACKAGE"/PromptUserPassword3");
            if(JNIUtil::isJavaExceptionThrown())
            {
                return false;
            }
            mid = env->GetMethodID(clazz, "prompt", 
                                   "(Ljava/lang/String;Ljava/lang/String;Z)Z");
            if(JNIUtil::isJavaExceptionThrown() || mid == 0)
            {
                return false;
            }
            mid2 = env->GetMethodID(clazz, "userAllowedSave", "()Z");
            if(JNIUtil::isJavaExceptionThrown() || mid == 0)
            {
                return false;
            }
            env->DeleteLocalRef(clazz);
            if(JNIUtil::isJavaExceptionThrown())
            {
                return false;
            }
        }

        jstring jrealm = JNIUtil::makeJString(realm);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        jstring jusername = JNIUtil::makeJString(pi_username);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        jboolean ret = env->CallBooleanMethod(m_prompter, mid, jrealm,
                                    jusername, maySave ? JNI_TRUE: JNI_FALSE);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        env->DeleteLocalRef(jusername);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        env->DeleteLocalRef(jrealm);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        m_maySave = env->CallBooleanMethod(m_prompter, mid2) ? true : false;
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        return ret ? true:false;
    }
    else
    {
        static jmethodID mid = 0;
        if(mid == 0)
        {
            jclass clazz = env->FindClass(JAVA_PACKAGE"/PromptUserPassword");
            if(JNIUtil::isJavaExceptionThrown())
            {
                return false;
            }
            mid = env->GetMethodID(clazz, "prompt", 
                                   "(Ljava/lang/String;Ljava/lang/String;)Z");
            if(JNIUtil::isJavaExceptionThrown() || mid == 0)
            {
                return false;
            }
            env->DeleteLocalRef(clazz);
            if(JNIUtil::isJavaExceptionThrown())
            {
                return false;
            }
        }

        jstring jrealm = JNIUtil::makeJString(realm);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        jstring jusername = JNIUtil::makeJString(pi_username);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        jboolean ret = env->CallBooleanMethod(m_prompter, mid, jrealm, 
            jusername);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        env->DeleteLocalRef(jusername);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        env->DeleteLocalRef(jrealm);
        if(JNIUtil::isJavaExceptionThrown())
        {
            return false;
        }
        if(maySave)
            m_maySave = askYesNo(realm, _("May save the answer ?"), true);
        else
            m_maySave = false;
        return ret ? true:false;
    }
}
svn_auth_provider_object_t *Prompter::getProviderSimple()
{
    apr_pool_t *pool = JNIUtil::getRequestPool()->pool();
    svn_auth_provider_object_t *provider;
    svn_client_get_simple_prompt_provider (&provider,
                                           simple_prompt,
                                           this,
                                           2, /* retry limit */
                                           pool);

    return provider;
}
svn_auth_provider_object_t *Prompter::getProviderUsername()
{
    apr_pool_t *pool = JNIUtil::getRequestPool()->pool();
    svn_auth_provider_object_t *provider;
    svn_client_get_username_prompt_provider (&provider,
                                             username_prompt,
                                             this,
                                             2, /* retry limit */
                                             pool);

    return provider;
}
svn_auth_provider_object_t *Prompter::getProviderServerSSLTrust()
{
    apr_pool_t *pool = JNIUtil::getRequestPool()->pool();
    svn_auth_provider_object_t *provider;
    svn_client_get_ssl_server_trust_prompt_provider
          (&provider, ssl_server_trust_prompt, this, pool);

    return provider;
}
svn_auth_provider_object_t *Prompter::getProviderClientSSL()
{
    apr_pool_t *pool = JNIUtil::getRequestPool()->pool();
    svn_auth_provider_object_t *provider;
    svn_client_get_ssl_client_cert_prompt_provider
          (&provider, ssl_client_cert_prompt, this, 2, /* retry limit */pool);

    return provider;
}
svn_auth_provider_object_t *Prompter::getProviderClientSSLPassword()
{
    apr_pool_t *pool = JNIUtil::getRequestPool()->pool();
    svn_auth_provider_object_t *provider;
    svn_client_get_ssl_client_cert_pw_prompt_provider
          (&provider, ssl_client_cert_pw_prompt, this, 2 /* retry limit */,
                                                         pool);

    return provider;
}
svn_error_t *Prompter::simple_prompt(svn_auth_cred_simple_t **cred_p, 
                                     void *baton,
                                     const char *realm, const char *username, 
                                     svn_boolean_t may_save,
                                     apr_pool_t *pool)
{
    Prompter *that = (Prompter*)baton;
    svn_auth_cred_simple_t *ret = (svn_auth_cred_simple_t*)apr_pcalloc(pool, 
                                                                sizeof(*ret));
    if(!that->prompt(realm, username, may_save ? true : false))
        return svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
                        _("User canceled dialog"));
    jstring juser = that->username();
    JNIStringHolder user(juser);
    if(user == NULL)
        return svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
                        _("User canceled dialog"));
    ret->username = apr_pstrdup(pool,user);
    jstring jpass = that->password();
    JNIStringHolder pass(jpass);
    if(pass == NULL)
        return svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
                            _("User canceled dialog"));
    else
    {
        ret->password  = apr_pstrdup(pool, pass);
        ret->may_save = that->m_maySave;
    }
    *cred_p = ret;
    return SVN_NO_ERROR;
}
svn_error_t *Prompter::username_prompt(svn_auth_cred_username_t **cred_p, 
                                       void *baton,
                                       const char *realm, 
                                       svn_boolean_t may_save, 
                                       apr_pool_t *pool)
{
    Prompter *that = (Prompter*)baton;
    svn_auth_cred_username_t *ret = 
        (svn_auth_cred_username_t*)apr_pcalloc(pool, sizeof(*ret));
    const char *user = that->askQuestion(realm, _("Username: "), true, 
                                         may_save ? true : false);
    if(user == NULL)
        return svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
                        _("User canceled dialog"));
    ret->username = apr_pstrdup(pool,user);
    ret->may_save = that->m_maySave;
    *cred_p = ret;
    return SVN_NO_ERROR;
}
svn_error_t *Prompter::ssl_server_trust_prompt(
                              svn_auth_cred_ssl_server_trust_t **cred_p,
                              void *baton,
                              const char *realm,
                              apr_uint32_t failures,
                              const svn_auth_ssl_server_cert_info_t *cert_info,
                              svn_boolean_t may_save,
                               apr_pool_t *pool)
{
    Prompter *that = (Prompter*)baton;
    svn_auth_cred_ssl_server_trust_t *ret = 
            (svn_auth_cred_ssl_server_trust_t*)apr_pcalloc(pool, sizeof(*ret));

    std::string question = _("Error validating server certificate for ");
    question += realm;
    question += ":\n";

    if(failures & SVN_AUTH_SSL_UNKNOWNCA)
    {
        question += _(" - Unknown certificate issuer\n");
        question += _("   Fingerprint: ");
        question += cert_info->fingerprint;
        question += "\n";
        question += _("   Distinguished name: ");
        question += cert_info->issuer_dname;
        question += "\n";
    }

    if(failures & SVN_AUTH_SSL_CNMISMATCH)
    {
        question += _(" - Hostname mismatch (");
        question += cert_info->hostname;
        question += _(")\n");
    }

    if(failures & SVN_AUTH_SSL_NOTYETVALID)
    {
        question += _(" - Certificate is not yet valid\n");
        question += _("   Valid from ");
        question += cert_info->valid_from;
        question += "\n";
    }

    if(failures & SVN_AUTH_SSL_EXPIRED)
    {
        question += _(" - Certificate is expired\n");
        question += _("   Valid until ");
        question += cert_info->valid_until;
        question += "\n";
    }

    switch(that->askTrust(question.c_str(), may_save ? true : false))
    {
    case org_tigris_subversion_javahl_PromptUserPassword2_AcceptTemporary:
        *cred_p = ret;
        ret->may_save = FALSE;
        break;
    case org_tigris_subversion_javahl_PromptUserPassword2_AcceptPermanently:
        *cred_p = ret;
        ret->may_save = TRUE;
        ret->accepted_failures = failures;
        break;
    default:
        *cred_p = NULL;
    }
    return SVN_NO_ERROR;
}
svn_error_t *Prompter::ssl_client_cert_prompt(
                                     svn_auth_cred_ssl_client_cert_t **cred_p,
                                     void *baton, 
                                     const char *realm, 
                                     svn_boolean_t may_save,
                                     apr_pool_t *pool)
{
    Prompter *that = (Prompter*)baton;
    svn_auth_cred_ssl_client_cert_t *ret = 
        (svn_auth_cred_ssl_client_cert_t*)apr_pcalloc(pool, sizeof(*ret));
    const char *cert_file = that->askQuestion(realm, 
                                _("client certificate filename: "), true, 
                                may_save ? true : false);
    if(cert_file == NULL)
        return svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
                        _("User canceled dialog"));
    ret->cert_file = apr_pstrdup(pool, cert_file);
    ret->may_save = that->m_maySave;
    *cred_p = ret;
    return SVN_NO_ERROR;
}
svn_error_t *Prompter::ssl_client_cert_pw_prompt(
                                  svn_auth_cred_ssl_client_cert_pw_t **cred_p,
                                  void *baton, 
                                  const char *realm, 
                                  svn_boolean_t may_save,
                                  apr_pool_t *pool)
{
    Prompter *that = (Prompter*)baton;
    svn_auth_cred_ssl_client_cert_pw_t *ret = 
        (svn_auth_cred_ssl_client_cert_pw_t*)apr_pcalloc(pool, sizeof(*ret));
    const char *info = that->askQuestion(realm, 
                                         _("client certificate passphrase: "), 
                                         false, may_save ? true : false);
    if(info == NULL)
        return svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
                        _("User canceled dialog"));
    ret->password = apr_pstrdup(pool, info);
    ret->may_save = that->m_maySave;
    *cred_p = ret;
    return SVN_NO_ERROR;
}