Alien-SVN
view release on metacpan or search on metacpan
src/subversion/CHANGES view on Meta::CPAN
during a unix build (r1637826)
* allow the use of libtool 2.4.3 (r1640862, r1640873, r1643793)
Version 1.8.10
(11 Aug 2014, from /branches/1.8.x)
http://svn.apache.org/repos/asf/subversion/tags/1.8.10
User-visible changes:
- Client-side bugfixes:
* guard against md5 hash collisions when finding cached credentials
(r1550691, r1550772, r1600909)
* ra_serf: properly match wildcards in SSL certs. (r1615211, 1615219)
* ra_serf: ignore the CommonName in SSL certs where there are Subject Alt
Names (r1565531, r1566503, r1568349, r1568361)
* ra_serf: fix a URI escaping bug that prevented deleting locked paths
(r1594223, r1553501, r1553556, r1559197, issue #3674)
* rm: Display the proper URL when deleting a URL in the commit log editor
(r1591123)
* log: Fix another instance of broken pipe error (r1596866, issue #3014)
* copy: Properly handle props not present or excluded on cross wc copy
src/subversion/CHANGES view on Meta::CPAN
* improve queries for compatibility with SQLite 3.7.16 (r1455239)
* remove support for in-tree apr, apr-util and apr-memcache (r1456924)
* FSFS caching supports prefixes now (r1462436)
* maintainer mode now prints symbolic error codes (r1465157)
* don't require NLS support for kwallet support (r1466445)
* make Julian happy (r1413030)
- API changes:
* fix inconsistent handling of log revs without changed paths (issue #3694)
* deprecated SVN_ERR_SQLITE_UNSUPPORTED_SCHEMA (r1173240)
* provide API to clear cached auth credentials (issue #2775)
* improve repository location information in various APIs (issue #4170)
* major rewrite of conflict storage and handling APIs (r1354973 et al)
* hide (deprecate) svn_wc APIs that use editors (r1243339)
* svn_stringbuf_ensure() allocates an extra byte for terminator (r1308966)
* switch and update apis are now more consistent (r1465292)
* deprecated svn_client_merge_reintegrate (r1466742)
* deprecated low level ra_svn apis (r1466907)
- Bindings:
* star-imports in swig-py only import 'svn_*' symbols (r1303375)
src/subversion/CHANGES view on Meta::CPAN
during a unix build (r1637826)
* allow the use of libtool 2.4.3 (r1640862, r1640873, r1643793)
Version 1.7.18
(11 Aug 2014, from /branches/1.7.x)
http://svn.apache.org/repos/asf/subversion/tags/1.7.18
User-visible changes:
- Client-side bugfixes:
* guard against md5 hash collisions when finding cached credentials
(r1550691, r1550772, r1600909)
* ra_serf: properly match wildcards in SSL certs. (r1615211, 1615219)
* ra_serf: ignore the CommonName in SSL certs where there are Subject Alt
Names (r1565531, r1566503, r1568349)
Developer-visible changes:
- General:
* fix ocassional failure in checkout_tests.py test 12. (r1496127)
* disable building ZLib's assembly optimizations on Windows.
src/subversion/build/ac-macros/kwallet.m4 view on Meta::CPAN
dnl
dnl SVN_LIB_KWALLET
dnl
dnl Check configure options and assign variables related to KWallet support
dnl
AC_DEFUN(SVN_LIB_KWALLET,
[
AC_ARG_WITH(kwallet,
[AS_HELP_STRING([[--with-kwallet[=PATH]]],
[Enable use of KWallet (KDE 4) for auth credentials])],
[svn_lib_kwallet="$withval"],
[svn_lib_kwallet=no])
AC_MSG_CHECKING([whether to look for KWallet])
if test "$svn_lib_kwallet" != "no"; then
AC_MSG_RESULT([yes])
if test "$svn_enable_shared" = "yes"; then
if test "$APR_HAS_DSO" = "yes"; then
if test -n "$PKG_CONFIG"; then
if test "$HAVE_DBUS" = "yes"; then
src/subversion/build/ac-macros/macosx.m4 view on Meta::CPAN
])
])
dnl SVN_LIB_MACOS_KEYCHAIN
dnl Check configure options and assign variables related to Keychain support
AC_DEFUN(SVN_LIB_MACOS_KEYCHAIN,
[
AC_ARG_ENABLE(keychain,
AS_HELP_STRING([--disable-keychain],
[Disable use of Mac OS KeyChain for auth credentials]),
[enable_keychain=$enableval],[enable_keychain=yes])
AC_MSG_CHECKING([for Mac OS KeyChain Services])
if test "$enable_keychain" = "yes"; then
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <AvailabilityMacros.h>
#if !defined(MAC_OS_X_VERSION_MAX_ALLOWED) \
|| !defined(MAC_OS_X_VERSION_10_2) \
|| (MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2)
src/subversion/configure view on Meta::CPAN
--enable-local-library-preloading
Enable preloading of locally built libraries in
locally built executables. This may be necessary for
testing prior to installation on some platforms. It
does not work on some platforms (Darwin, OpenBSD,
...).
--enable-bdb6 Allow building against BDB 6+. See
--with-berkeley-db for specifying the location of
the Berkeley DB installation. Using BDB 6 will fail
if this option is not used.
--disable-keychain Disable use of Mac OS KeyChain for auth credentials
--enable-ev2-impl Use Ev2 implementations, where available
[EXPERIMENTAL]
--disable-nls Disable gettext functionality
--disable-plaintext-password-storage
Disable on-disk caching of plaintext passwords and
passphrases. (Leaving this functionality enabled
will not force Subversion to store passwords in
plaintext, but does permit users to explicitly allow
that behavior via runtime configuration.)
--enable-debug Turn on debugging
src/subversion/configure view on Meta::CPAN
Specify location of Expat
--with-berkeley-db[=HEADER:INCLUDES:LIB_SEARCH_DIRS:LIBS]
The Subversion Berkeley DB based filesystem library
requires Berkeley DB $db_version or $db_alt_version.
If you specify `--without-berkeley-db', that library
will not be built. If you omit the argument of this
option completely, the configure script will use
Berkeley DB used by APR-UTIL.
--with-sasl=PATH Compile with libsasl2 in PATH
--without-gpg-agent Disable support for GPG-Agent
--with-gnome-keyring Enable use of GNOME Keyring for auth credentials
(enabled by default if found)
--with-libmagic=PREFIX libmagic filetype detection library
--with-kwallet[=PATH] Enable use of KWallet (KDE 4) for auth credentials
--with-openssl This option does NOT affect the Subversion build
process in any way. It tells an integrated Serf HTTP
client library build process where to locate the
OpenSSL library when (and only when) building Serf
as an integrated part of the Subversion build
process. When linking to a previously installed
version of Serf instead, you do not need to use this
option.
--with-editor=PATH Specify a default editor for the subversion client.
--with-zlib=PREFIX zlib compression library
src/subversion/configure.ac view on Meta::CPAN
else
AC_MSG_RESULT([no])
fi
AC_SUBST(SVN_HAVE_GPG_AGENT)
dnl GNOME Keyring -------------------
AC_ARG_WITH(gnome_keyring,
AS_HELP_STRING([--with-gnome-keyring],
[Enable use of GNOME Keyring for auth credentials (enabled by default if found)]),
[with_gnome_keyring="$withval"],
[with_gnome_keyring=auto])
found_gnome_keyring=no
AC_MSG_CHECKING([whether to look for GNOME Keyring])
if test "$with_gnome_keyring" != "no"; then
AC_MSG_RESULT([yes])
if test "$svn_enable_shared" = "yes"; then
if test "$APR_HAS_DSO" = "yes"; then
if test -n "$PKG_CONFIG"; then
src/subversion/doc/user/cvs-crossover-guide.html view on Meta::CPAN
</tr>
<tr>
<td>
<dl>
<dt>Commands:</dt>
<dd><tt>$ cvs -d :pserver:user@host:/repos <em>command</em>…</tt></dd>
<dt>Explanation:</dt>
<dd>When contacting a repository, the client pre-emptively
"pushes" its authentication credentials at the server.</dd>
</dl>
</td>
<td>
<dl>
<dt>Commands:</dt>
<dd><tt>$ svn <em>command</em> <em>URL</em>…</tt></dd>
<dd><tt>Password for 'user': XXXXXXX</tt></dd>
<dt>Explanation:</dt>
<dd>The client's authentication credentials are "pulled" from
the user interactively, and only when the server deems that a
challenge needs to be made. (And contrary to popular belief,
the <tt>--username</tt> and <tt>--password</tt> options are
merely values to be used <em>if</em> the server issues a
challenge; they do not "push" the credentials at the
server.)</dd>
</dl>
</td>
</tr>
</table>
<dl class="bookref">
<dt>Book References:</dt>
<dd><a href="http://svnbook.red-bean.com/svnbook/ch06s02.html">Network Model</a></dd>
src/subversion/subversion/bindings/ctypes-python/csvn/auth.py view on Meta::CPAN
to PATH.
If PATH is None, this function should check if the
REQUESTED_ACCESS is granted for at least one path
in the repository.
REQUESTED_ACCESS is an integer which may consist of
any combination of the following fields:
svn_authz_read: The path can be read
svn_authz_write: The path can be altered
svn_authz_recursive: The other access credentials
are recursive.
By default, this function always returns True, but
subclasses may behave differently.
This function is used by the "Repository" class to check
permissions (see repos.py).
FIXME: This function isn't currently used, because we
haven't implemented higher-level authz yet.
src/subversion/subversion/bindings/javahl/native/ClientContext.cpp view on Meta::CPAN
provider = m_prompter->getProviderClientSSL(in_pool);
APR_ARRAY_PUSH(providers, svn_auth_provider_object_t *) = provider;
provider = m_prompter->getProviderClientSSLPassword(in_pool);
APR_ARRAY_PUSH(providers, svn_auth_provider_object_t *) = provider;
}
/* Build an authentication baton to give to libsvn_client. */
svn_auth_open(&ab, providers, pool);
/* Place any default --username or --password credentials into the
* auth_baton's run-time parameter hash. ### Same with --no-auth-cache? */
if (!m_userName.empty())
svn_auth_set_parameter(ab, SVN_AUTH_PARAM_DEFAULT_USERNAME,
apr_pstrdup(in_pool.getPool(),
m_userName.c_str()));
if (!m_passWord.empty())
svn_auth_set_parameter(ab, SVN_AUTH_PARAM_DEFAULT_PASSWORD,
apr_pstrdup(in_pool.getPool(),
m_passWord.c_str()));
/* Store where to retrieve authentication data? */
src/subversion/subversion/bindings/javahl/src/org/apache/subversion/javahl/callback/UserPasswordCallback.java view on Meta::CPAN
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
* ====================================================================
* @endcopyright
*/
package org.apache.subversion.javahl.callback;
/**
* <p>The interface for requesting authentication credentials from the
* user. Should the javahl bindings need the matching information,
* these methodes will be called.</p>
*
* <p>This callback can also be used to provide the equivalent of the
* <code>--no-auth-cache</code> and <code>--non-interactive</code>
* arguments accepted by the command-line client.</p>
*/
public interface UserPasswordCallback
{
/**
src/subversion/subversion/bindings/javahl/src/org/apache/subversion/javahl/callback/UserPasswordCallback.java view on Meta::CPAN
*/
public int askTrustSSLServer(String info, boolean allowPermanently);
/**
* Ask the user for username and password
* The entered username/password is retrieved by the getUsername
* getPasswort methods.
*
* @param realm for which server realm this information is requested.
* @param username the default username
* @return Whether the prompt for authentication credentials was
* successful (e.g. in a GUI application whether the dialog box
* was canceled).
*/
public boolean prompt(String realm, String username);
/**
* ask the user a yes/no question
* @param realm for which server realm this information is
* requested.
* @param question question to be asked
src/subversion/subversion/bindings/javahl/src/org/apache/subversion/javahl/callback/UserPasswordCallback.java view on Meta::CPAN
*/
public String getPassword();
/**
* Request a user name and password from the user, and (usually)
* store the auth credential caching preference specified by
* <code>maySave</code> (used by {@link #userAllowedSave()}).
* Applications wanting to emulate the behavior of
* <code>--non-interactive</code> will implement this method in a
* manner which does not require user interaction (e.g. a no-op
* which assumes pre-cached auth credentials).
*
* @param realm The realm from which the question originates.
* @param username The name of the user in <code>realm</code>.
* @param maySave Whether caching of credentials is allowed.
* Usually affects the return value of the {@link
* #userAllowedSave()} method.
* @return Whether the prompt for authentication credentials was
* successful (e.g. in a GUI application whether the dialog box
* was canceled).
*/
public boolean prompt(String realm, String username, boolean maySave);
/**
* Ask the user a question, and (usually) store the auth
* credential caching preference specified by <code>maySave</code>
* (used by {@link #userAllowedSave()}). Applications wanting to
* emulate the behavior of <code>--non-interactive</code> will
* implement this method in a manner which does not require user
* interaction (e.g. a no-op).
*
* @param realm The realm from which the question originates.
* @param question The text of the question.
* @param showAnswer Whether the answer may be displayed.
* @param maySave Whether caching of credentials is allowed.
* Usually affects the return value of the {@link
* #userAllowedSave()} method.
* @return answer as entered or null if canceled
*/
public String askQuestion(String realm, String question,
boolean showAnswer, boolean maySave);
/**
* @return Whether the caller allowed caching of credentials the
* last time {@link #prompt(String, String, boolean)} was called.
* Applications wanting to emulate the behavior of
* <code>--no-auth-cache</code> will probably always return
* <code>false</code>.
*/
public boolean userAllowedSave();
}
src/subversion/subversion/bindings/javahl/src/org/tigris/subversion/javahl/PromptUserPassword.java view on Meta::CPAN
*/
public interface PromptUserPassword
{
/**
* Ask the user for username and password
* The entered username/password is retrieved by the getUsername
* getPasswort methods.
*
* @param realm for which server realm this information is requested.
* @param username the default username
* @return Whether the prompt for authentication credentials was
* successful (e.g. in a GUI application whether the dialog box
* was canceled).
*/
public boolean prompt(String realm, String username);
/**
* ask the user a yes/no question
* @param realm for which server realm this information is
* requested.
* @param question question to be asked
src/subversion/subversion/bindings/javahl/src/org/tigris/subversion/javahl/PromptUserPassword3.java view on Meta::CPAN
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
* ====================================================================
* @endcopyright
*/
package org.tigris.subversion.javahl;
/**
* <p>The interface for requesting authentication credentials from the
* user. Should the javahl bindings need the matching information,
* these methodes will be called.</p>
*
* <p>This callback can also be used to provide the equivalent of the
* <code>--no-auth-cache</code> and <code>--non-interactive</code>
* arguments accepted by the command-line client.</p>
*/
public interface PromptUserPassword3 extends PromptUserPassword2
{
/**
* Request a user name and password from the user, and (usually)
* store the auth credential caching preference specified by
* <code>maySave</code> (used by {@link #userAllowedSave()}).
* Applications wanting to emulate the behavior of
* <code>--non-interactive</code> will implement this method in a
* manner which does not require user interaction (e.g. a no-op
* which assumes pre-cached auth credentials).
*
* @param realm The realm from which the question originates.
* @param username The name of the user in <code>realm</code>.
* @param maySave Whether caching of credentials is allowed.
* Usually affects the return value of the {@link
* #userAllowedSave()} method.
* @return Whether the prompt for authentication credentials was
* successful (e.g. in a GUI application whether the dialog box
* was canceled).
*/
public boolean prompt(String realm, String username, boolean maySave);
/**
* Ask the user a question, and (usually) store the auth
* credential caching preference specified by <code>maySave</code>
* (used by {@link #userAllowedSave()}). Applications wanting to
* emulate the behavior of <code>--non-interactive</code> will
* implement this method in a manner which does not require user
* interaction (e.g. a no-op).
*
* @param realm The realm from which the question originates.
* @param question The text of the question.
* @param showAnswer Whether the answer may be displayed.
* @param maySave Whether caching of credentials is allowed.
* Usually affects the return value of the {@link
* #userAllowedSave()} method.
* @return answer as entered or null if canceled
*/
public String askQuestion(String realm, String question,
boolean showAnswer, boolean maySave);
/**
* @return Whether the caller allowed caching of credentials the
* last time {@link #prompt(String, String, boolean)} was called.
* Applications wanting to emulate the behavior of
* <code>--no-auth-cache</code> will probably always return
* <code>false</code>.
*/
public boolean userAllowedSave();
}
src/subversion/subversion/bindings/swig/include/svn_types.swg view on Meta::CPAN
svn_auth_cred_username_t **cred,
svn_auth_cred_ssl_client_cert_pw_t **cred,
svn_auth_cred_ssl_client_cert_t **cred,
svn_auth_cred_ssl_server_trust_t **cred,
svn_auth_iterstate_t **,
svn_auth_provider_object_t **,
svn_config_t **,
svn_diff_t **,
svn_patch_file_t **,
svn_patch_t **,
void **credentials,
void **iter_baton,
void **token,
/* svn_client */
svn_client_commit_info_t **,
svn_client_ctx_t **,
const svn_client_commit_item3_t **,
/* svn_delta */
const svn_delta_editor_t **,
svn_txdelta_stream_t **,
svn_txdelta_window_t **,
src/subversion/subversion/bindings/swig/perl/native/Core.pm view on Meta::CPAN
=item $simple-E<gt>username()
Username.
=item $simple-E<gt>password()
Password.
=item $simple-E<gt>may_save()
Indicates if the credentials may be saved (to disk).
=back
=cut
package _p_svn_auth_cred_username_t;
use SVN::Base qw(Core svn_auth_cred_username_t_);
=head2 svn_auth_cred_username_t
=over 4
=item $username-E<gt>username()
Username.
=item $username-E<gt>may_save()
Indicates if the credentials may be saved (to disk).
=back
=cut
package _p_svn_auth_cred_ssl_server_trust_t;
use SVN::Base qw(Core svn_auth_cred_ssl_server_trust_t_);
=head2 svn_auth_cred_ssl_server_trust_t
=over 4
=item $strust-E<gt>may_save()
Indicates if the credentials may be saved (to disk).
=item $strust-E<gt>accepted_failures()
Bit mask of the accepted failures.
=back
=cut
package _p_svn_auth_ssl_server_cert_info_t;
src/subversion/subversion/bindings/swig/perl/native/Core.pm view on Meta::CPAN
=head2 svn_auth_cred_ssl_client_cert_t
=over 4
=item $ccert-E<gt>cert_file()
Full paths to the certificate file.
=item $ccert-E<gt>may_save()
Indicates if the credentials may be saved (to disk).
=back
=cut
package _p_svn_auth_cred_ssl_client_cert_pw_t;
use SVN::Base qw(Core svn_auth_cred_ssl_client_cert_pw_t_);
=head2 svn_auth_cred_ssl_client_cert_pw_t
=over 4
=item $ccertpw-E<gt>password()
Certificate password.
=item $ccertpw-E<gt>may_save()
Indicates if the credentials may be saved (to disk).
=back
=cut
=head1 CONSTANTS
=head2 SVN::Auth::SSL
=over 4
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
{
SV *sv;
if (value <= UV_MAX)
sv = newSVuv(value);
else
sv = newSVpvf("%lu", value);
return sv_2mortal(sv);
}
static svn_error_t * svn_auth_provider_invoke_first_credentials(
svn_auth_provider_t * _obj, void **credentials, void **iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->first_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}
static svn_error_t * svn_auth_provider_invoke_next_credentials(
svn_auth_provider_t * _obj, void **credentials, void *iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->next_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}
static svn_error_t * svn_auth_provider_invoke_save_credentials(
svn_auth_provider_t * _obj, svn_boolean_t *saved, void *credentials, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->save_credentials)(saved, credentials, provider_baton, parameters, realmstring, pool);
}
static void svn_auth_invoke_simple_provider_func(
svn_auth_simple_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
_obj(provider, pool);
}
static void svn_auth_invoke_ssl_client_cert_pw_provider_func(
svn_auth_ssl_client_cert_pw_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
_obj(provider, pool);
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_t_first_credentials_set) {
{
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
SWIG_croak("Usage: svn_auth_provider_t_first_credentials_set(self,first_credentials);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_t_first_credentials_set" "', argument " "1"" of type '" "struct svn_auth_provider_t *""'");
}
arg1 = (struct svn_auth_provider_t *)(argp1);
{
int res = SWIG_ConvertFunctionPtr(ST(1), (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_first_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->first_credentials = arg2;
ST(argvi) = sv_newmortal();
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_t_first_credentials_get) {
{
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
svn_error_t *(*result)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
SWIG_croak("Usage: svn_auth_provider_t_first_credentials_get(self);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_t_first_credentials_get" "', argument " "1"" of type '" "struct svn_auth_provider_t *""'");
}
arg1 = (struct svn_auth_provider_t *)(argp1);
result = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->first_credentials);
ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t); argvi++ ;
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_t_next_credentials_set) {
{
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
SWIG_croak("Usage: svn_auth_provider_t_next_credentials_set(self,next_credentials);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_t_next_credentials_set" "', argument " "1"" of type '" "struct svn_auth_provider_t *""'");
}
arg1 = (struct svn_auth_provider_t *)(argp1);
{
int res = SWIG_ConvertFunctionPtr(ST(1), (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_next_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->next_credentials = arg2;
ST(argvi) = sv_newmortal();
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_t_next_credentials_get) {
{
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
svn_error_t *(*result)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
SWIG_croak("Usage: svn_auth_provider_t_next_credentials_get(self);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_t_next_credentials_get" "', argument " "1"" of type '" "struct svn_auth_provider_t *""'");
}
arg1 = (struct svn_auth_provider_t *)(argp1);
result = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->next_credentials);
ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t); argvi++ ;
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_t_save_credentials_set) {
{
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
SWIG_croak("Usage: svn_auth_provider_t_save_credentials_set(self,save_credentials);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_t_save_credentials_set" "', argument " "1"" of type '" "struct svn_auth_provider_t *""'");
}
arg1 = (struct svn_auth_provider_t *)(argp1);
{
int res = SWIG_ConvertFunctionPtr(ST(1), (void**)(&arg2), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_save_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->save_credentials = arg2;
ST(argvi) = sv_newmortal();
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_t_save_credentials_get) {
{
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
svn_error_t *(*result)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
dXSARGS;
if ((items < 1) || (items > 1)) {
SWIG_croak("Usage: svn_auth_provider_t_save_credentials_get(self);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_t_save_credentials_get" "', argument " "1"" of type '" "struct svn_auth_provider_t *""'");
}
arg1 = (struct svn_auth_provider_t *)(argp1);
result = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->save_credentials);
ST(argvi) = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t); argvi++ ;
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_first_credentials) {
{
void **arg1 = (void **) 0 ;
svn_auth_iterstate_t **arg2 = (svn_auth_iterstate_t **) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
svn_auth_baton_t *arg5 = (svn_auth_baton_t *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
void *temp1 ;
svn_auth_iterstate_t *temp2 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg6 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
arg2 = &temp2;
if ((items < 3) || (items > 4)) {
SWIG_croak("Usage: svn_auth_first_credentials(cred_kind,realmstring,auth_baton,pool);");
}
res3 = SWIG_AsCharPtrAndSize(ST(0), &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_auth_first_credentials" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
res4 = SWIG_AsCharPtrAndSize(ST(1), &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_auth_first_credentials" "', argument " "4"" of type '" "char const *""'");
}
arg4 = (char *)(buf4);
res5 = SWIG_ConvertPtr(ST(2), &argp5,SWIGTYPE_p_svn_auth_baton_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_auth_first_credentials" "', argument " "5"" of type '" "svn_auth_baton_t *""'");
}
arg5 = (svn_auth_baton_t *)(argp5);
if (items > 3) {
}
{
result = (svn_error_t *)svn_auth_first_credentials(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_next_credentials) {
{
void **arg1 = (void **) 0 ;
svn_auth_iterstate_t *arg2 = (svn_auth_iterstate_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
void *temp1 ;
void *argp2 = 0 ;
int res2 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg3 = svn_swig_pl_make_pool (ST(items-1));
}
arg1 = &temp1;
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_auth_next_credentials(state,pool);");
}
res2 = SWIG_ConvertPtr(ST(0), &argp2,SWIGTYPE_p_svn_auth_iterstate_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_auth_next_credentials" "', argument " "2"" of type '" "svn_auth_iterstate_t *""'");
}
arg2 = (svn_auth_iterstate_t *)(argp2);
if (items > 1) {
}
{
result = (svn_error_t *)svn_auth_next_credentials(arg1,arg2,arg3);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_save_credentials) {
{
svn_auth_iterstate_t *arg1 = (svn_auth_iterstate_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg2 = svn_swig_pl_make_pool (ST(items-1));
}
if ((items < 1) || (items > 2)) {
SWIG_croak("Usage: svn_auth_save_credentials(state,pool);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_iterstate_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_save_credentials" "', argument " "1"" of type '" "svn_auth_iterstate_t *""'");
}
arg1 = (svn_auth_iterstate_t *)(argp1);
if (items > 1) {
}
{
result = (svn_error_t *)svn_auth_save_credentials(arg1,arg2);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_forget_credentials) {
{
svn_auth_baton_t *arg1 = (svn_auth_baton_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
char *buf3 = 0 ;
int alloc3 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg4 = svn_swig_pl_make_pool (ST(items-1));
}
if ((items < 3) || (items > 4)) {
SWIG_croak("Usage: svn_auth_forget_credentials(auth_baton,cred_kind,realmstring,pool);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_baton_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_forget_credentials" "', argument " "1"" of type '" "svn_auth_baton_t *""'");
}
arg1 = (svn_auth_baton_t *)(argp1);
res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svn_auth_forget_credentials" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_auth_forget_credentials" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
if (items > 3) {
}
{
result = (svn_error_t *)svn_auth_forget_credentials(arg1,(char const *)arg2,(char const *)arg3,arg4);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
XSRETURN(argvi);
fail:
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_invoke_first_credentials) {
{
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
void **arg2 = (void **) 0 ;
void **arg3 = (void **) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg7 = svn_swig_pl_make_pool (ST(items-1));
}
arg2 = &temp2;
arg3 = &temp3;
if ((items < 4) || (items > 5)) {
SWIG_croak("Usage: svn_auth_provider_invoke_first_credentials(_obj,provider_baton,parameters,realmstring,pool);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_invoke_first_credentials" "', argument " "1"" of type '" "svn_auth_provider_t *""'");
}
arg1 = (svn_auth_provider_t *)(argp1);
res4 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_auth_provider_invoke_first_credentials" "', argument " "4"" of type '" "void *""'");
}
res5 = SWIG_ConvertPtr(ST(2), &argp5,SWIGTYPE_p_apr_hash_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_auth_provider_invoke_first_credentials" "', argument " "5"" of type '" "apr_hash_t *""'");
}
arg5 = (apr_hash_t *)(argp5);
res6 = SWIG_AsCharPtrAndSize(ST(3), &buf6, NULL, &alloc6);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svn_auth_provider_invoke_first_credentials" "', argument " "6"" of type '" "char const *""'");
}
arg6 = (char *)(buf6);
if (items > 4) {
}
{
result = (svn_error_t *)svn_auth_provider_invoke_first_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_invoke_next_credentials) {
{
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
void **arg2 = (void **) 0 ;
void *arg3 = (void *) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
int alloc6 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg7 = svn_swig_pl_make_pool (ST(items-1));
}
arg2 = &temp2;
if ((items < 5) || (items > 6)) {
SWIG_croak("Usage: svn_auth_provider_invoke_next_credentials(_obj,iter_baton,provider_baton,parameters,realmstring,pool);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_invoke_next_credentials" "', argument " "1"" of type '" "svn_auth_provider_t *""'");
}
arg1 = (svn_auth_provider_t *)(argp1);
res3 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_auth_provider_invoke_next_credentials" "', argument " "3"" of type '" "void *""'");
}
res4 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_auth_provider_invoke_next_credentials" "', argument " "4"" of type '" "void *""'");
}
res5 = SWIG_ConvertPtr(ST(3), &argp5,SWIGTYPE_p_apr_hash_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_auth_provider_invoke_next_credentials" "', argument " "5"" of type '" "apr_hash_t *""'");
}
arg5 = (apr_hash_t *)(argp5);
res6 = SWIG_AsCharPtrAndSize(ST(4), &buf6, NULL, &alloc6);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svn_auth_provider_invoke_next_credentials" "', argument " "6"" of type '" "char const *""'");
}
arg6 = (char *)(buf6);
if (items > 5) {
}
{
result = (svn_error_t *)svn_auth_provider_invoke_next_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
SWIG_croak_null();
}
}
XS(_wrap_svn_auth_provider_invoke_save_credentials) {
{
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
svn_boolean_t *arg2 = (svn_boolean_t *) 0 ;
void *arg3 = (void *) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
int alloc6 = 0 ;
int argvi = 0;
svn_error_t *result = 0 ;
dXSARGS;
{
_global_pool = arg7 = svn_swig_pl_make_pool (ST(items-1));
}
arg2 = &temp2;
if ((items < 5) || (items > 6)) {
SWIG_croak("Usage: svn_auth_provider_invoke_save_credentials(_obj,credentials,provider_baton,parameters,realmstring,pool);");
}
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svn_auth_provider_invoke_save_credentials" "', argument " "1"" of type '" "svn_auth_provider_t *""'");
}
arg1 = (svn_auth_provider_t *)(argp1);
res3 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svn_auth_provider_invoke_save_credentials" "', argument " "3"" of type '" "void *""'");
}
res4 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "svn_auth_provider_invoke_save_credentials" "', argument " "4"" of type '" "void *""'");
}
res5 = SWIG_ConvertPtr(ST(3), &argp5,SWIGTYPE_p_apr_hash_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "svn_auth_provider_invoke_save_credentials" "', argument " "5"" of type '" "apr_hash_t *""'");
}
arg5 = (apr_hash_t *)(argp5);
res6 = SWIG_AsCharPtrAndSize(ST(4), &buf6, NULL, &alloc6);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "svn_auth_provider_invoke_save_credentials" "', argument " "6"" of type '" "char const *""'");
}
arg6 = (char *)(buf6);
if (items > 5) {
}
{
result = (svn_error_t *)svn_auth_provider_invoke_save_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
}
{
if (result) {
SV *exception_handler = perl_get_sv ("SVN::Error::handler", FALSE);
if (SvOK(exception_handler)) {
SV *callback_result;
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
{"SVN::_Core::svn_opt_parse_all_args", _wrap_svn_opt_parse_all_args},
{"SVN::_Core::svn_opt_parse_path", _wrap_svn_opt_parse_path},
{"SVN::_Core::svn_opt_print_help4", _wrap_svn_opt_print_help4},
{"SVN::_Core::svn_opt_print_help3", _wrap_svn_opt_print_help3},
{"SVN::_Core::svn_opt_print_help2", _wrap_svn_opt_print_help2},
{"SVN::_Core::svn_opt_print_help", _wrap_svn_opt_print_help},
{"SVN::_Core::svn_cmdline_init", _wrap_svn_cmdline_init},
{"SVN::_Core::svn_cmdline_create_auth_baton", _wrap_svn_cmdline_create_auth_baton},
{"SVN::_Core::svn_auth_provider_t_cred_kind_set", _wrap_svn_auth_provider_t_cred_kind_set},
{"SVN::_Core::svn_auth_provider_t_cred_kind_get", _wrap_svn_auth_provider_t_cred_kind_get},
{"SVN::_Core::svn_auth_provider_t_first_credentials_set", _wrap_svn_auth_provider_t_first_credentials_set},
{"SVN::_Core::svn_auth_provider_t_first_credentials_get", _wrap_svn_auth_provider_t_first_credentials_get},
{"SVN::_Core::svn_auth_provider_t_next_credentials_set", _wrap_svn_auth_provider_t_next_credentials_set},
{"SVN::_Core::svn_auth_provider_t_next_credentials_get", _wrap_svn_auth_provider_t_next_credentials_get},
{"SVN::_Core::svn_auth_provider_t_save_credentials_set", _wrap_svn_auth_provider_t_save_credentials_set},
{"SVN::_Core::svn_auth_provider_t_save_credentials_get", _wrap_svn_auth_provider_t_save_credentials_get},
{"SVN::_Core::new_svn_auth_provider_t", _wrap_new_svn_auth_provider_t},
{"SVN::_Core::delete_svn_auth_provider_t", _wrap_delete_svn_auth_provider_t},
{"SVN::_Core::svn_auth_provider_object_t_vtable_set", _wrap_svn_auth_provider_object_t_vtable_set},
{"SVN::_Core::svn_auth_provider_object_t_vtable_get", _wrap_svn_auth_provider_object_t_vtable_get},
{"SVN::_Core::svn_auth_provider_object_t_provider_baton_set", _wrap_svn_auth_provider_object_t_provider_baton_set},
{"SVN::_Core::svn_auth_provider_object_t_provider_baton_get", _wrap_svn_auth_provider_object_t_provider_baton_get},
{"SVN::_Core::new_svn_auth_provider_object_t", _wrap_new_svn_auth_provider_object_t},
{"SVN::_Core::delete_svn_auth_provider_object_t", _wrap_delete_svn_auth_provider_object_t},
{"SVN::_Core::svn_auth_cred_simple_t_username_set", _wrap_svn_auth_cred_simple_t_username_set},
{"SVN::_Core::svn_auth_cred_simple_t_username_get", _wrap_svn_auth_cred_simple_t_username_get},
src/subversion/subversion/bindings/swig/perl/native/core.c view on Meta::CPAN
{"SVN::_Core::delete_svn_auth_ssl_server_cert_info_t", _wrap_delete_svn_auth_ssl_server_cert_info_t},
{"SVN::_Core::svn_auth_ssl_server_cert_info_dup", _wrap_svn_auth_ssl_server_cert_info_dup},
{"SVN::_Core::svn_auth_cred_ssl_server_trust_t_may_save_set", _wrap_svn_auth_cred_ssl_server_trust_t_may_save_set},
{"SVN::_Core::svn_auth_cred_ssl_server_trust_t_may_save_get", _wrap_svn_auth_cred_ssl_server_trust_t_may_save_get},
{"SVN::_Core::svn_auth_cred_ssl_server_trust_t_accepted_failures_set", _wrap_svn_auth_cred_ssl_server_trust_t_accepted_failures_set},
{"SVN::_Core::svn_auth_cred_ssl_server_trust_t_accepted_failures_get", _wrap_svn_auth_cred_ssl_server_trust_t_accepted_failures_get},
{"SVN::_Core::new_svn_auth_cred_ssl_server_trust_t", _wrap_new_svn_auth_cred_ssl_server_trust_t},
{"SVN::_Core::delete_svn_auth_cred_ssl_server_trust_t", _wrap_delete_svn_auth_cred_ssl_server_trust_t},
{"SVN::_Core::svn_auth_open", _wrap_svn_auth_open},
{"SVN::_Core::svn_auth_set_parameter", _wrap_svn_auth_set_parameter},
{"SVN::_Core::svn_auth_first_credentials", _wrap_svn_auth_first_credentials},
{"SVN::_Core::svn_auth_next_credentials", _wrap_svn_auth_next_credentials},
{"SVN::_Core::svn_auth_save_credentials", _wrap_svn_auth_save_credentials},
{"SVN::_Core::svn_auth_forget_credentials", _wrap_svn_auth_forget_credentials},
{"SVN::_Core::svn_auth_get_simple_prompt_provider", _wrap_svn_auth_get_simple_prompt_provider},
{"SVN::_Core::svn_auth_get_username_prompt_provider", _wrap_svn_auth_get_username_prompt_provider},
{"SVN::_Core::svn_auth_get_simple_provider2", _wrap_svn_auth_get_simple_provider2},
{"SVN::_Core::svn_auth_get_simple_provider", _wrap_svn_auth_get_simple_provider},
{"SVN::_Core::svn_auth_get_platform_specific_provider", _wrap_svn_auth_get_platform_specific_provider},
{"SVN::_Core::svn_auth_get_platform_specific_client_providers", _wrap_svn_auth_get_platform_specific_client_providers},
{"SVN::_Core::svn_auth_get_username_provider", _wrap_svn_auth_get_username_provider},
{"SVN::_Core::svn_auth_get_ssl_server_trust_file_provider", _wrap_svn_auth_get_ssl_server_trust_file_provider},
{"SVN::_Core::svn_auth_get_ssl_client_cert_file_provider", _wrap_svn_auth_get_ssl_client_cert_file_provider},
{"SVN::_Core::svn_auth_get_ssl_client_cert_pw_file_provider2", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider2},
{"SVN::_Core::svn_auth_get_ssl_client_cert_pw_file_provider", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider},
{"SVN::_Core::svn_auth_get_ssl_server_trust_prompt_provider", _wrap_svn_auth_get_ssl_server_trust_prompt_provider},
{"SVN::_Core::svn_auth_get_ssl_client_cert_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_prompt_provider},
{"SVN::_Core::svn_auth_get_ssl_client_cert_pw_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_pw_prompt_provider},
{"SVN::_Core::svn_auth_provider_invoke_first_credentials", _wrap_svn_auth_provider_invoke_first_credentials},
{"SVN::_Core::svn_auth_provider_invoke_next_credentials", _wrap_svn_auth_provider_invoke_next_credentials},
{"SVN::_Core::svn_auth_provider_invoke_save_credentials", _wrap_svn_auth_provider_invoke_save_credentials},
{"SVN::_Core::svn_auth_invoke_simple_provider_func", _wrap_svn_auth_invoke_simple_provider_func},
{"SVN::_Core::svn_auth_invoke_ssl_client_cert_pw_provider_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_provider_func},
{"SVN::_Core::svn_auth_invoke_simple_prompt_func", _wrap_svn_auth_invoke_simple_prompt_func},
{"SVN::_Core::svn_auth_invoke_username_prompt_func", _wrap_svn_auth_invoke_username_prompt_func},
{"SVN::_Core::svn_auth_invoke_ssl_server_trust_prompt_func", _wrap_svn_auth_invoke_ssl_server_trust_prompt_func},
{"SVN::_Core::svn_auth_invoke_ssl_client_cert_prompt_func", _wrap_svn_auth_invoke_ssl_client_cert_prompt_func},
{"SVN::_Core::svn_auth_invoke_ssl_client_cert_pw_prompt_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_prompt_func},
{"SVN::_Core::svn_auth_invoke_plaintext_prompt_func", _wrap_svn_auth_invoke_plaintext_prompt_func},
{"SVN::_Core::svn_auth_invoke_plaintext_passphrase_prompt_func", _wrap_svn_auth_invoke_plaintext_passphrase_prompt_func},
{"SVN::_Core::svn_config_get_config", _wrap_svn_config_get_config},
src/subversion/subversion/bindings/swig/proxy/svn_auth_h.swg view on Meta::CPAN
%proxy(svn_auth_cred_username_t);
%proxy(svn_auth_cred_ssl_client_cert_t);
%proxy(svn_auth_cred_ssl_client_cert_pw_t);
%proxy(svn_auth_ssl_server_cert_info_t);
%proxy(svn_auth_cred_ssl_server_trust_t);
#endif
/* Callbacks */
%inline %{
static svn_error_t * svn_auth_provider_invoke_first_credentials(
svn_auth_provider_t * _obj, void **credentials, void **iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->first_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}
static svn_error_t * svn_auth_provider_invoke_next_credentials(
svn_auth_provider_t * _obj, void **credentials, void *iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->next_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}
static svn_error_t * svn_auth_provider_invoke_save_credentials(
svn_auth_provider_t * _obj, svn_boolean_t *saved, void *credentials, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->save_credentials)(saved, credentials, provider_baton, parameters, realmstring, pool);
}
static void svn_auth_invoke_simple_provider_func(
svn_auth_simple_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
_obj(provider, pool);
}
static void svn_auth_invoke_ssl_client_cert_pw_provider_func(
svn_auth_ssl_client_cert_pw_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
_obj(provider, pool);
src/subversion/subversion/bindings/swig/proxy/svn_auth_h.swg view on Meta::CPAN
}
static svn_error_t * svn_auth_invoke_plaintext_passphrase_prompt_func(
svn_auth_plaintext_passphrase_prompt_func_t _obj, svn_boolean_t *may_save_plaintext, const char *realmstring, void *baton, apr_pool_t *pool) {
return _obj(may_save_plaintext, realmstring, baton, pool);
}
%}
#ifdef SWIGPYTHON
%funcptr_member_proxy(svn_auth_provider_t, first_credentials, svn_auth_provider_invoke_first_credentials);
%funcptr_member_proxy(svn_auth_provider_t, next_credentials, svn_auth_provider_invoke_next_credentials);
%funcptr_member_proxy(svn_auth_provider_t, save_credentials, svn_auth_provider_invoke_save_credentials);
%funcptr_proxy(svn_auth_simple_provider_func_t, svn_auth_invoke_simple_provider_func);
%funcptr_proxy(svn_auth_ssl_client_cert_pw_provider_func_t, svn_auth_invoke_ssl_client_cert_pw_provider_func);
%funcptr_proxy(svn_auth_simple_prompt_func_t, svn_auth_invoke_simple_prompt_func);
%funcptr_proxy(svn_auth_username_prompt_func_t, svn_auth_invoke_username_prompt_func);
%funcptr_proxy(svn_auth_ssl_server_trust_prompt_func_t, svn_auth_invoke_ssl_server_trust_prompt_func);
%funcptr_proxy(svn_auth_ssl_client_cert_prompt_func_t, svn_auth_invoke_ssl_client_cert_prompt_func);
%funcptr_proxy(svn_auth_ssl_client_cert_pw_prompt_func_t, svn_auth_invoke_ssl_client_cert_pw_prompt_func);
%funcptr_proxy(svn_auth_plaintext_prompt_func_t, svn_auth_invoke_plaintext_prompt_func);
%funcptr_proxy(svn_auth_plaintext_passphrase_prompt_func_t, svn_auth_invoke_plaintext_passphrase_prompt_func);
%funcptr_proxy(svn_auth_gnome_keyring_unlock_prompt_func_t, svn_auth_invoke_gnome_keyring_unlock_prompt_func);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
SWIGINTERNINLINE PyObject*
SWIG_From_unsigned_SS_long (unsigned long value)
{
return (value > LONG_MAX) ?
PyLong_FromUnsignedLong(value) : PyLong_FromLong((long)(value));
}
static svn_error_t * svn_auth_provider_invoke_first_credentials(
svn_auth_provider_t * _obj, void **credentials, void **iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->first_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}
static svn_error_t * svn_auth_provider_invoke_next_credentials(
svn_auth_provider_t * _obj, void **credentials, void *iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->next_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}
static svn_error_t * svn_auth_provider_invoke_save_credentials(
svn_auth_provider_t * _obj, svn_boolean_t *saved, void *credentials, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->save_credentials)(saved, credentials, provider_baton, parameters, realmstring, pool);
}
static void svn_auth_invoke_simple_provider_func(
svn_auth_simple_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
_obj(provider, pool);
}
static void svn_auth_invoke_ssl_client_cert_pw_provider_func(
svn_auth_ssl_client_cert_pw_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
_obj(provider, pool);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
}
result = (char *) ((arg1)->cred_kind);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_t_first_credentials_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_auth_provider_t_first_credentials_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_first_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->first_credentials = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_t_first_credentials_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_auth_provider_t_first_credentials_get",&obj0)) SWIG_fail;
{
arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->first_credentials);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_t_next_credentials_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_auth_provider_t_next_credentials_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_next_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->next_credentials = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_t_next_credentials_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_auth_provider_t_next_credentials_get",&obj0)) SWIG_fail;
{
arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->next_credentials);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_t_save_credentials_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:svn_auth_provider_t_save_credentials_set",&obj0,&obj1)) SWIG_fail;
{
arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "svn_auth_provider_t_save_credentials_set" "', argument " "2"" of type '" "svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)""'");
}
}
if (arg1) (arg1)->save_credentials = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_t_save_credentials_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
PyObject * obj0 = 0 ;
svn_error_t *(*result)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:svn_auth_provider_t_save_credentials_get",&obj0)) SWIG_fail;
{
arg1 = (struct svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
result = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->save_credentials);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_svn_auth_provider_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
struct svn_auth_provider_t *result = 0 ;
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
svn_swig_py_acquire_py_lock();
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_first_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void **arg1 = (void **) 0 ;
svn_auth_iterstate_t **arg2 = (svn_auth_iterstate_t **) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
svn_auth_baton_t *arg5 = (svn_auth_baton_t *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
void *temp1 ;
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg6 = _global_pool;
arg1 = &temp1;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"ssO|O:svn_auth_first_credentials",&arg3,&arg4,&obj2,&obj3)) SWIG_fail;
{
arg5 = (svn_auth_baton_t *)svn_swig_MustGetPtr(obj2, SWIGTYPE_p_svn_auth_baton_t, svn_argnum_obj2);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_auth_first_credentials(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_next_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void **arg1 = (void **) 0 ;
svn_auth_iterstate_t *arg2 = (svn_auth_iterstate_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
void *temp1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg3 = _global_pool;
arg1 = &temp1;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_auth_next_credentials",&obj0,&obj1)) SWIG_fail;
{
arg2 = (svn_auth_iterstate_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_iterstate_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_auth_next_credentials(arg1,arg2,arg3);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_save_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_auth_iterstate_t *arg1 = (svn_auth_iterstate_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg2 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"O|O:svn_auth_save_credentials",&obj0,&obj1)) SWIG_fail;
{
arg1 = (svn_auth_iterstate_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_iterstate_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj1) {
/* Verify that the user supplied a valid pool */
if (obj1 != Py_None && obj1 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj1);
SWIG_arg_fail(svn_argnum_obj1);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_auth_save_credentials(arg1,arg2);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_forget_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_auth_baton_t *arg1 = (svn_auth_baton_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg4 = _global_pool;
if (!PyArg_ParseTuple(args,(char *)"Oss|O:svn_auth_forget_credentials",&obj0,&arg2,&arg3,&obj3)) SWIG_fail;
{
arg1 = (svn_auth_baton_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_baton_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
if (obj3) {
/* Verify that the user supplied a valid pool */
if (obj3 != Py_None && obj3 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj3);
SWIG_arg_fail(svn_argnum_obj3);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_auth_forget_credentials(arg1,(char const *)arg2,(char const *)arg3,arg4);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
return SWIG_Py_Void();
}
SWIGINTERN PyObject *svn_auth_iterstate_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_svn_auth_iterstate_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_invoke_first_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
void **arg2 = (void **) 0 ;
void **arg3 = (void **) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
PyObject * obj2 = 0 ;
PyObject * obj4 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg2 = &temp2;
arg3 = &temp3;
if (!PyArg_ParseTuple(args,(char *)"OOOs|O:svn_auth_provider_invoke_first_credentials",&obj0,&obj1,&obj2,&arg6,&obj4)) SWIG_fail;
{
arg1 = (svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg4 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg4, 0, 0) == -1) {
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj4 != Py_None && obj4 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj4);
SWIG_arg_fail(svn_argnum_obj4);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_auth_provider_invoke_first_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_invoke_next_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
void **arg2 = (void **) 0 ;
void *arg3 = (void *) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOOOs|O:svn_auth_provider_invoke_next_credentials",&obj0,&obj1,&obj2,&obj3,&arg6,&obj5)) SWIG_fail;
{
arg1 = (svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
if (obj1 == Py_None) {
arg3 = NULL;
} else if (SWIG_ConvertPtr(obj1, (void **) &arg3, 0, 0) == -1) {
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_auth_provider_invoke_next_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
}
return resultobj;
fail:
{
Py_XDECREF(_global_py_pool);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_svn_auth_provider_invoke_save_credentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
svn_boolean_t *arg2 = (svn_boolean_t *) 0 ;
void *arg3 = (void *) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
apr_pool_t *_global_pool = NULL ;
PyObject *_global_py_pool = NULL ;
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj5 = 0 ;
svn_error_t *result = 0 ;
if (svn_swig_py_get_pool_arg(args, SWIGTYPE_p_apr_pool_t,
&_global_py_pool, &_global_pool))
SWIG_fail;
arg7 = _global_pool;
arg2 = &temp2;
if (!PyArg_ParseTuple(args,(char *)"OOOOs|O:svn_auth_provider_invoke_save_credentials",&obj0,&obj1,&obj2,&obj3,&arg6,&obj5)) SWIG_fail;
{
arg1 = (svn_auth_provider_t *)svn_swig_MustGetPtr(obj0, SWIGTYPE_p_svn_auth_provider_t, svn_argnum_obj0);
if (PyErr_Occurred()) {
SWIG_fail;
}
}
{
arg3 = (void *)svn_swig_MustGetPtr(obj1, SWIGTYPE_p_void, svn_argnum_obj1);
if (PyErr_Occurred()) {
SWIG_fail;
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
/* Verify that the user supplied a valid pool */
if (obj5 != Py_None && obj5 != _global_py_pool) {
SWIG_Python_TypeError(SWIG_TypePrettyName(SWIGTYPE_p_apr_pool_t), obj5);
SWIG_arg_fail(svn_argnum_obj5);
SWIG_fail;
}
}
{
svn_swig_py_release_py_lock();
result = (svn_error_t *)svn_auth_provider_invoke_save_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
svn_swig_py_acquire_py_lock();
}
{
if (result != NULL) {
if (result->apr_err != SVN_ERR_SWIG_PY_EXCEPTION_SET)
svn_swig_py_svn_exception(result);
else
svn_error_clear(result);
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_cmdline_init", _wrap_svn_cmdline_init, METH_VARARGS, (char *)"svn_cmdline_init(char const * progname, FILE * error_stream) -> int"},
{ (char *)"svn_cmdline_create_auth_baton", _wrap_svn_cmdline_create_auth_baton, METH_VARARGS, (char *)"\n"
"svn_cmdline_create_auth_baton(svn_boolean_t non_interactive, char const * username, char const * password, char const * config_dir, \n"
" svn_boolean_t no_auth_cache, svn_boolean_t trust_server_cert, \n"
" svn_config_t * cfg, svn_cancel_func_t cancel_func, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_auth_provider_t_cred_kind_set", _wrap_svn_auth_provider_t_cred_kind_set, METH_VARARGS, (char *)"svn_auth_provider_t_cred_kind_set(svn_auth_provider_t self, char const * cred_kind)"},
{ (char *)"svn_auth_provider_t_cred_kind_get", _wrap_svn_auth_provider_t_cred_kind_get, METH_VARARGS, (char *)"svn_auth_provider_t_cred_kind_get(svn_auth_provider_t self) -> char const *"},
{ (char *)"svn_auth_provider_t_first_credentials_set", _wrap_svn_auth_provider_t_first_credentials_set, METH_VARARGS, (char *)"svn_auth_provider_t_first_credentials_set(svn_auth_provider_t self, svn_error_t *(*)(void **,void **,void *,apr_hash_t *,...
{ (char *)"svn_auth_provider_t_first_credentials_get", _wrap_svn_auth_provider_t_first_credentials_get, METH_VARARGS, (char *)"svn_auth_provider_t_first_credentials_get(svn_auth_provider_t self) -> svn_error_t *(*)(void **,void **,void *,apr_hash_t...
{ (char *)"svn_auth_provider_t_next_credentials_set", _wrap_svn_auth_provider_t_next_credentials_set, METH_VARARGS, (char *)"svn_auth_provider_t_next_credentials_set(svn_auth_provider_t self, svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char...
{ (char *)"svn_auth_provider_t_next_credentials_get", _wrap_svn_auth_provider_t_next_credentials_get, METH_VARARGS, (char *)"svn_auth_provider_t_next_credentials_get(svn_auth_provider_t self) -> svn_error_t *(*)(void **,void *,void *,apr_hash_t *,c...
{ (char *)"svn_auth_provider_t_save_credentials_set", _wrap_svn_auth_provider_t_save_credentials_set, METH_VARARGS, (char *)"svn_auth_provider_t_save_credentials_set(svn_auth_provider_t self, svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_...
{ (char *)"svn_auth_provider_t_save_credentials_get", _wrap_svn_auth_provider_t_save_credentials_get, METH_VARARGS, (char *)"svn_auth_provider_t_save_credentials_get(svn_auth_provider_t self) -> svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_ha...
{ (char *)"new_svn_auth_provider_t", _wrap_new_svn_auth_provider_t, METH_VARARGS, (char *)"new_svn_auth_provider_t() -> svn_auth_provider_t"},
{ (char *)"delete_svn_auth_provider_t", _wrap_delete_svn_auth_provider_t, METH_VARARGS, (char *)"delete_svn_auth_provider_t(svn_auth_provider_t self)"},
{ (char *)"svn_auth_provider_t_swigregister", svn_auth_provider_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_auth_provider_object_t_vtable_set", _wrap_svn_auth_provider_object_t_vtable_set, METH_VARARGS, (char *)"svn_auth_provider_object_t_vtable_set(svn_auth_provider_object_t self, svn_auth_provider_t vtable)"},
{ (char *)"svn_auth_provider_object_t_vtable_get", _wrap_svn_auth_provider_object_t_vtable_get, METH_VARARGS, (char *)"svn_auth_provider_object_t_vtable_get(svn_auth_provider_object_t self) -> svn_auth_provider_t"},
{ (char *)"svn_auth_provider_object_t_provider_baton_set", _wrap_svn_auth_provider_object_t_provider_baton_set, METH_VARARGS, (char *)"svn_auth_provider_object_t_provider_baton_set(svn_auth_provider_object_t self, void * provider_baton)"},
{ (char *)"svn_auth_provider_object_t_provider_baton_get", _wrap_svn_auth_provider_object_t_provider_baton_get, METH_VARARGS, (char *)"svn_auth_provider_object_t_provider_baton_get(svn_auth_provider_object_t self) -> void *"},
{ (char *)"new_svn_auth_provider_object_t", _wrap_new_svn_auth_provider_object_t, METH_VARARGS, (char *)"new_svn_auth_provider_object_t() -> svn_auth_provider_object_t"},
{ (char *)"delete_svn_auth_provider_object_t", _wrap_delete_svn_auth_provider_object_t, METH_VARARGS, (char *)"delete_svn_auth_provider_object_t(svn_auth_provider_object_t self)"},
{ (char *)"svn_auth_provider_object_t_swigregister", svn_auth_provider_object_t_swigregister, METH_VARARGS, NULL},
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
{ (char *)"svn_auth_ssl_server_cert_info_dup", _wrap_svn_auth_ssl_server_cert_info_dup, METH_VARARGS, (char *)"svn_auth_ssl_server_cert_info_dup(svn_auth_ssl_server_cert_info_t info, apr_pool_t pool) -> svn_auth_ssl_server_cert_info_t"},
{ (char *)"svn_auth_cred_ssl_server_trust_t_may_save_set", _wrap_svn_auth_cred_ssl_server_trust_t_may_save_set, METH_VARARGS, (char *)"svn_auth_cred_ssl_server_trust_t_may_save_set(svn_auth_cred_ssl_server_trust_t self, svn_boolean_t may_save)"},
{ (char *)"svn_auth_cred_ssl_server_trust_t_may_save_get", _wrap_svn_auth_cred_ssl_server_trust_t_may_save_get, METH_VARARGS, (char *)"svn_auth_cred_ssl_server_trust_t_may_save_get(svn_auth_cred_ssl_server_trust_t self) -> svn_boolean_t"},
{ (char *)"svn_auth_cred_ssl_server_trust_t_accepted_failures_set", _wrap_svn_auth_cred_ssl_server_trust_t_accepted_failures_set, METH_VARARGS, (char *)"svn_auth_cred_ssl_server_trust_t_accepted_failures_set(svn_auth_cred_ssl_server_trust_t self, a...
{ (char *)"svn_auth_cred_ssl_server_trust_t_accepted_failures_get", _wrap_svn_auth_cred_ssl_server_trust_t_accepted_failures_get, METH_VARARGS, (char *)"svn_auth_cred_ssl_server_trust_t_accepted_failures_get(svn_auth_cred_ssl_server_trust_t self) -...
{ (char *)"new_svn_auth_cred_ssl_server_trust_t", _wrap_new_svn_auth_cred_ssl_server_trust_t, METH_VARARGS, (char *)"new_svn_auth_cred_ssl_server_trust_t() -> svn_auth_cred_ssl_server_trust_t"},
{ (char *)"delete_svn_auth_cred_ssl_server_trust_t", _wrap_delete_svn_auth_cred_ssl_server_trust_t, METH_VARARGS, (char *)"delete_svn_auth_cred_ssl_server_trust_t(svn_auth_cred_ssl_server_trust_t self)"},
{ (char *)"svn_auth_cred_ssl_server_trust_t_swigregister", svn_auth_cred_ssl_server_trust_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_auth_open", _wrap_svn_auth_open, METH_VARARGS, (char *)"svn_auth_open(apr_array_header_t providers, apr_pool_t pool)"},
{ (char *)"svn_auth_set_parameter", _wrap_svn_auth_set_parameter, METH_VARARGS, (char *)"svn_auth_set_parameter(svn_auth_baton_t * auth_baton, char const * name, void const * value)"},
{ (char *)"svn_auth_first_credentials", _wrap_svn_auth_first_credentials, METH_VARARGS, (char *)"\n"
"svn_auth_first_credentials(char const * cred_kind, char const * realmstring, svn_auth_baton_t * auth_baton, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_auth_next_credentials", _wrap_svn_auth_next_credentials, METH_VARARGS, (char *)"svn_auth_next_credentials(svn_auth_iterstate_t * state, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_auth_save_credentials", _wrap_svn_auth_save_credentials, METH_VARARGS, (char *)"svn_auth_save_credentials(svn_auth_iterstate_t * state, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_auth_forget_credentials", _wrap_svn_auth_forget_credentials, METH_VARARGS, (char *)"\n"
"svn_auth_forget_credentials(svn_auth_baton_t * auth_baton, char const * cred_kind, char const * realmstring, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_auth_get_simple_prompt_provider", _wrap_svn_auth_get_simple_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_simple_prompt_provider(svn_auth_simple_prompt_func_t prompt_func, int retry_limit, apr_pool_t pool)"},
{ (char *)"svn_auth_get_username_prompt_provider", _wrap_svn_auth_get_username_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_username_prompt_provider(svn_auth_username_prompt_func_t prompt_func, int retry_limit, apr_pool_t pool)"},
{ (char *)"svn_auth_get_simple_provider2", _wrap_svn_auth_get_simple_provider2, METH_VARARGS, (char *)"svn_auth_get_simple_provider2(svn_auth_plaintext_prompt_func_t plaintext_prompt_func, void * prompt_baton, apr_pool_t pool)"},
{ (char *)"svn_auth_get_simple_provider", _wrap_svn_auth_get_simple_provider, METH_VARARGS, (char *)"svn_auth_get_simple_provider(apr_pool_t pool)"},
{ (char *)"svn_auth_get_platform_specific_provider", _wrap_svn_auth_get_platform_specific_provider, METH_VARARGS, (char *)"svn_auth_get_platform_specific_provider(char const * provider_name, char const * provider_type, apr_pool_t pool) -> svn_error...
{ (char *)"svn_auth_get_platform_specific_client_providers", _wrap_svn_auth_get_platform_specific_client_providers, METH_VARARGS, (char *)"svn_auth_get_platform_specific_client_providers(svn_config_t * config, apr_pool_t pool) -> svn_error_t"},
{ (char *)"svn_auth_get_username_provider", _wrap_svn_auth_get_username_provider, METH_VARARGS, (char *)"svn_auth_get_username_provider(apr_pool_t pool)"},
{ (char *)"svn_auth_get_ssl_server_trust_file_provider", _wrap_svn_auth_get_ssl_server_trust_file_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_server_trust_file_provider(apr_pool_t pool)"},
src/subversion/subversion/bindings/swig/python/core.c view on Meta::CPAN
{ (char *)"svn_auth_get_ssl_client_cert_pw_file_provider2", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider2, METH_VARARGS, (char *)"\n"
"svn_auth_get_ssl_client_cert_pw_file_provider2(svn_auth_plaintext_passphrase_prompt_func_t plaintext_passphrase_prompt_func, void * prompt_baton, \n"
" apr_pool_t pool)\n"
""},
{ (char *)"svn_auth_get_ssl_client_cert_pw_file_provider", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_client_cert_pw_file_provider(apr_pool_t pool)"},
{ (char *)"svn_auth_get_ssl_server_trust_prompt_provider", _wrap_svn_auth_get_ssl_server_trust_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_server_trust_prompt_provider(svn_auth_ssl_server_trust_prompt_func_t prompt_func, apr_pool_t poo...
{ (char *)"svn_auth_get_ssl_client_cert_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_client_cert_prompt_provider(svn_auth_ssl_client_cert_prompt_func_t prompt_func, int retry_limit, a...
{ (char *)"svn_auth_get_ssl_client_cert_pw_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_pw_prompt_provider, METH_VARARGS, (char *)"svn_auth_get_ssl_client_cert_pw_prompt_provider(svn_auth_ssl_client_cert_pw_prompt_func_t prompt_func, int re...
{ (char *)"svn_auth_baton_t_swigregister", svn_auth_baton_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_auth_iterstate_t_swigregister", svn_auth_iterstate_t_swigregister, METH_VARARGS, NULL},
{ (char *)"svn_auth_provider_invoke_first_credentials", _wrap_svn_auth_provider_invoke_first_credentials, METH_VARARGS, (char *)"\n"
"svn_auth_provider_invoke_first_credentials(svn_auth_provider_t _obj, void * provider_baton, apr_hash_t parameters, char const * realmstring, \n"
" apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_auth_provider_invoke_next_credentials", _wrap_svn_auth_provider_invoke_next_credentials, METH_VARARGS, (char *)"\n"
"svn_auth_provider_invoke_next_credentials(svn_auth_provider_t _obj, void * iter_baton, void * provider_baton, apr_hash_t parameters, \n"
" char const * realmstring, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_auth_provider_invoke_save_credentials", _wrap_svn_auth_provider_invoke_save_credentials, METH_VARARGS, (char *)"\n"
"svn_auth_provider_invoke_save_credentials(svn_auth_provider_t _obj, void * credentials, void * provider_baton, apr_hash_t parameters, \n"
" char const * realmstring, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_auth_invoke_simple_provider_func", _wrap_svn_auth_invoke_simple_provider_func, METH_VARARGS, (char *)"svn_auth_invoke_simple_provider_func(svn_auth_simple_provider_func_t _obj, apr_pool_t pool)"},
{ (char *)"svn_auth_invoke_ssl_client_cert_pw_provider_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_provider_func, METH_VARARGS, (char *)"svn_auth_invoke_ssl_client_cert_pw_provider_func(svn_auth_ssl_client_cert_pw_provider_func_t _obj, apr_pool...
{ (char *)"svn_auth_invoke_simple_prompt_func", _wrap_svn_auth_invoke_simple_prompt_func, METH_VARARGS, (char *)"\n"
"svn_auth_invoke_simple_prompt_func(svn_auth_simple_prompt_func_t _obj, void * baton, char const * realm, char const * username, \n"
" svn_boolean_t may_save, apr_pool_t pool) -> svn_error_t\n"
""},
{ (char *)"svn_auth_invoke_username_prompt_func", _wrap_svn_auth_invoke_username_prompt_func, METH_VARARGS, (char *)"\n"
"svn_auth_invoke_username_prompt_func(svn_auth_username_prompt_func_t _obj, void * baton, char const * realm, svn_boolean_t may_save, \n"
src/subversion/subversion/bindings/swig/python/core.py view on Meta::CPAN
return _core.svn_cmdline_create_auth_baton(*args)
class svn_auth_provider_t:
"""Proxy of C svn_auth_provider_t struct"""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_provider_t, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, svn_auth_provider_t, name)
__repr__ = _swig_repr
__swig_setmethods__["cred_kind"] = _core.svn_auth_provider_t_cred_kind_set
__swig_getmethods__["cred_kind"] = _core.svn_auth_provider_t_cred_kind_get
__swig_setmethods__["first_credentials"] = _core.svn_auth_provider_t_first_credentials_set
__swig_getmethods__["first_credentials"] = _core.svn_auth_provider_t_first_credentials_get
__swig_setmethods__["next_credentials"] = _core.svn_auth_provider_t_next_credentials_set
__swig_getmethods__["next_credentials"] = _core.svn_auth_provider_t_next_credentials_get
__swig_setmethods__["save_credentials"] = _core.svn_auth_provider_t_save_credentials_set
__swig_getmethods__["save_credentials"] = _core.svn_auth_provider_t_save_credentials_get
def set_parent_pool(self, parent_pool=None):
"""Create a new proxy object for svn_auth_provider_t"""
import libsvn.core, weakref
self.__dict__["_parent_pool"] = \
parent_pool or libsvn.core.application_pool;
if self.__dict__["_parent_pool"]:
self.__dict__["_is_valid"] = weakref.ref(
self.__dict__["_parent_pool"]._is_valid)
def assert_valid(self):
src/subversion/subversion/bindings/swig/python/core.py view on Meta::CPAN
"""Set an attribute on this object"""
self.assert_valid()
self.__dict__.setdefault("_members",{})[name] = value
return _swig_setattr(self, self.__class__, name, value)
def first_credentials(self, *args):
return svn_auth_provider_invoke_first_credentials(self, *args)
def next_credentials(self, *args):
return svn_auth_provider_invoke_next_credentials(self, *args)
def save_credentials(self, *args):
return svn_auth_provider_invoke_save_credentials(self, *args)
def __init__(self):
"""__init__(svn_auth_provider_t self) -> svn_auth_provider_t"""
this = _core.new_svn_auth_provider_t()
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _core.delete_svn_auth_provider_t
__del__ = lambda self : None;
svn_auth_provider_t_swigregister = _core.svn_auth_provider_t_swigregister
svn_auth_provider_t_swigregister(svn_auth_provider_t)
src/subversion/subversion/bindings/swig/python/core.py view on Meta::CPAN
SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT = _core.SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT
SVN_AUTH_PARAM_NO_AUTH_CACHE = _core.SVN_AUTH_PARAM_NO_AUTH_CACHE
SVN_AUTH_PARAM_SSL_SERVER_FAILURES = _core.SVN_AUTH_PARAM_SSL_SERVER_FAILURES
SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO = _core.SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO
SVN_AUTH_PARAM_CONFIG_CATEGORY_CONFIG = _core.SVN_AUTH_PARAM_CONFIG_CATEGORY_CONFIG
SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS = _core.SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS
SVN_AUTH_PARAM_CONFIG = _core.SVN_AUTH_PARAM_CONFIG
SVN_AUTH_PARAM_SERVER_GROUP = _core.SVN_AUTH_PARAM_SERVER_GROUP
SVN_AUTH_PARAM_CONFIG_DIR = _core.SVN_AUTH_PARAM_CONFIG_DIR
def svn_auth_first_credentials(*args):
"""
svn_auth_first_credentials(char const * cred_kind, char const * realmstring, svn_auth_baton_t * auth_baton,
apr_pool_t pool) -> svn_error_t
"""
return _core.svn_auth_first_credentials(*args)
def svn_auth_next_credentials(*args):
"""svn_auth_next_credentials(svn_auth_iterstate_t * state, apr_pool_t pool) -> svn_error_t"""
return _core.svn_auth_next_credentials(*args)
def svn_auth_save_credentials(*args):
"""svn_auth_save_credentials(svn_auth_iterstate_t * state, apr_pool_t pool) -> svn_error_t"""
return _core.svn_auth_save_credentials(*args)
def svn_auth_forget_credentials(*args):
"""
svn_auth_forget_credentials(svn_auth_baton_t * auth_baton, char const * cred_kind, char const * realmstring,
apr_pool_t pool) -> svn_error_t
"""
return _core.svn_auth_forget_credentials(*args)
def svn_auth_get_simple_prompt_provider(*args):
"""svn_auth_get_simple_prompt_provider(svn_auth_simple_prompt_func_t prompt_func, int retry_limit, apr_pool_t pool)"""
return _core.svn_auth_get_simple_prompt_provider(*args)
def svn_auth_get_username_prompt_provider(*args):
"""svn_auth_get_username_prompt_provider(svn_auth_username_prompt_func_t prompt_func, int retry_limit, apr_pool_t pool)"""
return _core.svn_auth_get_username_prompt_provider(*args)
def svn_auth_get_simple_provider2(*args):
src/subversion/subversion/bindings/swig/python/core.py view on Meta::CPAN
self.__dict__.setdefault("_members",{})[name] = value
return _swig_setattr(self, self.__class__, name, value)
svn_auth_iterstate_t_swigregister = _core.svn_auth_iterstate_t_swigregister
svn_auth_iterstate_t_swigregister(svn_auth_iterstate_t)
def svn_auth_provider_invoke_first_credentials(*args):
"""
svn_auth_provider_invoke_first_credentials(svn_auth_provider_t _obj, void * provider_baton, apr_hash_t parameters, char const * realmstring,
apr_pool_t pool) -> svn_error_t
"""
return _core.svn_auth_provider_invoke_first_credentials(*args)
def svn_auth_provider_invoke_next_credentials(*args):
"""
svn_auth_provider_invoke_next_credentials(svn_auth_provider_t _obj, void * iter_baton, void * provider_baton, apr_hash_t parameters,
char const * realmstring, apr_pool_t pool) -> svn_error_t
"""
return _core.svn_auth_provider_invoke_next_credentials(*args)
def svn_auth_provider_invoke_save_credentials(*args):
"""
svn_auth_provider_invoke_save_credentials(svn_auth_provider_t _obj, void * credentials, void * provider_baton, apr_hash_t parameters,
char const * realmstring, apr_pool_t pool) -> svn_error_t
"""
return _core.svn_auth_provider_invoke_save_credentials(*args)
def svn_auth_invoke_simple_provider_func(*args):
"""svn_auth_invoke_simple_provider_func(svn_auth_simple_provider_func_t _obj, apr_pool_t pool)"""
return _core.svn_auth_invoke_simple_provider_func(*args)
def svn_auth_invoke_ssl_client_cert_pw_provider_func(*args):
"""svn_auth_invoke_ssl_client_cert_pw_provider_func(svn_auth_ssl_client_cert_pw_provider_func_t _obj, apr_pool_t pool)"""
return _core.svn_auth_invoke_ssl_client_cert_pw_provider_func(*args)
def svn_auth_invoke_simple_prompt_func(*args):
src/subversion/subversion/bindings/swig/python/tests/auth.py view on Meta::CPAN
baton = core.svn_auth_open([])
core.svn_auth_set_parameter(baton, "name", "somedata")
core.svn_auth_set_parameter(baton, "name", None)
core.svn_auth_set_parameter(baton, "name", 2)
core.svn_auth_set_parameter(baton, "name",
core.svn_auth_ssl_server_cert_info_t())
def test_invalid_cred_kind(self):
baton = core.svn_auth_open([])
self.assertRaises(core.SubversionException,
lambda: core.svn_auth_first_credentials(
"unknown", "somerealm", baton))
def test_credentials_get_username(self):
def myfunc(realm, maysave, pool):
self.assertEquals("somerealm", realm)
username_cred = core.svn_auth_cred_username_t()
username_cred.username = "bar"
username_cred.may_save = False
return username_cred
baton = core.svn_auth_open([core.svn_auth_get_username_prompt_provider(myfunc, 1)])
creds = core.svn_auth_first_credentials(
core.SVN_AUTH_CRED_USERNAME, "somerealm", baton)
self.assert_(creds is not None)
def test_credentials_get_simple(self):
def myfunc(realm, username, may_save, pool):
self.assertEquals("somerealm", realm)
simple_cred = core.svn_auth_cred_simple_t()
simple_cred.username = "mijnnaam"
simple_cred.password = "geheim"
simple_cred.may_save = False
return simple_cred
baton = core.svn_auth_open([core.svn_auth_get_simple_prompt_provider(myfunc, 1)])
creds = core.svn_auth_first_credentials(
core.SVN_AUTH_CRED_SIMPLE, "somerealm", baton)
self.assert_(creds is not None)
def test_credentials_get_ssl_client_cert(self):
def myfunc(realm, may_save, pool):
self.assertEquals("somerealm", realm)
ssl_cred = core.svn_auth_cred_ssl_client_cert_t()
ssl_cred.cert_file = "my-certs-file"
ssl_cred.may_save = False
return ssl_cred
baton = core.svn_auth_open([core.svn_auth_get_ssl_client_cert_prompt_provider(myfunc, 1)])
creds = core.svn_auth_first_credentials(
core.SVN_AUTH_CRED_SSL_CLIENT_CERT, "somerealm", baton)
self.assert_(creds is not None)
def test_credentials_get_ssl_client_cert_pw(self):
def myfunc(realm, may_save, pool):
self.assertEquals("somerealm", realm)
ssl_cred_pw = core.svn_auth_cred_ssl_client_cert_pw_t()
ssl_cred_pw.password = "supergeheim"
ssl_cred_pw.may_save = False
return ssl_cred_pw
baton = core.svn_auth_open([core.svn_auth_get_ssl_client_cert_pw_prompt_provider(myfunc, 1)])
creds = core.svn_auth_first_credentials(
core.SVN_AUTH_CRED_SSL_CLIENT_CERT_PW, "somerealm", baton)
self.assert_(creds is not None)
def test_credentials_get_ssl_server_trust(self):
def myfunc(realm, failures, cert_info, may_save, pool):
self.assertEquals("somerealm", realm)
ssl_trust = core.svn_auth_cred_ssl_server_trust_t()
ssl_trust.accepted_failures = 0
ssl_trust.may_save = False
return ssl_trust
baton = core.svn_auth_open([core.svn_auth_get_ssl_server_trust_prompt_provider(myfunc)])
core.svn_auth_set_parameter(baton, core.SVN_AUTH_PARAM_SSL_SERVER_FAILURES,
"2")
cert_info = core.svn_auth_ssl_server_cert_info_t()
core.svn_auth_set_parameter(baton, core.SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO,
cert_info)
creds = core.svn_auth_first_credentials(
core.SVN_AUTH_CRED_SSL_SERVER_TRUST, "somerealm", baton)
self.assert_(creds is not None)
def suite():
return unittest.defaultTestLoader.loadTestsFromTestCase(
SubversionAuthTestCase)
if __name__ == '__main__':
runner = unittest.TextTestRunner()
runner.run(suite())
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
}
SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_long (unsigned long value)
{
return ULONG2NUM(value);
}
static svn_error_t * svn_auth_provider_invoke_first_credentials(
svn_auth_provider_t * _obj, void **credentials, void **iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->first_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}
static svn_error_t * svn_auth_provider_invoke_next_credentials(
svn_auth_provider_t * _obj, void **credentials, void *iter_baton, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->next_credentials)(credentials, iter_baton, provider_baton, parameters, realmstring, pool);
}
static svn_error_t * svn_auth_provider_invoke_save_credentials(
svn_auth_provider_t * _obj, svn_boolean_t *saved, void *credentials, void *provider_baton, apr_hash_t *parameters, const char *realmstring, apr_pool_t *pool) {
return (_obj->save_credentials)(saved, credentials, provider_baton, parameters, realmstring, pool);
}
static void svn_auth_invoke_simple_provider_func(
svn_auth_simple_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
_obj(provider, pool);
}
static void svn_auth_invoke_ssl_client_cert_pw_provider_func(
svn_auth_ssl_client_cert_pw_provider_func_t _obj, svn_auth_provider_object_t **provider, apr_pool_t *pool) {
_obj(provider, pool);
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
vresult = Qnil;
}
}
return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_t_first_credentials_set(int argc, VALUE *argv, VALUE self) {
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","first_credentials", 1, self ));
}
arg1 = (struct svn_auth_provider_t *)(argp1);
{
int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)","first_credentials", 2, argv[0] ));
}
}
if (arg1) (arg1)->first_credentials = arg2;
return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_t_first_credentials_get(int argc, VALUE *argv, VALUE self) {
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
svn_error_t *(*result)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
VALUE vresult = Qnil;
if ((argc < 0) || (argc > 0)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","first_credentials", 1, self ));
}
arg1 = (struct svn_auth_provider_t *)(argp1);
result = (svn_error_t *(*)(void **,void **,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->first_credentials);
vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_t_next_credentials_set(int argc, VALUE *argv, VALUE self) {
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","next_credentials", 1, self ));
}
arg1 = (struct svn_auth_provider_t *)(argp1);
{
int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)","next_credentials", 2, argv[0] ));
}
}
if (arg1) (arg1)->next_credentials = arg2;
return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_t_next_credentials_get(int argc, VALUE *argv, VALUE self) {
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
svn_error_t *(*result)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
VALUE vresult = Qnil;
if ((argc < 0) || (argc > 0)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","next_credentials", 1, self ));
}
arg1 = (struct svn_auth_provider_t *)(argp1);
result = (svn_error_t *(*)(void **,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->next_credentials);
vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_t_save_credentials_set(int argc, VALUE *argv, VALUE self) {
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
svn_error_t *(*arg2)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","save_credentials", 1, self ));
}
arg1 = (struct svn_auth_provider_t *)(argp1);
{
int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)","save_credentials", 2, argv[0] ));
}
}
if (arg1) (arg1)->save_credentials = arg2;
return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_t_save_credentials_get(int argc, VALUE *argv, VALUE self) {
struct svn_auth_provider_t *arg1 = (struct svn_auth_provider_t *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
svn_error_t *(*result)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *) = 0 ;
VALUE vresult = Qnil;
if ((argc < 0) || (argc > 0)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct svn_auth_provider_t *","save_credentials", 1, self ));
}
arg1 = (struct svn_auth_provider_t *)(argp1);
result = (svn_error_t *(*)(svn_boolean_t *,void *,void *,apr_hash_t *,char const *,apr_pool_t *)) ((arg1)->save_credentials);
vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_svn_boolean_t_p_void_p_void_p_apr_hash_t_p_q_const__char_p_apr_pool_t__p_svn_error_t);
return vresult;
fail:
return Qnil;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_svn_auth_provider_t_allocate(VALUE self) {
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
}
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return vresult;
fail:
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_first_credentials(int argc, VALUE *argv, VALUE self) {
void **arg1 = (void **) 0 ;
svn_auth_iterstate_t **arg2 = (svn_auth_iterstate_t **) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
svn_auth_baton_t *arg5 = (svn_auth_baton_t *) 0 ;
apr_pool_t *arg6 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
void *temp1 ;
svn_auth_iterstate_t *temp2 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
_global_pool = arg6;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
arg2 = &temp2;
if ((argc < 3) || (argc > 4)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
res3 = SWIG_AsCharPtrAndSize(argv[0], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_auth_first_credentials", 3, argv[0] ));
}
arg3 = (char *)(buf3);
res4 = SWIG_AsCharPtrAndSize(argv[1], &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","svn_auth_first_credentials", 4, argv[1] ));
}
arg4 = (char *)(buf4);
res5 = SWIG_ConvertPtr(argv[2], &argp5,SWIGTYPE_p_svn_auth_baton_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "svn_auth_baton_t *","svn_auth_first_credentials", 5, argv[2] ));
}
arg5 = (svn_auth_baton_t *)(argp5);
if (argc > 3) {
}
{
result = (svn_error_t *)svn_auth_first_credentials(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_next_credentials(int argc, VALUE *argv, VALUE self) {
void **arg1 = (void **) 0 ;
svn_auth_iterstate_t *arg2 = (svn_auth_iterstate_t *) 0 ;
apr_pool_t *arg3 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
void *temp1 ;
void *argp2 = 0 ;
int res2 = 0 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg3);
_global_pool = arg3;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg1 = &temp1;
if ((argc < 1) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_svn_auth_iterstate_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "svn_auth_iterstate_t *","svn_auth_next_credentials", 2, argv[0] ));
}
arg2 = (svn_auth_iterstate_t *)(argp2);
if (argc > 1) {
}
{
result = (svn_error_t *)svn_auth_next_credentials(arg1,arg2,arg3);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_save_credentials(int argc, VALUE *argv, VALUE self) {
svn_auth_iterstate_t *arg1 = (svn_auth_iterstate_t *) 0 ;
apr_pool_t *arg2 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
int res1 = 0 ;
svn_error_t *result = 0 ;
VALUE vresult = Qnil;
{
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg2);
_global_pool = arg2;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
if ((argc < 1) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_iterstate_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_iterstate_t *","svn_auth_save_credentials", 1, argv[0] ));
}
arg1 = (svn_auth_iterstate_t *)(argp1);
if (argc > 1) {
}
{
result = (svn_error_t *)svn_auth_save_credentials(arg1,arg2);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_forget_credentials(int argc, VALUE *argv, VALUE self) {
svn_auth_baton_t *arg1 = (svn_auth_baton_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
apr_pool_t *arg4 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
{
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg4);
_global_pool = arg4;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
if ((argc < 3) || (argc > 4)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_baton_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_baton_t *","svn_auth_forget_credentials", 1, argv[0] ));
}
arg1 = (svn_auth_baton_t *)(argp1);
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","svn_auth_forget_credentials", 2, argv[1] ));
}
arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","svn_auth_forget_credentials", 3, argv[2] ));
}
arg3 = (char *)(buf3);
if (argc > 3) {
}
{
result = (svn_error_t *)svn_auth_forget_credentials(arg1,(char const *)arg2,(char const *)arg3,arg4);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_invoke_first_credentials(int argc, VALUE *argv, VALUE self) {
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
void **arg2 = (void **) 0 ;
void **arg3 = (void **) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
_global_pool = arg7;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg2 = &temp2;
arg3 = &temp3;
if ((argc < 4) || (argc > 5)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_provider_t *","svn_auth_provider_invoke_first_credentials", 1, argv[0] ));
}
arg1 = (svn_auth_provider_t *)(argp1);
res4 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_first_credentials", 4, argv[1] ));
}
res5 = SWIG_ConvertPtr(argv[2], &argp5,SWIGTYPE_p_apr_hash_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_hash_t *","svn_auth_provider_invoke_first_credentials", 5, argv[2] ));
}
arg5 = (apr_hash_t *)(argp5);
res6 = SWIG_AsCharPtrAndSize(argv[3], &buf6, NULL, &alloc6);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","svn_auth_provider_invoke_first_credentials", 6, argv[3] ));
}
arg6 = (char *)(buf6);
if (argc > 4) {
}
{
result = (svn_error_t *)svn_auth_provider_invoke_first_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_invoke_next_credentials(int argc, VALUE *argv, VALUE self) {
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
void **arg2 = (void **) 0 ;
void *arg3 = (void *) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
_global_pool = arg7;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg2 = &temp2;
if ((argc < 5) || (argc > 6)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_provider_t *","svn_auth_provider_invoke_next_credentials", 1, argv[0] ));
}
arg1 = (svn_auth_provider_t *)(argp1);
res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_next_credentials", 3, argv[1] ));
}
res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_next_credentials", 4, argv[2] ));
}
res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_apr_hash_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_hash_t *","svn_auth_provider_invoke_next_credentials", 5, argv[3] ));
}
arg5 = (apr_hash_t *)(argp5);
res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","svn_auth_provider_invoke_next_credentials", 6, argv[4] ));
}
arg6 = (char *)(buf6);
if (argc > 5) {
}
{
result = (svn_error_t *)svn_auth_provider_invoke_next_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
target = _global_vresult_address == &vresult ? self : vresult;
if (!svn_swig_rb_set_pool(target, _global_svn_swig_rb_pool))
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
}
return Qnil;
}
SWIGINTERN VALUE
_wrap_svn_auth_provider_invoke_save_credentials(int argc, VALUE *argv, VALUE self) {
svn_auth_provider_t *arg1 = (svn_auth_provider_t *) 0 ;
svn_boolean_t *arg2 = (svn_boolean_t *) 0 ;
void *arg3 = (void *) 0 ;
void *arg4 = (void *) 0 ;
apr_hash_t *arg5 = (apr_hash_t *) 0 ;
char *arg6 = (char *) 0 ;
apr_pool_t *arg7 = (apr_pool_t *) 0 ;
VALUE _global_svn_swig_rb_pool ;
apr_pool_t *_global_pool ;
void *argp1 = 0 ;
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
svn_swig_rb_get_pool(argc, argv, self, &_global_svn_swig_rb_pool, &arg7);
_global_pool = arg7;
svn_swig_rb_push_pool(_global_svn_swig_rb_pool);
}
arg2 = &temp2;
if ((argc < 5) || (argc > 6)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_svn_auth_provider_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "svn_auth_provider_t *","svn_auth_provider_invoke_save_credentials", 1, argv[0] ));
}
arg1 = (svn_auth_provider_t *)(argp1);
res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_save_credentials", 3, argv[1] ));
}
res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","svn_auth_provider_invoke_save_credentials", 4, argv[2] ));
}
res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_apr_hash_t, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "apr_hash_t *","svn_auth_provider_invoke_save_credentials", 5, argv[3] ));
}
arg5 = (apr_hash_t *)(argp5);
res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","svn_auth_provider_invoke_save_credentials", 6, argv[4] ));
}
arg6 = (char *)(buf6);
if (argc > 5) {
}
{
result = (svn_error_t *)svn_auth_provider_invoke_save_credentials(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
}
{
if (result) {
svn_swig_rb_destroy_pool(_global_svn_swig_rb_pool);
svn_swig_rb_pop_pool(_global_svn_swig_rb_pool);
svn_swig_rb_handle_svn_error(result);
}
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
rb_define_module_function(mCore, "svn_opt_print_help", _wrap_svn_opt_print_help, -1);
rb_define_module_function(mCore, "svn_cmdline_init", _wrap_svn_cmdline_init, -1);
rb_define_module_function(mCore, "svn_cmdline_create_auth_baton", _wrap_svn_cmdline_create_auth_baton, -1);
SwigClassSvn_auth_provider_t.klass = rb_define_class_under(mCore, "Svn_auth_provider_t", rb_cObject);
SWIG_TypeClientData(SWIGTYPE_p_svn_auth_provider_t, (void *) &SwigClassSvn_auth_provider_t);
rb_define_alloc_func(SwigClassSvn_auth_provider_t.klass, _wrap_svn_auth_provider_t_allocate);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "initialize", _wrap_new_svn_auth_provider_t, -1);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "cred_kind=", _wrap_svn_auth_provider_t_cred_kind_set, -1);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "cred_kind", _wrap_svn_auth_provider_t_cred_kind_get, -1);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "first_credentials=", _wrap_svn_auth_provider_t_first_credentials_set, -1);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "first_credentials", _wrap_svn_auth_provider_t_first_credentials_get, -1);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "next_credentials=", _wrap_svn_auth_provider_t_next_credentials_set, -1);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "next_credentials", _wrap_svn_auth_provider_t_next_credentials_get, -1);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "save_credentials=", _wrap_svn_auth_provider_t_save_credentials_set, -1);
rb_define_method(SwigClassSvn_auth_provider_t.klass, "save_credentials", _wrap_svn_auth_provider_t_save_credentials_get, -1);
SwigClassSvn_auth_provider_t.mark = 0;
SwigClassSvn_auth_provider_t.destroy = (void (*)(void *)) free_svn_auth_provider_t;
SwigClassSvn_auth_provider_t.trackObjects = 0;
SwigClassSvn_auth_provider_object_t.klass = rb_define_class_under(mCore, "Svn_auth_provider_object_t", rb_cObject);
SWIG_TypeClientData(SWIGTYPE_p_svn_auth_provider_object_t, (void *) &SwigClassSvn_auth_provider_object_t);
rb_define_alloc_func(SwigClassSvn_auth_provider_object_t.klass, _wrap_svn_auth_provider_object_t_allocate);
rb_define_method(SwigClassSvn_auth_provider_object_t.klass, "initialize", _wrap_new_svn_auth_provider_object_t, -1);
rb_define_method(SwigClassSvn_auth_provider_object_t.klass, "vtable=", _wrap_svn_auth_provider_object_t_vtable_set, -1);
rb_define_method(SwigClassSvn_auth_provider_object_t.klass, "vtable", _wrap_svn_auth_provider_object_t_vtable_get, -1);
src/subversion/subversion/bindings/swig/ruby/core.c view on Meta::CPAN
rb_define_const(mCore, "SVN_AUTH_PARAM_DONT_STORE_SSL_CLIENT_CERT_PP", SWIG_FromCharPtr("svn:auth:dont-store-ssl-client-cert-pp"));
rb_define_const(mCore, "SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT", SWIG_FromCharPtr("svn:auth:store-ssl-client-cert-pp-plaintext"));
rb_define_const(mCore, "SVN_AUTH_PARAM_NO_AUTH_CACHE", SWIG_FromCharPtr("svn:auth:no-auth-cache"));
rb_define_const(mCore, "SVN_AUTH_PARAM_SSL_SERVER_FAILURES", SWIG_FromCharPtr("svn:auth:ssl:failures"));
rb_define_const(mCore, "SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO", SWIG_FromCharPtr("svn:auth:ssl:cert-info"));
rb_define_const(mCore, "SVN_AUTH_PARAM_CONFIG_CATEGORY_CONFIG", SWIG_FromCharPtr("svn:auth:config-category-config"));
rb_define_const(mCore, "SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS", SWIG_FromCharPtr("svn:auth:config-category-servers"));
rb_define_const(mCore, "SVN_AUTH_PARAM_CONFIG", SWIG_FromCharPtr("svn:auth:config-category-servers"));
rb_define_const(mCore, "SVN_AUTH_PARAM_SERVER_GROUP", SWIG_FromCharPtr("svn:auth:server-group"));
rb_define_const(mCore, "SVN_AUTH_PARAM_CONFIG_DIR", SWIG_FromCharPtr("svn:auth:config-dir"));
rb_define_module_function(mCore, "svn_auth_first_credentials", _wrap_svn_auth_first_credentials, -1);
rb_define_module_function(mCore, "svn_auth_next_credentials", _wrap_svn_auth_next_credentials, -1);
rb_define_module_function(mCore, "svn_auth_save_credentials", _wrap_svn_auth_save_credentials, -1);
rb_define_module_function(mCore, "svn_auth_forget_credentials", _wrap_svn_auth_forget_credentials, -1);
rb_define_module_function(mCore, "svn_auth_get_simple_prompt_provider", _wrap_svn_auth_get_simple_prompt_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_username_prompt_provider", _wrap_svn_auth_get_username_prompt_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_simple_provider2", _wrap_svn_auth_get_simple_provider2, -1);
rb_define_module_function(mCore, "svn_auth_get_simple_provider", _wrap_svn_auth_get_simple_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_platform_specific_provider", _wrap_svn_auth_get_platform_specific_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_platform_specific_client_providers", _wrap_svn_auth_get_platform_specific_client_providers, -1);
rb_define_const(mCore, "SVN_AUTH_PARAM_GNOME_KEYRING_UNLOCK_PROMPT_FUNC", SWIG_FromCharPtr("gnome-keyring-unlock-prompt-func"));
rb_define_const(mCore, "SVN_AUTH_PARAM_GNOME_KEYRING_UNLOCK_PROMPT_BATON", SWIG_FromCharPtr("gnome-keyring-unlock-prompt-baton"));
rb_define_module_function(mCore, "svn_auth_get_username_provider", _wrap_svn_auth_get_username_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_ssl_server_trust_file_provider", _wrap_svn_auth_get_ssl_server_trust_file_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_file_provider", _wrap_svn_auth_get_ssl_client_cert_file_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_pw_file_provider2", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider2, -1);
rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_pw_file_provider", _wrap_svn_auth_get_ssl_client_cert_pw_file_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_ssl_server_trust_prompt_provider", _wrap_svn_auth_get_ssl_server_trust_prompt_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_prompt_provider, -1);
rb_define_module_function(mCore, "svn_auth_get_ssl_client_cert_pw_prompt_provider", _wrap_svn_auth_get_ssl_client_cert_pw_prompt_provider, -1);
rb_define_module_function(mCore, "svn_auth_provider_invoke_first_credentials", _wrap_svn_auth_provider_invoke_first_credentials, -1);
rb_define_module_function(mCore, "svn_auth_provider_invoke_next_credentials", _wrap_svn_auth_provider_invoke_next_credentials, -1);
rb_define_module_function(mCore, "svn_auth_provider_invoke_save_credentials", _wrap_svn_auth_provider_invoke_save_credentials, -1);
rb_define_module_function(mCore, "svn_auth_invoke_simple_provider_func", _wrap_svn_auth_invoke_simple_provider_func, -1);
rb_define_module_function(mCore, "svn_auth_invoke_ssl_client_cert_pw_provider_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_provider_func, -1);
rb_define_module_function(mCore, "svn_auth_invoke_simple_prompt_func", _wrap_svn_auth_invoke_simple_prompt_func, -1);
rb_define_module_function(mCore, "svn_auth_invoke_username_prompt_func", _wrap_svn_auth_invoke_username_prompt_func, -1);
rb_define_module_function(mCore, "svn_auth_invoke_ssl_server_trust_prompt_func", _wrap_svn_auth_invoke_ssl_server_trust_prompt_func, -1);
rb_define_module_function(mCore, "svn_auth_invoke_ssl_client_cert_prompt_func", _wrap_svn_auth_invoke_ssl_client_cert_prompt_func, -1);
rb_define_module_function(mCore, "svn_auth_invoke_ssl_client_cert_pw_prompt_func", _wrap_svn_auth_invoke_ssl_client_cert_pw_prompt_func, -1);
rb_define_module_function(mCore, "svn_auth_invoke_plaintext_prompt_func", _wrap_svn_auth_invoke_plaintext_prompt_func, -1);
rb_define_module_function(mCore, "svn_auth_invoke_plaintext_passphrase_prompt_func", _wrap_svn_auth_invoke_plaintext_passphrase_prompt_func, -1);
rb_define_const(mCore, "SVN_CONFIG_CATEGORY_SERVERS", SWIG_FromCharPtr("servers"));
src/subversion/subversion/include/private/svn_auth_private.h view on Meta::CPAN
(svn_boolean_t *done,
apr_hash_t *creds,
const char *realmstring,
const char *username,
const char *password,
apr_hash_t *parameters,
svn_boolean_t non_interactive,
apr_pool_t *pool);
/* Use PARAMETERS and REALMSTRING to set *CREDENTIALS to a set of
pre-cached authentication credentials pulled from the simple
credential cache store identified by PASSTYPE. PASSWORD_GET is
used to obtain the password value. Allocate *CREDENTIALS from
POOL.
NOTE: This function is a common implementation of code used by
several of the simple credential providers (the default disk cache
mechanism, Windows CryptoAPI, GNOME Keyring, etc.), typically in
their "first_creds" implementation. */
svn_error_t *
svn_auth__simple_creds_cache_get(void **credentials,
void **iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
svn_auth__password_get_t password_get,
const char *passtype,
apr_pool_t *pool);
/* Use PARAMETERS and REALMSTRING to save CREDENTIALS in the simple
credential cache store identified by PASSTYPE. PASSWORD_SET is
used to do the actual storage. Use POOL for necessary allocations.
Set *SAVED according to whether or not the credentials were
successfully stored.
NOTE: This function is a common implementation of code used by
several of the simple credential providers (the default disk cache
mechanism, Windows CryptoAPI, GNOME Keyring, etc.) typically in
their "save_creds" implementation. */
svn_error_t *
svn_auth__simple_creds_cache_set(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
svn_auth__password_set_t password_set,
const char *passtype,
apr_pool_t *pool);
/* Implementation of svn_auth__password_get_t that retrieves
the plaintext password from CREDS when USERNAME matches the stored
credentials. */
svn_error_t *
svn_auth__simple_password_get(svn_boolean_t *done,
const char **password,
apr_hash_t *creds,
const char *realmstring,
const char *username,
apr_hash_t *parameters,
svn_boolean_t non_interactive,
apr_pool_t *pool);
src/subversion/subversion/include/private/svn_auth_private.h view on Meta::CPAN
apr_hash_t *creds,
const char *realmstring,
const char *username,
const char *password,
apr_hash_t *parameters,
svn_boolean_t non_interactive,
apr_pool_t *pool);
/* Use PARAMETERS and REALMSTRING to set *CREDENTIALS to a set of
pre-cached authentication credentials pulled from the SSL client
certificate passphrase credential cache store identified by
PASSTYPE. PASSPHRASE_GET is used to obtain the passphrase value.
Allocate *CREDENTIALS from POOL.
NOTE: This function is a common implementation of code used by
several of the ssl client passphrase credential providers (the
default disk cache mechanism, Windows CryptoAPI, GNOME Keyring,
etc.), typically in their "first_creds" implementation. */
svn_error_t *
svn_auth__ssl_client_cert_pw_cache_get(void **credentials,
void **iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
svn_auth__password_get_t passphrase_get,
const char *passtype,
apr_pool_t *pool);
/* Use PARAMETERS and REALMSTRING to save CREDENTIALS in the SSL
client certificate passphrase credential cache store identified by
PASSTYPE. PASSPHRASE_SET is used to do the actual storage. Use
POOL for necessary allocations. Set *SAVED according to whether or
not the credentials were successfully stored.
NOTE: This function is a common implementation of code used by
several of the simple credential providers (the default disk cache
mechanism, Windows CryptoAPI, GNOME Keyring, etc.) typically in
their "save_creds" implementation. */
svn_error_t *
svn_auth__ssl_client_cert_pw_cache_set(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
svn_auth__password_set_t passphrase_set,
const char *passtype,
apr_pool_t *pool);
/* This implements the svn_auth__password_get_t interface.
Set **PASSPHRASE to the plaintext passphrase retrieved from CREDS;
ignore other parameters. */
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
#include "svn_types.h"
#include "svn_config.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/** Overview of the svn authentication system.
*
* We define an authentication "provider" as a module that is able to
* return a specific set of credentials. (e.g. username/password,
* certificate, etc.) Each provider implements a vtable that
*
* - can fetch initial credentials
* - can retry the fetch (or try to fetch something different)
* - can store the credentials for future use
*
* For any given type of credentials, there can exist any number of
* separate providers -- each provider has a different method of
* fetching. (i.e. from a disk store, by prompting the user, etc.)
*
* The application begins by creating an auth baton object, and
* "registers" some number of providers with the auth baton, in a
* specific order. (For example, it may first register a
* username/password provider that looks in disk store, then register
* a username/password provider that prompts the user.)
*
* Later on, when any svn library is challenged, it asks the auth
* baton for the specific credentials. If the initial credentials
* fail to authenticate, the caller keeps requesting new credentials.
* Under the hood, libsvn_auth effectively "walks" over each provider
* (in order of registry), one at a time, until all the providers have
* exhausted all their retry options.
*
* This system allows an application to flexibly define authentication
* behaviors (by changing registration order), and very easily write
* new authentication providers.
*
* An auth_baton also contains an internal hashtable of run-time
* parameters; any provider or library layer can set these run-time
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
/** The type of a Subversion authentication object */
typedef struct svn_auth_baton_t svn_auth_baton_t;
/** The type of a Subversion authentication-iteration object */
typedef struct svn_auth_iterstate_t svn_auth_iterstate_t;
/** The main authentication "provider" vtable. */
typedef struct svn_auth_provider_t
{
/** The kind of credentials this provider knows how to retrieve. */
const char *cred_kind;
/** Get an initial set of credentials.
*
* Set @a *credentials to a set of valid credentials within @a
* realmstring, or NULL if no credentials are available. Set @a
* *iter_baton to context that allows a subsequent call to @c
* next_credentials, in case the first credentials fail to
* authenticate. @a provider_baton is general context for the
* vtable, @a parameters contains any run-time data that the
* provider may need, and @a realmstring comes from the
* svn_auth_first_credentials() call.
*/
svn_error_t * (*first_credentials)(void **credentials,
void **iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool);
/** Get a different set of credentials.
*
* Set @a *credentials to another set of valid credentials (using @a
* iter_baton as the context from previous call to first_credentials
* or next_credentials). If no more credentials are available, set
* @a *credentials to NULL. If the provider only has one set of
* credentials, this function pointer should simply be NULL. @a
* provider_baton is general context for the vtable, @a parameters
* contains any run-time data that the provider may need, and @a
* realmstring comes from the svn_auth_first_credentials() call.
*/
svn_error_t * (*next_credentials)(void **credentials,
void *iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool);
/** Save credentials.
*
* Store @a credentials for future use. @a provider_baton is
* general context for the vtable, and @a parameters contains any
* run-time data the provider may need. Set @a *saved to TRUE if
* the save happened, or FALSE if not. The provider is not required
* to save; if it refuses or is unable to save for non-fatal
* reasons, return FALSE. If the provider never saves data, then
* this function pointer should simply be NULL. @a realmstring comes
* from the svn_auth_first_credentials() call.
*/
svn_error_t * (*save_credentials)(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool);
} svn_auth_provider_t;
/** A provider object, ready to be put into an array and given to
svn_auth_open(). */
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
void *provider_baton;
} svn_auth_provider_object_t;
/** The type of function returning authentication provider. */
typedef void (*svn_auth_simple_provider_func_t)(
svn_auth_provider_object_t **provider,
apr_pool_t *pool);
/** Specific types of credentials **/
/** Simple username/password pair credential kind.
*
* The following auth parameters are available to the providers:
*
* - @c SVN_AUTH_PARAM_CONFIG_CATEGORY_CONFIG (@c svn_config_t*)
* - @c SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS (@c svn_config_t*)
*
* The following auth parameters may be available to the providers:
*
* - @c SVN_AUTH_PARAM_NO_AUTH_CACHE (@c void*)
* - @c SVN_AUTH_PARAM_DEFAULT_USERNAME (@c char*)
* - @c SVN_AUTH_PARAM_DEFAULT_PASSWORD (@c char*)
*/
#define SVN_AUTH_CRED_SIMPLE "svn.simple"
/** @c SVN_AUTH_CRED_SIMPLE credentials. */
typedef struct svn_auth_cred_simple_t
{
/** Username */
const char *username;
/** Password */
const char *password;
/** Indicates if the credentials may be saved (to disk). For example, a
* GUI prompt implementation with a remember password checkbox shall set
* @a may_save to TRUE if the checkbox is checked.
*/
svn_boolean_t may_save;
} svn_auth_cred_simple_t;
/** Username credential kind.
*
* The following optional auth parameters are relevant to the providers:
*
* - @c SVN_AUTH_PARAM_NO_AUTH_CACHE (@c void*)
* - @c SVN_AUTH_PARAM_DEFAULT_USERNAME (@c char*)
*/
#define SVN_AUTH_CRED_USERNAME "svn.username"
/** @c SVN_AUTH_CRED_USERNAME credentials. */
typedef struct svn_auth_cred_username_t
{
/** Username */
const char *username;
/** Indicates if the credentials may be saved (to disk). For example, a
* GUI prompt implementation with a remember username checkbox shall set
* @a may_save to TRUE if the checkbox is checked.
*/
svn_boolean_t may_save;
} svn_auth_cred_username_t;
/** SSL client certificate credential type.
*
* The following auth parameters are available to the providers:
*
* - @c SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS (@c svn_config_t*)
* - @c SVN_AUTH_PARAM_SERVER_GROUP (@c char*)
*
* The following optional auth parameters are relevant to the providers:
*
* - @c SVN_AUTH_PARAM_NO_AUTH_CACHE (@c void*)
*/
#define SVN_AUTH_CRED_SSL_CLIENT_CERT "svn.ssl.client-cert"
/** @c SVN_AUTH_CRED_SSL_CLIENT_CERT credentials. */
typedef struct svn_auth_cred_ssl_client_cert_t
{
/** Absolute path to the certificate file */
const char *cert_file;
/** Indicates if the credentials may be saved (to disk). For example, a
* GUI prompt implementation with a remember certificate checkbox shall
* set @a may_save to TRUE if the checkbox is checked.
*/
svn_boolean_t may_save;
} svn_auth_cred_ssl_client_cert_t;
/** A function returning an SSL client certificate passphrase provider. */
typedef void (*svn_auth_ssl_client_cert_pw_provider_func_t)(
svn_auth_provider_object_t **provider,
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
* - @c SVN_AUTH_PARAM_CONFIG_CATEGORY_CONFIG (@c svn_config_t*)
* - @c SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS (@c svn_config_t*)
* - @c SVN_AUTH_PARAM_SERVER_GROUP (@c char*)
*
* The following optional auth parameters are relevant to the providers:
*
* - @c SVN_AUTH_PARAM_NO_AUTH_CACHE (@c void*)
*/
#define SVN_AUTH_CRED_SSL_CLIENT_CERT_PW "svn.ssl.client-passphrase"
/** @c SVN_AUTH_CRED_SSL_CLIENT_CERT_PW credentials. */
typedef struct svn_auth_cred_ssl_client_cert_pw_t
{
/** Certificate password */
const char *password;
/** Indicates if the credentials may be saved (to disk). For example, a
* GUI prompt implementation with a remember password checkbox shall set
* @a may_save to TRUE if the checkbox is checked.
*/
svn_boolean_t may_save;
} svn_auth_cred_ssl_client_cert_pw_t;
/** SSL server verification credential type.
*
* The following auth parameters are available to the providers:
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
/**
* Return a deep copy of @a info, allocated in @a pool.
*
* @since New in 1.3.
*/
svn_auth_ssl_server_cert_info_t *
svn_auth_ssl_server_cert_info_dup(const svn_auth_ssl_server_cert_info_t *info,
apr_pool_t *pool);
/** @c SVN_AUTH_CRED_SSL_SERVER_TRUST credentials. */
typedef struct svn_auth_cred_ssl_server_trust_t
{
/** Indicates if the credentials may be saved (to disk). For example, a
* GUI prompt implementation with a checkbox to accept the certificate
* permanently shall set @a may_save to TRUE if the checkbox is checked.
*/
svn_boolean_t may_save;
/** Bit mask of the accepted failures */
apr_uint32_t accepted_failures;
} svn_auth_cred_ssl_server_trust_t;
/** Credential-constructing prompt functions. **/
/** These exist so that different client applications can use
* different prompt mechanisms to supply the same credentials. For
* example, if authentication requires a username and password, a
* command-line client's prompting function might prompt first for the
* username and then for the password, whereas a GUI client's would
* present a single dialog box asking for both, and a telepathic
* client's would read all the information directly from the user's
* mind. All these prompting functions return the same type of
* credential, but the information used to construct the credential is
* gathered in an interface-specific way in each case.
*/
/** Set @a *cred by prompting the user, allocating @a *cred in @a pool.
* @a baton is an implementation-specific closure.
*
* If @a realm is non-NULL, maybe use it in the prompt string.
*
* If @a username is non-NULL, then the user might be prompted only
* for a password, but @a *cred would still be filled with both
* username and password. For example, a typical usage would be to
* pass @a username on the first call, but then leave it NULL for
* subsequent calls, on the theory that if credentials failed, it's
* as likely to be due to incorrect username as incorrect password.
*
* If @a may_save is FALSE, the auth system does not allow the credentials
* to be saved (to disk). A prompt function shall not ask the user if the
* credentials shall be saved if @a may_save is FALSE. For example, a GUI
* client with a remember password checkbox would grey out the checkbox if
* @a may_save is FALSE.
*/
typedef svn_error_t *(*svn_auth_simple_prompt_func_t)(
svn_auth_cred_simple_t **cred,
void *baton,
const char *realm,
const char *username,
svn_boolean_t may_save,
apr_pool_t *pool);
/** Set @a *cred by prompting the user, allocating @a *cred in @a pool.
* @a baton is an implementation-specific closure.
*
* If @a realm is non-NULL, maybe use it in the prompt string.
*
* If @a may_save is FALSE, the auth system does not allow the credentials
* to be saved (to disk). A prompt function shall not ask the user if the
* credentials shall be saved if @a may_save is FALSE. For example, a GUI
* client with a remember username checkbox would grey out the checkbox if
* @a may_save is FALSE.
*/
typedef svn_error_t *(*svn_auth_username_prompt_func_t)(
svn_auth_cred_username_t **cred,
void *baton,
const char *realm,
svn_boolean_t may_save,
apr_pool_t *pool);
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
/** Set @a *cred by prompting the user, allocating @a *cred in @a pool.
* @a baton is an implementation-specific closure.
*
* @a cert_info is a structure describing the server cert that was
* presented to the client, and @a failures is a bitmask that
* describes exactly why the cert could not be automatically validated,
* composed from the constants SVN_AUTH_SSL_* (@c SVN_AUTH_SSL_NOTYETVALID
* etc.). @a realm is a string that can be used in the prompt string.
*
* If @a may_save is FALSE, the auth system does not allow the credentials
* to be saved (to disk). A prompt function shall not ask the user if the
* credentials shall be saved if @a may_save is FALSE. For example, a GUI
* client with a trust permanently checkbox would grey out the checkbox if
* @a may_save is FALSE.
*/
typedef svn_error_t *(*svn_auth_ssl_server_trust_prompt_func_t)(
svn_auth_cred_ssl_server_trust_t **cred,
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);
/** Set @a *cred by prompting the user, allocating @a *cred in @a pool.
* @a baton is an implementation-specific closure. @a realm is a string
* that can be used in the prompt string.
*
* If @a may_save is FALSE, the auth system does not allow the credentials
* to be saved (to disk). A prompt function shall not ask the user if the
* credentials shall be saved if @a may_save is FALSE. For example, a GUI
* client with a remember certificate checkbox would grey out the checkbox
* if @a may_save is FALSE.
*/
typedef svn_error_t *(*svn_auth_ssl_client_cert_prompt_func_t)(
svn_auth_cred_ssl_client_cert_t **cred,
void *baton,
const char *realm,
svn_boolean_t may_save,
apr_pool_t *pool);
/** Set @a *cred by prompting the user, allocating @a *cred in @a pool.
* @a baton is an implementation-specific closure. @a realm is a string
* identifying the certificate, and can be used in the prompt string.
*
* If @a may_save is FALSE, the auth system does not allow the credentials
* to be saved (to disk). A prompt function shall not ask the user if the
* credentials shall be saved if @a may_save is FALSE. For example, a GUI
* client with a remember password checkbox would grey out the checkbox if
* @a may_save is FALSE.
*/
typedef svn_error_t *(*svn_auth_ssl_client_cert_pw_prompt_func_t)(
svn_auth_cred_ssl_client_cert_pw_t **cred,
void *baton,
const char *realm,
svn_boolean_t may_save,
apr_pool_t *pool);
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
If you are writing a new provider, then to be a "good citizen",
you should notice these global parameters! Note that these
run-time params should be treated as read-only by providers; the
application is responsible for placing them into the auth_baton
hash. */
/** The auth-hash prefix indicating that the parameter is global. */
#define SVN_AUTH_PARAM_PREFIX "svn:auth:"
/**
* @name Default credentials defines
* Property values are const char *.
* @{ */
/** Default username provided by the application itself (e.g. --username) */
#define SVN_AUTH_PARAM_DEFAULT_USERNAME SVN_AUTH_PARAM_PREFIX "username"
/** Default password provided by the application itself (e.g. --password) */
#define SVN_AUTH_PARAM_DEFAULT_PASSWORD SVN_AUTH_PARAM_PREFIX "password"
/** @} */
/** @brief The application doesn't want any providers to prompt
* users. Property value is irrelevant; only property's existence
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
SVN_AUTH_PARAM_PREFIX "dont-store-ssl-client-cert-pp"
/** @brief Indicates whether providers may save passphrase to disk in
* plaintext. Property value can be either SVN_CONFIG_TRUE,
* SVN_CONFIG_FALSE, or SVN_CONFIG_ASK.
* @since New in 1.6.
*/
#define SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT \
SVN_AUTH_PARAM_PREFIX "store-ssl-client-cert-pp-plaintext"
/** @brief The application doesn't want any providers to save credentials
* to disk. Property value is irrelevant; only property's existence
* matters. */
#define SVN_AUTH_PARAM_NO_AUTH_CACHE SVN_AUTH_PARAM_PREFIX "no-auth-cache"
/** @brief The following property is for SSL server cert providers. This
* provides a pointer to an @c apr_uint32_t containing the failures
* detected by the certificate validator. */
#define SVN_AUTH_PARAM_SSL_SERVER_FAILURES SVN_AUTH_PARAM_PREFIX \
"ssl:failures"
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
/** @deprecated Provided for backward compatibility with the 1.5 API. */
#define SVN_AUTH_PARAM_CONFIG SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS
/** The current server group. */
#define SVN_AUTH_PARAM_SERVER_GROUP SVN_AUTH_PARAM_PREFIX "server-group"
/** @brief A configuration directory that overrides the default
* ~/.subversion. */
#define SVN_AUTH_PARAM_CONFIG_DIR SVN_AUTH_PARAM_PREFIX "config-dir"
/** Get an initial set of credentials.
*
* Ask @a auth_baton to set @a *credentials to a set of credentials
* defined by @a cred_kind and valid within @a realmstring, or NULL if
* no credentials are available. Otherwise, return an iteration state
* in @a *state, so that the caller can call
* svn_auth_next_credentials(), in case the first set of credentials
* fails to authenticate.
*
* Use @a pool to allocate @a *state, and for temporary allocation.
* Note that @a *credentials will be allocated in @a auth_baton's pool.
*/
svn_error_t *
svn_auth_first_credentials(void **credentials,
svn_auth_iterstate_t **state,
const char *cred_kind,
const char *realmstring,
svn_auth_baton_t *auth_baton,
apr_pool_t *pool);
/** Get another set of credentials, assuming previous ones failed to
* authenticate.
*
* Use @a state to fetch a different set of @a *credentials, as a
* follow-up to svn_auth_first_credentials() or
* svn_auth_next_credentials(). If no more credentials are available,
* set @a *credentials to NULL.
*
* Note that @a *credentials will be allocated in @c auth_baton's pool.
*/
svn_error_t *
svn_auth_next_credentials(void **credentials,
svn_auth_iterstate_t *state,
apr_pool_t *pool);
/** Save a set of credentials.
*
* Ask @a state to store the most recently returned credentials,
* presumably because they successfully authenticated.
* All allocations should be done in @a pool.
*
* If no credentials were ever returned, do nothing.
*/
svn_error_t *
svn_auth_save_credentials(svn_auth_iterstate_t *state,
apr_pool_t *pool);
/** Forget a set (or all) memory-cached credentials.
*
* Remove references (if any) in @a auth_baton to credentials cached
* therein. If @a cred_kind and @a realmstring are non-NULL, forget
* only the credentials associated with those credential types and
* realm. Otherwise @a cred_kind and @a realmstring must both be
* NULL, and this function will forget all credentials cached within
* @a auth_baton.
*
* @note This function does not affect persisted authentication
* credential storage at all. It is merely a way to cause Subversion
* to forget about credentials already fetched from a provider,
* forcing them to be fetched again later should they be required.
*
* @since New in 1.8.
*/
svn_error_t *
svn_auth_forget_credentials(svn_auth_baton_t *auth_baton,
const char *cred_kind,
const char *realmstring,
apr_pool_t *pool);
/** @} */
/** Set @a *provider to an authentication provider of type
* svn_auth_cred_simple_t that gets information by prompting the user
* with @a prompt_func and @a prompt_baton. Allocate @a *provider in
* @a pool.
*
* If both @c SVN_AUTH_PARAM_DEFAULT_USERNAME and
* @c SVN_AUTH_PARAM_DEFAULT_PASSWORD are defined as runtime
* parameters in the @c auth_baton, then @a *provider will return the
* default arguments when svn_auth_first_credentials() is called. If
* svn_auth_first_credentials() fails, then @a *provider will
* re-prompt @a retry_limit times (via svn_auth_next_credentials()).
* For infinite retries, set @a retry_limit to value less than 0.
*
* @since New in 1.4.
*/
void
svn_auth_get_simple_prompt_provider(svn_auth_provider_object_t **provider,
svn_auth_simple_prompt_func_t prompt_func,
void *prompt_baton,
int retry_limit,
apr_pool_t *pool);
/** Set @a *provider to an authentication provider of type @c
* svn_auth_cred_username_t that gets information by prompting the
* user with @a prompt_func and @a prompt_baton. Allocate @a *provider
* in @a pool.
*
* If @c SVN_AUTH_PARAM_DEFAULT_USERNAME is defined as a runtime
* parameter in the @c auth_baton, then @a *provider will return the
* default argument when svn_auth_first_credentials() is called. If
* svn_auth_first_credentials() fails, then @a *provider will
* re-prompt @a retry_limit times (via svn_auth_next_credentials()).
* For infinite retries, set @a retry_limit to value less than 0.
*
* @since New in 1.4.
*/
void
svn_auth_get_username_prompt_provider(
svn_auth_provider_object_t **provider,
svn_auth_username_prompt_func_t prompt_func,
void *prompt_baton,
int retry_limit,
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
* default to not storing the password unencrypted if this callback is NULL.
*
* Clients can however set the callback to NULL and set
* SVN_AUTH_PARAM_STORE_PLAINTEXT_PASSWORDS to SVN_CONFIG_FALSE or
* SVN_CONFIG_TRUE to enforce a certain behaviour.
*
* Allocate @a *provider in @a pool.
*
* If a default username or password is available, @a *provider will
* honor them as well, and return them when
* svn_auth_first_credentials() is called. (see @c
* SVN_AUTH_PARAM_DEFAULT_USERNAME and @c
* SVN_AUTH_PARAM_DEFAULT_PASSWORD).
*
* @since New in 1.6.
*/
void
svn_auth_get_simple_provider2(
svn_auth_provider_object_t **provider,
svn_auth_plaintext_prompt_func_t plaintext_prompt_func,
void *prompt_baton,
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
apr_pool_t *pool);
#endif /* !defined(WIN32) || defined(DOXYGEN) */
/** Set @a *provider to an authentication provider of type @c
* svn_auth_cred_username_t that gets/sets information from a user's
* ~/.subversion configuration directory. Allocate @a *provider in
* @a pool.
*
* If a default username is available, @a *provider will honor it,
* and return it when svn_auth_first_credentials() is called. (See
* @c SVN_AUTH_PARAM_DEFAULT_USERNAME.)
*
* @since New in 1.4.
*/
void
svn_auth_get_username_provider(svn_auth_provider_object_t **provider,
apr_pool_t *pool);
/** Set @a *provider to an authentication provider of type @c
* svn_auth_cred_ssl_server_trust_t, allocated in @a pool.
*
* @a *provider retrieves its credentials from the configuration
* mechanism. The returned credential is used to override SSL
* security on an error.
*
* @since New in 1.4.
*/
void
svn_auth_get_ssl_server_trust_file_provider(
svn_auth_provider_object_t **provider,
apr_pool_t *pool);
/** Set @a *provider to an authentication provider of type @c
* svn_auth_cred_ssl_client_cert_t, allocated in @a pool.
*
* @a *provider retrieves its credentials from the configuration
* mechanism. The returned credential is used to load the appropriate
* client certificate for authentication when requested by a server.
*
* @since New in 1.4.
*/
void
svn_auth_get_ssl_client_cert_file_provider(
svn_auth_provider_object_t **provider,
apr_pool_t *pool);
src/subversion/subversion/include/svn_auth.h view on Meta::CPAN
SVN_DEPRECATED
void
svn_auth_get_ssl_client_cert_pw_file_provider(
svn_auth_provider_object_t **provider,
apr_pool_t *pool);
/** Set @a *provider to an authentication provider of type @c
* svn_auth_cred_ssl_server_trust_t, allocated in @a pool.
*
* @a *provider retrieves its credentials by using the @a prompt_func
* and @a prompt_baton. The returned credential is used to override
* SSL security on an error.
*
* @since New in 1.4.
*/
void
svn_auth_get_ssl_server_trust_prompt_provider(
svn_auth_provider_object_t **provider,
svn_auth_ssl_server_trust_prompt_func_t prompt_func,
void *prompt_baton,
apr_pool_t *pool);
/** Set @a *provider to an authentication provider of type @c
* svn_auth_cred_ssl_client_cert_t, allocated in @a pool.
*
* @a *provider retrieves its credentials by using the @a prompt_func
* and @a prompt_baton. The returned credential is used to load the
* appropriate client certificate for authentication when requested by
* a server. The prompt will be retried @a retry_limit times. For
* infinite retries, set @a retry_limit to value less than 0.
*
* @since New in 1.4.
*/
void
svn_auth_get_ssl_client_cert_prompt_provider(
svn_auth_provider_object_t **provider,
svn_auth_ssl_client_cert_prompt_func_t prompt_func,
void *prompt_baton,
int retry_limit,
apr_pool_t *pool);
/** Set @a *provider to an authentication provider of type @c
* svn_auth_cred_ssl_client_cert_pw_t, allocated in @a pool.
*
* @a *provider retrieves its credentials by using the @a prompt_func
* and @a prompt_baton. The returned credential is used when a loaded
* client certificate is protected by a passphrase. The prompt will
* be retried @a retry_limit times. For infinite retries, set
* @a retry_limit to value less than 0.
*
* @since New in 1.4.
*/
void
svn_auth_get_ssl_client_cert_pw_prompt_provider(
svn_auth_provider_object_t **provider,
src/subversion/subversion/include/svn_client.h view on Meta::CPAN
*/
/** Create and return @a *provider, an authentication provider of type
* svn_auth_cred_simple_t that gets information by prompting the user
* with @a prompt_func and @a prompt_baton. Allocate @a *provider in
* @a pool.
*
* If both #SVN_AUTH_PARAM_DEFAULT_USERNAME and
* #SVN_AUTH_PARAM_DEFAULT_PASSWORD are defined as runtime
* parameters in the @c auth_baton, then @a *provider will return the
* default arguments when svn_auth_first_credentials() is called. If
* svn_auth_first_credentials() fails, then @a *provider will
* re-prompt @a retry_limit times (via svn_auth_next_credentials()).
* For infinite retries, set @a retry_limit to value less than 0.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_simple_prompt_provider() instead.
*/
SVN_DEPRECATED
void
svn_client_get_simple_prompt_provider(
svn_auth_provider_object_t **provider,
svn_auth_simple_prompt_func_t prompt_func,
src/subversion/subversion/include/svn_client.h view on Meta::CPAN
apr_pool_t *pool);
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_username_t that gets information by prompting the
* user with @a prompt_func and @a prompt_baton. Allocate @a *provider
* in @a pool.
*
* If #SVN_AUTH_PARAM_DEFAULT_USERNAME is defined as a runtime
* parameter in the @c auth_baton, then @a *provider will return the
* default argument when svn_auth_first_credentials() is called. If
* svn_auth_first_credentials() fails, then @a *provider will
* re-prompt @a retry_limit times (via svn_auth_next_credentials()).
* For infinite retries, set @a retry_limit to value less than 0.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_username_prompt_provider() instead.
*/
SVN_DEPRECATED
void
svn_client_get_username_prompt_provider(
svn_auth_provider_object_t **provider,
svn_auth_username_prompt_func_t prompt_func,
src/subversion/subversion/include/svn_client.h view on Meta::CPAN
apr_pool_t *pool);
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_simple_t that gets/sets information from the user's
* ~/.subversion configuration directory. Allocate @a *provider in
* @a pool.
*
* If a default username or password is available, @a *provider will
* honor them as well, and return them when
* svn_auth_first_credentials() is called. (see
* #SVN_AUTH_PARAM_DEFAULT_USERNAME and #SVN_AUTH_PARAM_DEFAULT_PASSWORD).
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_simple_provider2() instead.
*/
SVN_DEPRECATED
void
svn_client_get_simple_provider(svn_auth_provider_object_t **provider,
apr_pool_t *pool);
src/subversion/subversion/include/svn_client.h view on Meta::CPAN
svn_client_get_windows_simple_provider(svn_auth_provider_object_t **provider,
apr_pool_t *pool);
#endif /* WIN32 && !__MINGW32__ || DOXYGEN || CTYPESGEN || SWIG */
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_username_t that gets/sets information from a user's
* ~/.subversion configuration directory. Allocate @a *provider in
* @a pool.
*
* If a default username is available, @a *provider will honor it,
* and return it when svn_auth_first_credentials() is called. (see
* #SVN_AUTH_PARAM_DEFAULT_USERNAME).
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_username_provider() instead.
*/
SVN_DEPRECATED
void
svn_client_get_username_provider(svn_auth_provider_object_t **provider,
apr_pool_t *pool);
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_ssl_server_trust_t, allocated in @a pool.
*
* @a *provider retrieves its credentials from the configuration
* mechanism. The returned credential is used to override SSL
* security on an error.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_ssl_server_trust_file_provider() instead.
*/
SVN_DEPRECATED
void
svn_client_get_ssl_server_trust_file_provider(
svn_auth_provider_object_t **provider,
apr_pool_t *pool);
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_ssl_client_cert_t, allocated in @a pool.
*
* @a *provider retrieves its credentials from the configuration
* mechanism. The returned credential is used to load the appropriate
* client certificate for authentication when requested by a server.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_ssl_client_cert_file_provider() instead.
*/
SVN_DEPRECATED
void
svn_client_get_ssl_client_cert_file_provider(
svn_auth_provider_object_t **provider,
apr_pool_t *pool);
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_ssl_client_cert_pw_t, allocated in @a pool.
*
* @a *provider retrieves its credentials from the configuration
* mechanism. The returned credential is used when a loaded client
* certificate is protected by a passphrase.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_ssl_client_cert_pw_file_provider2() instead.
*/
SVN_DEPRECATED
void
svn_client_get_ssl_client_cert_pw_file_provider(
svn_auth_provider_object_t **provider,
apr_pool_t *pool);
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_ssl_server_trust_t, allocated in @a pool.
*
* @a *provider retrieves its credentials by using the @a prompt_func
* and @a prompt_baton. The returned credential is used to override
* SSL security on an error.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_ssl_server_trust_prompt_provider() instead.
*/
SVN_DEPRECATED
void
svn_client_get_ssl_server_trust_prompt_provider(
svn_auth_provider_object_t **provider,
svn_auth_ssl_server_trust_prompt_func_t prompt_func,
void *prompt_baton,
apr_pool_t *pool);
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_ssl_client_cert_t, allocated in @a pool.
*
* @a *provider retrieves its credentials by using the @a prompt_func
* and @a prompt_baton. The returned credential is used to load the
* appropriate client certificate for authentication when requested by
* a server. The prompt will be retried @a retry_limit times.
* For infinite retries, set @a retry_limit to value less than 0.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_ssl_client_cert_prompt_provider() instead.
*/
SVN_DEPRECATED
void
src/subversion/subversion/include/svn_client.h view on Meta::CPAN
svn_auth_provider_object_t **provider,
svn_auth_ssl_client_cert_prompt_func_t prompt_func,
void *prompt_baton,
int retry_limit,
apr_pool_t *pool);
/** Create and return @a *provider, an authentication provider of type
* #svn_auth_cred_ssl_client_cert_pw_t, allocated in @a pool.
*
* @a *provider retrieves its credentials by using the @a prompt_func
* and @a prompt_baton. The returned credential is used when a loaded
* client certificate is protected by a passphrase. The prompt will
* be retried @a retry_limit times. For infinite retries, set @a retry_limit
* to value less than 0.
*
* @deprecated Provided for backward compatibility with the 1.3 API.
* Use svn_auth_get_ssl_client_cert_pw_prompt_provider() instead.
*/
SVN_DEPRECATED
void
src/subversion/subversion/include/svn_config.h view on Meta::CPAN
const char *config_dir,
apr_pool_t *pool);
/** Use @a cred_kind and @a realmstring to create or overwrite a file
* within the ~/.subversion/auth/ area. Write the contents of @a hash into
* the file. If @a config_dir is not NULL it specifies a directory to read
* the config overriding all other sources.
*
* Also, add @a realmstring to the file, with key @c
* SVN_CONFIG_REALMSTRING_KEY. This allows programs (or users) to
* verify exactly which set credentials live within the file.
*
* The hashtable must contain <tt>const char *</tt> keys and
* <tt>svn_string_t *</tt> values.
*/
svn_error_t *
svn_config_write_auth_data(apr_hash_t *hash,
const char *cred_kind,
const char *realmstring,
const char *config_dir,
apr_pool_t *pool);
/** Callback for svn_config_walk_auth_data().
*
* Called for each credential walked by that function (and able to be
* fully purged) to allow perusal and selective removal of credentials.
*
* @a cred_kind and @a realmstring specify the key of the credential.
* @a hash contains the hash data associated with the record.
*
* Before returning set @a *delete_cred to TRUE to remove the credential from
* the cache; leave @a *delete_cred unchanged or set it to FALSE to keep the
* credential.
*
* Implementations may return #SVN_ERR_CEASE_INVOCATION to indicate
* that the callback should not be called again. Note that when that
src/subversion/subversion/include/svn_config.h view on Meta::CPAN
* each credential cached within the Subversion auth store located
* under @a config_dir. If the callback sets its delete_cred return
* flag, delete the associated credential.
*
* If @a config_dir is not NULL, it must point to an alternative
* config directory location. If it is NULL, the default location
* is used.
*
* @note @a config_dir may only be NULL in 1.8.2 and later.
*
* @note Removing credentials from the config-based disk store will
* not purge them from any open svn_auth_baton_t instance. Consider
* using svn_auth_forget_credentials() -- from the @a cleanup_func,
* even -- for this purpose.
*
* @note Removing credentials from the config-based disk store will
* not also remove any related credentials from third-party password
* stores. (Implementations of @a walk_func which delete credentials
* may wish to consult the "passtype" element of @a hash, if any, to
* see if a third-party store -- such as "gnome-keyring" or "kwallet"
* is being used to hold the most sensitive portion of the credentials
* for this @a cred_kind and @a realmstring.)
*
* @see svn_auth_forget_credentials()
*
* @since New in 1.8.
*/
svn_error_t *
svn_config_walk_auth_data(const char *config_dir,
svn_config_auth_walk_func_t walk_func,
void *walk_baton,
apr_pool_t *scratch_pool);
/** Put the absolute path to the user's configuration directory,
src/subversion/subversion/include/svn_ra.h view on Meta::CPAN
/** Open a unique temporary file for writing in the working copy.
* This file will be automatically deleted when @a fp is closed.
*
* @deprecated This callback should no longer be used by RA layers.
*/
svn_error_t *(*open_tmp_file)(apr_file_t **fp,
void *callback_baton,
apr_pool_t *pool);
/** An authentication baton, created by the application, which is
* capable of retrieving all known types of credentials.
*/
svn_auth_baton_t *auth_baton;
/*** The following items may be set to NULL to disallow the RA layer
to perform the respective operations of the vtable functions.
Perhaps WC props are not defined or are in invalid for this
session, or perhaps the commit operation this RA session will
perform is a server-side only one that shouldn't do post-commit
processing on a working copy path. ***/
src/subversion/subversion/include/svn_repos.h view on Meta::CPAN
{
/** No access. */
svn_authz_none = 0,
/** Path can be read. */
svn_authz_read = 1,
/** Path can be altered. */
svn_authz_write = 2,
/** The other access credentials are recursive. */
svn_authz_recursive = 4
} svn_repos_authz_access_t;
/** Callback type for checking authorization on paths produced by
* the repository commit editor.
*
* Set @a *allowed to TRUE to indicate that the @a required access on
* @a path in @a root is authorized, or set it to FALSE to indicate
* unauthorized (presumable according to state stored in @a baton).
src/subversion/subversion/libsvn_auth_gnome_keyring/gnome_keyring.c view on Meta::CPAN
}
if (result != GNOME_KEYRING_RESULT_OK)
{
svn_hash_sets(parameters, "gnome-keyring-opening-failed", "");
}
*done = (result == GNOME_KEYRING_RESULT_OK);
return SVN_NO_ERROR;
}
/* Get cached encrypted credentials from the simple provider's cache. */
static svn_error_t *
simple_gnome_keyring_first_creds(void **credentials,
void **iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
return svn_auth__simple_creds_cache_get(credentials,
iter_baton, provider_baton,
parameters, realmstring,
password_get_gnome_keyring,
SVN_AUTH__GNOME_KEYRING_PASSWORD_TYPE,
pool);
}
/* Save encrypted credentials to the simple provider's cache. */
static svn_error_t *
simple_gnome_keyring_save_creds(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
return svn_auth__simple_creds_cache_set(saved, credentials,
provider_baton, parameters,
realmstring,
password_set_gnome_keyring,
SVN_AUTH__GNOME_KEYRING_PASSWORD_TYPE,
pool);
}
#if GLIB_CHECK_VERSION(2,6,0)
static void
log_noop(const gchar *log_domain, GLogLevelFlags log_level,
src/subversion/subversion/libsvn_auth_gnome_keyring/gnome_keyring.c view on Meta::CPAN
init_gnome_keyring();
}
/*-----------------------------------------------------------------------*/
/* GNOME Keyring SSL client certificate passphrase provider, */
/* puts passphrases in GNOME Keyring */
/*-----------------------------------------------------------------------*/
/* Get cached encrypted credentials from the ssl client cert password
provider's cache. */
static svn_error_t *
ssl_client_cert_pw_gnome_keyring_first_creds(void **credentials,
void **iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
return svn_auth__ssl_client_cert_pw_cache_get(
credentials, iter_baton, provider_baton, parameters, realmstring,
password_get_gnome_keyring, SVN_AUTH__GNOME_KEYRING_PASSWORD_TYPE,
pool);
}
/* Save encrypted credentials to the ssl client cert password provider's
cache. */
static svn_error_t *
ssl_client_cert_pw_gnome_keyring_save_creds(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
return svn_auth__ssl_client_cert_pw_cache_set(
saved, credentials, provider_baton, parameters, realmstring,
password_set_gnome_keyring, SVN_AUTH__GNOME_KEYRING_PASSWORD_TYPE,
pool);
}
static const svn_auth_provider_t gnome_keyring_ssl_client_cert_pw_provider = {
SVN_AUTH_CRED_SSL_CLIENT_CERT_PW,
ssl_client_cert_pw_gnome_keyring_first_creds,
NULL,
ssl_client_cert_pw_gnome_keyring_save_creds
};
src/subversion/subversion/libsvn_auth_kwallet/kwallet.cpp view on Meta::CPAN
}
}
}
apr_pool_cleanup_register(pool, parameters, kwallet_terminate,
apr_pool_cleanup_null);
return SVN_NO_ERROR;
}
/* Get cached encrypted credentials from the simple provider's cache. */
static svn_error_t *
kwallet_simple_first_creds(void **credentials,
void **iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
return svn_auth__simple_creds_cache_get(credentials,
iter_baton,
provider_baton,
parameters,
realmstring,
kwallet_password_get,
SVN_AUTH__KWALLET_PASSWORD_TYPE,
pool);
}
/* Save encrypted credentials to the simple provider's cache. */
static svn_error_t *
kwallet_simple_save_creds(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
return svn_auth__simple_creds_cache_set(saved, credentials,
provider_baton,
parameters,
realmstring,
kwallet_password_set,
SVN_AUTH__KWALLET_PASSWORD_TYPE,
pool);
}
static const svn_auth_provider_t kwallet_simple_provider = {
SVN_AUTH_CRED_SIMPLE,
src/subversion/subversion/libsvn_auth_kwallet/kwallet.cpp view on Meta::CPAN
*provider = po;
}
}
/*-----------------------------------------------------------------------*/
/* KWallet SSL client certificate passphrase provider, */
/* puts passphrases in KWallet */
/*-----------------------------------------------------------------------*/
/* Get cached encrypted credentials from the ssl client cert password
provider's cache. */
static svn_error_t *
kwallet_ssl_client_cert_pw_first_creds(void **credentials,
void **iter_baton,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
return svn_auth__ssl_client_cert_pw_cache_get(credentials,
iter_baton, provider_baton,
parameters, realmstring,
kwallet_password_get,
SVN_AUTH__KWALLET_PASSWORD_TYPE,
pool);
}
/* Save encrypted credentials to the ssl client cert password provider's
cache. */
static svn_error_t *
kwallet_ssl_client_cert_pw_save_creds(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
apr_pool_t *pool)
{
return svn_auth__ssl_client_cert_pw_cache_set(saved, credentials,
provider_baton, parameters,
realmstring,
kwallet_password_set,
SVN_AUTH__KWALLET_PASSWORD_TYPE,
pool);
}
static const svn_auth_provider_t kwallet_ssl_client_cert_pw_provider = {
SVN_AUTH_CRED_SSL_CLIENT_CERT_PW,
kwallet_ssl_client_cert_pw_first_creds,
src/subversion/subversion/libsvn_ra_local/ra_plugin.c view on Meta::CPAN
if (! sess->username)
{
/* Get a username somehow, so we have some svn:author property to
attach to a commit. */
if (sess->callbacks->auth_baton)
{
void *creds;
svn_auth_cred_username_t *username_creds;
svn_auth_iterstate_t *iterstate;
SVN_ERR(svn_auth_first_credentials(&creds, &iterstate,
SVN_AUTH_CRED_USERNAME,
sess->uuid, /* realmstring */
sess->callbacks->auth_baton,
scratch_pool));
/* No point in calling next_creds(), since that assumes that the
first_creds() somehow failed to authenticate. But there's no
challenge going on, so we use whatever creds we get back on
the first try. */
username_creds = creds;
if (username_creds && username_creds->username)
{
sess->username = apr_pstrdup(session->pool,
username_creds->username);
svn_error_clear(svn_auth_save_credentials(iterstate,
scratch_pool));
}
else
sess->username = "";
}
else
sess->username = "";
}
/* If we have a real username, attach it to the filesystem so that it can
src/subversion/subversion/libsvn_ra_serf/ra_serf.h view on Meta::CPAN
apr_pool_t *pool);
/* Implements svn_ra__vtable_t.register_editor_shim_callbacks(). */
svn_error_t *
svn_ra_serf__register_editor_shim_callbacks(svn_ra_session_t *session,
svn_delta_shim_callbacks_t *callbacks);
/*** Authentication handler declarations ***/
/**
* Callback function that loads the credentials for Basic and Digest
* authentications, both for server and proxy authentication.
*/
apr_status_t
svn_ra_serf__credentials_callback(char **username, char **password,
serf_request_t *request, void *baton,
int code, const char *authn_type,
const char *realm,
apr_pool_t *pool);
/*** General utility functions ***/
/**
* Convert an HTTP STATUS_CODE resulting from a WebDAV request against
src/subversion/subversion/libsvn_ra_serf/serf.c view on Meta::CPAN
else /* chunked_requests == svn_tristate_false */
{
session->detect_chunking = FALSE;
session->using_chunked_requests = FALSE;
}
/* Setup authentication. */
SVN_ERR(load_http_auth_types(pool, config, server_group,
&session->authn_types));
serf_config_authn_types(session->context, session->authn_types);
serf_config_credentials_callback(session->context,
svn_ra_serf__credentials_callback);
return SVN_NO_ERROR;
}
#undef DEFAULT_HTTP_TIMEOUT
static void
svn_ra_serf__progress(void *progress_baton, apr_off_t read, apr_off_t written)
{
const svn_ra_serf__session_t *serf_sess = progress_baton;
if (serf_sess->progress_func)
( run in 0.399 second using v1.01-cache-2.11-cpan-a5abf4f5562 )