void
svn_cl__check_boolean_prop_val(const char *propname, const char *propval,
apr_pool_t *pool)
{
svn_stringbuf_t *propbuf;
if (!svn_prop_is_boolean(propname))
return;
propbuf = svn_stringbuf_create(propval, pool);
svn_stringbuf_strip_whitespace(propbuf);
if (propbuf->data[0] == '\0'
|| svn_cstring_casecmp(propbuf->data, "0") == 0
|| svn_cstring_casecmp(propbuf->data, "no") == 0
|| svn_cstring_casecmp(propbuf->data, "off") == 0
|| svn_cstring_casecmp(propbuf->data, "false") == 0)
{
svn_error_t *err = svn_error_createf
(SVN_ERR_BAD_PROPERTY_VALUE, NULL,
_("To turn off the %s property, use 'svn propdel';\n"
"setting the property to '%s' will not turn it off."),
propname, propval);
svn_handle_warning2(stderr, err, "svn: ");
svn_error_clear(err);
}
}
svn_error_t *
svn_config_get_tristate(svn_config_t *cfg, svn_tristate_t *valuep,
const char *section, const char *option,
const char *unknown_value,
svn_tristate_t default_value)
{
const char *tmp_value;
svn_config_get(cfg, &tmp_value, section, option, NULL);
if (! tmp_value)
{
*valuep = default_value;
}
else if (0 == svn_cstring_casecmp(tmp_value, unknown_value))
{
*valuep = svn_tristate_unknown;
}
else
{
svn_boolean_t bool_val;
/* We already incorporated default_value into tmp_value if
necessary, so the FALSE below will be ignored unless the
caller is doing something it shouldn't be doing. */
SVN_ERR(get_bool(&bool_val, tmp_value, FALSE, section, option));
*valuep = bool_val ? svn_tristate_true : svn_tristate_false;
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_config_get_yes_no_ask(svn_config_t *cfg, const char **valuep,
const char *section, const char *option,
const char* default_value)
{
const char *tmp_value;
svn_config_get(cfg, &tmp_value, section, option, NULL);
if (! tmp_value)
tmp_value = default_value;
if (tmp_value && (0 == svn_cstring_casecmp(tmp_value, SVN_CONFIG_ASK)))
{
*valuep = SVN_CONFIG_ASK;
}
else
{
svn_boolean_t bool_val;
/* We already incorporated default_value into tmp_value if
necessary, so the FALSE below will be ignored unless the
caller is doing something it shouldn't be doing. */
SVN_ERR(get_bool(&bool_val, tmp_value, FALSE, section, option));
*valuep = bool_val ? SVN_CONFIG_TRUE : SVN_CONFIG_FALSE;
}
return SVN_NO_ERROR;
}
/* Load the setting http-auth-types from the global or server specific
section, parse its value and set the types of authentication we should
accept from the server. */
static svn_error_t *
load_http_auth_types(apr_pool_t *pool, svn_config_t *config,
const char *server_group,
int *authn_types)
{
const char *http_auth_types = NULL;
*authn_types = SERF_AUTHN_NONE;
svn_config_get(config, &http_auth_types, SVN_CONFIG_SECTION_GLOBAL,
SVN_CONFIG_OPTION_HTTP_AUTH_TYPES, NULL);
if (server_group)
{
svn_config_get(config, &http_auth_types, server_group,
SVN_CONFIG_OPTION_HTTP_AUTH_TYPES, http_auth_types);
}
if (http_auth_types)
{
char *token;
char *auth_types_list = apr_palloc(pool, strlen(http_auth_types) + 1);
apr_collapse_spaces(auth_types_list, http_auth_types);
while ((token = svn_cstring_tokenize(";", &auth_types_list)) != NULL)
{
if (svn_cstring_casecmp("basic", token) == 0)
*authn_types |= SERF_AUTHN_BASIC;
else if (svn_cstring_casecmp("digest", token) == 0)
*authn_types |= SERF_AUTHN_DIGEST;
else if (svn_cstring_casecmp("ntlm", token) == 0)
*authn_types |= SERF_AUTHN_NTLM;
else if (svn_cstring_casecmp("negotiate", token) == 0)
*authn_types |= SERF_AUTHN_NEGOTIATE;
else
return svn_error_createf(SVN_ERR_BAD_CONFIG_VALUE, NULL,
_("Invalid config: unknown %s "
"'%s'"),
SVN_CONFIG_OPTION_HTTP_AUTH_TYPES, token);
}
}
else
{
/* Nothing specified by the user, so accept all types. */
*authn_types = SERF_AUTHN_ALL;
}
return SVN_NO_ERROR;
}
/* If WORD matches one of the special revision descriptors,
* case-insensitively, set *REVISION accordingly:
*
* - For "head", set REVISION->kind to svn_opt_revision_head.
*
* - For "prev", set REVISION->kind to svn_opt_revision_previous.
*
* - For "base", set REVISION->kind to svn_opt_revision_base.
*
* - For "committed", set REVISION->kind to svn_opt_revision_committed.
*
* If match, return 0, else return -1 and don't touch REVISION.
*/
static int
revision_from_word(svn_opt_revision_t *revision, const char *word)
{
if (svn_cstring_casecmp(word, "head") == 0)
{
revision->kind = svn_opt_revision_head;
}
else if (svn_cstring_casecmp(word, "prev") == 0)
{
revision->kind = svn_opt_revision_previous;
}
else if (svn_cstring_casecmp(word, "base") == 0)
{
revision->kind = svn_opt_revision_base;
}
else if (svn_cstring_casecmp(word, "committed") == 0)
{
revision->kind = svn_opt_revision_committed;
}
else
return -1;
return 0;
}
svn_tristate_t
svn_tristate__from_word(const char *word)
{
if (word == NULL)
return svn_tristate_unknown;
else if (0 == svn_cstring_casecmp(word, "true")
|| 0 == svn_cstring_casecmp(word, "yes")
|| 0 == svn_cstring_casecmp(word, "on")
|| 0 == strcmp(word, "1"))
return svn_tristate_true;
else if (0 == svn_cstring_casecmp(word, "false")
|| 0 == svn_cstring_casecmp(word, "no")
|| 0 == svn_cstring_casecmp(word, "off")
|| 0 == strcmp(word, "0"))
return svn_tristate_false;
return svn_tristate_unknown;
}
/* Set *BOOLP to true or false depending (case-insensitively) on INPUT.
If INPUT is null, set *BOOLP to DEFAULT_VALUE.
INPUT is a string indicating truth or falsehood in any of the usual
ways: "true"/"yes"/"on"/etc, "false"/"no"/"off"/etc.
If INPUT is neither NULL nor a recognized string, return an error
with code SVN_ERR_BAD_CONFIG_VALUE; use SECTION and OPTION in
constructing the error string. */
static svn_error_t *
get_bool(svn_boolean_t *boolp, const char *input, svn_boolean_t default_value,
const char *section, const char *option)
{
if (input == NULL)
{
*boolp = default_value;
}
else if (0 == svn_cstring_casecmp(input, SVN_CONFIG_TRUE)
|| 0 == svn_cstring_casecmp(input, "yes")
|| 0 == svn_cstring_casecmp(input, "on")
|| 0 == strcmp(input, "1"))
{
*boolp = TRUE;
}
else if (0 == svn_cstring_casecmp(input, SVN_CONFIG_FALSE)
|| 0 == svn_cstring_casecmp(input, "no")
|| 0 == svn_cstring_casecmp(input, "off")
|| 0 == strcmp(input, "0"))
{
*boolp = FALSE;
}
else /* unrecognized value */
{
if (section)
{
return svn_error_createf(SVN_ERR_BAD_CONFIG_VALUE, NULL,
_("Config error: invalid boolean "
"value '%s' for '[%s] %s'"),
input, section, option);
}
else
{
return svn_error_createf(SVN_ERR_BAD_CONFIG_VALUE, NULL,
_("Config error: invalid boolean "
"value '%s' for '%s'"),
input, option);
}
}
return SVN_NO_ERROR;
}
/* This implements serf_bucket_headers_do_callback_fn_t.
*/
static int
capabilities_headers_iterator_callback(void *baton,
const char *key,
const char *val)
{
options_context_t *opt_ctx = baton;
svn_ra_serf__session_t *session = opt_ctx->session;
if (svn_cstring_casecmp(key, "dav") == 0)
{
/* Each header may contain multiple values, separated by commas, e.g.:
DAV: version-control,checkout,working-resource
DAV: merge,baseline,activity,version-controlled-collection
DAV: http://subversion.tigris.org/xmlns/dav/svn/depth */
apr_array_header_t *vals = svn_cstring_split(val, ",", TRUE,
opt_ctx->pool);
opt_ctx->received_dav_header = TRUE;
/* Right now we only have a few capabilities to detect, so just
seek for them directly. This could be written slightly more
efficiently, but that wouldn't be worth it until we have many
more capabilities. */
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_DEPTH, vals))
{
svn_hash_sets(session->capabilities,
SVN_RA_CAPABILITY_DEPTH, capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_MERGEINFO, vals))
{
/* The server doesn't know what repository we're referring
to, so it can't just say capability_yes. */
if (!svn_hash_gets(session->capabilities,
SVN_RA_CAPABILITY_MERGEINFO))
{
svn_hash_sets(session->capabilities, SVN_RA_CAPABILITY_MERGEINFO,
capability_server_yes);
}
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_LOG_REVPROPS, vals))
{
svn_hash_sets(session->capabilities,
SVN_RA_CAPABILITY_LOG_REVPROPS, capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_ATOMIC_REVPROPS, vals))
{
svn_hash_sets(session->capabilities,
SVN_RA_CAPABILITY_ATOMIC_REVPROPS, capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_PARTIAL_REPLAY, vals))
{
svn_hash_sets(session->capabilities,
SVN_RA_CAPABILITY_PARTIAL_REPLAY, capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_INHERITED_PROPS, vals))
{
svn_hash_sets(session->capabilities,
SVN_RA_CAPABILITY_INHERITED_PROPS, capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_REVERSE_FILE_REVS,
vals))
{
svn_hash_sets(session->capabilities,
SVN_RA_CAPABILITY_GET_FILE_REVS_REVERSE,
capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_EPHEMERAL_TXNPROPS, vals))
{
svn_hash_sets(session->capabilities,
SVN_RA_CAPABILITY_EPHEMERAL_TXNPROPS, capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_INLINE_PROPS, vals))
{
session->supports_inline_props = TRUE;
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_REPLAY_REV_RESOURCE, vals))
{
session->supports_rev_rsrc_replay = TRUE;
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_SVNDIFF1, vals))
{
/* Use compressed svndiff1 format for servers that properly
advertise this capability (Subversion 1.10 and greater). */
session->supports_svndiff1 = TRUE;
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_LIST, vals))
{
svn_hash_sets(session->capabilities,
SVN_RA_CAPABILITY_LIST, capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_SVNDIFF2, vals))
{
/* Same for svndiff2. */
session->supports_svndiff2 = TRUE;
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_PUT_RESULT_CHECKSUM, vals))
{
session->supports_put_result_checksum = TRUE;
}
}
/* SVN-specific headers -- if present, server supports HTTP protocol v2 */
else if (!svn_ctype_casecmp(key[0], 'S')
&& !svn_ctype_casecmp(key[1], 'V')
&& !svn_ctype_casecmp(key[2], 'N'))
{
/* If we've not yet seen any information about supported POST
requests, we'll initialize the list/hash with "create-txn"
(which we know is supported by virtue of the server speaking
HTTPv2 at all. */
if (! session->supported_posts)
{
session->supported_posts = apr_hash_make(session->pool);
apr_hash_set(session->supported_posts, "create-txn", 10, (void *)1);
}
if (svn_cstring_casecmp(key, SVN_DAV_ROOT_URI_HEADER) == 0)
{
session->repos_root = session->session_url;
session->repos_root.path =
(char *)svn_fspath__canonicalize(val, session->pool);
session->repos_root_str =
svn_urlpath__canonicalize(
apr_uri_unparse(session->pool, &session->repos_root, 0),
session->pool);
}
else if (svn_cstring_casecmp(key, SVN_DAV_ME_RESOURCE_HEADER) == 0)
{
#ifdef SVN_DEBUG
char *ignore_v2_env_var = getenv(SVN_IGNORE_V2_ENV_VAR);
if (!(ignore_v2_env_var
&& apr_strnatcasecmp(ignore_v2_env_var, "yes") == 0))
session->me_resource = apr_pstrdup(session->pool, val);
#else
session->me_resource = apr_pstrdup(session->pool, val);
#endif
}
else if (svn_cstring_casecmp(key, SVN_DAV_REV_STUB_HEADER) == 0)
{
session->rev_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_REV_ROOT_STUB_HEADER) == 0)
{
session->rev_root_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_TXN_STUB_HEADER) == 0)
{
session->txn_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_TXN_ROOT_STUB_HEADER) == 0)
{
session->txn_root_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_VTXN_STUB_HEADER) == 0)
{
session->vtxn_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_VTXN_ROOT_STUB_HEADER) == 0)
{
session->vtxn_root_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_REPOS_UUID_HEADER) == 0)
{
session->uuid = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_YOUNGEST_REV_HEADER) == 0)
{
opt_ctx->youngest_rev = SVN_STR_TO_REV(val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_ALLOW_BULK_UPDATES) == 0)
{
session->server_allows_bulk = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_SUPPORTED_POSTS_HEADER) == 0)
{
/* May contain multiple values, separated by commas. */
int i;
apr_array_header_t *vals = svn_cstring_split(val, ",", TRUE,
session->pool);
for (i = 0; i < vals->nelts; i++)
{
const char *post_val = APR_ARRAY_IDX(vals, i, const char *);
svn_hash_sets(session->supported_posts, post_val, (void *)1);
}
}
else if (svn_cstring_casecmp(key, SVN_DAV_REPOSITORY_MERGEINFO) == 0)
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)
{
svn_auth_cred_ssl_client_cert_pw_t *creds = credentials;
apr_hash_t *creds_hash = NULL;
const char *config_dir;
svn_error_t *err;
svn_boolean_t dont_store_passphrase =
svn_hash_gets(parameters, SVN_AUTH_PARAM_DONT_STORE_SSL_CLIENT_CERT_PP)
!= NULL;
svn_boolean_t non_interactive =
svn_hash_gets(parameters, SVN_AUTH_PARAM_NON_INTERACTIVE) != NULL;
svn_boolean_t no_auth_cache =
(! creds->may_save)
|| (svn_hash_gets(parameters, SVN_AUTH_PARAM_NO_AUTH_CACHE) != NULL);
*saved = FALSE;
if (no_auth_cache)
return SVN_NO_ERROR;
config_dir = svn_hash_gets(parameters, SVN_AUTH_PARAM_CONFIG_DIR);
creds_hash = apr_hash_make(pool);
/* Don't store passphrase in any form if the user has told
us not to do so. */
if (! dont_store_passphrase)
{
svn_boolean_t may_save_passphrase = FALSE;
/* If the passphrase is going to be stored encrypted, go right
ahead and store it to disk. Else determine whether saving
in plaintext is OK. */
if (strcmp(passtype, SVN_AUTH__WINCRYPT_PASSWORD_TYPE) == 0
|| strcmp(passtype, SVN_AUTH__KWALLET_PASSWORD_TYPE) == 0
|| strcmp(passtype, SVN_AUTH__GNOME_KEYRING_PASSWORD_TYPE) == 0
|| strcmp(passtype, SVN_AUTH__KEYCHAIN_PASSWORD_TYPE) == 0)
{
may_save_passphrase = TRUE;
}
else
{
#ifdef SVN_DISABLE_PLAINTEXT_PASSWORD_STORAGE
may_save_passphrase = FALSE;
#else
const char *store_ssl_client_cert_pp_plaintext =
svn_hash_gets(parameters,
SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT);
ssl_client_cert_pw_file_provider_baton_t *b =
(ssl_client_cert_pw_file_provider_baton_t *)provider_baton;
if (svn_cstring_casecmp(store_ssl_client_cert_pp_plaintext,
SVN_CONFIG_ASK) == 0)
{
if (non_interactive)
{
/* In non-interactive mode, the default behaviour is
to not store the passphrase */
may_save_passphrase = FALSE;
}
else if (b->plaintext_passphrase_prompt_func)
{
/* We're interactive, and the client provided a
prompt callback. So we can ask the user.
Check for a cached answer before prompting.
This is a pointer-to-boolean, rather than just a
boolean, because we must distinguish between
"cached answer is no" and "no answer has been
cached yet". */
svn_boolean_t *cached_answer =
svn_hash_gets(b->plaintext_answers, realmstring);
if (cached_answer != NULL)
{
may_save_passphrase = *cached_answer;
}
else
{
apr_pool_t *cached_answer_pool;
/* Nothing cached for this realm, prompt the user. */
SVN_ERR((*b->plaintext_passphrase_prompt_func)(
&may_save_passphrase,
realmstring,
b->prompt_baton,
pool));
/* Cache the user's answer in case we're called again
* for the same realm.
*
* We allocate the answer cache in the hash table's pool
* to make sure that is has the same life time as the
* hash table itself. This means that the answer will
* survive across RA sessions -- which is important,
* because otherwise we'd prompt users once per RA session.
*/
cached_answer_pool = apr_hash_pool_get(b->plaintext_answers);
cached_answer = apr_palloc(cached_answer_pool,
sizeof(*cached_answer));
*cached_answer = may_save_passphrase;
svn_hash_sets(b->plaintext_answers, realmstring,
cached_answer);
}
}
else
{
may_save_passphrase = FALSE;
}
}
else if (svn_cstring_casecmp(store_ssl_client_cert_pp_plaintext,
SVN_CONFIG_FALSE) == 0)
{
may_save_passphrase = FALSE;
}
else if (svn_cstring_casecmp(store_ssl_client_cert_pp_plaintext,
SVN_CONFIG_TRUE) == 0)
{
may_save_passphrase = TRUE;
}
else
{
return svn_error_createf
(SVN_ERR_RA_DAV_INVALID_CONFIG_VALUE, NULL,
_("Config error: invalid value '%s' for option '%s'"),
store_ssl_client_cert_pp_plaintext,
SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT);
}
#endif
}
if (may_save_passphrase)
{
SVN_ERR(passphrase_set(saved, creds_hash, realmstring,
NULL, creds->password, parameters,
non_interactive, pool));
if (*saved && passtype)
{
svn_hash_sets(creds_hash, AUTHN_PASSTYPE_KEY,
svn_string_create(passtype, pool));
}
/* Save credentials to disk. */
err = svn_config_write_auth_data(creds_hash,
SVN_AUTH_CRED_SSL_CLIENT_CERT_PW,
realmstring, config_dir, pool);
svn_error_clear(err);
*saved = ! err;
}
}
return SVN_NO_ERROR;
}
/* Standard svn test program */
int
main(int argc, const char *argv[])
{
const char *prog_name;
int i;
svn_boolean_t got_error = FALSE;
apr_pool_t *pool, *test_pool;
svn_boolean_t ran_a_test = FALSE;
svn_boolean_t list_mode = FALSE;
int opt_id;
apr_status_t apr_err;
apr_getopt_t *os;
svn_error_t *err;
char errmsg[200];
/* How many tests are there? */
int array_size = get_array_size();
svn_test_opts_t opts = { NULL };
opts.fs_type = DEFAULT_FS_TYPE;
/* Initialize APR (Apache pools) */
if (apr_initialize() != APR_SUCCESS)
{
printf("apr_initialize() failed.\n");
exit(1);
}
/* set up the global pool. Use a separate allocator to limit memory
* usage but make it thread-safe to allow for multi-threaded tests.
*/
pool = apr_allocator_owner_get(svn_pool_create_allocator(TRUE));
/* Remember the command line */
test_argc = argc;
test_argv = argv;
err = svn_cmdline__getopt_init(&os, argc, argv, pool);
os->interleave = TRUE; /* Let options and arguments be interleaved */
/* Strip off any leading path components from the program name. */
prog_name = strrchr(argv[0], '/');
if (prog_name)
prog_name++;
else
{
/* Just check if this is that weird platform that uses \ instead
of / for the path separator. */
prog_name = strrchr(argv[0], '\\');
if (prog_name)
prog_name++;
else
prog_name = argv[0];
}
if (err)
return svn_cmdline_handle_exit_error(err, pool, prog_name);
while (1)
{
const char *opt_arg;
/* Parse the next option. */
apr_err = apr_getopt_long(os, cl_options, &opt_id, &opt_arg);
if (APR_STATUS_IS_EOF(apr_err))
break;
else if (apr_err && (apr_err != APR_BADCH))
{
/* Ignore invalid option error to allow passing arbitary options */
fprintf(stderr, "apr_getopt_long failed : [%d] %s\n",
apr_err, apr_strerror(apr_err, errmsg, sizeof(errmsg)));
exit(1);
}
switch (opt_id) {
case cleanup_opt:
cleanup_mode = TRUE;
break;
case config_opt:
opts.config_file = apr_pstrdup(pool, opt_arg);
break;
case fstype_opt:
opts.fs_type = apr_pstrdup(pool, opt_arg);
break;
case list_opt:
list_mode = TRUE;
break;
case mode_filter_opt:
if (svn_cstring_casecmp(opt_arg, "PASS") == 0)
mode_filter = svn_test_pass;
else if (svn_cstring_casecmp(opt_arg, "XFAIL") == 0)
mode_filter = svn_test_xfail;
else if (svn_cstring_casecmp(opt_arg, "SKIP") == 0)
mode_filter = svn_test_skip;
else if (svn_cstring_casecmp(opt_arg, "ALL") == 0)
mode_filter = svn_test_all;
else
{
fprintf(stderr, "FAIL: Invalid --mode-filter option. Try ");
fprintf(stderr, " PASS, XFAIL, SKIP or ALL.\n");
exit(1);
}
break;
case verbose_opt:
verbose_mode = TRUE;
break;
case quiet_opt:
quiet_mode = TRUE;
break;
case allow_segfault_opt:
allow_segfaults = TRUE;
break;
case server_minor_version_opt:
{
char *end;
opts.server_minor_version = (int) strtol(opt_arg, &end, 10);
if (end == opt_arg || *end != '\0')
{
fprintf(stderr, "FAIL: Non-numeric minor version given\n");
exit(1);
}
if ((opts.server_minor_version < 3)
|| (opts.server_minor_version > 6))
{
fprintf(stderr, "FAIL: Invalid minor version given\n");
exit(1);
}
}
}
}
/* Disable sleeping for timestamps, to speed up the tests. */
apr_env_set(
"SVN_I_LOVE_CORRUPTED_WORKING_COPIES_SO_DISABLE_SLEEP_FOR_TIMESTAMPS",
"yes", pool);
/* You can't be both quiet and verbose. */
if (quiet_mode && verbose_mode)
{
fprintf(stderr, "FAIL: --verbose and --quiet are mutually exclusive\n");
exit(1);
}
/* Create an iteration pool for the tests */
cleanup_pool = svn_pool_create(pool);
test_pool = svn_pool_create(pool);
if (!allow_segfaults)
svn_error_set_malfunction_handler(svn_error_raise_on_malfunction);
if (argc >= 2) /* notice command-line arguments */
{
if (! strcmp(argv[1], "list") || list_mode)
{
const char *header_msg;
ran_a_test = TRUE;
/* run all tests with MSG_ONLY set to TRUE */
header_msg = "Test # Mode Test Description\n"
"------ ----- ----------------\n";
for (i = 1; i <= array_size; i++)
{
if (do_test_num(prog_name, i, TRUE, &opts, &header_msg,
test_pool))
got_error = TRUE;
/* Clear the per-function pool */
svn_pool_clear(test_pool);
svn_pool_clear(cleanup_pool);
}
}
else
{
for (i = 1; i < argc; i++)
{
if (svn_ctype_isdigit(argv[i][0]) || argv[i][0] == '-')
{
int test_num = atoi(argv[i]);
if (test_num == 0)
/* A --option argument, most likely. */
continue;
ran_a_test = TRUE;
if (do_test_num(prog_name, test_num, FALSE, &opts, NULL,
test_pool))
got_error = TRUE;
/* Clear the per-function pool */
svn_pool_clear(test_pool);
svn_pool_clear(cleanup_pool);
}
}
}
}
if (! ran_a_test)
{
/* just run all tests */
for (i = 1; i <= array_size; i++)
{
if (do_test_num(prog_name, i, FALSE, &opts, NULL, test_pool))
got_error = TRUE;
/* Clear the per-function pool */
svn_pool_clear(test_pool);
svn_pool_clear(cleanup_pool);
}
}
/* Clean up APR */
svn_pool_destroy(pool); /* takes test_pool with it */
apr_terminate();
return got_error;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__help(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = NULL;
svn_stringbuf_t *version_footer = NULL;
/* xgettext: the %s is for SVN_VER_NUMBER. */
char help_header_template[] =
N_("usage: svn <subcommand> [options] [args]\n"
"Subversion command-line client, version %s.\n"
"Type 'svn help <subcommand>' for help on a specific subcommand.\n"
"Type 'svn --version' to see the program version and RA modules\n"
" or 'svn --version --quiet' to see just the version number.\n"
"\n"
"Most subcommands take file and/or directory arguments, recursing\n"
"on the directories. If no arguments are supplied to such a\n"
"command, it recurses on the current directory (inclusive) by default.\n"
"\n"
"Available subcommands:\n");
char help_footer[] =
N_("Subversion is a tool for version control.\n"
"For additional information, see http://subversion.apache.org/\n");
char *help_header =
apr_psprintf(pool, _(help_header_template), SVN_VER_NUMBER);
const char *ra_desc_start
= _("The following repository access (RA) modules are available:\n\n");
if (baton)
{
svn_cl__cmd_baton_t *const cmd_baton = baton;
#ifndef SVN_DISABLE_PLAINTEXT_PASSWORD_STORAGE
/* Windows never actually stores plaintext passwords, it
encrypts the contents using CryptoAPI. ...
... If CryptoAPI is available ... but it should be on all
versions of Windows that are even remotely interesting two
days before the scheduled end of the world, when this comment
is being written. */
# ifndef WIN32
svn_boolean_t store_auth_creds =
SVN_CONFIG_DEFAULT_OPTION_STORE_AUTH_CREDS;
svn_boolean_t store_passwords =
SVN_CONFIG_DEFAULT_OPTION_STORE_PASSWORDS;
svn_boolean_t store_plaintext_passwords = FALSE;
svn_config_t *cfg;
if (cmd_baton->ctx->config)
{
cfg = svn_hash_gets(cmd_baton->ctx->config,
SVN_CONFIG_CATEGORY_CONFIG);
if (cfg)
{
SVN_ERR(svn_config_get_bool(cfg, &store_auth_creds,
SVN_CONFIG_SECTION_AUTH,
SVN_CONFIG_OPTION_STORE_AUTH_CREDS,
store_auth_creds));
SVN_ERR(svn_config_get_bool(cfg, &store_passwords,
SVN_CONFIG_SECTION_AUTH,
SVN_CONFIG_OPTION_STORE_PASSWORDS,
store_passwords));
}
cfg = svn_hash_gets(cmd_baton->ctx->config,
SVN_CONFIG_CATEGORY_SERVERS);
if (cfg)
{
const char *value;
SVN_ERR(svn_config_get_yes_no_ask
(cfg, &value,
SVN_CONFIG_SECTION_GLOBAL,
SVN_CONFIG_OPTION_STORE_PLAINTEXT_PASSWORDS,
SVN_CONFIG_DEFAULT_OPTION_STORE_PLAINTEXT_PASSWORDS));
if (0 == svn_cstring_casecmp(value, SVN_CONFIG_TRUE))
store_plaintext_passwords = TRUE;
}
}
if (store_plaintext_passwords && store_auth_creds && store_passwords)
{
version_footer = svn_stringbuf_create(
_("WARNING: Plaintext password storage is enabled!\n\n"),
pool);
svn_stringbuf_appendcstr(version_footer, ra_desc_start);
}
# endif /* !WIN32 */
#endif /* !SVN_DISABLE_PLAINTEXT_PASSWORD_STORAGE */
opt_state = cmd_baton->opt_state;
}
if (!version_footer)
version_footer = svn_stringbuf_create(ra_desc_start, pool);
SVN_ERR(svn_ra_print_modules(version_footer, pool));
return svn_opt_print_help4(os,
"svn", /* ### erm, derive somehow? */
opt_state ? opt_state->version : FALSE,
opt_state ? opt_state->quiet : FALSE,
opt_state ? opt_state->verbose : FALSE,
version_footer->data,
help_header, /* already gettext()'d */
svn_cl__cmd_table,
svn_cl__options,
svn_cl__global_options,
_(help_footer),
pool);
}
/* This implements serf_bucket_headers_do_callback_fn_t.
*/
static int
capabilities_headers_iterator_callback(void *baton,
const char *key,
const char *val)
{
options_context_t *opt_ctx = baton;
svn_ra_serf__session_t *session = opt_ctx->session;
if (svn_cstring_casecmp(key, "dav") == 0)
{
/* Each header may contain multiple values, separated by commas, e.g.:
DAV: version-control,checkout,working-resource
DAV: merge,baseline,activity,version-controlled-collection
DAV: http://subversion.tigris.org/xmlns/dav/svn/depth */
apr_array_header_t *vals = svn_cstring_split(val, ",", TRUE,
opt_ctx->pool);
/* Right now we only have a few capabilities to detect, so just
seek for them directly. This could be written slightly more
efficiently, but that wouldn't be worth it until we have many
more capabilities. */
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_DEPTH, vals))
{
apr_hash_set(session->capabilities,
SVN_RA_CAPABILITY_DEPTH, APR_HASH_KEY_STRING,
capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_MERGEINFO, vals))
{
/* The server doesn't know what repository we're referring
to, so it can't just say capability_yes. */
apr_hash_set(session->capabilities,
SVN_RA_CAPABILITY_MERGEINFO, APR_HASH_KEY_STRING,
capability_server_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_LOG_REVPROPS, vals))
{
apr_hash_set(session->capabilities,
SVN_RA_CAPABILITY_LOG_REVPROPS, APR_HASH_KEY_STRING,
capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_ATOMIC_REVPROPS, vals))
{
apr_hash_set(session->capabilities,
SVN_RA_CAPABILITY_ATOMIC_REVPROPS, APR_HASH_KEY_STRING,
capability_yes);
}
if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_PARTIAL_REPLAY, vals))
{
apr_hash_set(session->capabilities,
SVN_RA_CAPABILITY_PARTIAL_REPLAY, APR_HASH_KEY_STRING,
capability_yes);
}
}
/* SVN-specific headers -- if present, server supports HTTP protocol v2 */
else if (strncmp(key, "SVN", 3) == 0)
{
/* If we've not yet seen any information about supported POST
requests, we'll initialize the list/hash with "create-txn"
(which we know is supported by virtue of the server speaking
HTTPv2 at all. */
if (! session->supported_posts)
{
session->supported_posts = apr_hash_make(session->pool);
apr_hash_set(session->supported_posts, "create-txn", 10, (void *)1);
}
if (svn_cstring_casecmp(key, SVN_DAV_ROOT_URI_HEADER) == 0)
{
session->repos_root = session->session_url;
session->repos_root.path =
(char *)svn_fspath__canonicalize(val, session->pool);
session->repos_root_str =
svn_urlpath__canonicalize(
apr_uri_unparse(session->pool, &session->repos_root, 0),
session->pool);
}
else if (svn_cstring_casecmp(key, SVN_DAV_ME_RESOURCE_HEADER) == 0)
{
#ifdef SVN_DEBUG
char *ignore_v2_env_var = getenv(SVN_IGNORE_V2_ENV_VAR);
if (!(ignore_v2_env_var
&& apr_strnatcasecmp(ignore_v2_env_var, "yes") == 0))
session->me_resource = apr_pstrdup(session->pool, val);
#else
session->me_resource = apr_pstrdup(session->pool, val);
#endif
}
else if (svn_cstring_casecmp(key, SVN_DAV_REV_STUB_HEADER) == 0)
{
session->rev_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_REV_ROOT_STUB_HEADER) == 0)
{
session->rev_root_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_TXN_STUB_HEADER) == 0)
{
session->txn_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_TXN_ROOT_STUB_HEADER) == 0)
{
session->txn_root_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_VTXN_STUB_HEADER) == 0)
{
session->vtxn_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_VTXN_ROOT_STUB_HEADER) == 0)
{
session->vtxn_root_stub = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_REPOS_UUID_HEADER) == 0)
{
session->uuid = apr_pstrdup(session->pool, val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_YOUNGEST_REV_HEADER) == 0)
{
opt_ctx->youngest_rev = SVN_STR_TO_REV(val);
}
else if (svn_cstring_casecmp(key, SVN_DAV_SUPPORTED_POSTS_HEADER) == 0)
{
/* May contain multiple values, separated by commas. */
int i;
apr_array_header_t *vals = svn_cstring_split(val, ",", TRUE,
opt_ctx->pool);
for (i = 0; i < vals->nelts; i++)
{
const char *post_val = APR_ARRAY_IDX(vals, i, const char *);
apr_hash_set(session->supported_posts, post_val,
APR_HASH_KEY_STRING, (void *)1);
}
}
}
/* Implements svn_ra__vtable_t.open_session(). */
static svn_error_t *
svn_ra_serf__open(svn_ra_session_t *session,
const char **corrected_url,
const char *session_URL,
const svn_ra_callbacks2_t *callbacks,
void *callback_baton,
svn_auth_baton_t *auth_baton,
apr_hash_t *config,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_status_t status;
svn_ra_serf__session_t *serf_sess;
apr_uri_t url;
const char *client_string = NULL;
svn_error_t *err;
if (corrected_url)
*corrected_url = NULL;
serf_sess = apr_pcalloc(result_pool, sizeof(*serf_sess));
serf_sess->pool = result_pool;
if (config)
SVN_ERR(svn_config_copy_config(&serf_sess->config, config, result_pool));
else
serf_sess->config = NULL;
serf_sess->wc_callbacks = callbacks;
serf_sess->wc_callback_baton = callback_baton;
serf_sess->auth_baton = auth_baton;
serf_sess->progress_func = callbacks->progress_func;
serf_sess->progress_baton = callbacks->progress_baton;
serf_sess->cancel_func = callbacks->cancel_func;
serf_sess->cancel_baton = callback_baton;
/* todo: reuse serf context across sessions */
serf_sess->context = serf_context_create(serf_sess->pool);
SVN_ERR(svn_ra_serf__blncache_create(&serf_sess->blncache,
serf_sess->pool));
SVN_ERR(svn_ra_serf__uri_parse(&url, session_URL, serf_sess->pool));
if (!url.port)
{
url.port = apr_uri_port_of_scheme(url.scheme);
}
serf_sess->session_url = url;
serf_sess->session_url_str = apr_pstrdup(serf_sess->pool, session_URL);
serf_sess->using_ssl = (svn_cstring_casecmp(url.scheme, "https") == 0);
serf_sess->supports_deadprop_count = svn_tristate_unknown;
serf_sess->capabilities = apr_hash_make(serf_sess->pool);
/* We have to assume that the server only supports HTTP/1.0. Once it's clear
HTTP/1.1 is supported, we can upgrade. */
serf_sess->http10 = TRUE;
/* If we switch to HTTP/1.1, then we will use chunked requests. We may disable
this, if we find an intervening proxy does not support chunked requests. */
serf_sess->using_chunked_requests = TRUE;
SVN_ERR(load_config(serf_sess, config, serf_sess->pool));
serf_sess->conns[0] = apr_pcalloc(serf_sess->pool,
sizeof(*serf_sess->conns[0]));
serf_sess->conns[0]->bkt_alloc =
serf_bucket_allocator_create(serf_sess->pool, NULL, NULL);
serf_sess->conns[0]->session = serf_sess;
serf_sess->conns[0]->last_status_code = -1;
/* create the user agent string */
if (callbacks->get_client_string)
SVN_ERR(callbacks->get_client_string(callback_baton, &client_string,
scratch_pool));
if (client_string)
serf_sess->useragent = apr_pstrcat(result_pool,
get_user_agent_string(scratch_pool),
" ",
client_string, SVN_VA_NULL);
else
serf_sess->useragent = get_user_agent_string(result_pool);
/* go ahead and tell serf about the connection. */
status =
serf_connection_create2(&serf_sess->conns[0]->conn,
serf_sess->context,
url,
svn_ra_serf__conn_setup, serf_sess->conns[0],
svn_ra_serf__conn_closed, serf_sess->conns[0],
serf_sess->pool);
if (status)
return svn_ra_serf__wrap_err(status, NULL);
/* Set the progress callback. */
serf_context_set_progress_cb(serf_sess->context, svn_ra_serf__progress,
serf_sess);
serf_sess->num_conns = 1;
session->priv = serf_sess;
/* The following code explicitly works around a bug in serf <= r2319 / 1.3.8
where serf doesn't report the request as failed/cancelled when the
authorization request handler fails to handle the request.
As long as we allocate the request in a subpool of the serf connection
pool, we know that the handler is always cleaned before the connection.
Luckily our caller now passes us two pools which handle this case.
*/
#if defined(SVN_DEBUG) && !SERF_VERSION_AT_LEAST(1,4,0)
/* Currently ensured by svn_ra_open4().
If failing causes segfault in basic_tests.py 48, "basic auth test" */
SVN_ERR_ASSERT((serf_sess->pool != scratch_pool)
&& apr_pool_is_ancestor(serf_sess->pool, scratch_pool));
#endif
err = svn_ra_serf__exchange_capabilities(serf_sess, corrected_url,
result_pool, scratch_pool);
/* serf should produce a usable error code instead of APR_EGENERAL */
if (err && err->apr_err == APR_EGENERAL)
err = svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, err,
_("Connection to '%s' failed"), session_URL);
SVN_ERR(err);
/* We have set up a useful connection (that doesn't indication a redirect).
If we've been told there is possibly a worrisome proxy in our path to the
server AND we switched to HTTP/1.1 (chunked requests), then probe for
problems in any proxy. */
if ((corrected_url == NULL || *corrected_url == NULL)
&& serf_sess->detect_chunking && !serf_sess->http10)
SVN_ERR(svn_ra_serf__probe_proxy(serf_sess, scratch_pool));
return SVN_NO_ERROR;
}
