view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/javahl/native/Prompter.cpp  view on Meta::CPAN

                             "(Ljava/lang/String;Ljava/lang/String;Z)Z");
      if (JNIUtil::isJavaExceptionThrown() || mid == 0)
        POP_AND_RETURN(false);

      mid2 = env->GetMethodID(clazz, "userAllowedSave", "()Z");
      if (JNIUtil::isJavaExceptionThrown() || mid == 0)
        POP_AND_RETURN(false);
    }

  jstring jrealm = JNIUtil::makeJString(realm);
  if (JNIUtil::isJavaExceptionThrown())
    POP_AND_RETURN(false);

  jstring jusername = JNIUtil::makeJString(pi_username);
  if (JNIUtil::isJavaExceptionThrown())
    POP_AND_RETURN(false);

  ret = env->CallBooleanMethod(m_prompter, mid, jrealm, jusername,
                               maySave ? JNI_TRUE: JNI_FALSE);
  if (JNIUtil::isJavaExceptionThrown())
    POP_AND_RETURN(false);

  m_maySave = env->CallBooleanMethod(m_prompter, mid2) ? true : false;
  if (JNIUtil::isJavaExceptionThrown())
    POP_AND_RETURN(false);

  env->PopLocalFrame(NULL);
  return ret ? true:false;
}

svn_auth_provider_object_t *Prompter::getProviderSimple(SVN::Pool &in_pool)
{
  apr_pool_t *pool = in_pool.getPool();
  svn_auth_provider_object_t *provider;
  svn_auth_get_simple_prompt_provider(&provider,
                                      simple_prompt,
                                      this,
                                      2, /* retry limit */
                                      pool);

  return provider;
}

svn_auth_provider_object_t *Prompter::getProviderUsername(SVN::Pool &in_pool)
{
  apr_pool_t *pool = in_pool.getPool();
  svn_auth_provider_object_t *provider;
  svn_auth_get_username_prompt_provider(&provider,
                                        username_prompt,
                                        this,
                                        2, /* retry limit */
                                        pool);

  return provider;
}

svn_auth_provider_object_t *Prompter::getProviderServerSSLTrust(SVN::Pool &in_pool)
{
  apr_pool_t *pool = in_pool.getPool();
  svn_auth_provider_object_t *provider;
  svn_auth_get_ssl_server_trust_prompt_provider
    (&provider, ssl_server_trust_prompt, this, pool);

  return provider;
}

svn_auth_provider_object_t *Prompter::getProviderClientSSL(SVN::Pool &in_pool)
{
  apr_pool_t *pool = in_pool.getPool();
  svn_auth_provider_object_t *provider;
  svn_auth_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(SVN::Pool &in_pool)
{
  apr_pool_t *pool = in_pool.getPool();
  svn_auth_provider_object_t *provider;
  svn_auth_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 = static_cast<Prompter *>(baton);
  svn_auth_cred_simple_t *ret =
    reinterpret_cast<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 = static_cast<Prompter *>(baton);
  svn_auth_cred_username_t *ret =
    reinterpret_cast<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 = static_cast<Prompter *>(baton);
  svn_auth_cred_ssl_server_trust_t *ret =
    reinterpret_cast<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_apache_subversion_javahl_callback_UserPasswordCallback_AcceptTemporary:
      *cred_p = ret;
      ret->may_save = FALSE;
      break;
    case org_apache_subversion_javahl_callback_UserPasswordCallback_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 = static_cast<Prompter *>(baton);
  svn_auth_cred_ssl_client_cert_t *ret =
    reinterpret_cast<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 = static_cast<Prompter *>(baton);
  svn_auth_cred_ssl_client_cert_pw_t *ret =
    reinterpret_cast<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;
}

svn_error_t *
Prompter::plaintext_prompt(svn_boolean_t *may_save_plaintext,
                           const char *realmstring,
                           void *baton,
                           apr_pool_t *pool)
{
  Prompter *that = static_cast<Prompter *>(baton);

  bool result = that->askYesNo(realmstring,
                               _("Store password unencrypted?"),
                               false);

  *may_save_plaintext = (result ? TRUE : FALSE);

  return SVN_NO_ERROR;
}

svn_error_t *
Prompter::plaintext_passphrase_prompt(svn_boolean_t *may_save_plaintext,
                                      const char *realmstring,
                                      void *baton,
                                      apr_pool_t *pool)
{
  Prompter *that = static_cast<Prompter *>(baton);

  bool result = that->askYesNo(realmstring,
                               _("Store passphrase unencrypted?"),
                               false);

  *may_save_plaintext = (result ? TRUE : FALSE);

  return SVN_NO_ERROR;
}