aboutsummaryrefslogtreecommitdiffstats
path: root/subversion/libsvn_repos
diff options
context:
space:
mode:
authorPeter Wemm <peter@FreeBSD.org>2013-06-18 02:07:41 +0000
committerPeter Wemm <peter@FreeBSD.org>2013-06-18 02:07:41 +0000
commit32547653cc5376642e1231fb644db99933ac8db4 (patch)
tree135691142dc0e75a5e5d97b5074d03436435b8e0 /subversion/libsvn_repos
downloadsrc-32547653cc5376642e1231fb644db99933ac8db4.tar.gz
src-32547653cc5376642e1231fb644db99933ac8db4.zip
Import trimmed svn-1.8.0-rc3vendor/subversion/subversion-1.8.0-rc3
Notes
Notes: svn path=/vendor/subversion/dist/; revision=251881 svn path=/vendor/subversion/subversion-1.8.0-rc3/; revision=251882; tag=vendor/subversion/subversion-1.8.0-rc3
Diffstat (limited to 'subversion/libsvn_repos')
-rw-r--r--subversion/libsvn_repos/authz.c1075
-rw-r--r--subversion/libsvn_repos/commit.c1381
-rw-r--r--subversion/libsvn_repos/delta.c1074
-rw-r--r--subversion/libsvn_repos/deprecated.c1017
-rw-r--r--subversion/libsvn_repos/dump.c1503
-rw-r--r--subversion/libsvn_repos/fs-wrap.c844
-rw-r--r--subversion/libsvn_repos/hooks.c890
-rw-r--r--subversion/libsvn_repos/load-fs-vtable.c1140
-rw-r--r--subversion/libsvn_repos/load.c684
-rw-r--r--subversion/libsvn_repos/log.c2369
-rw-r--r--subversion/libsvn_repos/node_tree.c431
-rw-r--r--subversion/libsvn_repos/notify.c44
-rw-r--r--subversion/libsvn_repos/replay.c1591
-rw-r--r--subversion/libsvn_repos/reporter.c1610
-rw-r--r--subversion/libsvn_repos/repos.c2132
-rw-r--r--subversion/libsvn_repos/repos.h425
-rw-r--r--subversion/libsvn_repos/rev_hunt.c1699
17 files changed, 19909 insertions, 0 deletions
diff --git a/subversion/libsvn_repos/authz.c b/subversion/libsvn_repos/authz.c
new file mode 100644
index 000000000000..af4a1f255c59
--- /dev/null
+++ b/subversion/libsvn_repos/authz.c
@@ -0,0 +1,1075 @@
+/* authz.c : path-based access control
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+
+/*** Includes. ***/
+
+#include <apr_pools.h>
+#include <apr_file_io.h>
+
+#include "svn_hash.h"
+#include "svn_pools.h"
+#include "svn_error.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_repos.h"
+#include "svn_config.h"
+#include "svn_ctype.h"
+#include "private/svn_fspath.h"
+#include "repos.h"
+
+
+/*** Structures. ***/
+
+/* Information for the config enumerators called during authz
+ lookup. */
+struct authz_lookup_baton {
+ /* The authz configuration. */
+ svn_config_t *config;
+
+ /* The user to authorize. */
+ const char *user;
+
+ /* Explicitly granted rights. */
+ svn_repos_authz_access_t allow;
+ /* Explicitly denied rights. */
+ svn_repos_authz_access_t deny;
+
+ /* The rights required by the caller of the lookup. */
+ svn_repos_authz_access_t required_access;
+
+ /* The following are used exclusively in recursive lookups. */
+
+ /* The path in the repository (an fspath) to authorize. */
+ const char *repos_path;
+ /* repos_path prefixed by the repository name and a colon. */
+ const char *qualified_repos_path;
+
+ /* Whether, at the end of a recursive lookup, access is granted. */
+ svn_boolean_t access;
+};
+
+/* Information for the config enumeration functions called during the
+ validation process. */
+struct authz_validate_baton {
+ svn_config_t *config; /* The configuration file being validated. */
+ svn_error_t *err; /* The error being thrown out of the
+ enumerator, if any. */
+};
+
+/* Currently this structure is just a wrapper around a
+ svn_config_t. */
+struct svn_authz_t
+{
+ svn_config_t *cfg;
+};
+
+
+
+/*** Checking access. ***/
+
+/* Determine whether the REQUIRED access is granted given what authz
+ * to ALLOW or DENY. Return TRUE if the REQUIRED access is
+ * granted.
+ *
+ * Access is granted either when no required access is explicitly
+ * denied (implicit grant), or when the required access is explicitly
+ * granted, overriding any denials.
+ */
+static svn_boolean_t
+authz_access_is_granted(svn_repos_authz_access_t allow,
+ svn_repos_authz_access_t deny,
+ svn_repos_authz_access_t required)
+{
+ svn_repos_authz_access_t stripped_req =
+ required & (svn_authz_read | svn_authz_write);
+
+ if ((deny & required) == svn_authz_none)
+ return TRUE;
+ else if ((allow & required) == stripped_req)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+
+/* Decide whether the REQUIRED access has been conclusively
+ * determined. Return TRUE if the given ALLOW/DENY authz are
+ * conclusive regarding the REQUIRED authz.
+ *
+ * Conclusive determination occurs when any of the REQUIRED authz are
+ * granted or denied by ALLOW/DENY.
+ */
+static svn_boolean_t
+authz_access_is_determined(svn_repos_authz_access_t allow,
+ svn_repos_authz_access_t deny,
+ svn_repos_authz_access_t required)
+{
+ if ((deny & required) || (allow & required))
+ return TRUE;
+ else
+ return FALSE;
+}
+
+/* Return TRUE is USER equals ALIAS. The alias definitions are in the
+ "aliases" sections of CFG. Use POOL for temporary allocations during
+ the lookup. */
+static svn_boolean_t
+authz_alias_is_user(svn_config_t *cfg,
+ const char *alias,
+ const char *user,
+ apr_pool_t *pool)
+{
+ const char *value;
+
+ svn_config_get(cfg, &value, "aliases", alias, NULL);
+ if (!value)
+ return FALSE;
+
+ if (strcmp(value, user) == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+
+/* Return TRUE if USER is in GROUP. The group definitions are in the
+ "groups" section of CFG. Use POOL for temporary allocations during
+ the lookup. */
+static svn_boolean_t
+authz_group_contains_user(svn_config_t *cfg,
+ const char *group,
+ const char *user,
+ apr_pool_t *pool)
+{
+ const char *value;
+ apr_array_header_t *list;
+ int i;
+
+ svn_config_get(cfg, &value, "groups", group, NULL);
+
+ list = svn_cstring_split(value, ",", TRUE, pool);
+
+ for (i = 0; i < list->nelts; i++)
+ {
+ const char *group_user = APR_ARRAY_IDX(list, i, char *);
+
+ /* If the 'user' is a subgroup, recurse into it. */
+ if (*group_user == '@')
+ {
+ if (authz_group_contains_user(cfg, &group_user[1],
+ user, pool))
+ return TRUE;
+ }
+
+ /* If the 'user' is an alias, verify it. */
+ else if (*group_user == '&')
+ {
+ if (authz_alias_is_user(cfg, &group_user[1],
+ user, pool))
+ return TRUE;
+ }
+
+ /* If the user matches, stop. */
+ else if (strcmp(user, group_user) == 0)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+/* Determines whether an authz rule applies to the current
+ * user, given the name part of the rule's name-value pair
+ * in RULE_MATCH_STRING and the authz_lookup_baton object
+ * B with the username in question.
+ */
+static svn_boolean_t
+authz_line_applies_to_user(const char *rule_match_string,
+ struct authz_lookup_baton *b,
+ apr_pool_t *pool)
+{
+ /* If the rule has an inversion, recurse and invert the result. */
+ if (rule_match_string[0] == '~')
+ return !authz_line_applies_to_user(&rule_match_string[1], b, pool);
+
+ /* Check for special tokens. */
+ if (strcmp(rule_match_string, "$anonymous") == 0)
+ return (b->user == NULL);
+ if (strcmp(rule_match_string, "$authenticated") == 0)
+ return (b->user != NULL);
+
+ /* Check for a wildcard rule. */
+ if (strcmp(rule_match_string, "*") == 0)
+ return TRUE;
+
+ /* If we get here, then the rule is:
+ * - Not an inversion rule.
+ * - Not an authz token rule.
+ * - Not a wildcard rule.
+ *
+ * All that's left over is regular user or group specifications.
+ */
+
+ /* If the session is anonymous, then a user/group
+ * rule definitely won't match.
+ */
+ if (b->user == NULL)
+ return FALSE;
+
+ /* Process the rule depending on whether it is
+ * a user, alias or group rule.
+ */
+ if (rule_match_string[0] == '@')
+ return authz_group_contains_user(
+ b->config, &rule_match_string[1], b->user, pool);
+ else if (rule_match_string[0] == '&')
+ return authz_alias_is_user(
+ b->config, &rule_match_string[1], b->user, pool);
+ else
+ return (strcmp(b->user, rule_match_string) == 0);
+}
+
+
+/* Callback to parse one line of an authz file and update the
+ * authz_baton accordingly.
+ */
+static svn_boolean_t
+authz_parse_line(const char *name, const char *value,
+ void *baton, apr_pool_t *pool)
+{
+ struct authz_lookup_baton *b = baton;
+
+ /* Stop if the rule doesn't apply to this user. */
+ if (!authz_line_applies_to_user(name, b, pool))
+ return TRUE;
+
+ /* Set the access grants for the rule. */
+ if (strchr(value, 'r'))
+ b->allow |= svn_authz_read;
+ else
+ b->deny |= svn_authz_read;
+
+ if (strchr(value, 'w'))
+ b->allow |= svn_authz_write;
+ else
+ b->deny |= svn_authz_write;
+
+ return TRUE;
+}
+
+
+/* Return TRUE iff the access rules in SECTION_NAME apply to PATH_SPEC
+ * (which is a repository name, colon, and repository fspath, such as
+ * "myrepos:/trunk/foo").
+ */
+static svn_boolean_t
+is_applicable_section(const char *path_spec,
+ const char *section_name)
+{
+ apr_size_t path_spec_len = strlen(path_spec);
+
+ return ((strncmp(path_spec, section_name, path_spec_len) == 0)
+ && (path_spec[path_spec_len - 1] == '/'
+ || section_name[path_spec_len] == '/'
+ || section_name[path_spec_len] == '\0'));
+}
+
+
+/* Callback to parse a section and update the authz_baton if the
+ * section denies access to the subtree the baton describes.
+ */
+static svn_boolean_t
+authz_parse_section(const char *section_name, void *baton, apr_pool_t *pool)
+{
+ struct authz_lookup_baton *b = baton;
+ svn_boolean_t conclusive;
+
+ /* Does the section apply to us? */
+ if (!is_applicable_section(b->qualified_repos_path, section_name)
+ && !is_applicable_section(b->repos_path, section_name))
+ return TRUE;
+
+ /* Work out what this section grants. */
+ b->allow = b->deny = 0;
+ svn_config_enumerate2(b->config, section_name,
+ authz_parse_line, b, pool);
+
+ /* Has the section explicitly determined an access? */
+ conclusive = authz_access_is_determined(b->allow, b->deny,
+ b->required_access);
+
+ /* Is access granted OR inconclusive? */
+ b->access = authz_access_is_granted(b->allow, b->deny,
+ b->required_access)
+ || !conclusive;
+
+ /* As long as access isn't conclusively denied, carry on. */
+ return b->access;
+}
+
+
+/* Validate access to the given user for the given path. This
+ * function checks rules for exactly the given path, and first tries
+ * to access a section specific to the given repository before falling
+ * back to pan-repository rules.
+ *
+ * Update *access_granted to inform the caller of the outcome of the
+ * lookup. Return a boolean indicating whether the access rights were
+ * successfully determined.
+ */
+static svn_boolean_t
+authz_get_path_access(svn_config_t *cfg, const char *repos_name,
+ const char *path, const char *user,
+ svn_repos_authz_access_t required_access,
+ svn_boolean_t *access_granted,
+ apr_pool_t *pool)
+{
+ const char *qualified_path;
+ struct authz_lookup_baton baton = { 0 };
+
+ baton.config = cfg;
+ baton.user = user;
+
+ /* Try to locate a repository-specific block first. */
+ qualified_path = apr_pstrcat(pool, repos_name, ":", path, (char *)NULL);
+ svn_config_enumerate2(cfg, qualified_path,
+ authz_parse_line, &baton, pool);
+
+ *access_granted = authz_access_is_granted(baton.allow, baton.deny,
+ required_access);
+
+ /* If the first test has determined access, stop now. */
+ if (authz_access_is_determined(baton.allow, baton.deny,
+ required_access))
+ return TRUE;
+
+ /* No repository specific rule, try pan-repository rules. */
+ svn_config_enumerate2(cfg, path, authz_parse_line, &baton, pool);
+
+ *access_granted = authz_access_is_granted(baton.allow, baton.deny,
+ required_access);
+ return authz_access_is_determined(baton.allow, baton.deny,
+ required_access);
+}
+
+
+/* Validate access to the given user for the subtree starting at the
+ * given path. This function walks the whole authz file in search of
+ * rules applying to paths in the requested subtree which deny the
+ * requested access.
+ *
+ * As soon as one is found, or else when the whole ACL file has been
+ * searched, return the updated authorization status.
+ */
+static svn_boolean_t
+authz_get_tree_access(svn_config_t *cfg, const char *repos_name,
+ const char *path, const char *user,
+ svn_repos_authz_access_t required_access,
+ apr_pool_t *pool)
+{
+ struct authz_lookup_baton baton = { 0 };
+
+ baton.config = cfg;
+ baton.user = user;
+ baton.required_access = required_access;
+ baton.repos_path = path;
+ baton.qualified_repos_path = apr_pstrcat(pool, repos_name,
+ ":", path, (char *)NULL);
+ /* Default to access granted if no rules say otherwise. */
+ baton.access = TRUE;
+
+ svn_config_enumerate_sections2(cfg, authz_parse_section,
+ &baton, pool);
+
+ return baton.access;
+}
+
+
+/* Callback to parse sections of the configuration file, looking for
+ any kind of granted access. Implements the
+ svn_config_section_enumerator2_t interface. */
+static svn_boolean_t
+authz_get_any_access_parser_cb(const char *section_name, void *baton,
+ apr_pool_t *pool)
+{
+ struct authz_lookup_baton *b = baton;
+
+ /* Does the section apply to the query? */
+ if (section_name[0] == '/'
+ || strncmp(section_name, b->qualified_repos_path,
+ strlen(b->qualified_repos_path)) == 0)
+ {
+ b->allow = b->deny = svn_authz_none;
+
+ svn_config_enumerate2(b->config, section_name,
+ authz_parse_line, baton, pool);
+ b->access = authz_access_is_granted(b->allow, b->deny,
+ b->required_access);
+
+ /* Continue as long as we don't find a determined, granted access. */
+ return !(b->access
+ && authz_access_is_determined(b->allow, b->deny,
+ b->required_access));
+ }
+
+ return TRUE;
+}
+
+
+/* Walk through the authz CFG to check if USER has the REQUIRED_ACCESS
+ * to any path within the REPOSITORY. Return TRUE if so. Use POOL
+ * for temporary allocations. */
+static svn_boolean_t
+authz_get_any_access(svn_config_t *cfg, const char *repos_name,
+ const char *user,
+ svn_repos_authz_access_t required_access,
+ apr_pool_t *pool)
+{
+ struct authz_lookup_baton baton = { 0 };
+
+ baton.config = cfg;
+ baton.user = user;
+ baton.required_access = required_access;
+ baton.access = FALSE; /* Deny access by default. */
+ baton.repos_path = "/";
+ baton.qualified_repos_path = apr_pstrcat(pool, repos_name,
+ ":/", (char *)NULL);
+
+ /* We could have used svn_config_enumerate2 for "repos_name:/".
+ * However, this requires access for root explicitly (which the user
+ * may not always have). So we end up enumerating the sections in
+ * the authz CFG and stop on the first match with some access for
+ * this user. */
+ svn_config_enumerate_sections2(cfg, authz_get_any_access_parser_cb,
+ &baton, pool);
+
+ /* If walking the configuration was inconclusive, deny access. */
+ if (!authz_access_is_determined(baton.allow,
+ baton.deny, baton.required_access))
+ return FALSE;
+
+ return baton.access;
+}
+
+
+
+/*** Validating the authz file. ***/
+
+/* Check for errors in GROUP's definition of CFG. The errors
+ * detected are references to non-existent groups and circular
+ * dependencies between groups. If an error is found, return
+ * SVN_ERR_AUTHZ_INVALID_CONFIG. Use POOL for temporary
+ * allocations only.
+ *
+ * CHECKED_GROUPS should be an empty (it is used for recursive calls).
+ */
+static svn_error_t *
+authz_group_walk(svn_config_t *cfg,
+ const char *group,
+ apr_hash_t *checked_groups,
+ apr_pool_t *pool)
+{
+ const char *value;
+ apr_array_header_t *list;
+ int i;
+
+ svn_config_get(cfg, &value, "groups", group, NULL);
+ /* Having a non-existent group in the ACL configuration might be the
+ sign of a typo. Refuse to perform authz on uncertain rules. */
+ if (!value)
+ return svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "An authz rule refers to group '%s', "
+ "which is undefined",
+ group);
+
+ list = svn_cstring_split(value, ",", TRUE, pool);
+
+ for (i = 0; i < list->nelts; i++)
+ {
+ const char *group_user = APR_ARRAY_IDX(list, i, char *);
+
+ /* If the 'user' is a subgroup, recurse into it. */
+ if (*group_user == '@')
+ {
+ /* A circular dependency between groups is a Bad Thing. We
+ don't do authz with invalid ACL files. */
+ if (svn_hash_gets(checked_groups, &group_user[1]))
+ return svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG,
+ NULL,
+ "Circular dependency between "
+ "groups '%s' and '%s'",
+ &group_user[1], group);
+
+ /* Add group to hash of checked groups. */
+ svn_hash_sets(checked_groups, &group_user[1], "");
+
+ /* Recurse on that group. */
+ SVN_ERR(authz_group_walk(cfg, &group_user[1],
+ checked_groups, pool));
+
+ /* Remove group from hash of checked groups, so that we don't
+ incorrectly report an error if we see it again as part of
+ another group. */
+ svn_hash_sets(checked_groups, &group_user[1], NULL);
+ }
+ else if (*group_user == '&')
+ {
+ const char *alias;
+
+ svn_config_get(cfg, &alias, "aliases", &group_user[1], NULL);
+ /* Having a non-existent alias in the ACL configuration might be the
+ sign of a typo. Refuse to perform authz on uncertain rules. */
+ if (!alias)
+ return svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "An authz rule refers to alias '%s', "
+ "which is undefined",
+ &group_user[1]);
+ }
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Callback to perform some simple sanity checks on an authz rule.
+ *
+ * - If RULE_MATCH_STRING references a group or an alias, verify that
+ * the group or alias definition exists.
+ * - If RULE_MATCH_STRING specifies a token (starts with $), verify
+ * that the token name is valid.
+ * - If RULE_MATCH_STRING is using inversion, verify that it isn't
+ * doing it more than once within the one rule, and that it isn't
+ * "~*", as that would never match.
+ * - Check that VALUE part of the rule specifies only allowed rule
+ * flag characters ('r' and 'w').
+ *
+ * Return TRUE if the rule has no errors. Use BATON for context and
+ * error reporting.
+ */
+static svn_boolean_t authz_validate_rule(const char *rule_match_string,
+ const char *value,
+ void *baton,
+ apr_pool_t *pool)
+{
+ const char *val;
+ const char *match = rule_match_string;
+ struct authz_validate_baton *b = baton;
+
+ /* Make sure the user isn't using double-negatives. */
+ if (match[0] == '~')
+ {
+ /* Bump the pointer past the inversion for the other checks. */
+ match++;
+
+ /* Another inversion is a double negative; we can't not stop. */
+ if (match[0] == '~')
+ {
+ b->err = svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "Rule '%s' has more than one "
+ "inversion; double negatives are "
+ "not permitted.",
+ rule_match_string);
+ return FALSE;
+ }
+
+ /* Make sure that the rule isn't "~*", which won't ever match. */
+ if (strcmp(match, "*") == 0)
+ {
+ b->err = svn_error_create(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "Authz rules with match string '~*' "
+ "are not allowed, because they never "
+ "match anyone.");
+ return FALSE;
+ }
+ }
+
+ /* If the rule applies to a group, check its existence. */
+ if (match[0] == '@')
+ {
+ const char *group = &match[1];
+
+ svn_config_get(b->config, &val, "groups", group, NULL);
+
+ /* Having a non-existent group in the ACL configuration might be
+ the sign of a typo. Refuse to perform authz on uncertain
+ rules. */
+ if (!val)
+ {
+ b->err = svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "An authz rule refers to group "
+ "'%s', which is undefined",
+ rule_match_string);
+ return FALSE;
+ }
+ }
+
+ /* If the rule applies to an alias, check its existence. */
+ if (match[0] == '&')
+ {
+ const char *alias = &match[1];
+
+ svn_config_get(b->config, &val, "aliases", alias, NULL);
+
+ if (!val)
+ {
+ b->err = svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "An authz rule refers to alias "
+ "'%s', which is undefined",
+ rule_match_string);
+ return FALSE;
+ }
+ }
+
+ /* If the rule specifies a token, check its validity. */
+ if (match[0] == '$')
+ {
+ const char *token_name = &match[1];
+
+ if ((strcmp(token_name, "anonymous") != 0)
+ && (strcmp(token_name, "authenticated") != 0))
+ {
+ b->err = svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "Unrecognized authz token '%s'.",
+ rule_match_string);
+ return FALSE;
+ }
+ }
+
+ val = value;
+
+ while (*val)
+ {
+ if (*val != 'r' && *val != 'w' && ! svn_ctype_isspace(*val))
+ {
+ b->err = svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "The character '%c' in rule '%s' is not "
+ "allowed in authz rules", *val,
+ rule_match_string);
+ return FALSE;
+ }
+
+ ++val;
+ }
+
+ return TRUE;
+}
+
+/* Callback to check ALIAS's definition for validity. Use
+ BATON for context and error reporting. */
+static svn_boolean_t authz_validate_alias(const char *alias,
+ const char *value,
+ void *baton,
+ apr_pool_t *pool)
+{
+ /* No checking at the moment, every alias is valid */
+ return TRUE;
+}
+
+
+/* Callback to check GROUP's definition for cyclic dependancies. Use
+ BATON for context and error reporting. */
+static svn_boolean_t authz_validate_group(const char *group,
+ const char *value,
+ void *baton,
+ apr_pool_t *pool)
+{
+ struct authz_validate_baton *b = baton;
+
+ b->err = authz_group_walk(b->config, group, apr_hash_make(pool), pool);
+ if (b->err)
+ return FALSE;
+
+ return TRUE;
+}
+
+
+/* Callback to check the contents of the configuration section given
+ by NAME. Use BATON for context and error reporting. */
+static svn_boolean_t authz_validate_section(const char *name,
+ void *baton,
+ apr_pool_t *pool)
+{
+ struct authz_validate_baton *b = baton;
+
+ /* Use the group checking callback for the "groups" section... */
+ if (strcmp(name, "groups") == 0)
+ svn_config_enumerate2(b->config, name, authz_validate_group,
+ baton, pool);
+ /* ...and the alias checking callback for "aliases"... */
+ else if (strcmp(name, "aliases") == 0)
+ svn_config_enumerate2(b->config, name, authz_validate_alias,
+ baton, pool);
+ /* ...but for everything else use the rule checking callback. */
+ else
+ {
+ /* Validate the section's name. Skip the optional REPOS_NAME. */
+ const char *fspath = strchr(name, ':');
+ if (fspath)
+ fspath++;
+ else
+ fspath = name;
+ if (! svn_fspath__is_canonical(fspath))
+ {
+ b->err = svn_error_createf(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "Section name '%s' contains non-canonical "
+ "fspath '%s'",
+ name, fspath);
+ return FALSE;
+ }
+
+ svn_config_enumerate2(b->config, name, authz_validate_rule,
+ baton, pool);
+ }
+
+ if (b->err)
+ return FALSE;
+
+ return TRUE;
+}
+
+
+/* Walk the configuration in AUTHZ looking for any errors. */
+static svn_error_t *
+authz_validate(svn_authz_t *authz, apr_pool_t *pool)
+{
+ struct authz_validate_baton baton = { 0 };
+
+ baton.err = SVN_NO_ERROR;
+ baton.config = authz->cfg;
+
+ /* Step through the entire rule file stopping on error. */
+ svn_config_enumerate_sections2(authz->cfg, authz_validate_section,
+ &baton, pool);
+ SVN_ERR(baton.err);
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Retrieve the file at DIRENT (contained in a repo) then parse it as a config
+ * file placing the result into CFG_P allocated in POOL.
+ *
+ * If DIRENT cannot be parsed as a config file then an error is returned. The
+ * contents of CFG_P is then undefined. If MUST_EXIST is TRUE, a missing
+ * authz file is also an error.
+ *
+ * SCRATCH_POOL will be used for temporary allocations. */
+static svn_error_t *
+authz_retrieve_config_repo(svn_config_t **cfg_p, const char *dirent,
+ svn_boolean_t must_exist,
+ apr_pool_t *result_pool, apr_pool_t *scratch_pool)
+{
+ svn_error_t *err;
+ svn_repos_t *repos;
+ const char *repos_root_dirent;
+ const char *fs_path;
+ svn_fs_t *fs;
+ svn_fs_root_t *root;
+ svn_revnum_t youngest_rev;
+ svn_node_kind_t node_kind;
+ svn_stream_t *contents;
+
+ /* Search for a repository in the full path. */
+ repos_root_dirent = svn_repos_find_root_path(dirent, scratch_pool);
+ if (!repos_root_dirent)
+ return svn_error_createf(SVN_ERR_RA_LOCAL_REPOS_NOT_FOUND, NULL,
+ "Unable to find repository at '%s'", dirent);
+
+ /* Attempt to open a repository at repos_root_dirent. */
+ SVN_ERR(svn_repos_open2(&repos, repos_root_dirent, NULL, scratch_pool));
+
+ fs_path = &dirent[strlen(repos_root_dirent)];
+
+ /* Root path is always a directory so no reason to go any further */
+ if (*fs_path == '\0')
+ return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
+ "'/' is not a file in repo '%s'",
+ repos_root_dirent);
+
+ /* We skip some things that are non-important for how we're going to use
+ * this repo connection. We do not set any capabilities since none of
+ * the current ones are important for what we're doing. We also do not
+ * setup the environment that repos hooks would run under since we won't
+ * be triggering any. */
+
+ /* Get the filesystem. */
+ fs = svn_repos_fs(repos);
+
+ /* Find HEAD and the revision root */
+ SVN_ERR(svn_fs_youngest_rev(&youngest_rev, fs, scratch_pool));
+ SVN_ERR(svn_fs_revision_root(&root, fs, youngest_rev, scratch_pool));
+
+ SVN_ERR(svn_fs_check_path(&node_kind, root, fs_path, scratch_pool));
+ if (node_kind == svn_node_none)
+ {
+ if (!must_exist)
+ {
+ SVN_ERR(svn_config_create2(cfg_p, TRUE, TRUE, result_pool));
+ return SVN_NO_ERROR;
+ }
+ else
+ {
+ return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
+ "'%s' path not found in repo '%s'", fs_path,
+ repos_root_dirent);
+ }
+ }
+ else if (node_kind != svn_node_file)
+ {
+ return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
+ "'%s' is not a file in repo '%s'", fs_path,
+ repos_root_dirent);
+ }
+
+ SVN_ERR(svn_fs_file_contents(&contents, root, fs_path, scratch_pool));
+ err = svn_config_parse(cfg_p, contents, TRUE, TRUE, result_pool);
+
+ /* Add the URL to the error stack since the parser doesn't have it. */
+ if (err != SVN_NO_ERROR)
+ return svn_error_createf(err->apr_err, err,
+ "Error while parsing config file: '%s' in repo '%s':",
+ fs_path, repos_root_dirent);
+
+ return SVN_NO_ERROR;
+}
+
+/* Given a PATH which might be a relative repo URL (^/), an absolute
+ * local repo URL (file://), an absolute path outside of the repo
+ * or a location in the Windows registry.
+ *
+ * Retrieve the configuration data that PATH points at and parse it into
+ * CFG_P allocated in POOL.
+ *
+ * If PATH cannot be parsed as a config file then an error is returned. The
+ * contents of CFG_P is then undefined. If MUST_EXIST is TRUE, a missing
+ * authz file is also an error.
+ *
+ * REPOS_ROOT points at the root of the repos you are
+ * going to apply the authz against, can be NULL if you are sure that you
+ * don't have a repos relative URL in PATH. */
+static svn_error_t *
+authz_retrieve_config(svn_config_t **cfg_p, const char *path,
+ svn_boolean_t must_exist, apr_pool_t *pool)
+{
+ if (svn_path_is_url(path))
+ {
+ const char *dirent;
+ svn_error_t *err;
+ apr_pool_t *scratch_pool = svn_pool_create(pool);
+
+ err = svn_uri_get_dirent_from_file_url(&dirent, path, scratch_pool);
+
+ if (err == SVN_NO_ERROR)
+ err = authz_retrieve_config_repo(cfg_p, dirent, must_exist, pool,
+ scratch_pool);
+
+ /* Close the repos and streams we opened. */
+ svn_pool_destroy(scratch_pool);
+
+ return err;
+ }
+ else
+ {
+ /* Outside of repo file or Windows registry*/
+ SVN_ERR(svn_config_read3(cfg_p, path, must_exist, TRUE, TRUE, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Callback to copy (name, value) group into the "groups" section
+ of another configuration. */
+static svn_boolean_t
+authz_copy_group(const char *name, const char *value,
+ void *baton, apr_pool_t *pool)
+{
+ svn_config_t *authz_cfg = baton;
+
+ svn_config_set(authz_cfg, SVN_CONFIG_SECTION_GROUPS, name, value);
+
+ return TRUE;
+}
+
+/* Copy group definitions from GROUPS_CFG to the resulting AUTHZ.
+ * If AUTHZ already contains any group definition, report an error.
+ * Use POOL for temporary allocations. */
+static svn_error_t *
+authz_copy_groups(svn_authz_t *authz, svn_config_t *groups_cfg,
+ apr_pool_t *pool)
+{
+ /* Easy out: we prohibit local groups in the authz file when global
+ groups are being used. */
+ if (svn_config_has_section(authz->cfg, SVN_CONFIG_SECTION_GROUPS))
+ {
+ return svn_error_create(SVN_ERR_AUTHZ_INVALID_CONFIG, NULL,
+ "Authz file cannot contain any groups "
+ "when global groups are being used.");
+ }
+
+ svn_config_enumerate2(groups_cfg, SVN_CONFIG_SECTION_GROUPS,
+ authz_copy_group, authz->cfg, pool);
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_repos__authz_read(svn_authz_t **authz_p, const char *path,
+ const char *groups_path, svn_boolean_t must_exist,
+ svn_boolean_t accept_urls, apr_pool_t *pool)
+{
+ svn_authz_t *authz = apr_palloc(pool, sizeof(*authz));
+
+ /* Load the authz file */
+ if (accept_urls)
+ SVN_ERR(authz_retrieve_config(&authz->cfg, path, must_exist, pool));
+ else
+ SVN_ERR(svn_config_read3(&authz->cfg, path, must_exist, TRUE, TRUE, pool));
+
+ if (groups_path)
+ {
+ svn_config_t *groups_cfg;
+ svn_error_t *err;
+
+ /* Load the groups file */
+ if (accept_urls)
+ SVN_ERR(authz_retrieve_config(&groups_cfg, groups_path, must_exist,
+ pool));
+ else
+ SVN_ERR(svn_config_read3(&groups_cfg, groups_path, must_exist,
+ TRUE, TRUE, pool));
+
+ /* Copy the groups from groups_cfg into authz. */
+ err = authz_copy_groups(authz, groups_cfg, pool);
+
+ /* Add the paths to the error stack since the authz_copy_groups
+ routine knows nothing about them. */
+ if (err != SVN_NO_ERROR)
+ return svn_error_createf(err->apr_err, err,
+ "Error reading authz file '%s' with "
+ "groups file '%s':", path, groups_path);
+ }
+
+ /* Make sure there are no errors in the configuration. */
+ SVN_ERR(authz_validate(authz, pool));
+
+ *authz_p = authz;
+ return SVN_NO_ERROR;
+}
+
+
+
+/*** Public functions. ***/
+
+svn_error_t *
+svn_repos_authz_read2(svn_authz_t **authz_p, const char *path,
+ const char *groups_path, svn_boolean_t must_exist,
+ apr_pool_t *pool)
+{
+ return svn_repos__authz_read(authz_p, path, groups_path, must_exist,
+ TRUE, pool);
+}
+
+
+svn_error_t *
+svn_repos_authz_parse(svn_authz_t **authz_p, svn_stream_t *stream,
+ svn_stream_t *groups_stream, apr_pool_t *pool)
+{
+ svn_authz_t *authz = apr_palloc(pool, sizeof(*authz));
+
+ /* Parse the authz stream */
+ SVN_ERR(svn_config_parse(&authz->cfg, stream, TRUE, TRUE, pool));
+
+ if (groups_stream)
+ {
+ svn_config_t *groups_cfg;
+
+ /* Parse the groups stream */
+ SVN_ERR(svn_config_parse(&groups_cfg, groups_stream, TRUE, TRUE, pool));
+
+ SVN_ERR(authz_copy_groups(authz, groups_cfg, pool));
+ }
+
+ /* Make sure there are no errors in the configuration. */
+ SVN_ERR(authz_validate(authz, pool));
+
+ *authz_p = authz;
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_authz_check_access(svn_authz_t *authz, const char *repos_name,
+ const char *path, const char *user,
+ svn_repos_authz_access_t required_access,
+ svn_boolean_t *access_granted,
+ apr_pool_t *pool)
+{
+ const char *current_path;
+
+ if (!repos_name)
+ repos_name = "";
+
+ /* If PATH is NULL, check if the user has *any* access. */
+ if (!path)
+ {
+ *access_granted = authz_get_any_access(authz->cfg, repos_name,
+ user, required_access, pool);
+ return SVN_NO_ERROR;
+ }
+
+ /* Sanity check. */
+ SVN_ERR_ASSERT(path[0] == '/');
+
+ /* Determine the granted access for the requested path. */
+ path = svn_fspath__canonicalize(path, pool);
+ current_path = path;
+
+ while (!authz_get_path_access(authz->cfg, repos_name,
+ current_path, user,
+ required_access,
+ access_granted,
+ pool))
+ {
+ /* Stop if the loop hits the repository root with no
+ results. */
+ if (current_path[0] == '/' && current_path[1] == '\0')
+ {
+ /* Deny access by default. */
+ *access_granted = FALSE;
+ return SVN_NO_ERROR;
+ }
+
+ /* Work back to the parent path. */
+ current_path = svn_fspath__dirname(current_path, pool);
+ }
+
+ /* If the caller requested recursive access, we need to walk through
+ the entire authz config to see whether any child paths are denied
+ to the requested user. */
+ if (*access_granted && (required_access & svn_authz_recursive))
+ *access_granted = authz_get_tree_access(authz->cfg, repos_name, path,
+ user, required_access, pool);
+
+ return SVN_NO_ERROR;
+}
diff --git a/subversion/libsvn_repos/commit.c b/subversion/libsvn_repos/commit.c
new file mode 100644
index 000000000000..c4606ab4b7bd
--- /dev/null
+++ b/subversion/libsvn_repos/commit.c
@@ -0,0 +1,1381 @@
+/* commit.c --- editor for committing changes to a filesystem.
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+
+#include <string.h>
+
+#include <apr_pools.h>
+#include <apr_file_io.h>
+
+#include "svn_hash.h"
+#include "svn_compat.h"
+#include "svn_pools.h"
+#include "svn_error.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_delta.h"
+#include "svn_fs.h"
+#include "svn_repos.h"
+#include "svn_checksum.h"
+#include "svn_ctype.h"
+#include "svn_props.h"
+#include "svn_mergeinfo.h"
+#include "svn_private_config.h"
+
+#include "repos.h"
+
+#include "private/svn_fspath.h"
+#include "private/svn_fs_private.h"
+#include "private/svn_repos_private.h"
+#include "private/svn_editor.h"
+
+
+
+/*** Editor batons. ***/
+
+struct edit_baton
+{
+ apr_pool_t *pool;
+
+ /** Supplied when the editor is created: **/
+
+ /* Revision properties to set for this commit. */
+ apr_hash_t *revprop_table;
+
+ /* Callback to run when the commit is done. */
+ svn_commit_callback2_t commit_callback;
+ void *commit_callback_baton;
+
+ /* Callback to check authorizations on paths. */
+ svn_repos_authz_callback_t authz_callback;
+ void *authz_baton;
+
+ /* The already-open svn repository to commit to. */
+ svn_repos_t *repos;
+
+ /* URL to the root of the open repository. */
+ const char *repos_url;
+
+ /* The name of the repository (here for convenience). */
+ const char *repos_name;
+
+ /* The filesystem associated with the REPOS above (here for
+ convenience). */
+ svn_fs_t *fs;
+
+ /* Location in fs where the edit will begin. */
+ const char *base_path;
+
+ /* Does this set of interfaces 'own' the commit transaction? */
+ svn_boolean_t txn_owner;
+
+ /* svn transaction associated with this edit (created in
+ open_root, or supplied by the public API caller). */
+ svn_fs_txn_t *txn;
+
+ /** Filled in during open_root: **/
+
+ /* The name of the transaction. */
+ const char *txn_name;
+
+ /* The object representing the root directory of the svn txn. */
+ svn_fs_root_t *txn_root;
+
+ /* Avoid aborting an fs transaction more than once */
+ svn_boolean_t txn_aborted;
+
+ /** Filled in when the edit is closed: **/
+
+ /* The new revision created by this commit. */
+ svn_revnum_t *new_rev;
+
+ /* The date (according to the repository) of this commit. */
+ const char **committed_date;
+
+ /* The author (also according to the repository) of this commit. */
+ const char **committed_author;
+};
+
+
+struct dir_baton
+{
+ struct edit_baton *edit_baton;
+ struct dir_baton *parent;
+ const char *path; /* the -absolute- path to this dir in the fs */
+ svn_revnum_t base_rev; /* the revision I'm based on */
+ svn_boolean_t was_copied; /* was this directory added with history? */
+ apr_pool_t *pool; /* my personal pool, in which I am allocated. */
+};
+
+
+struct file_baton
+{
+ struct edit_baton *edit_baton;
+ const char *path; /* the -absolute- path to this file in the fs */
+};
+
+
+struct ev2_baton
+{
+ /* The repository we are editing. */
+ svn_repos_t *repos;
+
+ /* The authz baton for checks; NULL to skip authz. */
+ svn_authz_t *authz;
+
+ /* The repository name and user for performing authz checks. */
+ const char *authz_repos_name;
+ const char *authz_user;
+
+ /* Callback to provide info about the committed revision. */
+ svn_commit_callback2_t commit_cb;
+ void *commit_baton;
+
+ /* The FS txn editor */
+ svn_editor_t *inner;
+
+ /* The name of the open transaction (so we know what to commit) */
+ const char *txn_name;
+};
+
+
+/* Create and return a generic out-of-dateness error. */
+static svn_error_t *
+out_of_date(const char *path, svn_node_kind_t kind)
+{
+ return svn_error_createf(SVN_ERR_FS_TXN_OUT_OF_DATE, NULL,
+ (kind == svn_node_dir
+ ? _("Directory '%s' is out of date")
+ : kind == svn_node_file
+ ? _("File '%s' is out of date")
+ : _("'%s' is out of date")),
+ path);
+}
+
+
+static svn_error_t *
+invoke_commit_cb(svn_commit_callback2_t commit_cb,
+ void *commit_baton,
+ svn_fs_t *fs,
+ svn_revnum_t revision,
+ const char *post_commit_errstr,
+ apr_pool_t *scratch_pool)
+{
+ /* FS interface returns non-const values. */
+ /* const */ svn_string_t *date;
+ /* const */ svn_string_t *author;
+ svn_commit_info_t *commit_info;
+
+ if (commit_cb == NULL)
+ return SVN_NO_ERROR;
+
+ SVN_ERR(svn_fs_revision_prop(&date, fs, revision, SVN_PROP_REVISION_DATE,
+ scratch_pool));
+ SVN_ERR(svn_fs_revision_prop(&author, fs, revision,
+ SVN_PROP_REVISION_AUTHOR,
+ scratch_pool));
+
+ commit_info = svn_create_commit_info(scratch_pool);
+
+ /* fill up the svn_commit_info structure */
+ commit_info->revision = revision;
+ commit_info->date = date ? date->data : NULL;
+ commit_info->author = author ? author->data : NULL;
+ commit_info->post_commit_err = post_commit_errstr;
+
+ return svn_error_trace(commit_cb(commit_info, commit_baton, scratch_pool));
+}
+
+
+
+/* If EDITOR_BATON contains a valid authz callback, verify that the
+ REQUIRED access to PATH in ROOT is authorized. Return an error
+ appropriate for throwing out of the commit editor with SVN_ERR. If
+ no authz callback is present in EDITOR_BATON, then authorize all
+ paths. Use POOL for temporary allocation only. */
+static svn_error_t *
+check_authz(struct edit_baton *editor_baton, const char *path,
+ svn_fs_root_t *root, svn_repos_authz_access_t required,
+ apr_pool_t *pool)
+{
+ if (editor_baton->authz_callback)
+ {
+ svn_boolean_t allowed;
+
+ SVN_ERR(editor_baton->authz_callback(required, &allowed, root, path,
+ editor_baton->authz_baton, pool));
+ if (!allowed)
+ return svn_error_create(required & svn_authz_write ?
+ SVN_ERR_AUTHZ_UNWRITABLE :
+ SVN_ERR_AUTHZ_UNREADABLE,
+ NULL, "Access denied");
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Return a directory baton allocated in POOL which represents
+ FULL_PATH, which is the immediate directory child of the directory
+ represented by PARENT_BATON. EDIT_BATON is the commit editor
+ baton. WAS_COPIED reveals whether or not this directory is the
+ result of a copy operation. BASE_REVISION is the base revision of
+ the directory. */
+static struct dir_baton *
+make_dir_baton(struct edit_baton *edit_baton,
+ struct dir_baton *parent_baton,
+ const char *full_path,
+ svn_boolean_t was_copied,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool)
+{
+ struct dir_baton *db;
+ db = apr_pcalloc(pool, sizeof(*db));
+ db->edit_baton = edit_baton;
+ db->parent = parent_baton;
+ db->pool = pool;
+ db->path = full_path;
+ db->was_copied = was_copied;
+ db->base_rev = base_revision;
+ return db;
+}
+
+/* This function is the shared guts of add_file() and add_directory(),
+ which see for the meanings of the parameters. The only extra
+ parameter here is IS_DIR, which is TRUE when adding a directory,
+ and FALSE when adding a file. */
+static svn_error_t *
+add_file_or_directory(const char *path,
+ void *parent_baton,
+ const char *copy_path,
+ svn_revnum_t copy_revision,
+ svn_boolean_t is_dir,
+ apr_pool_t *pool,
+ void **return_baton)
+{
+ struct dir_baton *pb = parent_baton;
+ struct edit_baton *eb = pb->edit_baton;
+ apr_pool_t *subpool = svn_pool_create(pool);
+ svn_boolean_t was_copied = FALSE;
+ const char *full_path;
+
+ /* Reject paths which contain control characters (related to issue #4340). */
+ SVN_ERR(svn_path_check_valid(path, pool));
+
+ full_path = svn_fspath__join(eb->base_path,
+ svn_relpath_canonicalize(path, pool), pool);
+
+ /* Sanity check. */
+ if (copy_path && (! SVN_IS_VALID_REVNUM(copy_revision)))
+ return svn_error_createf
+ (SVN_ERR_FS_GENERAL, NULL,
+ _("Got source path but no source revision for '%s'"), full_path);
+
+ if (copy_path)
+ {
+ const char *fs_path;
+ svn_fs_root_t *copy_root;
+ svn_node_kind_t kind;
+ size_t repos_url_len;
+ svn_repos_authz_access_t required;
+
+ /* Copy requires recursive write access to the destination path
+ and write access to the parent path. */
+ required = svn_authz_write | (is_dir ? svn_authz_recursive : 0);
+ SVN_ERR(check_authz(eb, full_path, eb->txn_root,
+ required, subpool));
+ SVN_ERR(check_authz(eb, pb->path, eb->txn_root,
+ svn_authz_write, subpool));
+
+ /* Check PATH in our transaction. Make sure it does not exist
+ unless its parent directory was copied (in which case, the
+ thing might have been copied in as well), else return an
+ out-of-dateness error. */
+ SVN_ERR(svn_fs_check_path(&kind, eb->txn_root, full_path, subpool));
+ if ((kind != svn_node_none) && (! pb->was_copied))
+ return svn_error_trace(out_of_date(full_path, kind));
+
+ /* For now, require that the url come from the same repository
+ that this commit is operating on. */
+ copy_path = svn_path_uri_decode(copy_path, subpool);
+ repos_url_len = strlen(eb->repos_url);
+ if (strncmp(copy_path, eb->repos_url, repos_url_len) != 0)
+ return svn_error_createf
+ (SVN_ERR_FS_GENERAL, NULL,
+ _("Source url '%s' is from different repository"), copy_path);
+
+ fs_path = apr_pstrdup(subpool, copy_path + repos_url_len);
+
+ /* Now use the "fs_path" as an absolute path within the
+ repository to make the copy from. */
+ SVN_ERR(svn_fs_revision_root(&copy_root, eb->fs,
+ copy_revision, subpool));
+
+ /* Copy also requires (recursive) read access to the source */
+ required = svn_authz_read | (is_dir ? svn_authz_recursive : 0);
+ SVN_ERR(check_authz(eb, fs_path, copy_root, required, subpool));
+
+ SVN_ERR(svn_fs_copy(copy_root, fs_path,
+ eb->txn_root, full_path, subpool));
+ was_copied = TRUE;
+ }
+ else
+ {
+ /* No ancestry given, just make a new directory or empty file.
+ Note that we don't perform an existence check here like the
+ copy-from case does -- that's because svn_fs_make_*()
+ already errors out if the file already exists. Verify write
+ access to the full path and to the parent. */
+ SVN_ERR(check_authz(eb, full_path, eb->txn_root,
+ svn_authz_write, subpool));
+ SVN_ERR(check_authz(eb, pb->path, eb->txn_root,
+ svn_authz_write, subpool));
+ if (is_dir)
+ SVN_ERR(svn_fs_make_dir(eb->txn_root, full_path, subpool));
+ else
+ SVN_ERR(svn_fs_make_file(eb->txn_root, full_path, subpool));
+ }
+
+ /* Cleanup our temporary subpool. */
+ svn_pool_destroy(subpool);
+
+ /* Build a new child baton. */
+ if (is_dir)
+ {
+ *return_baton = make_dir_baton(eb, pb, full_path, was_copied,
+ SVN_INVALID_REVNUM, pool);
+ }
+ else
+ {
+ struct file_baton *new_fb = apr_pcalloc(pool, sizeof(*new_fb));
+ new_fb->edit_baton = eb;
+ new_fb->path = full_path;
+ *return_baton = new_fb;
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+
+/*** Editor functions ***/
+
+static svn_error_t *
+open_root(void *edit_baton,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool,
+ void **root_baton)
+{
+ struct dir_baton *dirb;
+ struct edit_baton *eb = edit_baton;
+ svn_revnum_t youngest;
+
+ /* Ignore BASE_REVISION. We always build our transaction against
+ HEAD. However, we will keep it in our dir baton for out of
+ dateness checks. */
+ SVN_ERR(svn_fs_youngest_rev(&youngest, eb->fs, eb->pool));
+
+ /* Unless we've been instructed to use a specific transaction, we'll
+ make our own. */
+ if (eb->txn_owner)
+ {
+ SVN_ERR(svn_repos_fs_begin_txn_for_commit2(&(eb->txn),
+ eb->repos,
+ youngest,
+ eb->revprop_table,
+ eb->pool));
+ }
+ else /* Even if we aren't the owner of the transaction, we might
+ have been instructed to set some properties. */
+ {
+ apr_array_header_t *props = svn_prop_hash_to_array(eb->revprop_table,
+ pool);
+ SVN_ERR(svn_repos_fs_change_txn_props(eb->txn, props, pool));
+ }
+ SVN_ERR(svn_fs_txn_name(&(eb->txn_name), eb->txn, eb->pool));
+ SVN_ERR(svn_fs_txn_root(&(eb->txn_root), eb->txn, eb->pool));
+
+ /* Create a root dir baton. The `base_path' field is an -absolute-
+ path in the filesystem, upon which all further editor paths are
+ based. */
+ dirb = apr_pcalloc(pool, sizeof(*dirb));
+ dirb->edit_baton = edit_baton;
+ dirb->parent = NULL;
+ dirb->pool = pool;
+ dirb->was_copied = FALSE;
+ dirb->path = apr_pstrdup(pool, eb->base_path);
+ dirb->base_rev = base_revision;
+
+ *root_baton = dirb;
+ return SVN_NO_ERROR;
+}
+
+
+
+static svn_error_t *
+delete_entry(const char *path,
+ svn_revnum_t revision,
+ void *parent_baton,
+ apr_pool_t *pool)
+{
+ struct dir_baton *parent = parent_baton;
+ struct edit_baton *eb = parent->edit_baton;
+ svn_node_kind_t kind;
+ svn_revnum_t cr_rev;
+ svn_repos_authz_access_t required = svn_authz_write;
+ const char *full_path;
+
+ full_path = svn_fspath__join(eb->base_path,
+ svn_relpath_canonicalize(path, pool), pool);
+
+ /* Check PATH in our transaction. */
+ SVN_ERR(svn_fs_check_path(&kind, eb->txn_root, full_path, pool));
+
+ /* Deletion requires a recursive write access, as well as write
+ access to the parent directory. */
+ if (kind == svn_node_dir)
+ required |= svn_authz_recursive;
+ SVN_ERR(check_authz(eb, full_path, eb->txn_root,
+ required, pool));
+ SVN_ERR(check_authz(eb, parent->path, eb->txn_root,
+ svn_authz_write, pool));
+
+ /* If PATH doesn't exist in the txn, the working copy is out of date. */
+ if (kind == svn_node_none)
+ return svn_error_trace(out_of_date(full_path, kind));
+
+ /* Now, make sure we're deleting the node we *think* we're
+ deleting, else return an out-of-dateness error. */
+ SVN_ERR(svn_fs_node_created_rev(&cr_rev, eb->txn_root, full_path, pool));
+ if (SVN_IS_VALID_REVNUM(revision) && (revision < cr_rev))
+ return svn_error_trace(out_of_date(full_path, kind));
+
+ /* This routine is a mindless wrapper. We call svn_fs_delete()
+ because that will delete files and recursively delete
+ directories. */
+ return svn_fs_delete(eb->txn_root, full_path, pool);
+}
+
+
+static svn_error_t *
+add_directory(const char *path,
+ void *parent_baton,
+ const char *copy_path,
+ svn_revnum_t copy_revision,
+ apr_pool_t *pool,
+ void **child_baton)
+{
+ return add_file_or_directory(path, parent_baton, copy_path, copy_revision,
+ TRUE /* is_dir */, pool, child_baton);
+}
+
+
+static svn_error_t *
+open_directory(const char *path,
+ void *parent_baton,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool,
+ void **child_baton)
+{
+ struct dir_baton *pb = parent_baton;
+ struct edit_baton *eb = pb->edit_baton;
+ svn_node_kind_t kind;
+ const char *full_path;
+
+ full_path = svn_fspath__join(eb->base_path,
+ svn_relpath_canonicalize(path, pool), pool);
+
+ /* Check PATH in our transaction. If it does not exist,
+ return a 'Path not present' error. */
+ SVN_ERR(svn_fs_check_path(&kind, eb->txn_root, full_path, pool));
+ if (kind == svn_node_none)
+ return svn_error_createf(SVN_ERR_FS_NOT_DIRECTORY, NULL,
+ _("Path '%s' not present"),
+ path);
+
+ /* Build a new dir baton for this directory. */
+ *child_baton = make_dir_baton(eb, pb, full_path, pb->was_copied,
+ base_revision, pool);
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+apply_textdelta(void *file_baton,
+ const char *base_checksum,
+ apr_pool_t *pool,
+ svn_txdelta_window_handler_t *handler,
+ void **handler_baton)
+{
+ struct file_baton *fb = file_baton;
+
+ /* Check for write authorization. */
+ SVN_ERR(check_authz(fb->edit_baton, fb->path,
+ fb->edit_baton->txn_root,
+ svn_authz_write, pool));
+
+ return svn_fs_apply_textdelta(handler, handler_baton,
+ fb->edit_baton->txn_root,
+ fb->path,
+ base_checksum,
+ NULL,
+ pool);
+}
+
+
+static svn_error_t *
+add_file(const char *path,
+ void *parent_baton,
+ const char *copy_path,
+ svn_revnum_t copy_revision,
+ apr_pool_t *pool,
+ void **file_baton)
+{
+ return add_file_or_directory(path, parent_baton, copy_path, copy_revision,
+ FALSE /* is_dir */, pool, file_baton);
+}
+
+
+static svn_error_t *
+open_file(const char *path,
+ void *parent_baton,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool,
+ void **file_baton)
+{
+ struct file_baton *new_fb;
+ struct dir_baton *pb = parent_baton;
+ struct edit_baton *eb = pb->edit_baton;
+ svn_revnum_t cr_rev;
+ apr_pool_t *subpool = svn_pool_create(pool);
+ const char *full_path;
+
+ full_path = svn_fspath__join(eb->base_path,
+ svn_relpath_canonicalize(path, pool), pool);
+
+ /* Check for read authorization. */
+ SVN_ERR(check_authz(eb, full_path, eb->txn_root,
+ svn_authz_read, subpool));
+
+ /* Get this node's creation revision (doubles as an existence check). */
+ SVN_ERR(svn_fs_node_created_rev(&cr_rev, eb->txn_root, full_path,
+ subpool));
+
+ /* If the node our caller has is an older revision number than the
+ one in our transaction, return an out-of-dateness error. */
+ if (SVN_IS_VALID_REVNUM(base_revision) && (base_revision < cr_rev))
+ return svn_error_trace(out_of_date(full_path, svn_node_file));
+
+ /* Build a new file baton */
+ new_fb = apr_pcalloc(pool, sizeof(*new_fb));
+ new_fb->edit_baton = eb;
+ new_fb->path = full_path;
+
+ *file_baton = new_fb;
+
+ /* Destory the work subpool. */
+ svn_pool_destroy(subpool);
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+change_file_prop(void *file_baton,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ struct file_baton *fb = file_baton;
+ struct edit_baton *eb = fb->edit_baton;
+
+ /* Check for write authorization. */
+ SVN_ERR(check_authz(eb, fb->path, eb->txn_root,
+ svn_authz_write, pool));
+
+ return svn_repos_fs_change_node_prop(eb->txn_root, fb->path,
+ name, value, pool);
+}
+
+
+static svn_error_t *
+close_file(void *file_baton,
+ const char *text_digest,
+ apr_pool_t *pool)
+{
+ struct file_baton *fb = file_baton;
+
+ if (text_digest)
+ {
+ svn_checksum_t *checksum;
+ svn_checksum_t *text_checksum;
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
+ fb->edit_baton->txn_root, fb->path,
+ TRUE, pool));
+ SVN_ERR(svn_checksum_parse_hex(&text_checksum, svn_checksum_md5,
+ text_digest, pool));
+
+ if (!svn_checksum_match(text_checksum, checksum))
+ return svn_checksum_mismatch_err(text_checksum, checksum, pool,
+ _("Checksum mismatch for resulting fulltext\n(%s)"),
+ fb->path);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+change_dir_prop(void *dir_baton,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ struct dir_baton *db = dir_baton;
+ struct edit_baton *eb = db->edit_baton;
+
+ /* Check for write authorization. */
+ SVN_ERR(check_authz(eb, db->path, eb->txn_root,
+ svn_authz_write, pool));
+
+ if (SVN_IS_VALID_REVNUM(db->base_rev))
+ {
+ /* Subversion rule: propchanges can only happen on a directory
+ which is up-to-date. */
+ svn_revnum_t created_rev;
+ SVN_ERR(svn_fs_node_created_rev(&created_rev,
+ eb->txn_root, db->path, pool));
+
+ if (db->base_rev < created_rev)
+ return svn_error_trace(out_of_date(db->path, svn_node_dir));
+ }
+
+ return svn_repos_fs_change_node_prop(eb->txn_root, db->path,
+ name, value, pool);
+}
+
+const char *
+svn_repos__post_commit_error_str(svn_error_t *err,
+ apr_pool_t *pool)
+{
+ svn_error_t *hook_err1, *hook_err2;
+ const char *msg;
+
+ if (! err)
+ return _("(no error)");
+
+ err = svn_error_purge_tracing(err);
+
+ /* hook_err1 is the SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED wrapped
+ error from the post-commit script, if any, and hook_err2 should
+ be the original error, but be defensive and handle a case where
+ SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED doesn't wrap an error. */
+ hook_err1 = svn_error_find_cause(err, SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED);
+ if (hook_err1 && hook_err1->child)
+ hook_err2 = hook_err1->child;
+ else
+ hook_err2 = hook_err1;
+
+ /* This implementation counts on svn_repos_fs_commit_txn() and
+ libsvn_repos/commit.c:complete_cb() returning
+ svn_fs_commit_txn() as the parent error with a child
+ SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED error. If the parent error
+ is SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED then there was no error
+ in svn_fs_commit_txn().
+
+ The post-commit hook error message is already self describing, so
+ it can be dropped into an error message without any additional
+ text. */
+ if (hook_err1)
+ {
+ if (err == hook_err1)
+ {
+ if (hook_err2->message)
+ msg = apr_pstrdup(pool, hook_err2->message);
+ else
+ msg = _("post-commit hook failed with no error message.");
+ }
+ else
+ {
+ msg = hook_err2->message
+ ? apr_pstrdup(pool, hook_err2->message)
+ : _("post-commit hook failed with no error message.");
+ msg = apr_psprintf(
+ pool,
+ _("post commit FS processing had error:\n%s\n%s"),
+ err->message ? err->message : _("(no error message)"),
+ msg);
+ }
+ }
+ else
+ {
+ msg = apr_psprintf(pool,
+ _("post commit FS processing had error:\n%s"),
+ err->message ? err->message
+ : _("(no error message)"));
+ }
+
+ return msg;
+}
+
+static svn_error_t *
+close_edit(void *edit_baton,
+ apr_pool_t *pool)
+{
+ struct edit_baton *eb = edit_baton;
+ svn_revnum_t new_revision = SVN_INVALID_REVNUM;
+ svn_error_t *err;
+ const char *conflict;
+ const char *post_commit_err = NULL;
+
+ /* If no transaction has been created (ie. if open_root wasn't
+ called before close_edit), abort the operation here with an
+ error. */
+ if (! eb->txn)
+ return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ "No valid transaction supplied to close_edit");
+
+ /* Commit. */
+ err = svn_repos_fs_commit_txn(&conflict, eb->repos,
+ &new_revision, eb->txn, pool);
+
+ if (SVN_IS_VALID_REVNUM(new_revision))
+ {
+ if (err)
+ {
+ /* If the error was in post-commit, then the commit itself
+ succeeded. In which case, save the post-commit warning
+ (to be reported back to the client, who will probably
+ display it as a warning) and clear the error. */
+ post_commit_err = svn_repos__post_commit_error_str(err, pool);
+ svn_error_clear(err);
+ }
+ }
+ else
+ {
+ /* ### todo: we should check whether it really was a conflict,
+ and return the conflict info if so? */
+
+ /* If the commit failed, it's *probably* due to a conflict --
+ that is, the txn being out-of-date. The filesystem gives us
+ the ability to continue diddling the transaction and try
+ again; but let's face it: that's not how the cvs or svn works
+ from a user interface standpoint. Thus we don't make use of
+ this fs feature (for now, at least.)
+
+ So, in a nutshell: svn commits are an all-or-nothing deal.
+ Each commit creates a new fs txn which either succeeds or is
+ aborted completely. No second chances; the user simply
+ needs to update and commit again :) */
+
+ eb->txn_aborted = TRUE;
+
+ return svn_error_trace(
+ svn_error_compose_create(err,
+ svn_fs_abort_txn(eb->txn, pool)));
+ }
+
+ /* At this point, the post-commit error has been converted to a string.
+ That information will be passed to a callback, if provided. If the
+ callback invocation fails in some way, that failure is returned here.
+ IOW, the post-commit error information is low priority compared to
+ other gunk here. */
+
+ /* Pass new revision information to the caller's callback. */
+ return svn_error_trace(invoke_commit_cb(eb->commit_callback,
+ eb->commit_callback_baton,
+ eb->repos->fs,
+ new_revision,
+ post_commit_err,
+ pool));
+}
+
+
+static svn_error_t *
+abort_edit(void *edit_baton,
+ apr_pool_t *pool)
+{
+ struct edit_baton *eb = edit_baton;
+ if ((! eb->txn) || (! eb->txn_owner) || eb->txn_aborted)
+ return SVN_NO_ERROR;
+
+ eb->txn_aborted = TRUE;
+
+ return svn_error_trace(svn_fs_abort_txn(eb->txn, pool));
+}
+
+
+static svn_error_t *
+fetch_props_func(apr_hash_t **props,
+ void *baton,
+ const char *path,
+ svn_revnum_t base_revision,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ struct edit_baton *eb = baton;
+ svn_fs_root_t *fs_root;
+ svn_error_t *err;
+
+ SVN_ERR(svn_fs_revision_root(&fs_root, eb->fs,
+ svn_fs_txn_base_revision(eb->txn),
+ scratch_pool));
+ err = svn_fs_node_proplist(props, fs_root, path, result_pool);
+ if (err && err->apr_err == SVN_ERR_FS_NOT_FOUND)
+ {
+ svn_error_clear(err);
+ *props = apr_hash_make(result_pool);
+ return SVN_NO_ERROR;
+ }
+ else if (err)
+ return svn_error_trace(err);
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+fetch_kind_func(svn_node_kind_t *kind,
+ void *baton,
+ const char *path,
+ svn_revnum_t base_revision,
+ apr_pool_t *scratch_pool)
+{
+ struct edit_baton *eb = baton;
+ svn_fs_root_t *fs_root;
+
+ if (!SVN_IS_VALID_REVNUM(base_revision))
+ base_revision = svn_fs_txn_base_revision(eb->txn);
+
+ SVN_ERR(svn_fs_revision_root(&fs_root, eb->fs, base_revision, scratch_pool));
+
+ SVN_ERR(svn_fs_check_path(kind, fs_root, path, scratch_pool));
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+fetch_base_func(const char **filename,
+ void *baton,
+ const char *path,
+ svn_revnum_t base_revision,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ struct edit_baton *eb = baton;
+ svn_stream_t *contents;
+ svn_stream_t *file_stream;
+ const char *tmp_filename;
+ svn_fs_root_t *fs_root;
+ svn_error_t *err;
+
+ if (!SVN_IS_VALID_REVNUM(base_revision))
+ base_revision = svn_fs_txn_base_revision(eb->txn);
+
+ SVN_ERR(svn_fs_revision_root(&fs_root, eb->fs, base_revision, scratch_pool));
+
+ err = svn_fs_file_contents(&contents, fs_root, path, scratch_pool);
+ if (err && err->apr_err == SVN_ERR_FS_NOT_FOUND)
+ {
+ svn_error_clear(err);
+ *filename = NULL;
+ return SVN_NO_ERROR;
+ }
+ else if (err)
+ return svn_error_trace(err);
+ SVN_ERR(svn_stream_open_unique(&file_stream, &tmp_filename, NULL,
+ svn_io_file_del_on_pool_cleanup,
+ scratch_pool, scratch_pool));
+ SVN_ERR(svn_stream_copy3(contents, file_stream, NULL, NULL, scratch_pool));
+
+ *filename = apr_pstrdup(result_pool, tmp_filename);
+
+ return SVN_NO_ERROR;
+}
+
+
+
+/*** Public interfaces. ***/
+
+svn_error_t *
+svn_repos_get_commit_editor5(const svn_delta_editor_t **editor,
+ void **edit_baton,
+ svn_repos_t *repos,
+ svn_fs_txn_t *txn,
+ const char *repos_url,
+ const char *base_path,
+ apr_hash_t *revprop_table,
+ svn_commit_callback2_t commit_callback,
+ void *commit_baton,
+ svn_repos_authz_callback_t authz_callback,
+ void *authz_baton,
+ apr_pool_t *pool)
+{
+ svn_delta_editor_t *e;
+ apr_pool_t *subpool = svn_pool_create(pool);
+ struct edit_baton *eb;
+ svn_delta_shim_callbacks_t *shim_callbacks =
+ svn_delta_shim_callbacks_default(pool);
+
+ /* Do a global authz access lookup. Users with no write access
+ whatsoever to the repository don't get a commit editor. */
+ if (authz_callback)
+ {
+ svn_boolean_t allowed;
+
+ SVN_ERR(authz_callback(svn_authz_write, &allowed, NULL, NULL,
+ authz_baton, pool));
+ if (!allowed)
+ return svn_error_create(SVN_ERR_AUTHZ_UNWRITABLE, NULL,
+ "Not authorized to open a commit editor.");
+ }
+
+ /* Allocate the structures. */
+ e = svn_delta_default_editor(pool);
+ eb = apr_pcalloc(subpool, sizeof(*eb));
+
+ /* Set up the editor. */
+ e->open_root = open_root;
+ e->delete_entry = delete_entry;
+ e->add_directory = add_directory;
+ e->open_directory = open_directory;
+ e->change_dir_prop = change_dir_prop;
+ e->add_file = add_file;
+ e->open_file = open_file;
+ e->close_file = close_file;
+ e->apply_textdelta = apply_textdelta;
+ e->change_file_prop = change_file_prop;
+ e->close_edit = close_edit;
+ e->abort_edit = abort_edit;
+
+ /* Set up the edit baton. */
+ eb->pool = subpool;
+ eb->revprop_table = svn_prop_hash_dup(revprop_table, subpool);
+ eb->commit_callback = commit_callback;
+ eb->commit_callback_baton = commit_baton;
+ eb->authz_callback = authz_callback;
+ eb->authz_baton = authz_baton;
+ eb->base_path = svn_fspath__canonicalize(base_path, subpool);
+ eb->repos = repos;
+ eb->repos_url = repos_url;
+ eb->repos_name = svn_dirent_basename(svn_repos_path(repos, subpool),
+ subpool);
+ eb->fs = svn_repos_fs(repos);
+ eb->txn = txn;
+ eb->txn_owner = txn == NULL;
+
+ *edit_baton = eb;
+ *editor = e;
+
+ shim_callbacks->fetch_props_func = fetch_props_func;
+ shim_callbacks->fetch_kind_func = fetch_kind_func;
+ shim_callbacks->fetch_base_func = fetch_base_func;
+ shim_callbacks->fetch_baton = eb;
+
+ SVN_ERR(svn_editor__insert_shims(editor, edit_baton, *editor, *edit_baton,
+ eb->repos_url, eb->base_path,
+ shim_callbacks, pool, pool));
+
+ return SVN_NO_ERROR;
+}
+
+
+#if 0
+static svn_error_t *
+ev2_check_authz(const struct ev2_baton *eb,
+ const char *relpath,
+ svn_repos_authz_access_t required,
+ apr_pool_t *scratch_pool)
+{
+ const char *fspath;
+ svn_boolean_t allowed;
+
+ if (eb->authz == NULL)
+ return SVN_NO_ERROR;
+
+ if (relpath)
+ fspath = apr_pstrcat(scratch_pool, "/", relpath, NULL);
+ else
+ fspath = NULL;
+
+ SVN_ERR(svn_repos_authz_check_access(eb->authz, eb->authz_repos_name, fspath,
+ eb->authz_user, required,
+ &allowed, scratch_pool));
+ if (!allowed)
+ return svn_error_create(required & svn_authz_write
+ ? SVN_ERR_AUTHZ_UNWRITABLE
+ : SVN_ERR_AUTHZ_UNREADABLE,
+ NULL, "Access denied");
+
+ return SVN_NO_ERROR;
+}
+#endif
+
+
+/* This implements svn_editor_cb_add_directory_t */
+static svn_error_t *
+add_directory_cb(void *baton,
+ const char *relpath,
+ const apr_array_header_t *children,
+ apr_hash_t *props,
+ svn_revnum_t replaces_rev,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_add_directory(eb->inner, relpath, children, props,
+ replaces_rev));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_add_file_t */
+static svn_error_t *
+add_file_cb(void *baton,
+ const char *relpath,
+ const svn_checksum_t *checksum,
+ svn_stream_t *contents,
+ apr_hash_t *props,
+ svn_revnum_t replaces_rev,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_add_file(eb->inner, relpath, checksum, contents, props,
+ replaces_rev));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_add_symlink_t */
+static svn_error_t *
+add_symlink_cb(void *baton,
+ const char *relpath,
+ const char *target,
+ apr_hash_t *props,
+ svn_revnum_t replaces_rev,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_add_symlink(eb->inner, relpath, target, props,
+ replaces_rev));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_add_absent_t */
+static svn_error_t *
+add_absent_cb(void *baton,
+ const char *relpath,
+ svn_node_kind_t kind,
+ svn_revnum_t replaces_rev,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_add_absent(eb->inner, relpath, kind, replaces_rev));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_alter_directory_t */
+static svn_error_t *
+alter_directory_cb(void *baton,
+ const char *relpath,
+ svn_revnum_t revision,
+ const apr_array_header_t *children,
+ apr_hash_t *props,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_alter_directory(eb->inner, relpath, revision,
+ children, props));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_alter_file_t */
+static svn_error_t *
+alter_file_cb(void *baton,
+ const char *relpath,
+ svn_revnum_t revision,
+ apr_hash_t *props,
+ const svn_checksum_t *checksum,
+ svn_stream_t *contents,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_alter_file(eb->inner, relpath, revision, props,
+ checksum, contents));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_alter_symlink_t */
+static svn_error_t *
+alter_symlink_cb(void *baton,
+ const char *relpath,
+ svn_revnum_t revision,
+ apr_hash_t *props,
+ const char *target,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_alter_symlink(eb->inner, relpath, revision, props,
+ target));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_delete_t */
+static svn_error_t *
+delete_cb(void *baton,
+ const char *relpath,
+ svn_revnum_t revision,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_delete(eb->inner, relpath, revision));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_copy_t */
+static svn_error_t *
+copy_cb(void *baton,
+ const char *src_relpath,
+ svn_revnum_t src_revision,
+ const char *dst_relpath,
+ svn_revnum_t replaces_rev,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_copy(eb->inner, src_relpath, src_revision, dst_relpath,
+ replaces_rev));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_move_t */
+static svn_error_t *
+move_cb(void *baton,
+ const char *src_relpath,
+ svn_revnum_t src_revision,
+ const char *dst_relpath,
+ svn_revnum_t replaces_rev,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_move(eb->inner, src_relpath, src_revision, dst_relpath,
+ replaces_rev));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_rotate_t */
+static svn_error_t *
+rotate_cb(void *baton,
+ const apr_array_header_t *relpaths,
+ const apr_array_header_t *revisions,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_rotate(eb->inner, relpaths, revisions));
+ return SVN_NO_ERROR;
+}
+
+
+/* This implements svn_editor_cb_complete_t */
+static svn_error_t *
+complete_cb(void *baton,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+ svn_revnum_t revision;
+ svn_error_t *post_commit_err;
+ const char *conflict_path;
+ svn_error_t *err;
+ const char *post_commit_errstr;
+ apr_hash_t *hooks_env;
+
+ /* Parse the hooks-env file (if any). */
+ SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, eb->repos->hooks_env_path,
+ scratch_pool, scratch_pool));
+
+ /* The transaction has been fully edited. Let the pre-commit hook
+ have a look at the thing. */
+ SVN_ERR(svn_repos__hooks_pre_commit(eb->repos, hooks_env,
+ eb->txn_name, scratch_pool));
+
+ /* Hook is done. Let's do the actual commit. */
+ SVN_ERR(svn_fs__editor_commit(&revision, &post_commit_err, &conflict_path,
+ eb->inner, scratch_pool, scratch_pool));
+
+ /* Did a conflict occur during the commit process? */
+ if (conflict_path != NULL)
+ return svn_error_createf(SVN_ERR_FS_CONFLICT, NULL,
+ _("Conflict at '%s'"), conflict_path);
+
+ /* Since did not receive an error during the commit process, and no
+ conflict was specified... we committed a revision. Run the hooks.
+ Other errors may have occurred within the FS (specified by the
+ POST_COMMIT_ERR localvar), but we need to run the hooks. */
+ SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(revision));
+ err = svn_repos__hooks_post_commit(eb->repos, hooks_env, revision,
+ eb->txn_name, scratch_pool);
+ if (err)
+ err = svn_error_create(SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED, err,
+ _("Commit succeeded, but post-commit hook failed"));
+
+ /* Combine the FS errors with the hook errors, and stringify. */
+ err = svn_error_compose_create(post_commit_err, err);
+ if (err)
+ {
+ post_commit_errstr = svn_repos__post_commit_error_str(err, scratch_pool);
+ svn_error_clear(err);
+ }
+ else
+ {
+ post_commit_errstr = NULL;
+ }
+
+ return svn_error_trace(invoke_commit_cb(eb->commit_cb, eb->commit_baton,
+ eb->repos->fs, revision,
+ post_commit_errstr,
+ scratch_pool));
+}
+
+
+/* This implements svn_editor_cb_abort_t */
+static svn_error_t *
+abort_cb(void *baton,
+ apr_pool_t *scratch_pool)
+{
+ struct ev2_baton *eb = baton;
+
+ SVN_ERR(svn_editor_abort(eb->inner));
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+apply_revprops(svn_fs_t *fs,
+ const char *txn_name,
+ apr_hash_t *revprops,
+ apr_pool_t *scratch_pool)
+{
+ svn_fs_txn_t *txn;
+ const apr_array_header_t *revprops_array;
+
+ /* The FS editor has a TXN inside it, but we can't access it. Open another
+ based on the TXN_NAME. */
+ SVN_ERR(svn_fs_open_txn(&txn, fs, txn_name, scratch_pool));
+
+ /* Validate and apply the revision properties. */
+ revprops_array = svn_prop_hash_to_array(revprops, scratch_pool);
+ SVN_ERR(svn_repos_fs_change_txn_props(txn, revprops_array, scratch_pool));
+
+ /* ### do we need to force the txn to close, or is it enough to wait
+ ### for the pool to be cleared? */
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos__get_commit_ev2(svn_editor_t **editor,
+ svn_repos_t *repos,
+ svn_authz_t *authz,
+ const char *authz_repos_name,
+ const char *authz_user,
+ apr_hash_t *revprops,
+ svn_commit_callback2_t commit_cb,
+ void *commit_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ static const svn_editor_cb_many_t editor_cbs = {
+ add_directory_cb,
+ add_file_cb,
+ add_symlink_cb,
+ add_absent_cb,
+ alter_directory_cb,
+ alter_file_cb,
+ alter_symlink_cb,
+ delete_cb,
+ copy_cb,
+ move_cb,
+ rotate_cb,
+ complete_cb,
+ abort_cb
+ };
+ struct ev2_baton *eb;
+ const svn_string_t *author;
+ apr_hash_t *hooks_env;
+
+ /* Parse the hooks-env file (if any). */
+ SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,
+ scratch_pool, scratch_pool));
+
+ /* Can the user modify the repository at all? */
+ /* ### check against AUTHZ. */
+
+ author = svn_hash_gets(revprops, SVN_PROP_REVISION_AUTHOR);
+
+ eb = apr_palloc(result_pool, sizeof(*eb));
+ eb->repos = repos;
+ eb->authz = authz;
+ eb->authz_repos_name = authz_repos_name;
+ eb->authz_user = authz_user;
+ eb->commit_cb = commit_cb;
+ eb->commit_baton = commit_baton;
+
+ SVN_ERR(svn_fs__editor_create(&eb->inner, &eb->txn_name,
+ repos->fs, SVN_FS_TXN_CHECK_LOCKS,
+ cancel_func, cancel_baton,
+ result_pool, scratch_pool));
+
+ /* The TXN has been created. Go ahead and apply all revision properties. */
+ SVN_ERR(apply_revprops(repos->fs, eb->txn_name, revprops, scratch_pool));
+
+ /* Okay... some access is allowed. Let's run the start-commit hook. */
+ SVN_ERR(svn_repos__hooks_start_commit(repos, hooks_env,
+ author ? author->data : NULL,
+ repos->client_capabilities,
+ eb->txn_name, scratch_pool));
+
+ /* Wrap the FS editor within our editor. */
+ SVN_ERR(svn_editor_create(editor, eb, cancel_func, cancel_baton,
+ result_pool, scratch_pool));
+ SVN_ERR(svn_editor_setcb_many(*editor, &editor_cbs, scratch_pool));
+
+ return SVN_NO_ERROR;
+}
diff --git a/subversion/libsvn_repos/delta.c b/subversion/libsvn_repos/delta.c
new file mode 100644
index 000000000000..51cfda7bfd2b
--- /dev/null
+++ b/subversion/libsvn_repos/delta.c
@@ -0,0 +1,1074 @@
+/*
+ * delta.c: an editor driver for expressing differences between two trees
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+
+#include <apr_hash.h>
+
+#include "svn_hash.h"
+#include "svn_types.h"
+#include "svn_delta.h"
+#include "svn_fs.h"
+#include "svn_checksum.h"
+#include "svn_path.h"
+#include "svn_repos.h"
+#include "svn_pools.h"
+#include "svn_props.h"
+#include "svn_private_config.h"
+#include "repos.h"
+
+
+
+/* THINGS TODO: Currently the code herein gives only a slight nod to
+ fully supporting directory deltas that involve renames, copies, and
+ such. */
+
+
+/* Some datatypes and declarations used throughout the file. */
+
+
+/* Parameters which remain constant throughout a delta traversal.
+ At the top of the recursion, we initialize one of these structures.
+ Then we pass it down to every call. This way, functions invoked
+ deep in the recursion can get access to this traversal's global
+ parameters, without using global variables. */
+struct context {
+ const svn_delta_editor_t *editor;
+ const char *edit_base_path;
+ svn_fs_root_t *source_root;
+ svn_fs_root_t *target_root;
+ svn_repos_authz_func_t authz_read_func;
+ void *authz_read_baton;
+ svn_boolean_t text_deltas;
+ svn_boolean_t entry_props;
+ svn_boolean_t ignore_ancestry;
+};
+
+
+/* The type of a function that accepts changes to an object's property
+ list. OBJECT is the object whose properties are being changed.
+ NAME is the name of the property to change. VALUE is the new value
+ for the property, or zero if the property should be deleted. */
+typedef svn_error_t *proplist_change_fn_t(struct context *c,
+ void *object,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool);
+
+
+
+/* Some prototypes for functions used throughout. See each individual
+ function for information about what it does. */
+
+
+/* Retrieving the base revision from the path/revision hash. */
+static svn_revnum_t get_path_revision(svn_fs_root_t *root,
+ const char *path,
+ apr_pool_t *pool);
+
+
+/* proplist_change_fn_t property changing functions. */
+static svn_error_t *change_dir_prop(struct context *c,
+ void *object,
+ const char *path,
+ const svn_string_t *value,
+ apr_pool_t *pool);
+
+static svn_error_t *change_file_prop(struct context *c,
+ void *object,
+ const char *path,
+ const svn_string_t *value,
+ apr_pool_t *pool);
+
+
+/* Constructing deltas for properties of files and directories. */
+static svn_error_t *delta_proplists(struct context *c,
+ const char *source_path,
+ const char *target_path,
+ proplist_change_fn_t *change_fn,
+ void *object,
+ apr_pool_t *pool);
+
+
+/* Constructing deltas for file constents. */
+static svn_error_t *send_text_delta(struct context *c,
+ void *file_baton,
+ const char *base_checksum,
+ svn_txdelta_stream_t *delta_stream,
+ apr_pool_t *pool);
+
+static svn_error_t *delta_files(struct context *c,
+ void *file_baton,
+ const char *source_path,
+ const char *target_path,
+ apr_pool_t *pool);
+
+
+/* Generic directory deltafication routines. */
+static svn_error_t *delete(struct context *c,
+ void *dir_baton,
+ const char *edit_path,
+ apr_pool_t *pool);
+
+static svn_error_t *add_file_or_dir(struct context *c,
+ void *dir_baton,
+ svn_depth_t depth,
+ const char *target_path,
+ const char *edit_path,
+ svn_node_kind_t tgt_kind,
+ apr_pool_t *pool);
+
+static svn_error_t *replace_file_or_dir(struct context *c,
+ void *dir_baton,
+ svn_depth_t depth,
+ const char *source_path,
+ const char *target_path,
+ const char *edit_path,
+ svn_node_kind_t tgt_kind,
+ apr_pool_t *pool);
+
+static svn_error_t *absent_file_or_dir(struct context *c,
+ void *dir_baton,
+ const char *edit_path,
+ svn_node_kind_t tgt_kind,
+ apr_pool_t *pool);
+
+static svn_error_t *delta_dirs(struct context *c,
+ void *dir_baton,
+ svn_depth_t depth,
+ const char *source_path,
+ const char *target_path,
+ const char *edit_path,
+ apr_pool_t *pool);
+
+
+
+#define MAYBE_DEMOTE_DEPTH(depth) \
+ (((depth) == svn_depth_immediates || (depth) == svn_depth_files) \
+ ? svn_depth_empty \
+ : (depth))
+
+
+/* Return the error 'SVN_ERR_AUTHZ_ROOT_UNREADABLE' if PATH in ROOT is
+ * unreadable according to AUTHZ_READ_FUNC with AUTHZ_READ_BATON.
+ *
+ * PATH should be the implicit root path of an editor drive, that is,
+ * the path used by editor->open_root().
+ */
+static svn_error_t *
+authz_root_check(svn_fs_root_t *root,
+ const char *path,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ svn_boolean_t allowed;
+
+ if (authz_read_func)
+ {
+ SVN_ERR(authz_read_func(&allowed, root, path, authz_read_baton, pool));
+
+ if (! allowed)
+ return svn_error_create(SVN_ERR_AUTHZ_ROOT_UNREADABLE, 0,
+ _("Unable to open root of edit"));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+not_a_dir_error(const char *role,
+ const char *path)
+{
+ return svn_error_createf
+ (SVN_ERR_FS_NOT_DIRECTORY, 0,
+ "Invalid %s directory '%s'",
+ role, path ? path : "(null)");
+}
+
+
+/* Public interface to computing directory deltas. */
+svn_error_t *
+svn_repos_dir_delta2(svn_fs_root_t *src_root,
+ const char *src_parent_dir,
+ const char *src_entry,
+ svn_fs_root_t *tgt_root,
+ const char *tgt_fullpath,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ svn_boolean_t text_deltas,
+ svn_depth_t depth,
+ svn_boolean_t entry_props,
+ svn_boolean_t ignore_ancestry,
+ apr_pool_t *pool)
+{
+ void *root_baton = NULL;
+ struct context c;
+ const char *src_fullpath;
+ const svn_fs_id_t *src_id, *tgt_id;
+ svn_node_kind_t src_kind, tgt_kind;
+ svn_revnum_t rootrev;
+ int distance;
+ const char *authz_root_path;
+
+ /* SRC_PARENT_DIR must be valid. */
+ if (src_parent_dir)
+ src_parent_dir = svn_relpath_canonicalize(src_parent_dir, pool);
+ else
+ return not_a_dir_error("source parent", src_parent_dir);
+
+ /* TGT_FULLPATH must be valid. */
+ if (tgt_fullpath)
+ tgt_fullpath = svn_relpath_canonicalize(tgt_fullpath, pool);
+ else
+ return svn_error_create(SVN_ERR_FS_PATH_SYNTAX, 0,
+ _("Invalid target path"));
+
+ if (depth == svn_depth_exclude)
+ return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("Delta depth 'exclude' not supported"));
+
+ /* Calculate the fs path implicitly used for editor->open_root, so
+ we can do an authz check on that path first. */
+ if (*src_entry)
+ authz_root_path = svn_relpath_dirname(tgt_fullpath, pool);
+ else
+ authz_root_path = tgt_fullpath;
+
+ /* Construct the full path of the source item. */
+ src_fullpath = svn_relpath_join(src_parent_dir, src_entry, pool);
+
+ /* Get the node kinds for the source and target paths. */
+ SVN_ERR(svn_fs_check_path(&tgt_kind, tgt_root, tgt_fullpath, pool));
+ SVN_ERR(svn_fs_check_path(&src_kind, src_root, src_fullpath, pool));
+
+ /* If neither of our paths exists, we don't really have anything to do. */
+ if ((tgt_kind == svn_node_none) && (src_kind == svn_node_none))
+ goto cleanup;
+
+ /* If either the source or the target is a non-directory, we
+ require that a SRC_ENTRY be supplied. */
+ if ((! *src_entry) && ((src_kind != svn_node_dir)
+ || tgt_kind != svn_node_dir))
+ return svn_error_create
+ (SVN_ERR_FS_PATH_SYNTAX, 0,
+ _("Invalid editor anchoring; at least one of the "
+ "input paths is not a directory and there was no source entry"));
+
+ /* Set the global target revision if one can be determined. */
+ if (svn_fs_is_revision_root(tgt_root))
+ {
+ SVN_ERR(editor->set_target_revision
+ (edit_baton, svn_fs_revision_root_revision(tgt_root), pool));
+ }
+ else if (svn_fs_is_txn_root(tgt_root))
+ {
+ SVN_ERR(editor->set_target_revision
+ (edit_baton, svn_fs_txn_root_base_revision(tgt_root), pool));
+ }
+
+ /* Setup our pseudo-global structure here. We need these variables
+ throughout the deltafication process, so pass them around by
+ reference to all the helper functions. */
+ c.editor = editor;
+ c.source_root = src_root;
+ c.target_root = tgt_root;
+ c.authz_read_func = authz_read_func;
+ c.authz_read_baton = authz_read_baton;
+ c.text_deltas = text_deltas;
+ c.entry_props = entry_props;
+ c.ignore_ancestry = ignore_ancestry;
+
+ /* Get our editor root's revision. */
+ rootrev = get_path_revision(src_root, src_parent_dir, pool);
+
+ /* If one or the other of our paths doesn't exist, we have to handle
+ those cases specially. */
+ if (tgt_kind == svn_node_none)
+ {
+ /* Caller thinks that target still exists, but it doesn't.
+ So transform their source path to "nothing" by deleting it. */
+ SVN_ERR(authz_root_check(tgt_root, authz_root_path,
+ authz_read_func, authz_read_baton, pool));
+ SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
+ SVN_ERR(delete(&c, root_baton, src_entry, pool));
+ goto cleanup;
+ }
+ if (src_kind == svn_node_none)
+ {
+ /* The source path no longer exists, but the target does.
+ So transform "nothing" into "something" by adding. */
+ SVN_ERR(authz_root_check(tgt_root, authz_root_path,
+ authz_read_func, authz_read_baton, pool));
+ SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
+ SVN_ERR(add_file_or_dir(&c, root_baton, depth, tgt_fullpath,
+ src_entry, tgt_kind, pool));
+ goto cleanup;
+ }
+
+ /* Get and compare the node IDs for the source and target. */
+ SVN_ERR(svn_fs_node_id(&tgt_id, tgt_root, tgt_fullpath, pool));
+ SVN_ERR(svn_fs_node_id(&src_id, src_root, src_fullpath, pool));
+ distance = svn_fs_compare_ids(src_id, tgt_id);
+
+ if (distance == 0)
+ {
+ /* They are the same node! No-op (you gotta love those). */
+ goto cleanup;
+ }
+ else if (*src_entry)
+ {
+ /* If the nodes have different kinds, we must delete the one and
+ add the other. Also, if they are completely unrelated and
+ our caller is interested in relatedness, we do the same thing. */
+ if ((src_kind != tgt_kind)
+ || ((distance == -1) && (! ignore_ancestry)))
+ {
+ SVN_ERR(authz_root_check(tgt_root, authz_root_path,
+ authz_read_func, authz_read_baton, pool));
+ SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
+ SVN_ERR(delete(&c, root_baton, src_entry, pool));
+ SVN_ERR(add_file_or_dir(&c, root_baton, depth, tgt_fullpath,
+ src_entry, tgt_kind, pool));
+ }
+ /* Otherwise, we just replace the one with the other. */
+ else
+ {
+ SVN_ERR(authz_root_check(tgt_root, authz_root_path,
+ authz_read_func, authz_read_baton, pool));
+ SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
+ SVN_ERR(replace_file_or_dir(&c, root_baton, depth, src_fullpath,
+ tgt_fullpath, src_entry,
+ tgt_kind, pool));
+ }
+ }
+ else
+ {
+ /* There is no entry given, so delta the whole parent directory. */
+ SVN_ERR(authz_root_check(tgt_root, authz_root_path,
+ authz_read_func, authz_read_baton, pool));
+ SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
+ SVN_ERR(delta_dirs(&c, root_baton, depth, src_fullpath,
+ tgt_fullpath, "", pool));
+ }
+
+ cleanup:
+
+ /* Make sure we close the root directory if we opened one above. */
+ if (root_baton)
+ SVN_ERR(editor->close_directory(root_baton, pool));
+
+ /* Close the edit. */
+ return editor->close_edit(edit_baton, pool);
+}
+
+
+/* Retrieving the base revision from the path/revision hash. */
+
+
+static svn_revnum_t
+get_path_revision(svn_fs_root_t *root,
+ const char *path,
+ apr_pool_t *pool)
+{
+ svn_revnum_t revision;
+ svn_error_t *err;
+
+ /* Easy out -- if ROOT is a revision root, we can use the revision
+ that it's a root of. */
+ if (svn_fs_is_revision_root(root))
+ return svn_fs_revision_root_revision(root);
+
+ /* Else, this must be a transaction root, so ask the filesystem in
+ what revision this path was created. */
+ if ((err = svn_fs_node_created_rev(&revision, root, path, pool)))
+ {
+ revision = SVN_INVALID_REVNUM;
+ svn_error_clear(err);
+ }
+
+ /* If we don't get back a valid revision, this path is mutable in
+ the transaction. We should probably examine the node on which it
+ is based, doable by querying for the node-id of the path, and
+ then examining that node-id's predecessor. ### This predecessor
+ determination isn't exposed via the FS public API right now, so
+ for now, we'll just return the SVN_INVALID_REVNUM. */
+ return revision;
+}
+
+
+/* proplist_change_fn_t property changing functions. */
+
+
+/* Call the directory property-setting function of C->editor to set
+ the property NAME to given VALUE on the OBJECT passed to this
+ function. */
+static svn_error_t *
+change_dir_prop(struct context *c,
+ void *object,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ return c->editor->change_dir_prop(object, name, value, pool);
+}
+
+
+/* Call the file property-setting function of C->editor to set the
+ property NAME to given VALUE on the OBJECT passed to this
+ function. */
+static svn_error_t *
+change_file_prop(struct context *c,
+ void *object,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ return c->editor->change_file_prop(object, name, value, pool);
+}
+
+
+
+
+/* Constructing deltas for properties of files and directories. */
+
+
+/* Generate the appropriate property editing calls to turn the
+ properties of SOURCE_PATH into those of TARGET_PATH. If
+ SOURCE_PATH is NULL, this is an add, so assume the target starts
+ with no properties. Pass OBJECT on to the editor function wrapper
+ CHANGE_FN. */
+static svn_error_t *
+delta_proplists(struct context *c,
+ const char *source_path,
+ const char *target_path,
+ proplist_change_fn_t *change_fn,
+ void *object,
+ apr_pool_t *pool)
+{
+ apr_hash_t *s_props = 0;
+ apr_hash_t *t_props = 0;
+ apr_pool_t *subpool;
+ apr_array_header_t *prop_diffs;
+ int i;
+
+ SVN_ERR_ASSERT(target_path);
+
+ /* Make a subpool for local allocations. */
+ subpool = svn_pool_create(pool);
+
+ /* If we're supposed to send entry props for all non-deleted items,
+ here we go! */
+ if (c->entry_props)
+ {
+ svn_revnum_t committed_rev = SVN_INVALID_REVNUM;
+ svn_string_t *cr_str = NULL;
+ svn_string_t *committed_date = NULL;
+ svn_string_t *last_author = NULL;
+
+ /* Get the CR and two derivative props. ### check for error returns. */
+ SVN_ERR(svn_fs_node_created_rev(&committed_rev, c->target_root,
+ target_path, subpool));
+ if (SVN_IS_VALID_REVNUM(committed_rev))
+ {
+ svn_fs_t *fs = svn_fs_root_fs(c->target_root);
+ apr_hash_t *r_props;
+ const char *uuid;
+
+ /* Transmit the committed-rev. */
+ cr_str = svn_string_createf(subpool, "%ld",
+ committed_rev);
+ SVN_ERR(change_fn(c, object, SVN_PROP_ENTRY_COMMITTED_REV,
+ cr_str, subpool));
+
+ SVN_ERR(svn_fs_revision_proplist(&r_props, fs, committed_rev,
+ pool));
+
+ /* Transmit the committed-date. */
+ committed_date = svn_hash_gets(r_props, SVN_PROP_REVISION_DATE);
+ if (committed_date || source_path)
+ {
+ SVN_ERR(change_fn(c, object, SVN_PROP_ENTRY_COMMITTED_DATE,
+ committed_date, subpool));
+ }
+
+ /* Transmit the last-author. */
+ last_author = svn_hash_gets(r_props, SVN_PROP_REVISION_AUTHOR);
+ if (last_author || source_path)
+ {
+ SVN_ERR(change_fn(c, object, SVN_PROP_ENTRY_LAST_AUTHOR,
+ last_author, subpool));
+ }
+
+ /* Transmit the UUID. */
+ SVN_ERR(svn_fs_get_uuid(fs, &uuid, subpool));
+ SVN_ERR(change_fn(c, object, SVN_PROP_ENTRY_UUID,
+ svn_string_create(uuid, subpool),
+ subpool));
+ }
+ }
+
+ if (source_path)
+ {
+ svn_boolean_t changed;
+
+ /* Is this deltification worth our time? */
+ SVN_ERR(svn_fs_props_changed(&changed, c->target_root, target_path,
+ c->source_root, source_path, subpool));
+ if (! changed)
+ goto cleanup;
+
+ /* If so, go ahead and get the source path's properties. */
+ SVN_ERR(svn_fs_node_proplist(&s_props, c->source_root,
+ source_path, subpool));
+ }
+ else
+ {
+ s_props = apr_hash_make(subpool);
+ }
+
+ /* Get the target path's properties */
+ SVN_ERR(svn_fs_node_proplist(&t_props, c->target_root,
+ target_path, subpool));
+
+ /* Now transmit the differences. */
+ SVN_ERR(svn_prop_diffs(&prop_diffs, t_props, s_props, subpool));
+ for (i = 0; i < prop_diffs->nelts; i++)
+ {
+ const svn_prop_t *pc = &APR_ARRAY_IDX(prop_diffs, i, svn_prop_t);
+ SVN_ERR(change_fn(c, object, pc->name, pc->value, subpool));
+ }
+
+ cleanup:
+ /* Destroy local subpool. */
+ svn_pool_destroy(subpool);
+
+ return SVN_NO_ERROR;
+}
+
+
+
+
+/* Constructing deltas for file contents. */
+
+
+/* Change the contents of FILE_BATON in C->editor, according to the
+ text delta from DELTA_STREAM. Pass BASE_CHECKSUM along to
+ C->editor->apply_textdelta. */
+static svn_error_t *
+send_text_delta(struct context *c,
+ void *file_baton,
+ const char *base_checksum,
+ svn_txdelta_stream_t *delta_stream,
+ apr_pool_t *pool)
+{
+ svn_txdelta_window_handler_t delta_handler;
+ void *delta_handler_baton;
+
+ /* Get a handler that will apply the delta to the file. */
+ SVN_ERR(c->editor->apply_textdelta
+ (file_baton, base_checksum, pool,
+ &delta_handler, &delta_handler_baton));
+
+ if (c->text_deltas && delta_stream)
+ {
+ /* Deliver the delta stream to the file. */
+ return svn_txdelta_send_txstream(delta_stream,
+ delta_handler,
+ delta_handler_baton,
+ pool);
+ }
+ else
+ {
+ /* The caller doesn't want text delta data. Just send a single
+ NULL window. */
+ return delta_handler(NULL, delta_handler_baton);
+ }
+}
+
+svn_error_t *
+svn_repos__compare_files(svn_boolean_t *changed_p,
+ svn_fs_root_t *root1,
+ const char *path1,
+ svn_fs_root_t *root2,
+ const char *path2,
+ apr_pool_t *pool)
+{
+ svn_filesize_t size1, size2;
+ svn_checksum_t *checksum1, *checksum2;
+ svn_stream_t *stream1, *stream2;
+ svn_boolean_t same;
+
+ /* If the filesystem claims the things haven't changed, then they
+ haven't changed. */
+ SVN_ERR(svn_fs_contents_changed(changed_p, root1, path1,
+ root2, path2, pool));
+ if (!*changed_p)
+ return SVN_NO_ERROR;
+
+ /* If the SHA1 checksums match for these things, we'll claim they
+ have the same contents. (We don't give quite as much weight to
+ MD5 checksums.) */
+ SVN_ERR(svn_fs_file_checksum(&checksum1, svn_checksum_sha1,
+ root1, path1, FALSE, pool));
+ SVN_ERR(svn_fs_file_checksum(&checksum2, svn_checksum_sha1,
+ root2, path2, FALSE, pool));
+ if (checksum1 && checksum2)
+ {
+ *changed_p = !svn_checksum_match(checksum1, checksum2);
+ return SVN_NO_ERROR;
+ }
+
+ /* From this point on, our default answer is "Nothing's changed". */
+ *changed_p = FALSE;
+
+ /* Different filesizes means the contents are different. */
+ SVN_ERR(svn_fs_file_length(&size1, root1, path1, pool));
+ SVN_ERR(svn_fs_file_length(&size2, root2, path2, pool));
+ if (size1 != size2)
+ {
+ *changed_p = TRUE;
+ return SVN_NO_ERROR;
+ }
+
+ /* Different MD5 checksums means the contents are different. */
+ SVN_ERR(svn_fs_file_checksum(&checksum1, svn_checksum_md5, root1, path1,
+ FALSE, pool));
+ SVN_ERR(svn_fs_file_checksum(&checksum2, svn_checksum_md5, root2, path2,
+ FALSE, pool));
+ if (! svn_checksum_match(checksum1, checksum2))
+ {
+ *changed_p = TRUE;
+ return SVN_NO_ERROR;
+ }
+
+ /* And finally, different contents means the ... uh ... contents are
+ different. */
+ SVN_ERR(svn_fs_file_contents(&stream1, root1, path1, pool));
+ SVN_ERR(svn_fs_file_contents(&stream2, root2, path2, pool));
+ SVN_ERR(svn_stream_contents_same2(&same, stream1, stream2, pool));
+ *changed_p = !same;
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Make the appropriate edits on FILE_BATON to change its contents and
+ properties from those in SOURCE_PATH to those in TARGET_PATH. */
+static svn_error_t *
+delta_files(struct context *c,
+ void *file_baton,
+ const char *source_path,
+ const char *target_path,
+ apr_pool_t *pool)
+{
+ apr_pool_t *subpool;
+ svn_boolean_t changed = TRUE;
+
+ SVN_ERR_ASSERT(target_path);
+
+ /* Make a subpool for local allocations. */
+ subpool = svn_pool_create(pool);
+
+ /* Compare the files' property lists. */
+ SVN_ERR(delta_proplists(c, source_path, target_path,
+ change_file_prop, file_baton, subpool));
+
+ if (source_path)
+ {
+ /* Is this delta calculation worth our time? If we are ignoring
+ ancestry, then our editor implementor isn't concerned by the
+ theoretical differences between "has contents which have not
+ changed with respect to" and "has the same actual contents
+ as". We'll do everything we can to avoid transmitting even
+ an empty text-delta in that case. */
+ if (c->ignore_ancestry)
+ SVN_ERR(svn_repos__compare_files(&changed,
+ c->target_root, target_path,
+ c->source_root, source_path,
+ subpool));
+ else
+ SVN_ERR(svn_fs_contents_changed(&changed,
+ c->target_root, target_path,
+ c->source_root, source_path,
+ subpool));
+ }
+ else
+ {
+ /* If there isn't a source path, this is an add, which
+ necessarily has textual mods. */
+ }
+
+ /* If there is a change, and the context indicates that we should
+ care about it, then hand it off to a delta stream. */
+ if (changed)
+ {
+ svn_txdelta_stream_t *delta_stream = NULL;
+ svn_checksum_t *source_checksum;
+ const char *source_hex_digest = NULL;
+
+ if (c->text_deltas)
+ {
+ /* Get a delta stream turning an empty file into one having
+ TARGET_PATH's contents. */
+ SVN_ERR(svn_fs_get_file_delta_stream
+ (&delta_stream,
+ source_path ? c->source_root : NULL,
+ source_path ? source_path : NULL,
+ c->target_root, target_path, subpool));
+ }
+
+ if (source_path)
+ {
+ SVN_ERR(svn_fs_file_checksum(&source_checksum, svn_checksum_md5,
+ c->source_root, source_path, TRUE,
+ subpool));
+
+ source_hex_digest = svn_checksum_to_cstring(source_checksum,
+ subpool);
+ }
+
+ SVN_ERR(send_text_delta(c, file_baton, source_hex_digest,
+ delta_stream, subpool));
+ }
+
+ /* Cleanup. */
+ svn_pool_destroy(subpool);
+
+ return SVN_NO_ERROR;
+}
+
+
+
+
+/* Generic directory deltafication routines. */
+
+
+/* Emit a delta to delete the entry named TARGET_ENTRY from DIR_BATON. */
+static svn_error_t *
+delete(struct context *c,
+ void *dir_baton,
+ const char *edit_path,
+ apr_pool_t *pool)
+{
+ return c->editor->delete_entry(edit_path, SVN_INVALID_REVNUM,
+ dir_baton, pool);
+}
+
+
+/* If authorized, emit a delta to create the entry named TARGET_ENTRY
+ at the location EDIT_PATH. If not authorized, indicate that
+ EDIT_PATH is absent. Pass DIR_BATON through to editor functions
+ that require it. DEPTH is the depth from this point downward. */
+static svn_error_t *
+add_file_or_dir(struct context *c, void *dir_baton,
+ svn_depth_t depth,
+ const char *target_path,
+ const char *edit_path,
+ svn_node_kind_t tgt_kind,
+ apr_pool_t *pool)
+{
+ struct context *context = c;
+ svn_boolean_t allowed;
+
+ SVN_ERR_ASSERT(target_path && edit_path);
+
+ if (c->authz_read_func)
+ {
+ SVN_ERR(c->authz_read_func(&allowed, c->target_root, target_path,
+ c->authz_read_baton, pool));
+ if (!allowed)
+ return absent_file_or_dir(c, dir_baton, edit_path, tgt_kind, pool);
+ }
+
+ if (tgt_kind == svn_node_dir)
+ {
+ void *subdir_baton;
+
+ SVN_ERR(context->editor->add_directory(edit_path, dir_baton, NULL,
+ SVN_INVALID_REVNUM, pool,
+ &subdir_baton));
+ SVN_ERR(delta_dirs(context, subdir_baton, MAYBE_DEMOTE_DEPTH(depth),
+ NULL, target_path, edit_path, pool));
+ return context->editor->close_directory(subdir_baton, pool);
+ }
+ else
+ {
+ void *file_baton;
+ svn_checksum_t *checksum;
+
+ SVN_ERR(context->editor->add_file(edit_path, dir_baton,
+ NULL, SVN_INVALID_REVNUM, pool,
+ &file_baton));
+ SVN_ERR(delta_files(context, file_baton, NULL, target_path, pool));
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
+ context->target_root, target_path,
+ TRUE, pool));
+ return context->editor->close_file
+ (file_baton, svn_checksum_to_cstring(checksum, pool), pool);
+ }
+}
+
+
+/* If authorized, emit a delta to modify EDIT_PATH with the changes
+ from SOURCE_PATH to TARGET_PATH. If not authorized, indicate that
+ EDIT_PATH is absent. Pass DIR_BATON through to editor functions
+ that require it. DEPTH is the depth from this point downward. */
+static svn_error_t *
+replace_file_or_dir(struct context *c,
+ void *dir_baton,
+ svn_depth_t depth,
+ const char *source_path,
+ const char *target_path,
+ const char *edit_path,
+ svn_node_kind_t tgt_kind,
+ apr_pool_t *pool)
+{
+ svn_revnum_t base_revision = SVN_INVALID_REVNUM;
+ svn_boolean_t allowed;
+
+ SVN_ERR_ASSERT(target_path && source_path && edit_path);
+
+ if (c->authz_read_func)
+ {
+ SVN_ERR(c->authz_read_func(&allowed, c->target_root, target_path,
+ c->authz_read_baton, pool));
+ if (!allowed)
+ return absent_file_or_dir(c, dir_baton, edit_path, tgt_kind, pool);
+ }
+
+ /* Get the base revision for the entry from the hash. */
+ base_revision = get_path_revision(c->source_root, source_path, pool);
+
+ if (tgt_kind == svn_node_dir)
+ {
+ void *subdir_baton;
+
+ SVN_ERR(c->editor->open_directory(edit_path, dir_baton,
+ base_revision, pool,
+ &subdir_baton));
+ SVN_ERR(delta_dirs(c, subdir_baton, MAYBE_DEMOTE_DEPTH(depth),
+ source_path, target_path, edit_path, pool));
+ return c->editor->close_directory(subdir_baton, pool);
+ }
+ else
+ {
+ void *file_baton;
+ svn_checksum_t *checksum;
+
+ SVN_ERR(c->editor->open_file(edit_path, dir_baton, base_revision,
+ pool, &file_baton));
+ SVN_ERR(delta_files(c, file_baton, source_path, target_path, pool));
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
+ c->target_root, target_path, TRUE,
+ pool));
+ return c->editor->close_file
+ (file_baton, svn_checksum_to_cstring(checksum, pool), pool);
+ }
+}
+
+
+/* In directory DIR_BATON, indicate that EDIT_PATH (relative to the
+ edit root) is absent by invoking C->editor->absent_directory or
+ C->editor->absent_file (depending on TGT_KIND). */
+static svn_error_t *
+absent_file_or_dir(struct context *c,
+ void *dir_baton,
+ const char *edit_path,
+ svn_node_kind_t tgt_kind,
+ apr_pool_t *pool)
+{
+ SVN_ERR_ASSERT(edit_path);
+
+ if (tgt_kind == svn_node_dir)
+ return c->editor->absent_directory(edit_path, dir_baton, pool);
+ else
+ return c->editor->absent_file(edit_path, dir_baton, pool);
+}
+
+
+/* Emit deltas to turn SOURCE_PATH into TARGET_PATH. Assume that
+ DIR_BATON represents the directory we're constructing to the editor
+ in the context C. */
+static svn_error_t *
+delta_dirs(struct context *c,
+ void *dir_baton,
+ svn_depth_t depth,
+ const char *source_path,
+ const char *target_path,
+ const char *edit_path,
+ apr_pool_t *pool)
+{
+ apr_hash_t *s_entries = 0, *t_entries = 0;
+ apr_hash_index_t *hi;
+ apr_pool_t *subpool;
+
+ SVN_ERR_ASSERT(target_path);
+
+ /* Compare the property lists. */
+ SVN_ERR(delta_proplists(c, source_path, target_path,
+ change_dir_prop, dir_baton, pool));
+
+ /* Get the list of entries in each of source and target. */
+ SVN_ERR(svn_fs_dir_entries(&t_entries, c->target_root,
+ target_path, pool));
+ if (source_path)
+ SVN_ERR(svn_fs_dir_entries(&s_entries, c->source_root,
+ source_path, pool));
+
+ /* Make a subpool for local allocations. */
+ subpool = svn_pool_create(pool);
+
+ /* Loop over the hash of entries in the target, searching for its
+ partner in the source. If we find the matching partner entry,
+ use editor calls to replace the one in target with a new version
+ if necessary, then remove that entry from the source entries
+ hash. If we can't find a related node in the source, we use
+ editor calls to add the entry as a new item in the target.
+ Having handled all the entries that exist in target, any entries
+ still remaining the source entries hash represent entries that no
+ longer exist in target. Use editor calls to delete those entries
+ from the target tree. */
+ for (hi = apr_hash_first(pool, t_entries); hi; hi = apr_hash_next(hi))
+ {
+ const svn_fs_dirent_t *s_entry, *t_entry;
+ const void *key;
+ void *val;
+ apr_ssize_t klen;
+ const char *t_fullpath;
+ const char *e_fullpath;
+ const char *s_fullpath;
+ svn_node_kind_t tgt_kind;
+
+ /* Clear out our subpool for the next iteration... */
+ svn_pool_clear(subpool);
+
+ /* KEY is the entry name in target, VAL the dirent */
+ apr_hash_this(hi, &key, &klen, &val);
+ t_entry = val;
+ tgt_kind = t_entry->kind;
+ t_fullpath = svn_relpath_join(target_path, t_entry->name, subpool);
+ e_fullpath = svn_relpath_join(edit_path, t_entry->name, subpool);
+
+ /* Can we find something with the same name in the source
+ entries hash? */
+ if (s_entries && ((s_entry = apr_hash_get(s_entries, key, klen)) != 0))
+ {
+ svn_node_kind_t src_kind;
+
+ s_fullpath = svn_relpath_join(source_path, t_entry->name, subpool);
+ src_kind = s_entry->kind;
+
+ if (depth == svn_depth_infinity
+ || src_kind != svn_node_dir
+ || (src_kind == svn_node_dir
+ && depth == svn_depth_immediates))
+ {
+ /* Use svn_fs_compare_ids() to compare our current
+ source and target ids.
+
+ 0: means they are the same id, and this is a noop.
+ -1: means they are unrelated, so we have to delete the
+ old one and add the new one.
+ 1: means the nodes are related through ancestry, so go
+ ahead and do the replace directly. */
+ int distance = svn_fs_compare_ids(s_entry->id, t_entry->id);
+ if (distance == 0)
+ {
+ /* no-op */
+ }
+ else if ((src_kind != tgt_kind)
+ || ((distance == -1) && (! c->ignore_ancestry)))
+ {
+ SVN_ERR(delete(c, dir_baton, e_fullpath, subpool));
+ SVN_ERR(add_file_or_dir(c, dir_baton,
+ MAYBE_DEMOTE_DEPTH(depth),
+ t_fullpath, e_fullpath, tgt_kind,
+ subpool));
+ }
+ else
+ {
+ SVN_ERR(replace_file_or_dir(c, dir_baton,
+ MAYBE_DEMOTE_DEPTH(depth),
+ s_fullpath, t_fullpath,
+ e_fullpath, tgt_kind,
+ subpool));
+ }
+ }
+
+ /* Remove the entry from the source_hash. */
+ svn_hash_sets(s_entries, key, NULL);
+ }
+ else
+ {
+ if (depth == svn_depth_infinity
+ || tgt_kind != svn_node_dir
+ || (tgt_kind == svn_node_dir
+ && depth == svn_depth_immediates))
+ {
+ SVN_ERR(add_file_or_dir(c, dir_baton,
+ MAYBE_DEMOTE_DEPTH(depth),
+ t_fullpath, e_fullpath, tgt_kind,
+ subpool));
+ }
+ }
+ }
+
+ /* All that is left in the source entries hash are things that need
+ to be deleted. Delete them. */
+ if (s_entries)
+ {
+ for (hi = apr_hash_first(pool, s_entries); hi; hi = apr_hash_next(hi))
+ {
+ const svn_fs_dirent_t *s_entry;
+ void *val;
+ const char *e_fullpath;
+ svn_node_kind_t src_kind;
+
+ /* Clear out our subpool for the next iteration... */
+ svn_pool_clear(subpool);
+
+ /* KEY is the entry name in source, VAL the dirent */
+ apr_hash_this(hi, NULL, NULL, &val);
+ s_entry = val;
+ src_kind = s_entry->kind;
+ e_fullpath = svn_relpath_join(edit_path, s_entry->name, subpool);
+
+ /* Do we actually want to delete the dir if we're non-recursive? */
+ if (depth == svn_depth_infinity
+ || src_kind != svn_node_dir
+ || (src_kind == svn_node_dir
+ && depth == svn_depth_immediates))
+ {
+ SVN_ERR(delete(c, dir_baton, e_fullpath, subpool));
+ }
+ }
+ }
+
+ /* Destroy local allocation subpool. */
+ svn_pool_destroy(subpool);
+
+ return SVN_NO_ERROR;
+}
diff --git a/subversion/libsvn_repos/deprecated.c b/subversion/libsvn_repos/deprecated.c
new file mode 100644
index 000000000000..7208ba6731e9
--- /dev/null
+++ b/subversion/libsvn_repos/deprecated.c
@@ -0,0 +1,1017 @@
+/*
+ * deprecated.c: holding file for all deprecated APIs.
+ * "we can't lose 'em, but we can shun 'em!"
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+/* We define this here to remove any further warnings about the usage of
+ deprecated functions in this file. */
+#define SVN_DEPRECATED
+
+#include "svn_repos.h"
+#include "svn_compat.h"
+#include "svn_hash.h"
+#include "svn_props.h"
+
+#include "svn_private_config.h"
+
+#include "repos.h"
+
+
+
+
+/*** From commit.c ***/
+
+svn_error_t *
+svn_repos_get_commit_editor4(const svn_delta_editor_t **editor,
+ void **edit_baton,
+ svn_repos_t *repos,
+ svn_fs_txn_t *txn,
+ const char *repos_url,
+ const char *base_path,
+ const char *user,
+ const char *log_msg,
+ svn_commit_callback2_t commit_callback,
+ void *commit_baton,
+ svn_repos_authz_callback_t authz_callback,
+ void *authz_baton,
+ apr_pool_t *pool)
+{
+ apr_hash_t *revprop_table = apr_hash_make(pool);
+ if (user)
+ svn_hash_sets(revprop_table, SVN_PROP_REVISION_AUTHOR,
+ svn_string_create(user, pool));
+ if (log_msg)
+ svn_hash_sets(revprop_table, SVN_PROP_REVISION_LOG,
+ svn_string_create(log_msg, pool));
+ return svn_repos_get_commit_editor5(editor, edit_baton, repos, txn,
+ repos_url, base_path, revprop_table,
+ commit_callback, commit_baton,
+ authz_callback, authz_baton, pool);
+}
+
+
+svn_error_t *
+svn_repos_get_commit_editor3(const svn_delta_editor_t **editor,
+ void **edit_baton,
+ svn_repos_t *repos,
+ svn_fs_txn_t *txn,
+ const char *repos_url,
+ const char *base_path,
+ const char *user,
+ const char *log_msg,
+ svn_commit_callback_t callback,
+ void *callback_baton,
+ svn_repos_authz_callback_t authz_callback,
+ void *authz_baton,
+ apr_pool_t *pool)
+{
+ svn_commit_callback2_t callback2;
+ void *callback2_baton;
+
+ svn_compat_wrap_commit_callback(&callback2, &callback2_baton,
+ callback, callback_baton,
+ pool);
+
+ return svn_repos_get_commit_editor4(editor, edit_baton, repos, txn,
+ repos_url, base_path, user,
+ log_msg, callback2,
+ callback2_baton, authz_callback,
+ authz_baton, pool);
+}
+
+
+svn_error_t *
+svn_repos_get_commit_editor2(const svn_delta_editor_t **editor,
+ void **edit_baton,
+ svn_repos_t *repos,
+ svn_fs_txn_t *txn,
+ const char *repos_url,
+ const char *base_path,
+ const char *user,
+ const char *log_msg,
+ svn_commit_callback_t callback,
+ void *callback_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_get_commit_editor3(editor, edit_baton, repos, txn,
+ repos_url, base_path, user,
+ log_msg, callback, callback_baton,
+ NULL, NULL, pool);
+}
+
+
+svn_error_t *
+svn_repos_get_commit_editor(const svn_delta_editor_t **editor,
+ void **edit_baton,
+ svn_repos_t *repos,
+ const char *repos_url,
+ const char *base_path,
+ const char *user,
+ const char *log_msg,
+ svn_commit_callback_t callback,
+ void *callback_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_get_commit_editor2(editor, edit_baton, repos, NULL,
+ repos_url, base_path, user,
+ log_msg, callback,
+ callback_baton, pool);
+}
+
+svn_error_t *
+svn_repos_open(svn_repos_t **repos_p,
+ const char *path,
+ apr_pool_t *pool)
+{
+ return svn_repos_open2(repos_p, path, NULL, pool);
+}
+
+
+/*** From repos.c ***/
+struct recover_baton
+{
+ svn_error_t *(*start_callback)(void *baton);
+ void *start_callback_baton;
+};
+
+static void
+recovery_started(void *baton,
+ const svn_repos_notify_t *notify,
+ apr_pool_t *scratch_pool)
+{
+ struct recover_baton *rb = baton;
+
+ if (notify->action == svn_repos_notify_mutex_acquired
+ && rb->start_callback != NULL)
+ svn_error_clear(rb->start_callback(rb->start_callback_baton));
+}
+
+svn_error_t *
+svn_repos_recover3(const char *path,
+ svn_boolean_t nonblocking,
+ svn_error_t *(*start_callback)(void *baton),
+ void *start_callback_baton,
+ svn_cancel_func_t cancel_func, void *cancel_baton,
+ apr_pool_t *pool)
+{
+ struct recover_baton rb;
+
+ rb.start_callback = start_callback;
+ rb.start_callback_baton = start_callback_baton;
+
+ return svn_repos_recover4(path, nonblocking, recovery_started, &rb,
+ cancel_func, cancel_baton, pool);
+}
+
+svn_error_t *
+svn_repos_recover2(const char *path,
+ svn_boolean_t nonblocking,
+ svn_error_t *(*start_callback)(void *baton),
+ void *start_callback_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_recover3(path, nonblocking,
+ start_callback, start_callback_baton,
+ NULL, NULL,
+ pool);
+}
+
+svn_error_t *
+svn_repos_recover(const char *path,
+ apr_pool_t *pool)
+{
+ return svn_repos_recover2(path, FALSE, NULL, NULL, pool);
+}
+
+svn_error_t *
+svn_repos_upgrade(const char *path,
+ svn_boolean_t nonblocking,
+ svn_error_t *(*start_callback)(void *baton),
+ void *start_callback_baton,
+ apr_pool_t *pool)
+{
+ struct recover_baton rb;
+
+ rb.start_callback = start_callback;
+ rb.start_callback_baton = start_callback_baton;
+
+ return svn_repos_upgrade2(path, nonblocking, recovery_started, &rb, pool);
+}
+
+/*** From reporter.c ***/
+svn_error_t *
+svn_repos_begin_report(void **report_baton,
+ svn_revnum_t revnum,
+ const char *username,
+ svn_repos_t *repos,
+ const char *fs_base,
+ const char *s_operand,
+ const char *switch_path,
+ svn_boolean_t text_deltas,
+ svn_boolean_t recurse,
+ svn_boolean_t ignore_ancestry,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_begin_report2(report_baton,
+ revnum,
+ repos,
+ fs_base,
+ s_operand,
+ switch_path,
+ text_deltas,
+ SVN_DEPTH_INFINITY_OR_FILES(recurse),
+ ignore_ancestry,
+ FALSE, /* don't send copyfrom args */
+ editor,
+ edit_baton,
+ authz_read_func,
+ authz_read_baton,
+ pool);
+}
+
+svn_error_t *
+svn_repos_begin_report2(void **report_baton,
+ svn_revnum_t revnum,
+ svn_repos_t *repos,
+ const char *fs_base,
+ const char *target,
+ const char *tgt_path,
+ svn_boolean_t text_deltas,
+ svn_depth_t depth,
+ svn_boolean_t ignore_ancestry,
+ svn_boolean_t send_copyfrom_args,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_begin_report3(report_baton,
+ revnum,
+ repos,
+ fs_base,
+ target,
+ tgt_path,
+ text_deltas,
+ depth,
+ ignore_ancestry,
+ send_copyfrom_args,
+ editor,
+ edit_baton,
+ authz_read_func,
+ authz_read_baton,
+ 0, /* disable zero-copy code path */
+ pool);
+}
+
+svn_error_t *
+svn_repos_set_path2(void *baton, const char *path, svn_revnum_t rev,
+ svn_boolean_t start_empty, const char *lock_token,
+ apr_pool_t *pool)
+{
+ return svn_repos_set_path3(baton, path, rev, svn_depth_infinity,
+ start_empty, lock_token, pool);
+}
+
+svn_error_t *
+svn_repos_set_path(void *baton, const char *path, svn_revnum_t rev,
+ svn_boolean_t start_empty, apr_pool_t *pool)
+{
+ return svn_repos_set_path2(baton, path, rev, start_empty, NULL, pool);
+}
+
+svn_error_t *
+svn_repos_link_path2(void *baton, const char *path, const char *link_path,
+ svn_revnum_t rev, svn_boolean_t start_empty,
+ const char *lock_token, apr_pool_t *pool)
+{
+ return svn_repos_link_path3(baton, path, link_path, rev, svn_depth_infinity,
+ start_empty, lock_token, pool);
+}
+
+svn_error_t *
+svn_repos_link_path(void *baton, const char *path, const char *link_path,
+ svn_revnum_t rev, svn_boolean_t start_empty,
+ apr_pool_t *pool)
+{
+ return svn_repos_link_path2(baton, path, link_path, rev, start_empty,
+ NULL, pool);
+}
+
+/*** From dir-delta.c ***/
+svn_error_t *
+svn_repos_dir_delta(svn_fs_root_t *src_root,
+ const char *src_parent_dir,
+ const char *src_entry,
+ svn_fs_root_t *tgt_root,
+ const char *tgt_fullpath,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ svn_boolean_t text_deltas,
+ svn_boolean_t recurse,
+ svn_boolean_t entry_props,
+ svn_boolean_t ignore_ancestry,
+ apr_pool_t *pool)
+{
+ return svn_repos_dir_delta2(src_root,
+ src_parent_dir,
+ src_entry,
+ tgt_root,
+ tgt_fullpath,
+ editor,
+ edit_baton,
+ authz_read_func,
+ authz_read_baton,
+ text_deltas,
+ SVN_DEPTH_INFINITY_OR_FILES(recurse),
+ entry_props,
+ ignore_ancestry,
+ pool);
+}
+
+/*** From replay.c ***/
+svn_error_t *
+svn_repos_replay(svn_fs_root_t *root,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_replay2(root,
+ "" /* the whole tree */,
+ SVN_INVALID_REVNUM, /* no low water mark */
+ FALSE /* no text deltas */,
+ editor, edit_baton,
+ NULL /* no authz func */,
+ NULL /* no authz baton */,
+ pool);
+}
+
+/*** From fs-wrap.c ***/
+svn_error_t *
+svn_repos_fs_change_rev_prop3(svn_repos_t *repos,
+ svn_revnum_t rev,
+ const char *author,
+ const char *name,
+ const svn_string_t *new_value,
+ svn_boolean_t use_pre_revprop_change_hook,
+ svn_boolean_t use_post_revprop_change_hook,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_fs_change_rev_prop4(repos, rev, author, name, NULL,
+ new_value,
+ use_pre_revprop_change_hook,
+ use_post_revprop_change_hook,
+ authz_read_func,
+ authz_read_baton, pool);
+}
+
+svn_error_t *
+svn_repos_fs_change_rev_prop2(svn_repos_t *repos,
+ svn_revnum_t rev,
+ const char *author,
+ const char *name,
+ const svn_string_t *new_value,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_fs_change_rev_prop3(repos, rev, author, name, new_value,
+ TRUE, TRUE, authz_read_func,
+ authz_read_baton, pool);
+}
+
+
+
+svn_error_t *
+svn_repos_fs_change_rev_prop(svn_repos_t *repos,
+ svn_revnum_t rev,
+ const char *author,
+ const char *name,
+ const svn_string_t *new_value,
+ apr_pool_t *pool)
+{
+ return svn_repos_fs_change_rev_prop2(repos, rev, author, name, new_value,
+ NULL, NULL, pool);
+}
+
+struct pack_notify_wrapper_baton
+{
+ svn_fs_pack_notify_t notify_func;
+ void *notify_baton;
+};
+
+static void
+pack_notify_wrapper_func(void *baton,
+ const svn_repos_notify_t *notify,
+ apr_pool_t *scratch_pool)
+{
+ struct pack_notify_wrapper_baton *pnwb = baton;
+
+ svn_error_clear(pnwb->notify_func(pnwb->notify_baton, notify->shard,
+ notify->action - 3, scratch_pool));
+}
+
+svn_error_t *
+svn_repos_fs_pack(svn_repos_t *repos,
+ svn_fs_pack_notify_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ struct pack_notify_wrapper_baton pnwb;
+
+ pnwb.notify_func = notify_func;
+ pnwb.notify_baton = notify_baton;
+
+ return svn_repos_fs_pack2(repos, pack_notify_wrapper_func, &pnwb,
+ cancel_func, cancel_baton, pool);
+}
+
+
+svn_error_t *
+svn_repos_fs_get_locks(apr_hash_t **locks,
+ svn_repos_t *repos,
+ const char *path,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ return svn_error_trace(svn_repos_fs_get_locks2(locks, repos, path,
+ svn_depth_infinity,
+ authz_read_func,
+ authz_read_baton, pool));
+}
+
+
+/*** From logs.c ***/
+svn_error_t *
+svn_repos_get_logs3(svn_repos_t *repos,
+ const apr_array_header_t *paths,
+ svn_revnum_t start,
+ svn_revnum_t end,
+ int limit,
+ svn_boolean_t discover_changed_paths,
+ svn_boolean_t strict_node_history,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ svn_log_message_receiver_t receiver,
+ void *receiver_baton,
+ apr_pool_t *pool)
+{
+ svn_log_entry_receiver_t receiver2;
+ void *receiver2_baton;
+
+ svn_compat_wrap_log_receiver(&receiver2, &receiver2_baton,
+ receiver, receiver_baton,
+ pool);
+
+ return svn_repos_get_logs4(repos, paths, start, end, limit,
+ discover_changed_paths, strict_node_history,
+ FALSE, svn_compat_log_revprops_in(pool),
+ authz_read_func, authz_read_baton,
+ receiver2, receiver2_baton,
+ pool);
+}
+
+svn_error_t *
+svn_repos_get_logs2(svn_repos_t *repos,
+ const apr_array_header_t *paths,
+ svn_revnum_t start,
+ svn_revnum_t end,
+ svn_boolean_t discover_changed_paths,
+ svn_boolean_t strict_node_history,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ svn_log_message_receiver_t receiver,
+ void *receiver_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_get_logs3(repos, paths, start, end, 0,
+ discover_changed_paths, strict_node_history,
+ authz_read_func, authz_read_baton, receiver,
+ receiver_baton, pool);
+}
+
+
+svn_error_t *
+svn_repos_get_logs(svn_repos_t *repos,
+ const apr_array_header_t *paths,
+ svn_revnum_t start,
+ svn_revnum_t end,
+ svn_boolean_t discover_changed_paths,
+ svn_boolean_t strict_node_history,
+ svn_log_message_receiver_t receiver,
+ void *receiver_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_get_logs3(repos, paths, start, end, 0,
+ discover_changed_paths, strict_node_history,
+ NULL, NULL, /* no authz stuff */
+ receiver, receiver_baton, pool);
+}
+
+/*** From rev_hunt.c ***/
+svn_error_t *
+svn_repos_history(svn_fs_t *fs,
+ const char *path,
+ svn_repos_history_func_t history_func,
+ void *history_baton,
+ svn_revnum_t start,
+ svn_revnum_t end,
+ svn_boolean_t cross_copies,
+ apr_pool_t *pool)
+{
+ return svn_repos_history2(fs, path, history_func, history_baton,
+ NULL, NULL,
+ start, end, cross_copies, pool);
+}
+
+svn_error_t *
+svn_repos_get_file_revs(svn_repos_t *repos,
+ const char *path,
+ svn_revnum_t start,
+ svn_revnum_t end,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ svn_repos_file_rev_handler_t handler,
+ void *handler_baton,
+ apr_pool_t *pool)
+{
+ svn_file_rev_handler_t handler2;
+ void *handler2_baton;
+
+ svn_compat_wrap_file_rev_handler(&handler2, &handler2_baton, handler,
+ handler_baton, pool);
+
+ return svn_repos_get_file_revs2(repos, path, start, end, FALSE,
+ authz_read_func, authz_read_baton,
+ handler2, handler2_baton, pool);
+}
+
+/*** From dump.c ***/
+svn_error_t *
+svn_repos_dump_fs(svn_repos_t *repos,
+ svn_stream_t *stream,
+ svn_stream_t *feedback_stream,
+ svn_revnum_t start_rev,
+ svn_revnum_t end_rev,
+ svn_boolean_t incremental,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_dump_fs2(repos, stream, feedback_stream, start_rev,
+ end_rev, incremental, FALSE, cancel_func,
+ cancel_baton, pool);
+}
+
+/* Implementation of svn_repos_notify_func_t to wrap the output to a
+ response stream for svn_repos_dump_fs2() and svn_repos_verify_fs() */
+static void
+repos_notify_handler(void *baton,
+ const svn_repos_notify_t *notify,
+ apr_pool_t *scratch_pool)
+{
+ svn_stream_t *feedback_stream = baton;
+ apr_size_t len;
+
+ switch (notify->action)
+ {
+ case svn_repos_notify_warning:
+ svn_error_clear(svn_stream_puts(feedback_stream, notify->warning_str));
+ return;
+
+ case svn_repos_notify_dump_rev_end:
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _("* Dumped revision %ld.\n"),
+ notify->revision));
+ return;
+
+ case svn_repos_notify_verify_rev_end:
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _("* Verified revision %ld.\n"),
+ notify->revision));
+ return;
+
+ case svn_repos_notify_load_txn_committed:
+ if (notify->old_revision == SVN_INVALID_REVNUM)
+ {
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _("\n------- Committed revision %ld >>>\n\n"),
+ notify->new_revision));
+ }
+ else
+ {
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _("\n------- Committed new rev %ld"
+ " (loaded from original rev %ld"
+ ") >>>\n\n"), notify->new_revision,
+ notify->old_revision));
+ }
+ return;
+
+ case svn_repos_notify_load_node_start:
+ {
+ switch (notify->node_action)
+ {
+ case svn_node_action_change:
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _(" * editing path : %s ..."),
+ notify->path));
+ break;
+
+ case svn_node_action_delete:
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _(" * deleting path : %s ..."),
+ notify->path));
+ break;
+
+ case svn_node_action_add:
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _(" * adding path : %s ..."),
+ notify->path));
+ break;
+
+ case svn_node_action_replace:
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _(" * replacing path : %s ..."),
+ notify->path));
+ break;
+
+ }
+ }
+ return;
+
+ case svn_repos_notify_load_node_done:
+ len = 7;
+ svn_error_clear(svn_stream_write(feedback_stream, _(" done.\n"), &len));
+ return;
+
+ case svn_repos_notify_load_copied_node:
+ len = 9;
+ svn_error_clear(svn_stream_write(feedback_stream, "COPIED...", &len));
+ return;
+
+ case svn_repos_notify_load_txn_start:
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _("<<< Started new transaction, based on "
+ "original revision %ld\n"),
+ notify->old_revision));
+ return;
+
+ case svn_repos_notify_load_normalized_mergeinfo:
+ svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
+ _(" removing '\\r' from %s ..."),
+ SVN_PROP_MERGEINFO));
+ return;
+
+ default:
+ return;
+ }
+}
+
+
+svn_error_t *
+svn_repos_dump_fs2(svn_repos_t *repos,
+ svn_stream_t *stream,
+ svn_stream_t *feedback_stream,
+ svn_revnum_t start_rev,
+ svn_revnum_t end_rev,
+ svn_boolean_t incremental,
+ svn_boolean_t use_deltas,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ return svn_error_trace(svn_repos_dump_fs3(repos,
+ stream,
+ start_rev,
+ end_rev,
+ incremental,
+ use_deltas,
+ feedback_stream
+ ? repos_notify_handler
+ : NULL,
+ feedback_stream,
+ cancel_func,
+ cancel_baton,
+ pool));
+}
+
+svn_error_t *
+svn_repos_verify_fs(svn_repos_t *repos,
+ svn_stream_t *feedback_stream,
+ svn_revnum_t start_rev,
+ svn_revnum_t end_rev,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ return svn_error_trace(svn_repos_verify_fs2(repos,
+ start_rev,
+ end_rev,
+ feedback_stream
+ ? repos_notify_handler
+ : NULL,
+ feedback_stream,
+ cancel_func,
+ cancel_baton,
+ pool));
+}
+
+/*** From load.c ***/
+
+svn_error_t *
+svn_repos_load_fs3(svn_repos_t *repos,
+ svn_stream_t *dumpstream,
+ enum svn_repos_load_uuid uuid_action,
+ const char *parent_dir,
+ svn_boolean_t use_pre_commit_hook,
+ svn_boolean_t use_post_commit_hook,
+ svn_boolean_t validate_props,
+ svn_repos_notify_func_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_load_fs4(repos, dumpstream,
+ SVN_INVALID_REVNUM, SVN_INVALID_REVNUM,
+ uuid_action, parent_dir,
+ use_pre_commit_hook, use_post_commit_hook,
+ validate_props, notify_func, notify_baton,
+ cancel_func, cancel_baton, pool);
+}
+
+svn_error_t *
+svn_repos_load_fs2(svn_repos_t *repos,
+ svn_stream_t *dumpstream,
+ svn_stream_t *feedback_stream,
+ enum svn_repos_load_uuid uuid_action,
+ const char *parent_dir,
+ svn_boolean_t use_pre_commit_hook,
+ svn_boolean_t use_post_commit_hook,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_load_fs3(repos, dumpstream, uuid_action, parent_dir,
+ use_pre_commit_hook, use_post_commit_hook, FALSE,
+ feedback_stream ? repos_notify_handler : NULL,
+ feedback_stream, cancel_func, cancel_baton, pool);
+}
+
+
+static svn_repos_parser_fns_t *
+fns_from_fns2(const svn_repos_parse_fns2_t *fns2,
+ apr_pool_t *pool)
+{
+ svn_repos_parser_fns_t *fns;
+
+ fns = apr_palloc(pool, sizeof(*fns));
+ fns->new_revision_record = fns2->new_revision_record;
+ fns->uuid_record = fns2->uuid_record;
+ fns->new_node_record = fns2->new_node_record;
+ fns->set_revision_property = fns2->set_revision_property;
+ fns->set_node_property = fns2->set_node_property;
+ fns->remove_node_props = fns2->remove_node_props;
+ fns->set_fulltext = fns2->set_fulltext;
+ fns->close_node = fns2->close_node;
+ fns->close_revision = fns2->close_revision;
+ return fns;
+}
+
+static svn_repos_parser_fns2_t *
+fns2_from_fns3(const svn_repos_parse_fns3_t *fns3,
+ apr_pool_t *pool)
+{
+ svn_repos_parser_fns2_t *fns2;
+
+ fns2 = apr_palloc(pool, sizeof(*fns2));
+ fns2->new_revision_record = fns3->new_revision_record;
+ fns2->uuid_record = fns3->uuid_record;
+ fns2->new_node_record = fns3->new_node_record;
+ fns2->set_revision_property = fns3->set_revision_property;
+ fns2->set_node_property = fns3->set_node_property;
+ fns2->remove_node_props = fns3->remove_node_props;
+ fns2->set_fulltext = fns3->set_fulltext;
+ fns2->close_node = fns3->close_node;
+ fns2->close_revision = fns3->close_revision;
+ fns2->delete_node_property = fns3->delete_node_property;
+ fns2->apply_textdelta = fns3->apply_textdelta;
+ return fns2;
+}
+
+static svn_repos_parse_fns2_t *
+fns2_from_fns(const svn_repos_parser_fns_t *fns,
+ apr_pool_t *pool)
+{
+ svn_repos_parse_fns2_t *fns2;
+
+ fns2 = apr_palloc(pool, sizeof(*fns2));
+ fns2->new_revision_record = fns->new_revision_record;
+ fns2->uuid_record = fns->uuid_record;
+ fns2->new_node_record = fns->new_node_record;
+ fns2->set_revision_property = fns->set_revision_property;
+ fns2->set_node_property = fns->set_node_property;
+ fns2->remove_node_props = fns->remove_node_props;
+ fns2->set_fulltext = fns->set_fulltext;
+ fns2->close_node = fns->close_node;
+ fns2->close_revision = fns->close_revision;
+ fns2->delete_node_property = NULL;
+ fns2->apply_textdelta = NULL;
+ return fns2;
+}
+
+static svn_repos_parse_fns3_t *
+fns3_from_fns2(const svn_repos_parser_fns2_t *fns2,
+ apr_pool_t *pool)
+{
+ svn_repos_parse_fns3_t *fns3;
+
+ fns3 = apr_palloc(pool, sizeof(*fns3));
+ fns3->magic_header_record = NULL;
+ fns3->uuid_record = fns2->uuid_record;
+ fns3->new_revision_record = fns2->new_revision_record;
+ fns3->new_node_record = fns2->new_node_record;
+ fns3->set_revision_property = fns2->set_revision_property;
+ fns3->set_node_property = fns2->set_node_property;
+ fns3->remove_node_props = fns2->remove_node_props;
+ fns3->set_fulltext = fns2->set_fulltext;
+ fns3->close_node = fns2->close_node;
+ fns3->close_revision = fns2->close_revision;
+ fns3->delete_node_property = fns2->delete_node_property;
+ fns3->apply_textdelta = fns2->apply_textdelta;
+ return fns3;
+}
+
+svn_error_t *
+svn_repos_parse_dumpstream2(svn_stream_t *stream,
+ const svn_repos_parser_fns2_t *parse_fns,
+ void *parse_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ svn_repos_parse_fns3_t *fns3 = fns3_from_fns2(parse_fns, pool);
+
+ return svn_repos_parse_dumpstream3(stream, fns3, parse_baton, FALSE,
+ cancel_func, cancel_baton, pool);
+}
+
+svn_error_t *
+svn_repos_parse_dumpstream(svn_stream_t *stream,
+ const svn_repos_parser_fns_t *parse_fns,
+ void *parse_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ svn_repos_parse_fns2_t *fns2 = fns2_from_fns(parse_fns, pool);
+
+ return svn_repos_parse_dumpstream2(stream, fns2, parse_baton,
+ cancel_func, cancel_baton, pool);
+}
+
+svn_error_t *
+svn_repos_load_fs(svn_repos_t *repos,
+ svn_stream_t *dumpstream,
+ svn_stream_t *feedback_stream,
+ enum svn_repos_load_uuid uuid_action,
+ const char *parent_dir,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ return svn_repos_load_fs2(repos, dumpstream, feedback_stream,
+ uuid_action, parent_dir, FALSE, FALSE,
+ cancel_func, cancel_baton, pool);
+}
+
+svn_error_t *
+svn_repos_get_fs_build_parser3(const svn_repos_parse_fns2_t **callbacks,
+ void **parse_baton,
+ svn_repos_t *repos,
+ svn_boolean_t use_history,
+ svn_boolean_t validate_props,
+ enum svn_repos_load_uuid uuid_action,
+ const char *parent_dir,
+ svn_repos_notify_func_t notify_func,
+ void *notify_baton,
+ apr_pool_t *pool)
+{
+ const svn_repos_parse_fns3_t *fns3;
+
+ SVN_ERR(svn_repos_get_fs_build_parser4(&fns3, parse_baton, repos,
+ SVN_INVALID_REVNUM,
+ SVN_INVALID_REVNUM,
+ use_history, validate_props,
+ uuid_action, parent_dir,
+ notify_func, notify_baton, pool));
+
+ *callbacks = fns2_from_fns3(fns3, pool);
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_repos_get_fs_build_parser2(const svn_repos_parse_fns2_t **parser,
+ void **parse_baton,
+ svn_repos_t *repos,
+ svn_boolean_t use_history,
+ enum svn_repos_load_uuid uuid_action,
+ svn_stream_t *outstream,
+ const char *parent_dir,
+ apr_pool_t *pool)
+{
+ return svn_repos_get_fs_build_parser3(parser, parse_baton, repos, use_history,
+ FALSE, uuid_action, parent_dir,
+ outstream ? repos_notify_handler : NULL,
+ outstream, pool);
+}
+
+svn_error_t *
+svn_repos_get_fs_build_parser(const svn_repos_parser_fns_t **parser_callbacks,
+ void **parse_baton,
+ svn_repos_t *repos,
+ svn_boolean_t use_history,
+ enum svn_repos_load_uuid uuid_action,
+ svn_stream_t *outstream,
+ const char *parent_dir,
+ apr_pool_t *pool)
+{
+ const svn_repos_parse_fns2_t *fns2;
+
+ SVN_ERR(svn_repos_get_fs_build_parser2(&fns2, parse_baton, repos,
+ use_history, uuid_action, outstream,
+ parent_dir, pool));
+
+ *parser_callbacks = fns_from_fns2(fns2, pool);
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_fs_begin_txn_for_update(svn_fs_txn_t **txn_p,
+ svn_repos_t *repos,
+ svn_revnum_t rev,
+ const char *author,
+ apr_pool_t *pool)
+{
+ /* ### someday, we might run a read-hook here. */
+
+ /* Begin the transaction. */
+ SVN_ERR(svn_fs_begin_txn2(txn_p, repos->fs, rev, 0, pool));
+
+ /* We pass the author to the filesystem by adding it as a property
+ on the txn. */
+
+ /* User (author). */
+ if (author)
+ {
+ svn_string_t val;
+ val.data = author;
+ val.len = strlen(author);
+ SVN_ERR(svn_fs_change_txn_prop(*txn_p, SVN_PROP_REVISION_AUTHOR,
+ &val, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/*** From authz.c ***/
+
+svn_error_t *
+svn_repos_authz_read(svn_authz_t **authz_p, const char *file,
+ svn_boolean_t must_exist, apr_pool_t *pool)
+{
+ return svn_repos__authz_read(authz_p, file, NULL, must_exist,
+ FALSE, pool);
+}
diff --git a/subversion/libsvn_repos/dump.c b/subversion/libsvn_repos/dump.c
new file mode 100644
index 000000000000..75843d7057ad
--- /dev/null
+++ b/subversion/libsvn_repos/dump.c
@@ -0,0 +1,1503 @@
+/* dump.c --- writing filesystem contents into a portable 'dumpfile' format.
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+
+#include "svn_private_config.h"
+#include "svn_pools.h"
+#include "svn_error.h"
+#include "svn_fs.h"
+#include "svn_hash.h"
+#include "svn_iter.h"
+#include "svn_repos.h"
+#include "svn_string.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_time.h"
+#include "svn_checksum.h"
+#include "svn_props.h"
+#include "svn_sorts.h"
+
+#include "private/svn_mergeinfo_private.h"
+#include "private/svn_fs_private.h"
+
+#define ARE_VALID_COPY_ARGS(p,r) ((p) && SVN_IS_VALID_REVNUM(r))
+
+/*----------------------------------------------------------------------*/
+
+
+
+/* Compute the delta between OLDROOT/OLDPATH and NEWROOT/NEWPATH and
+ store it into a new temporary file *TEMPFILE. OLDROOT may be NULL,
+ in which case the delta will be computed against an empty file, as
+ per the svn_fs_get_file_delta_stream docstring. Record the length
+ of the temporary file in *LEN, and rewind the file before
+ returning. */
+static svn_error_t *
+store_delta(apr_file_t **tempfile, svn_filesize_t *len,
+ svn_fs_root_t *oldroot, const char *oldpath,
+ svn_fs_root_t *newroot, const char *newpath, apr_pool_t *pool)
+{
+ svn_stream_t *temp_stream;
+ apr_off_t offset = 0;
+ svn_txdelta_stream_t *delta_stream;
+ svn_txdelta_window_handler_t wh;
+ void *whb;
+
+ /* Create a temporary file and open a stream to it. Note that we need
+ the file handle in order to rewind it. */
+ SVN_ERR(svn_io_open_unique_file3(tempfile, NULL, NULL,
+ svn_io_file_del_on_pool_cleanup,
+ pool, pool));
+ temp_stream = svn_stream_from_aprfile2(*tempfile, TRUE, pool);
+
+ /* Compute the delta and send it to the temporary file. */
+ SVN_ERR(svn_fs_get_file_delta_stream(&delta_stream, oldroot, oldpath,
+ newroot, newpath, pool));
+ svn_txdelta_to_svndiff3(&wh, &whb, temp_stream, 0,
+ SVN_DELTA_COMPRESSION_LEVEL_DEFAULT, pool);
+ SVN_ERR(svn_txdelta_send_txstream(delta_stream, wh, whb, pool));
+
+ /* Get the length of the temporary file and rewind it. */
+ SVN_ERR(svn_io_file_seek(*tempfile, APR_CUR, &offset, pool));
+ *len = offset;
+ offset = 0;
+ return svn_io_file_seek(*tempfile, APR_SET, &offset, pool);
+}
+
+
+/*----------------------------------------------------------------------*/
+
+/** An editor which dumps node-data in 'dumpfile format' to a file. **/
+
+/* Look, mom! No file batons! */
+
+struct edit_baton
+{
+ /* The relpath which implicitly prepends all full paths coming into
+ this editor. This will almost always be "". */
+ const char *path;
+
+ /* The stream to dump to. */
+ svn_stream_t *stream;
+
+ /* Send feedback here, if non-NULL */
+ svn_repos_notify_func_t notify_func;
+ void *notify_baton;
+
+ /* The fs revision root, so we can read the contents of paths. */
+ svn_fs_root_t *fs_root;
+ svn_revnum_t current_rev;
+
+ /* The fs, so we can grab historic information if needed. */
+ svn_fs_t *fs;
+
+ /* True if dumped nodes should output deltas instead of full text. */
+ svn_boolean_t use_deltas;
+
+ /* True if this "dump" is in fact a verify. */
+ svn_boolean_t verify;
+
+ /* The first revision dumped in this dumpstream. */
+ svn_revnum_t oldest_dumped_rev;
+
+ /* If not NULL, set to true if any references to revisions older than
+ OLDEST_DUMPED_REV were found in the dumpstream. */
+ svn_boolean_t *found_old_reference;
+
+ /* If not NULL, set to true if any mergeinfo was dumped which contains
+ revisions older than OLDEST_DUMPED_REV. */
+ svn_boolean_t *found_old_mergeinfo;
+
+ /* reusable buffer for writing file contents */
+ char buffer[SVN__STREAM_CHUNK_SIZE];
+ apr_size_t bufsize;
+};
+
+struct dir_baton
+{
+ struct edit_baton *edit_baton;
+ struct dir_baton *parent_dir_baton;
+
+ /* is this directory a new addition to this revision? */
+ svn_boolean_t added;
+
+ /* has this directory been written to the output stream? */
+ svn_boolean_t written_out;
+
+ /* the repository relpath associated with this directory */
+ const char *path;
+
+ /* The comparison repository relpath and revision of this directory.
+ If both of these are valid, use them as a source against which to
+ compare the directory instead of the default comparison source of
+ PATH in the previous revision. */
+ const char *cmp_path;
+ svn_revnum_t cmp_rev;
+
+ /* hash of paths that need to be deleted, though some -might- be
+ replaced. maps const char * paths to this dir_baton. (they're
+ full paths, because that's what the editor driver gives us. but
+ really, they're all within this directory.) */
+ apr_hash_t *deleted_entries;
+
+ /* pool to be used for deleting the hash items */
+ apr_pool_t *pool;
+};
+
+
+/* Make a directory baton to represent the directory was path
+ (relative to EDIT_BATON's path) is PATH.
+
+ CMP_PATH/CMP_REV are the path/revision against which this directory
+ should be compared for changes. If either is omitted (NULL for the
+ path, SVN_INVALID_REVNUM for the rev), just compare this directory
+ PATH against itself in the previous revision.
+
+ PARENT_DIR_BATON is the directory baton of this directory's parent,
+ or NULL if this is the top-level directory of the edit. ADDED
+ indicated if this directory is newly added in this revision.
+ Perform all allocations in POOL. */
+static struct dir_baton *
+make_dir_baton(const char *path,
+ const char *cmp_path,
+ svn_revnum_t cmp_rev,
+ void *edit_baton,
+ void *parent_dir_baton,
+ svn_boolean_t added,
+ apr_pool_t *pool)
+{
+ struct edit_baton *eb = edit_baton;
+ struct dir_baton *pb = parent_dir_baton;
+ struct dir_baton *new_db = apr_pcalloc(pool, sizeof(*new_db));
+ const char *full_path;
+
+ /* A path relative to nothing? I don't think so. */
+ SVN_ERR_ASSERT_NO_RETURN(!path || pb);
+
+ /* Construct the full path of this node. */
+ if (pb)
+ full_path = svn_relpath_join(eb->path, path, pool);
+ else
+ full_path = apr_pstrdup(pool, eb->path);
+
+ /* Remove leading slashes from copyfrom paths. */
+ if (cmp_path)
+ cmp_path = svn_relpath_canonicalize(cmp_path, pool);
+
+ new_db->edit_baton = eb;
+ new_db->parent_dir_baton = pb;
+ new_db->path = full_path;
+ new_db->cmp_path = cmp_path;
+ new_db->cmp_rev = cmp_rev;
+ new_db->added = added;
+ new_db->written_out = FALSE;
+ new_db->deleted_entries = apr_hash_make(pool);
+ new_db->pool = pool;
+
+ return new_db;
+}
+
+
+/* This helper is the main "meat" of the editor -- it does all the
+ work of writing a node record.
+
+ Write out a node record for PATH of type KIND under EB->FS_ROOT.
+ ACTION describes what is happening to the node (see enum svn_node_action).
+ Write record to writable EB->STREAM, using EB->BUFFER to write in chunks.
+
+ If the node was itself copied, IS_COPY is TRUE and the
+ path/revision of the copy source are in CMP_PATH/CMP_REV. If
+ IS_COPY is FALSE, yet CMP_PATH/CMP_REV are valid, this node is part
+ of a copied subtree.
+ */
+static svn_error_t *
+dump_node(struct edit_baton *eb,
+ const char *path,
+ svn_node_kind_t kind,
+ enum svn_node_action action,
+ svn_boolean_t is_copy,
+ const char *cmp_path,
+ svn_revnum_t cmp_rev,
+ apr_pool_t *pool)
+{
+ svn_stringbuf_t *propstring;
+ svn_filesize_t content_length = 0;
+ apr_size_t len;
+ svn_boolean_t must_dump_text = FALSE, must_dump_props = FALSE;
+ const char *compare_path = path;
+ svn_revnum_t compare_rev = eb->current_rev - 1;
+ svn_fs_root_t *compare_root = NULL;
+ apr_file_t *delta_file = NULL;
+
+ /* Maybe validate the path. */
+ if (eb->verify || eb->notify_func)
+ {
+ svn_error_t *err = svn_fs__path_valid(path, pool);
+
+ if (err)
+ {
+ if (eb->notify_func)
+ {
+ char errbuf[512]; /* ### svn_strerror() magic number */
+ svn_repos_notify_t *notify;
+ notify = svn_repos_notify_create(svn_repos_notify_warning, pool);
+
+ notify->warning = svn_repos_notify_warning_invalid_fspath;
+ notify->warning_str = apr_psprintf(
+ pool,
+ _("E%06d: While validating fspath '%s': %s"),
+ err->apr_err, path,
+ svn_err_best_message(err, errbuf, sizeof(errbuf)));
+
+ eb->notify_func(eb->notify_baton, notify, pool);
+ }
+
+ /* Return the error in addition to notifying about it. */
+ if (eb->verify)
+ return svn_error_trace(err);
+ else
+ svn_error_clear(err);
+ }
+ }
+
+ /* Write out metadata headers for this file node. */
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_NODE_PATH ": %s\n",
+ path));
+ if (kind == svn_node_file)
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_NODE_KIND ": file\n"));
+ else if (kind == svn_node_dir)
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_NODE_KIND ": dir\n"));
+
+ /* Remove leading slashes from copyfrom paths. */
+ if (cmp_path)
+ cmp_path = svn_relpath_canonicalize(cmp_path, pool);
+
+ /* Validate the comparison path/rev. */
+ if (ARE_VALID_COPY_ARGS(cmp_path, cmp_rev))
+ {
+ compare_path = cmp_path;
+ compare_rev = cmp_rev;
+ }
+
+ if (action == svn_node_action_change)
+ {
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_NODE_ACTION ": change\n"));
+
+ /* either the text or props changed, or possibly both. */
+ SVN_ERR(svn_fs_revision_root(&compare_root,
+ svn_fs_root_fs(eb->fs_root),
+ compare_rev, pool));
+
+ SVN_ERR(svn_fs_props_changed(&must_dump_props,
+ compare_root, compare_path,
+ eb->fs_root, path, pool));
+ if (kind == svn_node_file)
+ SVN_ERR(svn_fs_contents_changed(&must_dump_text,
+ compare_root, compare_path,
+ eb->fs_root, path, pool));
+ }
+ else if (action == svn_node_action_replace)
+ {
+ if (! is_copy)
+ {
+ /* a simple delete+add, implied by a single 'replace' action. */
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_NODE_ACTION
+ ": replace\n"));
+
+ /* definitely need to dump all content for a replace. */
+ if (kind == svn_node_file)
+ must_dump_text = TRUE;
+ must_dump_props = TRUE;
+ }
+ else
+ {
+ /* more complex: delete original, then add-with-history. */
+
+ /* the path & kind headers have already been printed; just
+ add a delete action, and end the current record.*/
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_NODE_ACTION
+ ": delete\n\n"));
+
+ /* recurse: print an additional add-with-history record. */
+ SVN_ERR(dump_node(eb, path, kind, svn_node_action_add,
+ is_copy, compare_path, compare_rev, pool));
+
+ /* we can leave this routine quietly now, don't need to dump
+ any content; that was already done in the second record. */
+ must_dump_text = FALSE;
+ must_dump_props = FALSE;
+ }
+ }
+ else if (action == svn_node_action_delete)
+ {
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_NODE_ACTION ": delete\n"));
+
+ /* we can leave this routine quietly now, don't need to dump
+ any content. */
+ must_dump_text = FALSE;
+ must_dump_props = FALSE;
+ }
+ else if (action == svn_node_action_add)
+ {
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_NODE_ACTION ": add\n"));
+
+ if (! is_copy)
+ {
+ /* Dump all contents for a simple 'add'. */
+ if (kind == svn_node_file)
+ must_dump_text = TRUE;
+ must_dump_props = TRUE;
+ }
+ else
+ {
+ if (!eb->verify && cmp_rev < eb->oldest_dumped_rev
+ && eb->notify_func)
+ {
+ svn_repos_notify_t *notify =
+ svn_repos_notify_create(svn_repos_notify_warning, pool);
+
+ notify->warning = svn_repos_notify_warning_found_old_reference;
+ notify->warning_str = apr_psprintf(
+ pool,
+ _("Referencing data in revision %ld,"
+ " which is older than the oldest"
+ " dumped revision (r%ld). Loading this dump"
+ " into an empty repository"
+ " will fail."),
+ cmp_rev, eb->oldest_dumped_rev);
+ if (eb->found_old_reference)
+ *eb->found_old_reference = TRUE;
+ eb->notify_func(eb->notify_baton, notify, pool);
+ }
+
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_NODE_COPYFROM_REV
+ ": %ld\n"
+ SVN_REPOS_DUMPFILE_NODE_COPYFROM_PATH
+ ": %s\n",
+ cmp_rev, cmp_path));
+
+ SVN_ERR(svn_fs_revision_root(&compare_root,
+ svn_fs_root_fs(eb->fs_root),
+ compare_rev, pool));
+
+ /* Need to decide if the copied node had any extra textual or
+ property mods as well. */
+ SVN_ERR(svn_fs_props_changed(&must_dump_props,
+ compare_root, compare_path,
+ eb->fs_root, path, pool));
+ if (kind == svn_node_file)
+ {
+ svn_checksum_t *checksum;
+ const char *hex_digest;
+ SVN_ERR(svn_fs_contents_changed(&must_dump_text,
+ compare_root, compare_path,
+ eb->fs_root, path, pool));
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
+ compare_root, compare_path,
+ FALSE, pool));
+ hex_digest = svn_checksum_to_cstring(checksum, pool);
+ if (hex_digest)
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_MD5
+ ": %s\n", hex_digest));
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
+ compare_root, compare_path,
+ FALSE, pool));
+ hex_digest = svn_checksum_to_cstring(checksum, pool);
+ if (hex_digest)
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_SHA1
+ ": %s\n", hex_digest));
+ }
+ }
+ }
+
+ if ((! must_dump_text) && (! must_dump_props))
+ {
+ /* If we're not supposed to dump text or props, so be it, we can
+ just go home. However, if either one needs to be dumped,
+ then our dumpstream format demands that at a *minimum*, we
+ see a lone "PROPS-END" as a divider between text and props
+ content within the content-block. */
+ len = 2;
+ return svn_stream_write(eb->stream, "\n\n", &len); /* ### needed? */
+ }
+
+ /*** Start prepping content to dump... ***/
+
+ /* If we are supposed to dump properties, write out a property
+ length header and generate a stringbuf that contains those
+ property values here. */
+ if (must_dump_props)
+ {
+ apr_hash_t *prophash, *oldhash = NULL;
+ apr_size_t proplen;
+ svn_stream_t *propstream;
+
+ SVN_ERR(svn_fs_node_proplist(&prophash, eb->fs_root, path, pool));
+
+ /* If this is a partial dump, then issue a warning if we dump mergeinfo
+ properties that refer to revisions older than the first revision
+ dumped. */
+ if (!eb->verify && eb->notify_func && eb->oldest_dumped_rev > 1)
+ {
+ svn_string_t *mergeinfo_str = svn_hash_gets(prophash,
+ SVN_PROP_MERGEINFO);
+ if (mergeinfo_str)
+ {
+ svn_mergeinfo_t mergeinfo, old_mergeinfo;
+
+ SVN_ERR(svn_mergeinfo_parse(&mergeinfo, mergeinfo_str->data,
+ pool));
+ SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
+ &old_mergeinfo, mergeinfo,
+ eb->oldest_dumped_rev - 1, 0,
+ TRUE, pool, pool));
+ if (apr_hash_count(old_mergeinfo))
+ {
+ svn_repos_notify_t *notify =
+ svn_repos_notify_create(svn_repos_notify_warning, pool);
+
+ notify->warning = svn_repos_notify_warning_found_old_mergeinfo;
+ notify->warning_str = apr_psprintf(
+ pool,
+ _("Mergeinfo referencing revision(s) prior "
+ "to the oldest dumped revision (r%ld). "
+ "Loading this dump may result in invalid "
+ "mergeinfo."),
+ eb->oldest_dumped_rev);
+
+ if (eb->found_old_mergeinfo)
+ *eb->found_old_mergeinfo = TRUE;
+ eb->notify_func(eb->notify_baton, notify, pool);
+ }
+ }
+ }
+
+ if (eb->use_deltas && compare_root)
+ {
+ /* Fetch the old property hash to diff against and output a header
+ saying that our property contents are a delta. */
+ SVN_ERR(svn_fs_node_proplist(&oldhash, compare_root, compare_path,
+ pool));
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_PROP_DELTA ": true\n"));
+ }
+ else
+ oldhash = apr_hash_make(pool);
+ propstring = svn_stringbuf_create_ensure(0, pool);
+ propstream = svn_stream_from_stringbuf(propstring, pool);
+ SVN_ERR(svn_hash_write_incremental(prophash, oldhash, propstream,
+ "PROPS-END", pool));
+ SVN_ERR(svn_stream_close(propstream));
+ proplen = propstring->len;
+ content_length += proplen;
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH
+ ": %" APR_SIZE_T_FMT "\n", proplen));
+ }
+
+ /* If we are supposed to dump text, write out a text length header
+ here, and an MD5 checksum (if available). */
+ if (must_dump_text && (kind == svn_node_file))
+ {
+ svn_checksum_t *checksum;
+ const char *hex_digest;
+ svn_filesize_t textlen;
+
+ if (eb->use_deltas)
+ {
+ /* Compute the text delta now and write it into a temporary
+ file, so that we can find its length. Output a header
+ saying our text contents are a delta. */
+ SVN_ERR(store_delta(&delta_file, &textlen, compare_root,
+ compare_path, eb->fs_root, path, pool));
+ SVN_ERR(svn_stream_puts(eb->stream,
+ SVN_REPOS_DUMPFILE_TEXT_DELTA ": true\n"));
+
+ if (compare_root)
+ {
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
+ compare_root, compare_path,
+ FALSE, pool));
+ hex_digest = svn_checksum_to_cstring(checksum, pool);
+ if (hex_digest)
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_MD5
+ ": %s\n", hex_digest));
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
+ compare_root, compare_path,
+ FALSE, pool));
+ hex_digest = svn_checksum_to_cstring(checksum, pool);
+ if (hex_digest)
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_SHA1
+ ": %s\n", hex_digest));
+ }
+ }
+ else
+ {
+ /* Just fetch the length of the file. */
+ SVN_ERR(svn_fs_file_length(&textlen, eb->fs_root, path, pool));
+ }
+
+ content_length += textlen;
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_TEXT_CONTENT_LENGTH
+ ": %" SVN_FILESIZE_T_FMT "\n", textlen));
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
+ eb->fs_root, path, FALSE, pool));
+ hex_digest = svn_checksum_to_cstring(checksum, pool);
+ if (hex_digest)
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_TEXT_CONTENT_MD5
+ ": %s\n", hex_digest));
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
+ eb->fs_root, path, FALSE, pool));
+ hex_digest = svn_checksum_to_cstring(checksum, pool);
+ if (hex_digest)
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_TEXT_CONTENT_SHA1
+ ": %s\n", hex_digest));
+ }
+
+ /* 'Content-length:' is the last header before we dump the content,
+ and is the sum of the text and prop contents lengths. We write
+ this only for the benefit of non-Subversion RFC-822 parsers. */
+ SVN_ERR(svn_stream_printf(eb->stream, pool,
+ SVN_REPOS_DUMPFILE_CONTENT_LENGTH
+ ": %" SVN_FILESIZE_T_FMT "\n\n",
+ content_length));
+
+ /* Dump property content if we're supposed to do so. */
+ if (must_dump_props)
+ {
+ len = propstring->len;
+ SVN_ERR(svn_stream_write(eb->stream, propstring->data, &len));
+ }
+
+ /* Dump text content */
+ if (must_dump_text && (kind == svn_node_file))
+ {
+ svn_stream_t *contents;
+
+ if (delta_file)
+ {
+ /* Make sure to close the underlying file when the stream is
+ closed. */
+ contents = svn_stream_from_aprfile2(delta_file, FALSE, pool);
+ }
+ else
+ SVN_ERR(svn_fs_file_contents(&contents, eb->fs_root, path, pool));
+
+ SVN_ERR(svn_stream_copy3(contents, svn_stream_disown(eb->stream, pool),
+ NULL, NULL, pool));
+ }
+
+ len = 2;
+ return svn_stream_write(eb->stream, "\n\n", &len); /* ### needed? */
+}
+
+
+static svn_error_t *
+open_root(void *edit_baton,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool,
+ void **root_baton)
+{
+ *root_baton = make_dir_baton(NULL, NULL, SVN_INVALID_REVNUM,
+ edit_baton, NULL, FALSE, pool);
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+delete_entry(const char *path,
+ svn_revnum_t revision,
+ void *parent_baton,
+ apr_pool_t *pool)
+{
+ struct dir_baton *pb = parent_baton;
+ const char *mypath = apr_pstrdup(pb->pool, path);
+
+ /* remember this path needs to be deleted. */
+ svn_hash_sets(pb->deleted_entries, mypath, pb);
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+add_directory(const char *path,
+ void *parent_baton,
+ const char *copyfrom_path,
+ svn_revnum_t copyfrom_rev,
+ apr_pool_t *pool,
+ void **child_baton)
+{
+ struct dir_baton *pb = parent_baton;
+ struct edit_baton *eb = pb->edit_baton;
+ void *val;
+ svn_boolean_t is_copy = FALSE;
+ struct dir_baton *new_db
+ = make_dir_baton(path, copyfrom_path, copyfrom_rev, eb, pb, TRUE, pool);
+
+ /* This might be a replacement -- is the path already deleted? */
+ val = svn_hash_gets(pb->deleted_entries, path);
+
+ /* Detect an add-with-history. */
+ is_copy = ARE_VALID_COPY_ARGS(copyfrom_path, copyfrom_rev);
+
+ /* Dump the node. */
+ SVN_ERR(dump_node(eb, path,
+ svn_node_dir,
+ val ? svn_node_action_replace : svn_node_action_add,
+ is_copy,
+ is_copy ? copyfrom_path : NULL,
+ is_copy ? copyfrom_rev : SVN_INVALID_REVNUM,
+ pool));
+
+ if (val)
+ /* Delete the path, it's now been dumped. */
+ svn_hash_sets(pb->deleted_entries, path, NULL);
+
+ new_db->written_out = TRUE;
+
+ *child_baton = new_db;
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+open_directory(const char *path,
+ void *parent_baton,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool,
+ void **child_baton)
+{
+ struct dir_baton *pb = parent_baton;
+ struct edit_baton *eb = pb->edit_baton;
+ struct dir_baton *new_db;
+ const char *cmp_path = NULL;
+ svn_revnum_t cmp_rev = SVN_INVALID_REVNUM;
+
+ /* If the parent directory has explicit comparison path and rev,
+ record the same for this one. */
+ if (ARE_VALID_COPY_ARGS(pb->cmp_path, pb->cmp_rev))
+ {
+ cmp_path = svn_relpath_join(pb->cmp_path,
+ svn_relpath_basename(path, pool), pool);
+ cmp_rev = pb->cmp_rev;
+ }
+
+ new_db = make_dir_baton(path, cmp_path, cmp_rev, eb, pb, FALSE, pool);
+ *child_baton = new_db;
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+close_directory(void *dir_baton,
+ apr_pool_t *pool)
+{
+ struct dir_baton *db = dir_baton;
+ struct edit_baton *eb = db->edit_baton;
+ apr_pool_t *subpool = svn_pool_create(pool);
+ int i;
+ apr_array_header_t *sorted_entries;
+
+ /* Sort entries lexically instead of as paths. Even though the entries
+ * are full paths they're all in the same directory (see comment in struct
+ * dir_baton definition). So we really want to sort by basename, in which
+ * case the lexical sort function is more efficient. */
+ sorted_entries = svn_sort__hash(db->deleted_entries,
+ svn_sort_compare_items_lexically, pool);
+ for (i = 0; i < sorted_entries->nelts; i++)
+ {
+ const char *path = APR_ARRAY_IDX(sorted_entries, i,
+ svn_sort__item_t).key;
+
+ svn_pool_clear(subpool);
+
+ /* By sending 'svn_node_unknown', the Node-kind: header simply won't
+ be written out. No big deal at all, really. The loader
+ shouldn't care. */
+ SVN_ERR(dump_node(eb, path,
+ svn_node_unknown, svn_node_action_delete,
+ FALSE, NULL, SVN_INVALID_REVNUM, subpool));
+ }
+
+ svn_pool_destroy(subpool);
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+add_file(const char *path,
+ void *parent_baton,
+ const char *copyfrom_path,
+ svn_revnum_t copyfrom_rev,
+ apr_pool_t *pool,
+ void **file_baton)
+{
+ struct dir_baton *pb = parent_baton;
+ struct edit_baton *eb = pb->edit_baton;
+ void *val;
+ svn_boolean_t is_copy = FALSE;
+
+ /* This might be a replacement -- is the path already deleted? */
+ val = svn_hash_gets(pb->deleted_entries, path);
+
+ /* Detect add-with-history. */
+ is_copy = ARE_VALID_COPY_ARGS(copyfrom_path, copyfrom_rev);
+
+ /* Dump the node. */
+ SVN_ERR(dump_node(eb, path,
+ svn_node_file,
+ val ? svn_node_action_replace : svn_node_action_add,
+ is_copy,
+ is_copy ? copyfrom_path : NULL,
+ is_copy ? copyfrom_rev : SVN_INVALID_REVNUM,
+ pool));
+
+ if (val)
+ /* delete the path, it's now been dumped. */
+ svn_hash_sets(pb->deleted_entries, path, NULL);
+
+ *file_baton = NULL; /* muhahahaha */
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+open_file(const char *path,
+ void *parent_baton,
+ svn_revnum_t ancestor_revision,
+ apr_pool_t *pool,
+ void **file_baton)
+{
+ struct dir_baton *pb = parent_baton;
+ struct edit_baton *eb = pb->edit_baton;
+ const char *cmp_path = NULL;
+ svn_revnum_t cmp_rev = SVN_INVALID_REVNUM;
+
+ /* If the parent directory has explicit comparison path and rev,
+ record the same for this one. */
+ if (ARE_VALID_COPY_ARGS(pb->cmp_path, pb->cmp_rev))
+ {
+ cmp_path = svn_relpath_join(pb->cmp_path,
+ svn_relpath_basename(path, pool), pool);
+ cmp_rev = pb->cmp_rev;
+ }
+
+ SVN_ERR(dump_node(eb, path,
+ svn_node_file, svn_node_action_change,
+ FALSE, cmp_path, cmp_rev, pool));
+
+ *file_baton = NULL; /* muhahahaha again */
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+change_dir_prop(void *parent_baton,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ struct dir_baton *db = parent_baton;
+ struct edit_baton *eb = db->edit_baton;
+
+ /* This function is what distinguishes between a directory that is
+ opened to merely get somewhere, vs. one that is opened because it
+ *actually* changed by itself. */
+ if (! db->written_out)
+ {
+ SVN_ERR(dump_node(eb, db->path,
+ svn_node_dir, svn_node_action_change,
+ FALSE, db->cmp_path, db->cmp_rev, pool));
+ db->written_out = TRUE;
+ }
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+fetch_props_func(apr_hash_t **props,
+ void *baton,
+ const char *path,
+ svn_revnum_t base_revision,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ struct edit_baton *eb = baton;
+ svn_error_t *err;
+ svn_fs_root_t *fs_root;
+
+ if (!SVN_IS_VALID_REVNUM(base_revision))
+ base_revision = eb->current_rev - 1;
+
+ SVN_ERR(svn_fs_revision_root(&fs_root, eb->fs, base_revision, scratch_pool));
+
+ err = svn_fs_node_proplist(props, fs_root, path, result_pool);
+ if (err && err->apr_err == SVN_ERR_FS_NOT_FOUND)
+ {
+ svn_error_clear(err);
+ *props = apr_hash_make(result_pool);
+ return SVN_NO_ERROR;
+ }
+ else if (err)
+ return svn_error_trace(err);
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+fetch_kind_func(svn_node_kind_t *kind,
+ void *baton,
+ const char *path,
+ svn_revnum_t base_revision,
+ apr_pool_t *scratch_pool)
+{
+ struct edit_baton *eb = baton;
+ svn_fs_root_t *fs_root;
+
+ if (!SVN_IS_VALID_REVNUM(base_revision))
+ base_revision = eb->current_rev - 1;
+
+ SVN_ERR(svn_fs_revision_root(&fs_root, eb->fs, base_revision, scratch_pool));
+
+ SVN_ERR(svn_fs_check_path(kind, fs_root, path, scratch_pool));
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+fetch_base_func(const char **filename,
+ void *baton,
+ const char *path,
+ svn_revnum_t base_revision,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ struct edit_baton *eb = baton;
+ svn_stream_t *contents;
+ svn_stream_t *file_stream;
+ const char *tmp_filename;
+ svn_error_t *err;
+ svn_fs_root_t *fs_root;
+
+ if (!SVN_IS_VALID_REVNUM(base_revision))
+ base_revision = eb->current_rev - 1;
+
+ SVN_ERR(svn_fs_revision_root(&fs_root, eb->fs, base_revision, scratch_pool));
+
+ err = svn_fs_file_contents(&contents, fs_root, path, scratch_pool);
+ if (err && err->apr_err == SVN_ERR_FS_NOT_FOUND)
+ {
+ svn_error_clear(err);
+ *filename = NULL;
+ return SVN_NO_ERROR;
+ }
+ else if (err)
+ return svn_error_trace(err);
+ SVN_ERR(svn_stream_open_unique(&file_stream, &tmp_filename, NULL,
+ svn_io_file_del_on_pool_cleanup,
+ scratch_pool, scratch_pool));
+ SVN_ERR(svn_stream_copy3(contents, file_stream, NULL, NULL, scratch_pool));
+
+ *filename = apr_pstrdup(result_pool, tmp_filename);
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+get_dump_editor(const svn_delta_editor_t **editor,
+ void **edit_baton,
+ svn_fs_t *fs,
+ svn_revnum_t to_rev,
+ const char *root_path,
+ svn_stream_t *stream,
+ svn_boolean_t *found_old_reference,
+ svn_boolean_t *found_old_mergeinfo,
+ svn_error_t *(*custom_close_directory)(void *dir_baton,
+ apr_pool_t *scratch_pool),
+ svn_repos_notify_func_t notify_func,
+ void *notify_baton,
+ svn_revnum_t oldest_dumped_rev,
+ svn_boolean_t use_deltas,
+ svn_boolean_t verify,
+ apr_pool_t *pool)
+{
+ /* Allocate an edit baton to be stored in every directory baton.
+ Set it up for the directory baton we create here, which is the
+ root baton. */
+ struct edit_baton *eb = apr_pcalloc(pool, sizeof(*eb));
+ svn_delta_editor_t *dump_editor = svn_delta_default_editor(pool);
+ svn_delta_shim_callbacks_t *shim_callbacks =
+ svn_delta_shim_callbacks_default(pool);
+
+ /* Set up the edit baton. */
+ eb->stream = stream;
+ eb->notify_func = notify_func;
+ eb->notify_baton = notify_baton;
+ eb->oldest_dumped_rev = oldest_dumped_rev;
+ eb->bufsize = sizeof(eb->buffer);
+ eb->path = apr_pstrdup(pool, root_path);
+ SVN_ERR(svn_fs_revision_root(&(eb->fs_root), fs, to_rev, pool));
+ eb->fs = fs;
+ eb->current_rev = to_rev;
+ eb->use_deltas = use_deltas;
+ eb->verify = verify;
+ eb->found_old_reference = found_old_reference;
+ eb->found_old_mergeinfo = found_old_mergeinfo;
+
+ /* Set up the editor. */
+ dump_editor->open_root = open_root;
+ dump_editor->delete_entry = delete_entry;
+ dump_editor->add_directory = add_directory;
+ dump_editor->open_directory = open_directory;
+ if (custom_close_directory)
+ dump_editor->close_directory = custom_close_directory;
+ else
+ dump_editor->close_directory = close_directory;
+ dump_editor->change_dir_prop = change_dir_prop;
+ dump_editor->add_file = add_file;
+ dump_editor->open_file = open_file;
+
+ *edit_baton = eb;
+ *editor = dump_editor;
+
+ shim_callbacks->fetch_kind_func = fetch_kind_func;
+ shim_callbacks->fetch_props_func = fetch_props_func;
+ shim_callbacks->fetch_base_func = fetch_base_func;
+ shim_callbacks->fetch_baton = eb;
+
+ SVN_ERR(svn_editor__insert_shims(editor, edit_baton, *editor, *edit_baton,
+ NULL, NULL, shim_callbacks, pool, pool));
+
+ return SVN_NO_ERROR;
+}
+
+/*----------------------------------------------------------------------*/
+
+/** The main dumping routine, svn_repos_dump_fs. **/
+
+
+/* Helper for svn_repos_dump_fs.
+
+ Write a revision record of REV in FS to writable STREAM, using POOL.
+ */
+static svn_error_t *
+write_revision_record(svn_stream_t *stream,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *pool)
+{
+ apr_size_t len;
+ apr_hash_t *props;
+ svn_stringbuf_t *encoded_prophash;
+ apr_time_t timetemp;
+ svn_string_t *datevalue;
+ svn_stream_t *propstream;
+
+ /* Read the revision props even if we're aren't going to dump
+ them for verification purposes */
+ SVN_ERR(svn_fs_revision_proplist(&props, fs, rev, pool));
+
+ /* Run revision date properties through the time conversion to
+ canonicalize them. */
+ /* ### Remove this when it is no longer needed for sure. */
+ datevalue = svn_hash_gets(props, SVN_PROP_REVISION_DATE);
+ if (datevalue)
+ {
+ SVN_ERR(svn_time_from_cstring(&timetemp, datevalue->data, pool));
+ datevalue = svn_string_create(svn_time_to_cstring(timetemp, pool),
+ pool);
+ svn_hash_sets(props, SVN_PROP_REVISION_DATE, datevalue);
+ }
+
+ encoded_prophash = svn_stringbuf_create_ensure(0, pool);
+ propstream = svn_stream_from_stringbuf(encoded_prophash, pool);
+ SVN_ERR(svn_hash_write2(props, propstream, "PROPS-END", pool));
+ SVN_ERR(svn_stream_close(propstream));
+
+ /* ### someday write a revision-content-checksum */
+
+ SVN_ERR(svn_stream_printf(stream, pool,
+ SVN_REPOS_DUMPFILE_REVISION_NUMBER
+ ": %ld\n", rev));
+ SVN_ERR(svn_stream_printf(stream, pool,
+ SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH
+ ": %" APR_SIZE_T_FMT "\n",
+ encoded_prophash->len));
+
+ /* Write out a regular Content-length header for the benefit of
+ non-Subversion RFC-822 parsers. */
+ SVN_ERR(svn_stream_printf(stream, pool,
+ SVN_REPOS_DUMPFILE_CONTENT_LENGTH
+ ": %" APR_SIZE_T_FMT "\n\n",
+ encoded_prophash->len));
+
+ len = encoded_prophash->len;
+ SVN_ERR(svn_stream_write(stream, encoded_prophash->data, &len));
+
+ len = 1;
+ return svn_stream_write(stream, "\n", &len);
+}
+
+
+
+/* The main dumper. */
+svn_error_t *
+svn_repos_dump_fs3(svn_repos_t *repos,
+ svn_stream_t *stream,
+ svn_revnum_t start_rev,
+ svn_revnum_t end_rev,
+ svn_boolean_t incremental,
+ svn_boolean_t use_deltas,
+ svn_repos_notify_func_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ const svn_delta_editor_t *dump_editor;
+ void *dump_edit_baton = NULL;
+ svn_revnum_t i;
+ svn_fs_t *fs = svn_repos_fs(repos);
+ apr_pool_t *subpool = svn_pool_create(pool);
+ svn_revnum_t youngest;
+ const char *uuid;
+ int version;
+ svn_boolean_t found_old_reference = FALSE;
+ svn_boolean_t found_old_mergeinfo = FALSE;
+ svn_repos_notify_t *notify;
+
+ /* Determine the current youngest revision of the filesystem. */
+ SVN_ERR(svn_fs_youngest_rev(&youngest, fs, pool));
+
+ /* Use default vals if necessary. */
+ if (! SVN_IS_VALID_REVNUM(start_rev))
+ start_rev = 0;
+ if (! SVN_IS_VALID_REVNUM(end_rev))
+ end_rev = youngest;
+ if (! stream)
+ stream = svn_stream_empty(pool);
+
+ /* Validate the revisions. */
+ if (start_rev > end_rev)
+ return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("Start revision %ld"
+ " is greater than end revision %ld"),
+ start_rev, end_rev);
+ if (end_rev > youngest)
+ return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("End revision %ld is invalid "
+ "(youngest revision is %ld)"),
+ end_rev, youngest);
+ if ((start_rev == 0) && incremental)
+ incremental = FALSE; /* revision 0 looks the same regardless of
+ whether or not this is an incremental
+ dump, so just simplify things. */
+
+ /* Write out the UUID. */
+ SVN_ERR(svn_fs_get_uuid(fs, &uuid, pool));
+
+ /* If we're not using deltas, use the previous version, for
+ compatibility with svn 1.0.x. */
+ version = SVN_REPOS_DUMPFILE_FORMAT_VERSION;
+ if (!use_deltas)
+ version--;
+
+ /* Write out "general" metadata for the dumpfile. In this case, a
+ magic header followed by a dumpfile format version. */
+ SVN_ERR(svn_stream_printf(stream, pool,
+ SVN_REPOS_DUMPFILE_MAGIC_HEADER ": %d\n\n",
+ version));
+ SVN_ERR(svn_stream_printf(stream, pool, SVN_REPOS_DUMPFILE_UUID
+ ": %s\n\n", uuid));
+
+ /* Create a notify object that we can reuse in the loop. */
+ if (notify_func)
+ notify = svn_repos_notify_create(svn_repos_notify_dump_rev_end,
+ pool);
+
+ /* Main loop: we're going to dump revision i. */
+ for (i = start_rev; i <= end_rev; i++)
+ {
+ svn_revnum_t from_rev, to_rev;
+ svn_fs_root_t *to_root;
+ svn_boolean_t use_deltas_for_rev;
+
+ svn_pool_clear(subpool);
+
+ /* Check for cancellation. */
+ if (cancel_func)
+ SVN_ERR(cancel_func(cancel_baton));
+
+ /* Special-case the initial revision dump: it needs to contain
+ *all* nodes, because it's the foundation of all future
+ revisions in the dumpfile. */
+ if ((i == start_rev) && (! incremental))
+ {
+ /* Special-special-case a dump of revision 0. */
+ if (i == 0)
+ {
+ /* Just write out the one revision 0 record and move on.
+ The parser might want to use its properties. */
+ SVN_ERR(write_revision_record(stream, fs, 0, subpool));
+ to_rev = 0;
+ goto loop_end;
+ }
+
+ /* Compare START_REV to revision 0, so that everything
+ appears to be added. */
+ from_rev = 0;
+ to_rev = i;
+ }
+ else
+ {
+ /* In the normal case, we want to compare consecutive revs. */
+ from_rev = i - 1;
+ to_rev = i;
+ }
+
+ /* Write the revision record. */
+ SVN_ERR(write_revision_record(stream, fs, to_rev, subpool));
+
+ /* Fetch the editor which dumps nodes to a file. Regardless of
+ what we've been told, don't use deltas for the first rev of a
+ non-incremental dump. */
+ use_deltas_for_rev = use_deltas && (incremental || i != start_rev);
+ SVN_ERR(get_dump_editor(&dump_editor, &dump_edit_baton, fs, to_rev,
+ "", stream, &found_old_reference,
+ &found_old_mergeinfo, NULL,
+ notify_func, notify_baton,
+ start_rev, use_deltas_for_rev, FALSE, subpool));
+
+ /* Drive the editor in one way or another. */
+ SVN_ERR(svn_fs_revision_root(&to_root, fs, to_rev, subpool));
+
+ /* If this is the first revision of a non-incremental dump,
+ we're in for a full tree dump. Otherwise, we want to simply
+ replay the revision. */
+ if ((i == start_rev) && (! incremental))
+ {
+ svn_fs_root_t *from_root;
+ SVN_ERR(svn_fs_revision_root(&from_root, fs, from_rev, subpool));
+ SVN_ERR(svn_repos_dir_delta2(from_root, "", "",
+ to_root, "",
+ dump_editor, dump_edit_baton,
+ NULL,
+ NULL,
+ FALSE, /* don't send text-deltas */
+ svn_depth_infinity,
+ FALSE, /* don't send entry props */
+ FALSE, /* don't ignore ancestry */
+ subpool));
+ }
+ else
+ {
+ SVN_ERR(svn_repos_replay2(to_root, "", SVN_INVALID_REVNUM, FALSE,
+ dump_editor, dump_edit_baton,
+ NULL, NULL, subpool));
+
+ /* While our editor close_edit implementation is a no-op, we still
+ do this for completeness. */
+ SVN_ERR(dump_editor->close_edit(dump_edit_baton, subpool));
+ }
+
+ loop_end:
+ if (notify_func)
+ {
+ notify->revision = to_rev;
+ notify_func(notify_baton, notify, subpool);
+ }
+ }
+
+ if (notify_func)
+ {
+ /* Did we issue any warnings about references to revisions older than
+ the oldest dumped revision? If so, then issue a final generic
+ warning, since the inline warnings already issued might easily be
+ missed. */
+
+ notify = svn_repos_notify_create(svn_repos_notify_dump_end, subpool);
+ notify_func(notify_baton, notify, subpool);
+
+ if (found_old_reference)
+ {
+ notify = svn_repos_notify_create(svn_repos_notify_warning, subpool);
+
+ notify->warning = svn_repos_notify_warning_found_old_reference;
+ notify->warning_str = _("The range of revisions dumped "
+ "contained references to "
+ "copy sources outside that "
+ "range.");
+ notify_func(notify_baton, notify, subpool);
+ }
+
+ /* Ditto if we issued any warnings about old revisions referenced
+ in dumped mergeinfo. */
+ if (found_old_mergeinfo)
+ {
+ notify = svn_repos_notify_create(svn_repos_notify_warning, subpool);
+
+ notify->warning = svn_repos_notify_warning_found_old_mergeinfo;
+ notify->warning_str = _("The range of revisions dumped "
+ "contained mergeinfo "
+ "which reference revisions outside "
+ "that range.");
+ notify_func(notify_baton, notify, subpool);
+ }
+ }
+
+ svn_pool_destroy(subpool);
+
+ return SVN_NO_ERROR;
+}
+
+
+/*----------------------------------------------------------------------*/
+
+/* verify, based on dump */
+
+
+/* Creating a new revision that changes /A/B/E/bravo means creating new
+ directory listings for /, /A, /A/B, and /A/B/E in the new revision, with
+ each entry not changed in the new revision a link back to the entry in a
+ previous revision. svn_repos_replay()ing a revision does not verify that
+ those links are correct.
+
+ For paths actually changed in the revision we verify, we get directory
+ contents or file length twice: once in the dump editor, and once here.
+ We could create a new verify baton, store in it the changed paths, and
+ skip those here, but that means building an entire wrapper editor and
+ managing two levels of batons. The impact from checking these entries
+ twice should be minimal, while the code to avoid it is not.
+*/
+
+static svn_error_t *
+verify_directory_entry(void *baton, const void *key, apr_ssize_t klen,
+ void *val, apr_pool_t *pool)
+{
+ struct dir_baton *db = baton;
+ svn_fs_dirent_t *dirent = (svn_fs_dirent_t *)val;
+ char *path = svn_relpath_join(db->path, (const char *)key, pool);
+ apr_hash_t *dirents;
+ svn_filesize_t len;
+
+ /* since we can't access the directory entries directly by their ID,
+ we need to navigate from the FS_ROOT to them (relatively expensive
+ because we may start at a never rev than the last change to node). */
+ switch (dirent->kind) {
+ case svn_node_dir:
+ /* Getting this directory's contents is enough to ensure that our
+ link to it is correct. */
+ SVN_ERR(svn_fs_dir_entries(&dirents, db->edit_baton->fs_root, path, pool));
+ break;
+ case svn_node_file:
+ /* Getting this file's size is enough to ensure that our link to it
+ is correct. */
+ SVN_ERR(svn_fs_file_length(&len, db->edit_baton->fs_root, path, pool));
+ break;
+ default:
+ return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
+ _("Unexpected node kind %d for '%s'"),
+ dirent->kind, path);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+verify_close_directory(void *dir_baton,
+ apr_pool_t *pool)
+{
+ struct dir_baton *db = dir_baton;
+ apr_hash_t *dirents;
+ SVN_ERR(svn_fs_dir_entries(&dirents, db->edit_baton->fs_root,
+ db->path, pool));
+ SVN_ERR(svn_iter_apr_hash(NULL, dirents, verify_directory_entry,
+ dir_baton, pool));
+ return close_directory(dir_baton, pool);
+}
+
+/* Baton type used for forwarding notifications from FS API to REPOS API. */
+struct verify_fs2_notify_func_baton_t
+{
+ /* notification function to call (must not be NULL) */
+ svn_repos_notify_func_t notify_func;
+
+ /* baton to use for it */
+ void *notify_baton;
+
+ /* type of notification to send (we will simply plug in the revision) */
+ svn_repos_notify_t *notify;
+};
+
+/* Forward the notification to BATON. */
+static void
+verify_fs2_notify_func(svn_revnum_t revision,
+ void *baton,
+ apr_pool_t *pool)
+{
+ struct verify_fs2_notify_func_baton_t *notify_baton = baton;
+
+ notify_baton->notify->revision = revision;
+ notify_baton->notify_func(notify_baton->notify_baton,
+ notify_baton->notify, pool);
+}
+
+svn_error_t *
+svn_repos_verify_fs2(svn_repos_t *repos,
+ svn_revnum_t start_rev,
+ svn_revnum_t end_rev,
+ svn_repos_notify_func_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ svn_fs_t *fs = svn_repos_fs(repos);
+ svn_revnum_t youngest;
+ svn_revnum_t rev;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ svn_repos_notify_t *notify;
+ svn_fs_progress_notify_func_t verify_notify = NULL;
+ struct verify_fs2_notify_func_baton_t *verify_notify_baton = NULL;
+
+ /* Determine the current youngest revision of the filesystem. */
+ SVN_ERR(svn_fs_youngest_rev(&youngest, fs, pool));
+
+ /* Use default vals if necessary. */
+ if (! SVN_IS_VALID_REVNUM(start_rev))
+ start_rev = 0;
+ if (! SVN_IS_VALID_REVNUM(end_rev))
+ end_rev = youngest;
+
+ /* Validate the revisions. */
+ if (start_rev > end_rev)
+ return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("Start revision %ld"
+ " is greater than end revision %ld"),
+ start_rev, end_rev);
+ if (end_rev > youngest)
+ return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("End revision %ld is invalid "
+ "(youngest revision is %ld)"),
+ end_rev, youngest);
+
+ /* Create a notify object that we can reuse within the loop and a
+ forwarding structure for notifications from inside svn_fs_verify(). */
+ if (notify_func)
+ {
+ notify = svn_repos_notify_create(svn_repos_notify_verify_rev_end,
+ pool);
+
+ verify_notify = verify_fs2_notify_func;
+ verify_notify_baton = apr_palloc(pool, sizeof(*verify_notify_baton));
+ verify_notify_baton->notify_func = notify_func;
+ verify_notify_baton->notify_baton = notify_baton;
+ verify_notify_baton->notify
+ = svn_repos_notify_create(svn_repos_notify_verify_rev_structure, pool);
+ }
+
+ /* Verify global metadata and backend-specific data first. */
+ SVN_ERR(svn_fs_verify(svn_fs_path(fs, pool), svn_fs_config(fs, pool),
+ start_rev, end_rev,
+ verify_notify, verify_notify_baton,
+ cancel_func, cancel_baton, pool));
+
+ for (rev = start_rev; rev <= end_rev; rev++)
+ {
+ const svn_delta_editor_t *dump_editor;
+ void *dump_edit_baton;
+ const svn_delta_editor_t *cancel_editor;
+ void *cancel_edit_baton;
+ svn_fs_root_t *to_root;
+ apr_hash_t *props;
+
+ svn_pool_clear(iterpool);
+
+ /* Get cancellable dump editor, but with our close_directory handler. */
+ SVN_ERR(get_dump_editor(&dump_editor, &dump_edit_baton,
+ fs, rev, "",
+ svn_stream_empty(iterpool),
+ NULL, NULL,
+ verify_close_directory,
+ notify_func, notify_baton,
+ start_rev,
+ FALSE, TRUE, /* use_deltas, verify */
+ iterpool));
+ SVN_ERR(svn_delta_get_cancellation_editor(cancel_func, cancel_baton,
+ dump_editor, dump_edit_baton,
+ &cancel_editor,
+ &cancel_edit_baton,
+ iterpool));
+
+ SVN_ERR(svn_fs_revision_root(&to_root, fs, rev, iterpool));
+ SVN_ERR(svn_fs_verify_root(to_root, iterpool));
+
+ SVN_ERR(svn_repos_replay2(to_root, "", SVN_INVALID_REVNUM, FALSE,
+ cancel_editor, cancel_edit_baton,
+ NULL, NULL, iterpool));
+ /* While our editor close_edit implementation is a no-op, we still
+ do this for completeness. */
+ SVN_ERR(cancel_editor->close_edit(cancel_edit_baton, iterpool));
+
+ SVN_ERR(svn_fs_revision_proplist(&props, fs, rev, iterpool));
+
+ if (notify_func)
+ {
+ notify->revision = rev;
+ notify_func(notify_baton, notify, iterpool);
+ }
+ }
+
+ /* We're done. */
+ if (notify_func)
+ {
+ notify = svn_repos_notify_create(svn_repos_notify_verify_end, iterpool);
+ notify_func(notify_baton, notify, iterpool);
+ }
+
+ /* Per-backend verification. */
+ svn_pool_destroy(iterpool);
+
+ return SVN_NO_ERROR;
+}
diff --git a/subversion/libsvn_repos/fs-wrap.c b/subversion/libsvn_repos/fs-wrap.c
new file mode 100644
index 000000000000..b759c57fe101
--- /dev/null
+++ b/subversion/libsvn_repos/fs-wrap.c
@@ -0,0 +1,844 @@
+/* fs-wrap.c --- filesystem interface wrappers.
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "svn_hash.h"
+#include "svn_pools.h"
+#include "svn_error.h"
+#include "svn_fs.h"
+#include "svn_path.h"
+#include "svn_props.h"
+#include "svn_repos.h"
+#include "svn_time.h"
+#include "svn_sorts.h"
+#include "repos.h"
+#include "svn_private_config.h"
+#include "private/svn_repos_private.h"
+#include "private/svn_utf_private.h"
+#include "private/svn_fspath.h"
+
+
+/*** Commit wrappers ***/
+
+svn_error_t *
+svn_repos_fs_commit_txn(const char **conflict_p,
+ svn_repos_t *repos,
+ svn_revnum_t *new_rev,
+ svn_fs_txn_t *txn,
+ apr_pool_t *pool)
+{
+ svn_error_t *err, *err2;
+ const char *txn_name;
+ apr_hash_t *props;
+ apr_pool_t *iterpool;
+ apr_hash_index_t *hi;
+ apr_hash_t *hooks_env;
+
+ *new_rev = SVN_INVALID_REVNUM;
+
+ /* Parse the hooks-env file (if any). */
+ SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,
+ pool, pool));
+
+ /* Run pre-commit hooks. */
+ SVN_ERR(svn_fs_txn_name(&txn_name, txn, pool));
+ SVN_ERR(svn_repos__hooks_pre_commit(repos, hooks_env, txn_name, pool));
+
+ /* Remove any ephemeral transaction properties. */
+ SVN_ERR(svn_fs_txn_proplist(&props, txn, pool));
+ iterpool = svn_pool_create(pool);
+ for (hi = apr_hash_first(pool, props); hi; hi = apr_hash_next(hi))
+ {
+ const void *key;
+ apr_hash_this(hi, &key, NULL, NULL);
+
+ svn_pool_clear(iterpool);
+
+ if (strncmp(key, SVN_PROP_TXN_PREFIX,
+ (sizeof(SVN_PROP_TXN_PREFIX) - 1)) == 0)
+ {
+ SVN_ERR(svn_fs_change_txn_prop(txn, key, NULL, iterpool));
+ }
+ }
+ svn_pool_destroy(iterpool);
+
+ /* Commit. */
+ err = svn_fs_commit_txn(conflict_p, new_rev, txn, pool);
+ if (! SVN_IS_VALID_REVNUM(*new_rev))
+ return err;
+
+ /* Run post-commit hooks. */
+ if ((err2 = svn_repos__hooks_post_commit(repos, hooks_env,
+ *new_rev, txn_name, pool)))
+ {
+ err2 = svn_error_create
+ (SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED, err2,
+ _("Commit succeeded, but post-commit hook failed"));
+ }
+
+ return svn_error_compose_create(err, err2);
+}
+
+
+
+/*** Transaction creation wrappers. ***/
+
+
+svn_error_t *
+svn_repos_fs_begin_txn_for_commit2(svn_fs_txn_t **txn_p,
+ svn_repos_t *repos,
+ svn_revnum_t rev,
+ apr_hash_t *revprop_table,
+ apr_pool_t *pool)
+{
+ apr_array_header_t *revprops;
+ const char *txn_name;
+ svn_string_t *author = svn_hash_gets(revprop_table, SVN_PROP_REVISION_AUTHOR);
+ apr_hash_t *hooks_env;
+
+ /* Parse the hooks-env file (if any). */
+ SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,
+ pool, pool));
+
+ /* Begin the transaction, ask for the fs to do on-the-fly lock checks.
+ We fetch its name, too, so the start-commit hook can use it. */
+ SVN_ERR(svn_fs_begin_txn2(txn_p, repos->fs, rev,
+ SVN_FS_TXN_CHECK_LOCKS, pool));
+ SVN_ERR(svn_fs_txn_name(&txn_name, *txn_p, pool));
+
+ /* We pass the revision properties to the filesystem by adding them
+ as properties on the txn. Later, when we commit the txn, these
+ properties will be copied into the newly created revision. */
+ revprops = svn_prop_hash_to_array(revprop_table, pool);
+ SVN_ERR(svn_repos_fs_change_txn_props(*txn_p, revprops, pool));
+
+ /* Run start-commit hooks. */
+ SVN_ERR(svn_repos__hooks_start_commit(repos, hooks_env,
+ author ? author->data : NULL,
+ repos->client_capabilities, txn_name,
+ pool));
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_fs_begin_txn_for_commit(svn_fs_txn_t **txn_p,
+ svn_repos_t *repos,
+ svn_revnum_t rev,
+ const char *author,
+ const char *log_msg,
+ apr_pool_t *pool)
+{
+ apr_hash_t *revprop_table = apr_hash_make(pool);
+ if (author)
+ svn_hash_sets(revprop_table, SVN_PROP_REVISION_AUTHOR,
+ svn_string_create(author, pool));
+ if (log_msg)
+ svn_hash_sets(revprop_table, SVN_PROP_REVISION_LOG,
+ svn_string_create(log_msg, pool));
+ return svn_repos_fs_begin_txn_for_commit2(txn_p, repos, rev, revprop_table,
+ pool);
+}
+
+
+/*** Property wrappers ***/
+
+svn_error_t *
+svn_repos__validate_prop(const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ svn_prop_kind_t kind = svn_property_kind2(name);
+
+ /* Disallow setting non-regular properties. */
+ if (kind != svn_prop_regular_kind)
+ return svn_error_createf
+ (SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("Storage of non-regular property '%s' is disallowed through the "
+ "repository interface, and could indicate a bug in your client"),
+ name);
+
+ /* Validate "svn:" properties. */
+ if (svn_prop_is_svn_prop(name) && value != NULL)
+ {
+ /* Validate that translated props (e.g., svn:log) are UTF-8 with
+ * LF line endings. */
+ if (svn_prop_needs_translation(name))
+ {
+ if (!svn_utf__is_valid(value->data, value->len))
+ {
+ return svn_error_createf
+ (SVN_ERR_BAD_PROPERTY_VALUE, NULL,
+ _("Cannot accept '%s' property because it is not encoded in "
+ "UTF-8"), name);
+ }
+
+ /* Disallow inconsistent line ending style, by simply looking for
+ * carriage return characters ('\r'). */
+ if (strchr(value->data, '\r') != NULL)
+ {
+ return svn_error_createf
+ (SVN_ERR_BAD_PROPERTY_VALUE, NULL,
+ _("Cannot accept non-LF line endings in '%s' property"),
+ name);
+ }
+ }
+
+ /* "svn:date" should be a valid date. */
+ if (strcmp(name, SVN_PROP_REVISION_DATE) == 0)
+ {
+ apr_time_t temp;
+ svn_error_t *err;
+
+ err = svn_time_from_cstring(&temp, value->data, pool);
+ if (err)
+ return svn_error_create(SVN_ERR_BAD_PROPERTY_VALUE,
+ err, NULL);
+ }
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Verify the mergeinfo property value VALUE and return an error if it
+ * is invalid. The PATH on which that property is set is used for error
+ * messages only. Use SCRATCH_POOL for temporary allocations. */
+static svn_error_t *
+verify_mergeinfo(const svn_string_t *value,
+ const char *path,
+ apr_pool_t *scratch_pool)
+{
+ svn_error_t *err;
+ svn_mergeinfo_t mergeinfo;
+
+ /* It's okay to delete svn:mergeinfo. */
+ if (value == NULL)
+ return SVN_NO_ERROR;
+
+ /* Mergeinfo is UTF-8 encoded so the number of bytes returned by strlen()
+ * should match VALUE->LEN. Prevents trailing garbage in the property. */
+ if (strlen(value->data) != value->len)
+ return svn_error_createf(SVN_ERR_MERGEINFO_PARSE_ERROR, NULL,
+ _("Commit rejected because mergeinfo on '%s' "
+ "contains unexpected string terminator"),
+ path);
+
+ err = svn_mergeinfo_parse(&mergeinfo, value->data, scratch_pool);
+ if (err)
+ return svn_error_createf(err->apr_err, err,
+ _("Commit rejected because mergeinfo on '%s' "
+ "is syntactically invalid"),
+ path);
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_fs_change_node_prop(svn_fs_root_t *root,
+ const char *path,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ if (value && strcmp(name, SVN_PROP_MERGEINFO) == 0)
+ SVN_ERR(verify_mergeinfo(value, path, pool));
+
+ /* Validate the property, then call the wrapped function. */
+ SVN_ERR(svn_repos__validate_prop(name, value, pool));
+ return svn_fs_change_node_prop(root, path, name, value, pool);
+}
+
+
+svn_error_t *
+svn_repos_fs_change_txn_props(svn_fs_txn_t *txn,
+ const apr_array_header_t *txnprops,
+ apr_pool_t *pool)
+{
+ int i;
+
+ for (i = 0; i < txnprops->nelts; i++)
+ {
+ svn_prop_t *prop = &APR_ARRAY_IDX(txnprops, i, svn_prop_t);
+ SVN_ERR(svn_repos__validate_prop(prop->name, prop->value, pool));
+ }
+
+ return svn_fs_change_txn_props(txn, txnprops, pool);
+}
+
+
+svn_error_t *
+svn_repos_fs_change_txn_prop(svn_fs_txn_t *txn,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ apr_array_header_t *props = apr_array_make(pool, 1, sizeof(svn_prop_t));
+ svn_prop_t prop;
+
+ prop.name = name;
+ prop.value = value;
+ APR_ARRAY_PUSH(props, svn_prop_t) = prop;
+
+ return svn_repos_fs_change_txn_props(txn, props, pool);
+}
+
+
+svn_error_t *
+svn_repos_fs_change_rev_prop4(svn_repos_t *repos,
+ svn_revnum_t rev,
+ const char *author,
+ const char *name,
+ const svn_string_t *const *old_value_p,
+ const svn_string_t *new_value,
+ svn_boolean_t use_pre_revprop_change_hook,
+ svn_boolean_t use_post_revprop_change_hook,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ svn_repos_revision_access_level_t readability;
+
+ SVN_ERR(svn_repos_check_revision_access(&readability, repos, rev,
+ authz_read_func, authz_read_baton,
+ pool));
+
+ if (readability == svn_repos_revision_access_full)
+ {
+ const svn_string_t *old_value;
+ char action;
+ apr_hash_t *hooks_env;
+
+ SVN_ERR(svn_repos__validate_prop(name, new_value, pool));
+
+ /* Fetch OLD_VALUE for svn_fs_change_rev_prop2(). */
+ if (old_value_p)
+ {
+ old_value = *old_value_p;
+ }
+ else
+ {
+ /* Get OLD_VALUE anyway, in order for ACTION and OLD_VALUE arguments
+ * to the hooks to be accurate. */
+ svn_string_t *old_value2;
+
+ SVN_ERR(svn_fs_revision_prop(&old_value2, repos->fs, rev, name, pool));
+ old_value = old_value2;
+ }
+
+ /* Prepare ACTION. */
+ if (! new_value)
+ action = 'D';
+ else if (! old_value)
+ action = 'A';
+ else
+ action = 'M';
+
+ /* Parse the hooks-env file (if any, and if to be used). */
+ if (use_pre_revprop_change_hook || use_post_revprop_change_hook)
+ SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,
+ pool, pool));
+
+ /* ### currently not passing the old_value to hooks */
+ if (use_pre_revprop_change_hook)
+ SVN_ERR(svn_repos__hooks_pre_revprop_change(repos, hooks_env, rev,
+ author, name, new_value,
+ action, pool));
+
+ SVN_ERR(svn_fs_change_rev_prop2(repos->fs, rev, name,
+ &old_value, new_value, pool));
+
+ if (use_post_revprop_change_hook)
+ SVN_ERR(svn_repos__hooks_post_revprop_change(repos, hooks_env, rev,
+ author, name, old_value,
+ action, pool));
+ }
+ else /* rev is either unreadable or only partially readable */
+ {
+ return svn_error_createf
+ (SVN_ERR_AUTHZ_UNREADABLE, NULL,
+ _("Write denied: not authorized to read all of revision %ld"), rev);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_fs_revision_prop(svn_string_t **value_p,
+ svn_repos_t *repos,
+ svn_revnum_t rev,
+ const char *propname,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ svn_repos_revision_access_level_t readability;
+
+ SVN_ERR(svn_repos_check_revision_access(&readability, repos, rev,
+ authz_read_func, authz_read_baton,
+ pool));
+
+ if (readability == svn_repos_revision_access_none)
+ {
+ /* Property? What property? */
+ *value_p = NULL;
+ }
+ else if (readability == svn_repos_revision_access_partial)
+ {
+ /* Only svn:author and svn:date are fetchable. */
+ if ((strcmp(propname, SVN_PROP_REVISION_AUTHOR) != 0)
+ && (strcmp(propname, SVN_PROP_REVISION_DATE) != 0))
+ *value_p = NULL;
+
+ else
+ SVN_ERR(svn_fs_revision_prop(value_p, repos->fs,
+ rev, propname, pool));
+ }
+ else /* wholly readable revision */
+ {
+ SVN_ERR(svn_fs_revision_prop(value_p, repos->fs, rev, propname, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+
+svn_error_t *
+svn_repos_fs_revision_proplist(apr_hash_t **table_p,
+ svn_repos_t *repos,
+ svn_revnum_t rev,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ svn_repos_revision_access_level_t readability;
+
+ SVN_ERR(svn_repos_check_revision_access(&readability, repos, rev,
+ authz_read_func, authz_read_baton,
+ pool));
+
+ if (readability == svn_repos_revision_access_none)
+ {
+ /* Return an empty hash. */
+ *table_p = apr_hash_make(pool);
+ }
+ else if (readability == svn_repos_revision_access_partial)
+ {
+ apr_hash_t *tmphash;
+ svn_string_t *value;
+
+ /* Produce two property hashtables, both in POOL. */
+ SVN_ERR(svn_fs_revision_proplist(&tmphash, repos->fs, rev, pool));
+ *table_p = apr_hash_make(pool);
+
+ /* If they exist, we only copy svn:author and svn:date into the
+ 'real' hashtable being returned. */
+ value = svn_hash_gets(tmphash, SVN_PROP_REVISION_AUTHOR);
+ if (value)
+ svn_hash_sets(*table_p, SVN_PROP_REVISION_AUTHOR, value);
+
+ value = svn_hash_gets(tmphash, SVN_PROP_REVISION_DATE);
+ if (value)
+ svn_hash_sets(*table_p, SVN_PROP_REVISION_DATE, value);
+ }
+ else /* wholly readable revision */
+ {
+ SVN_ERR(svn_fs_revision_proplist(table_p, repos->fs, rev, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_repos_fs_lock(svn_lock_t **lock,
+ svn_repos_t *repos,
+ const char *path,
+ const char *token,
+ const char *comment,
+ svn_boolean_t is_dav_comment,
+ apr_time_t expiration_date,
+ svn_revnum_t current_rev,
+ svn_boolean_t steal_lock,
+ apr_pool_t *pool)
+{
+ svn_error_t *err;
+ svn_fs_access_t *access_ctx = NULL;
+ const char *username = NULL;
+ const char *new_token;
+ apr_array_header_t *paths;
+ apr_hash_t *hooks_env;
+
+ /* Parse the hooks-env file (if any). */
+ SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,
+ pool, pool));
+
+ /* Setup an array of paths in anticipation of the ra layers handling
+ multiple locks in one request (1.3 most likely). This is only
+ used by svn_repos__hooks_post_lock. */
+ paths = apr_array_make(pool, 1, sizeof(const char *));
+ APR_ARRAY_PUSH(paths, const char *) = path;
+
+ SVN_ERR(svn_fs_get_access(&access_ctx, repos->fs));
+ if (access_ctx)
+ SVN_ERR(svn_fs_access_get_username(&username, access_ctx));
+
+ if (! username)
+ return svn_error_createf
+ (SVN_ERR_FS_NO_USER, NULL,
+ "Cannot lock path '%s', no authenticated username available.", path);
+
+ /* Run pre-lock hook. This could throw error, preventing
+ svn_fs_lock() from happening. */
+ SVN_ERR(svn_repos__hooks_pre_lock(repos, hooks_env, &new_token, path,
+ username, comment, steal_lock, pool));
+ if (*new_token)
+ token = new_token;
+
+ /* Lock. */
+ SVN_ERR(svn_fs_lock(lock, repos->fs, path, token, comment, is_dav_comment,
+ expiration_date, current_rev, steal_lock, pool));
+
+ /* Run post-lock hook. */
+ if ((err = svn_repos__hooks_post_lock(repos, hooks_env,
+ paths, username, pool)))
+ return svn_error_create
+ (SVN_ERR_REPOS_POST_LOCK_HOOK_FAILED, err,
+ "Lock succeeded, but post-lock hook failed");
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_fs_unlock(svn_repos_t *repos,
+ const char *path,
+ const char *token,
+ svn_boolean_t break_lock,
+ apr_pool_t *pool)
+{
+ svn_error_t *err;
+ svn_fs_access_t *access_ctx = NULL;
+ const char *username = NULL;
+ apr_array_header_t *paths;
+ apr_hash_t *hooks_env;
+
+ /* Parse the hooks-env file (if any). */
+ SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,
+ pool, pool));
+
+ /* Setup an array of paths in anticipation of the ra layers handling
+ multiple locks in one request (1.3 most likely). This is only
+ used by svn_repos__hooks_post_lock. */
+ paths = apr_array_make(pool, 1, sizeof(const char *));
+ APR_ARRAY_PUSH(paths, const char *) = path;
+
+ SVN_ERR(svn_fs_get_access(&access_ctx, repos->fs));
+ if (access_ctx)
+ SVN_ERR(svn_fs_access_get_username(&username, access_ctx));
+
+ if (! break_lock && ! username)
+ return svn_error_createf
+ (SVN_ERR_FS_NO_USER, NULL,
+ _("Cannot unlock path '%s', no authenticated username available"),
+ path);
+
+ /* Run pre-unlock hook. This could throw error, preventing
+ svn_fs_unlock() from happening. */
+ SVN_ERR(svn_repos__hooks_pre_unlock(repos, hooks_env, path, username, token,
+ break_lock, pool));
+
+ /* Unlock. */
+ SVN_ERR(svn_fs_unlock(repos->fs, path, token, break_lock, pool));
+
+ /* Run post-unlock hook. */
+ if ((err = svn_repos__hooks_post_unlock(repos, hooks_env, paths,
+ username, pool)))
+ return svn_error_create
+ (SVN_ERR_REPOS_POST_UNLOCK_HOOK_FAILED, err,
+ _("Unlock succeeded, but post-unlock hook failed"));
+
+ return SVN_NO_ERROR;
+}
+
+
+struct get_locks_baton_t
+{
+ svn_fs_t *fs;
+ svn_fs_root_t *head_root;
+ svn_repos_authz_func_t authz_read_func;
+ void *authz_read_baton;
+ apr_hash_t *locks;
+};
+
+
+/* This implements the svn_fs_get_locks_callback_t interface. */
+static svn_error_t *
+get_locks_callback(void *baton,
+ svn_lock_t *lock,
+ apr_pool_t *pool)
+{
+ struct get_locks_baton_t *b = baton;
+ svn_boolean_t readable = TRUE;
+ apr_pool_t *hash_pool = apr_hash_pool_get(b->locks);
+
+ /* If there's auth to deal with, deal with it. */
+ if (b->authz_read_func)
+ SVN_ERR(b->authz_read_func(&readable, b->head_root, lock->path,
+ b->authz_read_baton, pool));
+
+ /* If we can read this lock path, add the lock to the return hash. */
+ if (readable)
+ svn_hash_sets(b->locks, apr_pstrdup(hash_pool, lock->path),
+ svn_lock_dup(lock, hash_pool));
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_fs_get_locks2(apr_hash_t **locks,
+ svn_repos_t *repos,
+ const char *path,
+ svn_depth_t depth,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ apr_hash_t *all_locks = apr_hash_make(pool);
+ svn_revnum_t head_rev;
+ struct get_locks_baton_t baton;
+
+ SVN_ERR_ASSERT((depth == svn_depth_empty) ||
+ (depth == svn_depth_files) ||
+ (depth == svn_depth_immediates) ||
+ (depth == svn_depth_infinity));
+
+ SVN_ERR(svn_fs_youngest_rev(&head_rev, repos->fs, pool));
+
+ /* Populate our callback baton. */
+ baton.fs = repos->fs;
+ baton.locks = all_locks;
+ baton.authz_read_func = authz_read_func;
+ baton.authz_read_baton = authz_read_baton;
+ SVN_ERR(svn_fs_revision_root(&(baton.head_root), repos->fs,
+ head_rev, pool));
+
+ /* Get all the locks. */
+ SVN_ERR(svn_fs_get_locks2(repos->fs, path, depth,
+ get_locks_callback, &baton, pool));
+
+ *locks = baton.locks;
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_fs_get_mergeinfo(svn_mergeinfo_catalog_t *mergeinfo,
+ svn_repos_t *repos,
+ const apr_array_header_t *paths,
+ svn_revnum_t rev,
+ svn_mergeinfo_inheritance_t inherit,
+ svn_boolean_t include_descendants,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ /* Here we cast away 'const', but won't try to write through this pointer
+ * without first allocating a new array. */
+ apr_array_header_t *readable_paths = (apr_array_header_t *) paths;
+ svn_fs_root_t *root;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+
+ if (!SVN_IS_VALID_REVNUM(rev))
+ SVN_ERR(svn_fs_youngest_rev(&rev, repos->fs, pool));
+ SVN_ERR(svn_fs_revision_root(&root, repos->fs, rev, pool));
+
+ /* Filter out unreadable paths before divining merge tracking info. */
+ if (authz_read_func)
+ {
+ int i;
+
+ for (i = 0; i < paths->nelts; i++)
+ {
+ svn_boolean_t readable;
+ const char *path = APR_ARRAY_IDX(paths, i, char *);
+ svn_pool_clear(iterpool);
+ SVN_ERR(authz_read_func(&readable, root, path, authz_read_baton,
+ iterpool));
+ if (readable && readable_paths != paths)
+ APR_ARRAY_PUSH(readable_paths, const char *) = path;
+ else if (!readable && readable_paths == paths)
+ {
+ /* Requested paths differ from readable paths. Fork
+ list of readable paths from requested paths. */
+ int j;
+ readable_paths = apr_array_make(pool, paths->nelts - 1,
+ sizeof(char *));
+ for (j = 0; j < i; j++)
+ {
+ path = APR_ARRAY_IDX(paths, j, char *);
+ APR_ARRAY_PUSH(readable_paths, const char *) = path;
+ }
+ }
+ }
+ }
+
+ /* We consciously do not perform authz checks on the paths returned
+ in *MERGEINFO, avoiding massive authz overhead which would allow
+ us to protect the name of where a change was merged from, but not
+ the change itself. */
+ /* ### TODO(reint): ... but how about descendant merged-to paths? */
+ if (readable_paths->nelts > 0)
+ SVN_ERR(svn_fs_get_mergeinfo2(mergeinfo, root, readable_paths, inherit,
+ include_descendants, TRUE, pool, pool));
+ else
+ *mergeinfo = apr_hash_make(pool);
+
+ svn_pool_destroy(iterpool);
+ return SVN_NO_ERROR;
+}
+
+struct pack_notify_baton
+{
+ svn_repos_notify_func_t notify_func;
+ void *notify_baton;
+};
+
+/* Implements svn_fs_pack_notify_t. */
+static svn_error_t *
+pack_notify_func(void *baton,
+ apr_int64_t shard,
+ svn_fs_pack_notify_action_t pack_action,
+ apr_pool_t *pool)
+{
+ struct pack_notify_baton *pnb = baton;
+ svn_repos_notify_t *notify;
+
+ /* Simple conversion works for these values. */
+ SVN_ERR_ASSERT(pack_action >= svn_fs_pack_notify_start
+ && pack_action <= svn_fs_pack_notify_end_revprop);
+
+ notify = svn_repos_notify_create(pack_action
+ + svn_repos_notify_pack_shard_start
+ - svn_fs_pack_notify_start,
+ pool);
+ notify->shard = shard;
+ pnb->notify_func(pnb->notify_baton, notify, pool);
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_repos_fs_pack2(svn_repos_t *repos,
+ svn_repos_notify_func_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ struct pack_notify_baton pnb;
+
+ pnb.notify_func = notify_func;
+ pnb.notify_baton = notify_baton;
+
+ return svn_fs_pack(repos->db_path,
+ notify_func ? pack_notify_func : NULL,
+ notify_func ? &pnb : NULL,
+ cancel_func, cancel_baton, pool);
+}
+
+svn_error_t *
+svn_repos_fs_get_inherited_props(apr_array_header_t **inherited_props_p,
+ svn_fs_root_t *root,
+ const char *path,
+ const char *propname,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+ apr_array_header_t *inherited_props;
+ const char *parent_path = path;
+
+ inherited_props = apr_array_make(result_pool, 1,
+ sizeof(svn_prop_inherited_item_t *));
+ while (!(parent_path[0] == '/' && parent_path[1] == '\0'))
+ {
+ svn_boolean_t allowed = TRUE;
+ apr_hash_t *parent_properties = NULL;
+
+ svn_pool_clear(iterpool);
+ parent_path = svn_fspath__dirname(parent_path, scratch_pool);
+
+ if (authz_read_func)
+ SVN_ERR(authz_read_func(&allowed, root, parent_path,
+ authz_read_baton, iterpool));
+ if (allowed)
+ {
+ if (propname)
+ {
+ svn_string_t *propval;
+
+ SVN_ERR(svn_fs_node_prop(&propval, root, parent_path, propname,
+ result_pool));
+ if (propval)
+ {
+ parent_properties = apr_hash_make(result_pool);
+ svn_hash_sets(parent_properties, propname, propval);
+ }
+ }
+ else
+ {
+ SVN_ERR(svn_fs_node_proplist(&parent_properties, root,
+ parent_path, result_pool));
+ }
+
+ if (parent_properties && apr_hash_count(parent_properties))
+ {
+ svn_prop_inherited_item_t *i_props =
+ apr_pcalloc(result_pool, sizeof(*i_props));
+ i_props->path_or_url =
+ apr_pstrdup(result_pool, parent_path + 1);
+ i_props->prop_hash = parent_properties;
+ /* Build the output array in depth-first order. */
+ svn_sort__array_insert(&i_props, inherited_props, 0);
+ }
+ }
+ }
+
+ svn_pool_destroy(iterpool);
+
+ *inherited_props_p = inherited_props;
+ return SVN_NO_ERROR;
+}
+
+/*
+ * vim:ts=4:sw=2:expandtab:tw=80:fo=tcroq
+ * vim:isk=a-z,A-Z,48-57,_,.,-,>
+ * vim:cino=>1s,e0,n0,f0,{.5s,}0,^-.5s,=.5s,t0,+1s,c3,(0,u0,\:0
+ */
diff --git a/subversion/libsvn_repos/hooks.c b/subversion/libsvn_repos/hooks.c
new file mode 100644
index 000000000000..972759915159
--- /dev/null
+++ b/subversion/libsvn_repos/hooks.c
@@ -0,0 +1,890 @@
+/* hooks.c : running repository hooks
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <apr_pools.h>
+#include <apr_file_io.h>
+
+#include "svn_config.h"
+#include "svn_hash.h"
+#include "svn_error.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_pools.h"
+#include "svn_repos.h"
+#include "svn_utf.h"
+#include "repos.h"
+#include "svn_private_config.h"
+#include "private/svn_fs_private.h"
+#include "private/svn_repos_private.h"
+#include "private/svn_string_private.h"
+
+
+
+/*** Hook drivers. ***/
+
+/* Helper function for run_hook_cmd(). Wait for a hook to finish
+ executing and return either SVN_NO_ERROR if the hook script completed
+ without error, or an error describing the reason for failure.
+
+ NAME and CMD are the name and path of the hook program, CMD_PROC
+ is a pointer to the structure representing the running process,
+ and READ_ERRHANDLE is an open handle to the hook's stderr.
+
+ Hooks are considered to have failed if we are unable to wait for the
+ process, if we are unable to read from the hook's stderr, if the
+ process has failed to exit cleanly (due to a coredump, for example),
+ or if the process returned a non-zero return code.
+
+ Any error output returned by the hook's stderr will be included in an
+ error message, though the presence of output on stderr is not itself
+ a reason to fail a hook. */
+static svn_error_t *
+check_hook_result(const char *name, const char *cmd, apr_proc_t *cmd_proc,
+ apr_file_t *read_errhandle, apr_pool_t *pool)
+{
+ svn_error_t *err, *err2;
+ svn_stringbuf_t *native_stderr, *failure_message;
+ const char *utf8_stderr;
+ int exitcode;
+ apr_exit_why_e exitwhy;
+
+ err2 = svn_stringbuf_from_aprfile(&native_stderr, read_errhandle, pool);
+
+ err = svn_io_wait_for_cmd(cmd_proc, cmd, &exitcode, &exitwhy, pool);
+ if (err)
+ {
+ svn_error_clear(err2);
+ return svn_error_trace(err);
+ }
+
+ if (APR_PROC_CHECK_EXIT(exitwhy) && exitcode == 0)
+ {
+ /* The hook exited cleanly. However, if we got an error reading
+ the hook's stderr, fail the hook anyway, because this might be
+ symptomatic of a more important problem. */
+ if (err2)
+ {
+ return svn_error_createf
+ (SVN_ERR_REPOS_HOOK_FAILURE, err2,
+ _("'%s' hook succeeded, but error output could not be read"),
+ name);
+ }
+
+ return SVN_NO_ERROR;
+ }
+
+ /* The hook script failed. */
+
+ /* If we got the stderr output okay, try to translate it into UTF-8.
+ Ensure there is something sensible in the UTF-8 string regardless. */
+ if (!err2)
+ {
+ err2 = svn_utf_cstring_to_utf8(&utf8_stderr, native_stderr->data, pool);
+ if (err2)
+ utf8_stderr = _("[Error output could not be translated from the "
+ "native locale to UTF-8.]");
+ }
+ else
+ {
+ utf8_stderr = _("[Error output could not be read.]");
+ }
+ /*### It would be nice to include the text of any translation or read
+ error in the messages above before we clear it here. */
+ svn_error_clear(err2);
+
+ if (!APR_PROC_CHECK_EXIT(exitwhy))
+ {
+ failure_message = svn_stringbuf_createf(pool,
+ _("'%s' hook failed (did not exit cleanly: "
+ "apr_exit_why_e was %d, exitcode was %d). "),
+ name, exitwhy, exitcode);
+ }
+ else
+ {
+ const char *action;
+ if (strcmp(name, "start-commit") == 0
+ || strcmp(name, "pre-commit") == 0)
+ action = _("Commit");
+ else if (strcmp(name, "pre-revprop-change") == 0)
+ action = _("Revprop change");
+ else if (strcmp(name, "pre-lock") == 0)
+ action = _("Lock");
+ else if (strcmp(name, "pre-unlock") == 0)
+ action = _("Unlock");
+ else
+ action = NULL;
+ if (action == NULL)
+ failure_message = svn_stringbuf_createf(
+ pool, _("%s hook failed (exit code %d)"),
+ name, exitcode);
+ else
+ failure_message = svn_stringbuf_createf(
+ pool, _("%s blocked by %s hook (exit code %d)"),
+ action, name, exitcode);
+ }
+
+ if (utf8_stderr[0])
+ {
+ svn_stringbuf_appendcstr(failure_message,
+ _(" with output:\n"));
+ svn_stringbuf_appendcstr(failure_message, utf8_stderr);
+ }
+ else
+ {
+ svn_stringbuf_appendcstr(failure_message,
+ _(" with no output."));
+ }
+
+ return svn_error_create(SVN_ERR_REPOS_HOOK_FAILURE, err,
+ failure_message->data);
+}
+
+/* Copy the environment given as key/value pairs of ENV_HASH into
+ * an array of C strings allocated in RESULT_POOL.
+ * If the hook environment is empty, return NULL.
+ * Use SCRATCH_POOL for temporary allocations. */
+static const char **
+env_from_env_hash(apr_hash_t *env_hash,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ apr_hash_index_t *hi;
+ const char **env;
+ const char **envp;
+
+ if (!env_hash)
+ return NULL;
+
+ env = apr_palloc(result_pool,
+ sizeof(const char *) * (apr_hash_count(env_hash) + 1));
+ envp = env;
+ for (hi = apr_hash_first(scratch_pool, env_hash); hi; hi = apr_hash_next(hi))
+ {
+ *envp = apr_psprintf(result_pool, "%s=%s",
+ (const char *)svn__apr_hash_index_key(hi),
+ (const char *)svn__apr_hash_index_val(hi));
+ envp++;
+ }
+ *envp = NULL;
+
+ return env;
+}
+
+/* NAME, CMD and ARGS are the name, path to and arguments for the hook
+ program that is to be run. The hook's exit status will be checked,
+ and if an error occurred the hook's stderr output will be added to
+ the returned error.
+
+ If STDIN_HANDLE is non-null, pass it as the hook's stdin, else pass
+ no stdin to the hook.
+
+ If RESULT is non-null, set *RESULT to the stdout of the hook or to
+ a zero-length string if the hook generates no output on stdout. */
+static svn_error_t *
+run_hook_cmd(svn_string_t **result,
+ const char *name,
+ const char *cmd,
+ const char **args,
+ apr_hash_t *hooks_env,
+ apr_file_t *stdin_handle,
+ apr_pool_t *pool)
+{
+ apr_file_t *null_handle;
+ apr_status_t apr_err;
+ svn_error_t *err;
+ apr_proc_t cmd_proc = {0};
+ apr_pool_t *cmd_pool;
+ apr_hash_t *hook_env = NULL;
+
+ if (result)
+ {
+ null_handle = NULL;
+ }
+ else
+ {
+ /* Redirect stdout to the null device */
+ apr_err = apr_file_open(&null_handle, SVN_NULL_DEVICE_NAME, APR_WRITE,
+ APR_OS_DEFAULT, pool);
+ if (apr_err)
+ return svn_error_wrap_apr
+ (apr_err, _("Can't create null stdout for hook '%s'"), cmd);
+ }
+
+ /* Tie resources allocated for the command to a special pool which we can
+ * destroy in order to clean up the stderr pipe opened for the process. */
+ cmd_pool = svn_pool_create(pool);
+
+ /* Check if a custom environment is defined for this hook, or else
+ * whether a default environment is defined. */
+ if (hooks_env)
+ {
+ hook_env = svn_hash_gets(hooks_env, name);
+ if (hook_env == NULL)
+ hook_env = svn_hash_gets(hooks_env,
+ SVN_REPOS__HOOKS_ENV_DEFAULT_SECTION);
+ }
+
+ err = svn_io_start_cmd3(&cmd_proc, ".", cmd, args,
+ env_from_env_hash(hook_env, pool, pool),
+ FALSE, FALSE, stdin_handle, result != NULL,
+ null_handle, TRUE, NULL, cmd_pool);
+ if (!err)
+ err = check_hook_result(name, cmd, &cmd_proc, cmd_proc.err, pool);
+ else
+ {
+ /* The command could not be started for some reason. */
+ err = svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, err,
+ _("Failed to start '%s' hook"), cmd);
+ }
+
+ /* Hooks are fallible, and so hook failure is "expected" to occur at
+ times. When such a failure happens we still want to close the pipe
+ and null file */
+ if (!err && result)
+ {
+ svn_stringbuf_t *native_stdout;
+ err = svn_stringbuf_from_aprfile(&native_stdout, cmd_proc.out, pool);
+ if (!err)
+ *result = svn_stringbuf__morph_into_string(native_stdout);
+ }
+
+ /* Close resources allocated by svn_io_start_cmd3(), such as the pipe. */
+ svn_pool_destroy(cmd_pool);
+
+ /* Close the null handle. */
+ if (null_handle)
+ {
+ apr_err = apr_file_close(null_handle);
+ if (!err && apr_err)
+ return svn_error_wrap_apr(apr_err, _("Error closing null file"));
+ }
+
+ return svn_error_trace(err);
+}
+
+
+/* Create a temporary file F that will automatically be deleted when the
+ pool is cleaned up. Fill it with VALUE, and leave it open and rewound,
+ ready to be read from. */
+static svn_error_t *
+create_temp_file(apr_file_t **f, const svn_string_t *value, apr_pool_t *pool)
+{
+ apr_off_t offset = 0;
+
+ SVN_ERR(svn_io_open_unique_file3(f, NULL, NULL,
+ svn_io_file_del_on_pool_cleanup,
+ pool, pool));
+ SVN_ERR(svn_io_file_write_full(*f, value->data, value->len, NULL, pool));
+ return svn_io_file_seek(*f, APR_SET, &offset, pool);
+}
+
+
+/* Check if the HOOK program exists and is a file or a symbolic link, using
+ POOL for temporary allocations.
+
+ If the hook exists but is a broken symbolic link, set *BROKEN_LINK
+ to TRUE, else if the hook program exists set *BROKEN_LINK to FALSE.
+
+ Return the hook program if found, else return NULL and don't touch
+ *BROKEN_LINK.
+*/
+static const char*
+check_hook_cmd(const char *hook, svn_boolean_t *broken_link, apr_pool_t *pool)
+{
+ static const char* const check_extns[] = {
+#ifdef WIN32
+ /* For WIN32, we need to check with file name extension(s) added.
+
+ As Windows Scripting Host (.wsf) files can accomodate (at least)
+ JavaScript (.js) and VB Script (.vbs) code, extensions for the
+ corresponding file types need not be enumerated explicitly. */
+ ".exe", ".cmd", ".bat", ".wsf", /* ### Any other extensions? */
+#else
+ "",
+#endif
+ NULL
+ };
+
+ const char *const *extn;
+ svn_error_t *err = NULL;
+ svn_boolean_t is_special;
+ for (extn = check_extns; *extn; ++extn)
+ {
+ const char *const hook_path =
+ (**extn ? apr_pstrcat(pool, hook, *extn, (char *)NULL) : hook);
+
+ svn_node_kind_t kind;
+ if (!(err = svn_io_check_resolved_path(hook_path, &kind, pool))
+ && kind == svn_node_file)
+ {
+ *broken_link = FALSE;
+ return hook_path;
+ }
+ svn_error_clear(err);
+ if (!(err = svn_io_check_special_path(hook_path, &kind, &is_special,
+ pool))
+ && is_special)
+ {
+ *broken_link = TRUE;
+ return hook_path;
+ }
+ svn_error_clear(err);
+ }
+ return NULL;
+}
+
+/* Baton for parse_hooks_env_option. */
+struct parse_hooks_env_option_baton {
+ /* The name of the section being parsed. If not the default section,
+ * the section name should match the name of a hook to which the
+ * options apply. */
+ const char *section;
+ apr_hash_t *hooks_env;
+} parse_hooks_env_option_baton;
+
+/* An implementation of svn_config_enumerator2_t.
+ * Set environment variable NAME to value VALUE in the environment for
+ * all hooks (in case the current section is the default section),
+ * or the hook with the name corresponding to the current section's name. */
+static svn_boolean_t
+parse_hooks_env_option(const char *name, const char *value,
+ void *baton, apr_pool_t *pool)
+{
+ struct parse_hooks_env_option_baton *bo = baton;
+ apr_pool_t *result_pool = apr_hash_pool_get(bo->hooks_env);
+ apr_hash_t *hook_env;
+
+ hook_env = svn_hash_gets(bo->hooks_env, bo->section);
+ if (hook_env == NULL)
+ {
+ hook_env = apr_hash_make(result_pool);
+ svn_hash_sets(bo->hooks_env, apr_pstrdup(result_pool, bo->section),
+ hook_env);
+ }
+ svn_hash_sets(hook_env, apr_pstrdup(result_pool, name),
+ apr_pstrdup(result_pool, value));
+
+ return TRUE;
+}
+
+struct parse_hooks_env_section_baton {
+ svn_config_t *cfg;
+ apr_hash_t *hooks_env;
+} parse_hooks_env_section_baton;
+
+/* An implementation of svn_config_section_enumerator2_t. */
+static svn_boolean_t
+parse_hooks_env_section(const char *name, void *baton, apr_pool_t *pool)
+{
+ struct parse_hooks_env_section_baton *b = baton;
+ struct parse_hooks_env_option_baton bo;
+
+ bo.section = name;
+ bo.hooks_env = b->hooks_env;
+
+ (void)svn_config_enumerate2(b->cfg, name, parse_hooks_env_option, &bo, pool);
+
+ return TRUE;
+}
+
+svn_error_t *
+svn_repos__parse_hooks_env(apr_hash_t **hooks_env_p,
+ const char *local_abspath,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_config_t *cfg;
+ struct parse_hooks_env_section_baton b;
+
+ if (local_abspath)
+ {
+ SVN_ERR(svn_config_read3(&cfg, local_abspath, FALSE,
+ TRUE, TRUE, scratch_pool));
+ b.cfg = cfg;
+ b.hooks_env = apr_hash_make(result_pool);
+ (void)svn_config_enumerate_sections2(cfg, parse_hooks_env_section, &b,
+ scratch_pool);
+ *hooks_env_p = b.hooks_env;
+ }
+ else
+ {
+ *hooks_env_p = NULL;
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Return an error for the failure of HOOK due to a broken symlink. */
+static svn_error_t *
+hook_symlink_error(const char *hook)
+{
+ return svn_error_createf
+ (SVN_ERR_REPOS_HOOK_FAILURE, NULL,
+ _("Failed to run '%s' hook; broken symlink"), hook);
+}
+
+svn_error_t *
+svn_repos__hooks_start_commit(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ const char *user,
+ const apr_array_header_t *capabilities,
+ const char *txn_name,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_start_commit_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[6];
+ char *capabilities_string;
+
+ if (capabilities)
+ {
+ capabilities_string = svn_cstring_join(capabilities, ":", pool);
+
+ /* Get rid of that annoying final colon. */
+ if (capabilities_string[0])
+ capabilities_string[strlen(capabilities_string) - 1] = '\0';
+ }
+ else
+ {
+ capabilities_string = apr_pstrdup(pool, "");
+ }
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = user ? user : "";
+ args[3] = capabilities_string;
+ args[4] = txn_name;
+ args[5] = NULL;
+
+ SVN_ERR(run_hook_cmd(NULL, SVN_REPOS__HOOK_START_COMMIT, hook, args,
+ hooks_env, NULL, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Set *HANDLE to an open filehandle for a temporary file (i.e.,
+ automatically deleted when closed), into which the LOCK_TOKENS have
+ been written out in the format described in the pre-commit hook
+ template.
+
+ LOCK_TOKENS is as returned by svn_fs__access_get_lock_tokens().
+
+ Allocate *HANDLE in POOL, and use POOL for temporary allocations. */
+static svn_error_t *
+lock_token_content(apr_file_t **handle, apr_hash_t *lock_tokens,
+ apr_pool_t *pool)
+{
+ svn_stringbuf_t *lock_str = svn_stringbuf_create("LOCK-TOKENS:\n", pool);
+ apr_hash_index_t *hi;
+
+ for (hi = apr_hash_first(pool, lock_tokens); hi;
+ hi = apr_hash_next(hi))
+ {
+ void *val;
+ const char *path, *token;
+
+ apr_hash_this(hi, (void *)&token, NULL, &val);
+ path = val;
+ svn_stringbuf_appendstr(lock_str,
+ svn_stringbuf_createf(pool, "%s|%s\n",
+ svn_path_uri_autoescape(path, pool),
+ token));
+ }
+
+ svn_stringbuf_appendcstr(lock_str, "\n");
+ return create_temp_file(handle,
+ svn_stringbuf__morph_into_string(lock_str), pool);
+}
+
+
+
+svn_error_t *
+svn_repos__hooks_pre_commit(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ const char *txn_name,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_pre_commit_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[4];
+ svn_fs_access_t *access_ctx;
+ apr_file_t *stdin_handle = NULL;
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = txn_name;
+ args[3] = NULL;
+
+ SVN_ERR(svn_fs_get_access(&access_ctx, repos->fs));
+ if (access_ctx)
+ {
+ apr_hash_t *lock_tokens = svn_fs__access_get_lock_tokens(access_ctx);
+ if (apr_hash_count(lock_tokens)) {
+ SVN_ERR(lock_token_content(&stdin_handle, lock_tokens, pool));
+ }
+ }
+
+ if (!stdin_handle)
+ SVN_ERR(svn_io_file_open(&stdin_handle, SVN_NULL_DEVICE_NAME,
+ APR_READ, APR_OS_DEFAULT, pool));
+
+ SVN_ERR(run_hook_cmd(NULL, SVN_REPOS__HOOK_PRE_COMMIT, hook, args,
+ hooks_env, stdin_handle, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos__hooks_post_commit(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ svn_revnum_t rev,
+ const char *txn_name,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_post_commit_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[5];
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = apr_psprintf(pool, "%ld", rev);
+ args[3] = txn_name;
+ args[4] = NULL;
+
+ SVN_ERR(run_hook_cmd(NULL, SVN_REPOS__HOOK_POST_COMMIT, hook, args,
+ hooks_env, NULL, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos__hooks_pre_revprop_change(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ svn_revnum_t rev,
+ const char *author,
+ const char *name,
+ const svn_string_t *new_value,
+ char action,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_pre_revprop_change_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[7];
+ apr_file_t *stdin_handle = NULL;
+ char action_string[2];
+
+ /* Pass the new value as stdin to hook */
+ if (new_value)
+ SVN_ERR(create_temp_file(&stdin_handle, new_value, pool));
+ else
+ SVN_ERR(svn_io_file_open(&stdin_handle, SVN_NULL_DEVICE_NAME,
+ APR_READ, APR_OS_DEFAULT, pool));
+
+ action_string[0] = action;
+ action_string[1] = '\0';
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = apr_psprintf(pool, "%ld", rev);
+ args[3] = author ? author : "";
+ args[4] = name;
+ args[5] = action_string;
+ args[6] = NULL;
+
+ SVN_ERR(run_hook_cmd(NULL, SVN_REPOS__HOOK_PRE_REVPROP_CHANGE, hook,
+ args, hooks_env, stdin_handle, pool));
+
+ SVN_ERR(svn_io_file_close(stdin_handle, pool));
+ }
+ else
+ {
+ /* If the pre- hook doesn't exist at all, then default to
+ MASSIVE PARANOIA. Changing revision properties is a lossy
+ operation; so unless the repository admininstrator has
+ *deliberately* created the pre-hook, disallow all changes. */
+ return
+ svn_error_create
+ (SVN_ERR_REPOS_DISABLED_FEATURE, NULL,
+ _("Repository has not been enabled to accept revision propchanges;\n"
+ "ask the administrator to create a pre-revprop-change hook"));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos__hooks_post_revprop_change(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ svn_revnum_t rev,
+ const char *author,
+ const char *name,
+ const svn_string_t *old_value,
+ char action,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_post_revprop_change_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[7];
+ apr_file_t *stdin_handle = NULL;
+ char action_string[2];
+
+ /* Pass the old value as stdin to hook */
+ if (old_value)
+ SVN_ERR(create_temp_file(&stdin_handle, old_value, pool));
+ else
+ SVN_ERR(svn_io_file_open(&stdin_handle, SVN_NULL_DEVICE_NAME,
+ APR_READ, APR_OS_DEFAULT, pool));
+
+ action_string[0] = action;
+ action_string[1] = '\0';
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = apr_psprintf(pool, "%ld", rev);
+ args[3] = author ? author : "";
+ args[4] = name;
+ args[5] = action_string;
+ args[6] = NULL;
+
+ SVN_ERR(run_hook_cmd(NULL, SVN_REPOS__HOOK_POST_REVPROP_CHANGE, hook,
+ args, hooks_env, stdin_handle, pool));
+
+ SVN_ERR(svn_io_file_close(stdin_handle, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos__hooks_pre_lock(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ const char **token,
+ const char *path,
+ const char *username,
+ const char *comment,
+ svn_boolean_t steal_lock,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_pre_lock_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[7];
+ svn_string_t *buf;
+
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = path;
+ args[3] = username;
+ args[4] = comment ? comment : "";
+ args[5] = steal_lock ? "1" : "0";
+ args[6] = NULL;
+
+ SVN_ERR(run_hook_cmd(&buf, SVN_REPOS__HOOK_PRE_LOCK, hook, args,
+ hooks_env, NULL, pool));
+
+ if (token)
+ /* No validation here; the FS will take care of that. */
+ *token = buf->data;
+
+ }
+ else if (token)
+ *token = "";
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos__hooks_post_lock(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ const apr_array_header_t *paths,
+ const char *username,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_post_lock_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[5];
+ apr_file_t *stdin_handle = NULL;
+ svn_string_t *paths_str = svn_string_create(svn_cstring_join
+ (paths, "\n", pool),
+ pool);
+
+ SVN_ERR(create_temp_file(&stdin_handle, paths_str, pool));
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = username;
+ args[3] = NULL;
+ args[4] = NULL;
+
+ SVN_ERR(run_hook_cmd(NULL, SVN_REPOS__HOOK_POST_LOCK, hook, args,
+ hooks_env, stdin_handle, pool));
+
+ SVN_ERR(svn_io_file_close(stdin_handle, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos__hooks_pre_unlock(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ const char *path,
+ const char *username,
+ const char *token,
+ svn_boolean_t break_lock,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_pre_unlock_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[7];
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = path;
+ args[3] = username ? username : "";
+ args[4] = token ? token : "";
+ args[5] = break_lock ? "1" : "0";
+ args[6] = NULL;
+
+ SVN_ERR(run_hook_cmd(NULL, SVN_REPOS__HOOK_PRE_UNLOCK, hook, args,
+ hooks_env, NULL, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos__hooks_post_unlock(svn_repos_t *repos,
+ apr_hash_t *hooks_env,
+ const apr_array_header_t *paths,
+ const char *username,
+ apr_pool_t *pool)
+{
+ const char *hook = svn_repos_post_unlock_hook(repos, pool);
+ svn_boolean_t broken_link;
+
+ if ((hook = check_hook_cmd(hook, &broken_link, pool)) && broken_link)
+ {
+ return hook_symlink_error(hook);
+ }
+ else if (hook)
+ {
+ const char *args[5];
+ apr_file_t *stdin_handle = NULL;
+ svn_string_t *paths_str = svn_string_create(svn_cstring_join
+ (paths, "\n", pool),
+ pool);
+
+ SVN_ERR(create_temp_file(&stdin_handle, paths_str, pool));
+
+ args[0] = hook;
+ args[1] = svn_dirent_local_style(svn_repos_path(repos, pool), pool);
+ args[2] = username ? username : "";
+ args[3] = NULL;
+ args[4] = NULL;
+
+ SVN_ERR(run_hook_cmd(NULL, SVN_REPOS__HOOK_POST_UNLOCK, hook, args,
+ hooks_env, stdin_handle, pool));
+
+ SVN_ERR(svn_io_file_close(stdin_handle, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+
+/*
+ * vim:ts=4:sw=4:expandtab:tw=80:fo=tcroq
+ * vim:isk=a-z,A-Z,48-57,_,.,-,>
+ * vim:cino=>1s,e0,n0,f0,{.5s,}0,^-.5s,=.5s,t0,+1s,c3,(0,u0,\:0
+ */
diff --git a/subversion/libsvn_repos/load-fs-vtable.c b/subversion/libsvn_repos/load-fs-vtable.c
new file mode 100644
index 000000000000..c8c5e95d5101
--- /dev/null
+++ b/subversion/libsvn_repos/load-fs-vtable.c
@@ -0,0 +1,1140 @@
+/* load-fs-vtable.c --- dumpstream loader vtable for committing into a
+ * Subversion filesystem.
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+
+#include "svn_private_config.h"
+#include "svn_hash.h"
+#include "svn_pools.h"
+#include "svn_error.h"
+#include "svn_fs.h"
+#include "svn_repos.h"
+#include "svn_string.h"
+#include "svn_props.h"
+#include "repos.h"
+#include "svn_private_config.h"
+#include "svn_mergeinfo.h"
+#include "svn_checksum.h"
+#include "svn_subst.h"
+#include "svn_ctype.h"
+#include "svn_dirent_uri.h"
+
+#include <apr_lib.h>
+
+#include "private/svn_fspath.h"
+#include "private/svn_dep_compat.h"
+#include "private/svn_mergeinfo_private.h"
+
+/*----------------------------------------------------------------------*/
+
+/** Batons used herein **/
+
+struct parse_baton
+{
+ svn_repos_t *repos;
+ svn_fs_t *fs;
+
+ svn_boolean_t use_history;
+ svn_boolean_t validate_props;
+ svn_boolean_t use_pre_commit_hook;
+ svn_boolean_t use_post_commit_hook;
+ enum svn_repos_load_uuid uuid_action;
+ const char *parent_dir; /* repository relpath, or NULL */
+ svn_repos_notify_func_t notify_func;
+ void *notify_baton;
+ svn_repos_notify_t *notify;
+ apr_pool_t *pool;
+
+ /* Start and end (inclusive) of revision range we'll pay attention
+ to, or a pair of SVN_INVALID_REVNUMs if we're not filtering by
+ revisions. */
+ svn_revnum_t start_rev;
+ svn_revnum_t end_rev;
+
+ /* A hash mapping copy-from revisions and mergeinfo range revisions
+ (svn_revnum_t *) in the dump stream to their corresponding revisions
+ (svn_revnum_t *) in the loaded repository. The hash and its
+ contents are allocated in POOL. */
+ /* ### See http://subversion.tigris.org/issues/show_bug.cgi?id=3903
+ ### for discussion about improving the memory costs of this mapping. */
+ apr_hash_t *rev_map;
+
+ /* The most recent (youngest) revision from the dump stream mapped in
+ REV_MAP. If no revisions have been mapped yet, this is set to
+ SVN_INVALID_REVNUM. */
+ svn_revnum_t last_rev_mapped;
+
+ /* The oldest old revision loaded from the dump stream. If no revisions
+ have been loaded yet, this is set to SVN_INVALID_REVNUM. */
+ svn_revnum_t oldest_old_rev;
+};
+
+struct revision_baton
+{
+ svn_revnum_t rev;
+ svn_fs_txn_t *txn;
+ svn_fs_root_t *txn_root;
+
+ const svn_string_t *datestamp;
+
+ apr_int32_t rev_offset;
+ svn_boolean_t skipped;
+
+ struct parse_baton *pb;
+ apr_pool_t *pool;
+};
+
+struct node_baton
+{
+ const char *path;
+ svn_node_kind_t kind;
+ enum svn_node_action action;
+ svn_checksum_t *base_checksum; /* null, if not available */
+ svn_checksum_t *result_checksum; /* null, if not available */
+ svn_checksum_t *copy_source_checksum; /* null, if not available */
+
+ svn_revnum_t copyfrom_rev;
+ const char *copyfrom_path;
+
+ struct revision_baton *rb;
+ apr_pool_t *pool;
+};
+
+
+/*----------------------------------------------------------------------*/
+
+/* Record the mapping of FROM_REV to TO_REV in REV_MAP, ensuring that
+ anything added to the hash is allocated in the hash's pool. */
+static void
+set_revision_mapping(apr_hash_t *rev_map,
+ svn_revnum_t from_rev,
+ svn_revnum_t to_rev)
+{
+ svn_revnum_t *mapped_revs = apr_palloc(apr_hash_pool_get(rev_map),
+ sizeof(svn_revnum_t) * 2);
+ mapped_revs[0] = from_rev;
+ mapped_revs[1] = to_rev;
+ apr_hash_set(rev_map, mapped_revs,
+ sizeof(svn_revnum_t), mapped_revs + 1);
+}
+
+/* Return the revision to which FROM_REV maps in REV_MAP, or
+ SVN_INVALID_REVNUM if no such mapping exists. */
+static svn_revnum_t
+get_revision_mapping(apr_hash_t *rev_map,
+ svn_revnum_t from_rev)
+{
+ svn_revnum_t *to_rev = apr_hash_get(rev_map, &from_rev,
+ sizeof(from_rev));
+ return to_rev ? *to_rev : SVN_INVALID_REVNUM;
+}
+
+
+/* Change revision property NAME to VALUE for REVISION in REPOS. If
+ VALIDATE_PROPS is set, use functions which perform validation of
+ the property value. Otherwise, bypass those checks. */
+static svn_error_t *
+change_rev_prop(svn_repos_t *repos,
+ svn_revnum_t revision,
+ const char *name,
+ const svn_string_t *value,
+ svn_boolean_t validate_props,
+ apr_pool_t *pool)
+{
+ if (validate_props)
+ return svn_repos_fs_change_rev_prop4(repos, revision, NULL, name,
+ NULL, value, FALSE, FALSE,
+ NULL, NULL, pool);
+ else
+ return svn_fs_change_rev_prop2(svn_repos_fs(repos), revision, name,
+ NULL, value, pool);
+}
+
+/* Change property NAME to VALUE for PATH in TXN_ROOT. If
+ VALIDATE_PROPS is set, use functions which perform validation of
+ the property value. Otherwise, bypass those checks. */
+static svn_error_t *
+change_node_prop(svn_fs_root_t *txn_root,
+ const char *path,
+ const char *name,
+ const svn_string_t *value,
+ svn_boolean_t validate_props,
+ apr_pool_t *pool)
+{
+ if (validate_props)
+ return svn_repos_fs_change_node_prop(txn_root, path, name, value, pool);
+ else
+ return svn_fs_change_node_prop(txn_root, path, name, value, pool);
+}
+
+/* Prepend the mergeinfo source paths in MERGEINFO_ORIG with PARENT_DIR, and
+ return it in *MERGEINFO_VAL. */
+/* ### FIXME: Consider somehow sharing code with
+ ### svnrdump/load_editor.c:prefix_mergeinfo_paths() */
+static svn_error_t *
+prefix_mergeinfo_paths(svn_string_t **mergeinfo_val,
+ const svn_string_t *mergeinfo_orig,
+ const char *parent_dir,
+ apr_pool_t *pool)
+{
+ apr_hash_t *prefixed_mergeinfo, *mergeinfo;
+ apr_hash_index_t *hi;
+ void *rangelist;
+
+ SVN_ERR(svn_mergeinfo_parse(&mergeinfo, mergeinfo_orig->data, pool));
+ prefixed_mergeinfo = apr_hash_make(pool);
+ for (hi = apr_hash_first(pool, mergeinfo); hi; hi = apr_hash_next(hi))
+ {
+ const void *key;
+ const char *path, *merge_source;
+
+ apr_hash_this(hi, &key, NULL, &rangelist);
+ merge_source = svn_relpath_canonicalize(key, pool);
+
+ /* The svn:mergeinfo property syntax demands a repos abspath */
+ path = svn_fspath__canonicalize(svn_relpath_join(parent_dir,
+ merge_source, pool),
+ pool);
+ svn_hash_sets(prefixed_mergeinfo, path, rangelist);
+ }
+ return svn_mergeinfo_to_string(mergeinfo_val, prefixed_mergeinfo, pool);
+}
+
+
+/* Examine the mergeinfo in INITIAL_VAL, renumber revisions in rangelists
+ as appropriate, and return the (possibly new) mergeinfo in *FINAL_VAL
+ (allocated from POOL). */
+/* ### FIXME: Consider somehow sharing code with
+ ### svnrdump/load_editor.c:renumber_mergeinfo_revs() */
+static svn_error_t *
+renumber_mergeinfo_revs(svn_string_t **final_val,
+ const svn_string_t *initial_val,
+ struct revision_baton *rb,
+ apr_pool_t *pool)
+{
+ apr_pool_t *subpool = svn_pool_create(pool);
+ svn_mergeinfo_t mergeinfo, predates_stream_mergeinfo;
+ svn_mergeinfo_t final_mergeinfo = apr_hash_make(subpool);
+ apr_hash_index_t *hi;
+
+ SVN_ERR(svn_mergeinfo_parse(&mergeinfo, initial_val->data, subpool));
+
+ /* Issue #3020
+ http://subversion.tigris.org/issues/show_bug.cgi?id=3020#desc16
+ Remove mergeinfo older than the oldest revision in the dump stream
+ and adjust its revisions by the difference between the head rev of
+ the target repository and the current dump stream rev. */
+ if (rb->pb->oldest_old_rev > 1)
+ {
+ SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
+ &predates_stream_mergeinfo, mergeinfo,
+ rb->pb->oldest_old_rev - 1, 0,
+ TRUE, subpool, subpool));
+ SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
+ &mergeinfo, mergeinfo,
+ rb->pb->oldest_old_rev - 1, 0,
+ FALSE, subpool, subpool));
+ SVN_ERR(svn_mergeinfo__adjust_mergeinfo_rangelists(
+ &predates_stream_mergeinfo, predates_stream_mergeinfo,
+ -rb->rev_offset, subpool, subpool));
+ }
+ else
+ {
+ predates_stream_mergeinfo = NULL;
+ }
+
+ for (hi = apr_hash_first(subpool, mergeinfo); hi; hi = apr_hash_next(hi))
+ {
+ const char *merge_source;
+ svn_rangelist_t *rangelist;
+ struct parse_baton *pb = rb->pb;
+ int i;
+ const void *key;
+ void *val;
+
+ apr_hash_this(hi, &key, NULL, &val);
+ merge_source = key;
+ rangelist = val;
+
+ /* Possibly renumber revisions in merge source's rangelist. */
+ for (i = 0; i < rangelist->nelts; i++)
+ {
+ svn_revnum_t rev_from_map;
+ svn_merge_range_t *range = APR_ARRAY_IDX(rangelist, i,
+ svn_merge_range_t *);
+ rev_from_map = get_revision_mapping(pb->rev_map, range->start);
+ if (SVN_IS_VALID_REVNUM(rev_from_map))
+ {
+ range->start = rev_from_map;
+ }
+ else if (range->start == pb->oldest_old_rev - 1)
+ {
+ /* Since the start revision of svn_merge_range_t are not
+ inclusive there is one possible valid start revision that
+ won't be found in the PB->REV_MAP mapping of load stream
+ revsions to loaded revisions: The revision immediately
+ preceeding the oldest revision from the load stream.
+ This is a valid revision for mergeinfo, but not a valid
+ copy from revision (which PB->REV_MAP also maps for) so it
+ will never be in the mapping.
+
+ If that is what we have here, then find the mapping for the
+ oldest rev from the load stream and subtract 1 to get the
+ renumbered, non-inclusive, start revision. */
+ rev_from_map = get_revision_mapping(pb->rev_map,
+ pb->oldest_old_rev);
+ if (SVN_IS_VALID_REVNUM(rev_from_map))
+ range->start = rev_from_map - 1;
+ }
+ else
+ {
+ /* If we can't remap the start revision then don't even bother
+ trying to remap the end revision. It's possible we might
+ actually succeed at the latter, which can result in invalid
+ mergeinfo with a start rev > end rev. If that gets into the
+ repository then a world of bustage breaks loose anytime that
+ bogus mergeinfo is parsed. See
+ http://subversion.tigris.org/issues/show_bug.cgi?id=3020#desc16.
+ */
+ continue;
+ }
+
+ rev_from_map = get_revision_mapping(pb->rev_map, range->end);
+ if (SVN_IS_VALID_REVNUM(rev_from_map))
+ range->end = rev_from_map;
+ }
+ svn_hash_sets(final_mergeinfo, merge_source, rangelist);
+ }
+
+ if (predates_stream_mergeinfo)
+ SVN_ERR(svn_mergeinfo_merge2(final_mergeinfo, predates_stream_mergeinfo,
+ subpool, subpool));
+
+ SVN_ERR(svn_mergeinfo_sort(final_mergeinfo, subpool));
+
+ /* Mergeinfo revision sources for r0 and r1 are invalid; you can't merge r0
+ or r1. However, svndumpfilter can be abused to produce r1 merge source
+ revs. So if we encounter any, then strip them out, no need to put them
+ into the load target. */
+ SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(&final_mergeinfo,
+ final_mergeinfo,
+ 1, 0, FALSE,
+ subpool, subpool));
+
+ SVN_ERR(svn_mergeinfo_to_string(final_val, final_mergeinfo, pool));
+ svn_pool_destroy(subpool);
+
+ return SVN_NO_ERROR;
+}
+
+/*----------------------------------------------------------------------*/
+
+/** vtable for doing commits to a fs **/
+
+
+static svn_error_t *
+make_node_baton(struct node_baton **node_baton_p,
+ apr_hash_t *headers,
+ struct revision_baton *rb,
+ apr_pool_t *pool)
+{
+ struct node_baton *nb = apr_pcalloc(pool, sizeof(*nb));
+ const char *val;
+
+ /* Start with sensible defaults. */
+ nb->rb = rb;
+ nb->pool = pool;
+ nb->kind = svn_node_unknown;
+
+ /* Then add info from the headers. */
+ if ((val = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_NODE_PATH)))
+ {
+ val = svn_relpath_canonicalize(val, pool);
+ if (rb->pb->parent_dir)
+ nb->path = svn_relpath_join(rb->pb->parent_dir, val, pool);
+ else
+ nb->path = val;
+ }
+
+ if ((val = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_NODE_KIND)))
+ {
+ if (! strcmp(val, "file"))
+ nb->kind = svn_node_file;
+ else if (! strcmp(val, "dir"))
+ nb->kind = svn_node_dir;
+ }
+
+ nb->action = (enum svn_node_action)(-1); /* an invalid action code */
+ if ((val = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_NODE_ACTION)))
+ {
+ if (! strcmp(val, "change"))
+ nb->action = svn_node_action_change;
+ else if (! strcmp(val, "add"))
+ nb->action = svn_node_action_add;
+ else if (! strcmp(val, "delete"))
+ nb->action = svn_node_action_delete;
+ else if (! strcmp(val, "replace"))
+ nb->action = svn_node_action_replace;
+ }
+
+ nb->copyfrom_rev = SVN_INVALID_REVNUM;
+ if ((val = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_NODE_COPYFROM_REV)))
+ {
+ nb->copyfrom_rev = SVN_STR_TO_REV(val);
+ }
+ if ((val = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_NODE_COPYFROM_PATH)))
+ {
+ val = svn_relpath_canonicalize(val, pool);
+ if (rb->pb->parent_dir)
+ nb->copyfrom_path = svn_relpath_join(rb->pb->parent_dir, val, pool);
+ else
+ nb->copyfrom_path = val;
+ }
+
+ if ((val = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_TEXT_CONTENT_CHECKSUM)))
+ {
+ SVN_ERR(svn_checksum_parse_hex(&nb->result_checksum, svn_checksum_md5,
+ val, pool));
+ }
+
+ if ((val = svn_hash_gets(headers,
+ SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_CHECKSUM)))
+ {
+ SVN_ERR(svn_checksum_parse_hex(&nb->base_checksum, svn_checksum_md5, val,
+ pool));
+ }
+
+ if ((val = svn_hash_gets(headers,
+ SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_CHECKSUM)))
+ {
+ SVN_ERR(svn_checksum_parse_hex(&nb->copy_source_checksum,
+ svn_checksum_md5, val, pool));
+ }
+
+ /* What's cool about this dump format is that the parser just
+ ignores any unrecognized headers. :-) */
+
+ *node_baton_p = nb;
+ return SVN_NO_ERROR;
+}
+
+static struct revision_baton *
+make_revision_baton(apr_hash_t *headers,
+ struct parse_baton *pb,
+ apr_pool_t *pool)
+{
+ struct revision_baton *rb = apr_pcalloc(pool, sizeof(*rb));
+ const char *val;
+
+ rb->pb = pb;
+ rb->pool = pool;
+ rb->rev = SVN_INVALID_REVNUM;
+
+ if ((val = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_REVISION_NUMBER)))
+ {
+ rb->rev = SVN_STR_TO_REV(val);
+
+ /* If we're filtering revisions, is this one we'll skip? */
+ rb->skipped = (SVN_IS_VALID_REVNUM(pb->start_rev)
+ && ((rb->rev < pb->start_rev) ||
+ (rb->rev > pb->end_rev)));
+ }
+
+ return rb;
+}
+
+
+static svn_error_t *
+new_revision_record(void **revision_baton,
+ apr_hash_t *headers,
+ void *parse_baton,
+ apr_pool_t *pool)
+{
+ struct parse_baton *pb = parse_baton;
+ struct revision_baton *rb;
+ svn_revnum_t head_rev;
+
+ rb = make_revision_baton(headers, pb, pool);
+
+ /* ### If we're filtering revisions, and this is one we've skipped,
+ ### and we've skipped it because it has a revision number younger
+ ### than the youngest in our acceptable range, then should we
+ ### just bail out here? */
+ /*
+ if (rb->skipped && (rb->rev > pb->end_rev))
+ return svn_error_createf(SVN_ERR_CEASE_INVOCATION, 0,
+ _("Finished processing acceptable load "
+ "revision range"));
+ */
+
+ SVN_ERR(svn_fs_youngest_rev(&head_rev, pb->fs, pool));
+
+ /* FIXME: This is a lame fallback loading multiple segments of dump in
+ several separate operations. It is highly susceptible to race conditions.
+ Calculate the revision 'offset' for finding copyfrom sources.
+ It might be positive or negative. */
+ rb->rev_offset = (apr_int32_t) ((rb->rev) - (head_rev + 1));
+
+ if ((rb->rev > 0) && (! rb->skipped))
+ {
+ /* Create a new fs txn. */
+ SVN_ERR(svn_fs_begin_txn2(&(rb->txn), pb->fs, head_rev, 0, pool));
+ SVN_ERR(svn_fs_txn_root(&(rb->txn_root), rb->txn, pool));
+
+ if (pb->notify_func)
+ {
+ pb->notify->action = svn_repos_notify_load_txn_start;
+ pb->notify->old_revision = rb->rev;
+ pb->notify_func(pb->notify_baton, pb->notify, rb->pool);
+ }
+
+ /* Stash the oldest "old" revision committed from the load stream. */
+ if (!SVN_IS_VALID_REVNUM(pb->oldest_old_rev))
+ pb->oldest_old_rev = rb->rev;
+ }
+
+ /* If we're skipping this revision, try to notify someone. */
+ if (rb->skipped && pb->notify_func)
+ {
+ pb->notify->action = svn_repos_notify_load_skipped_rev;
+ pb->notify->old_revision = rb->rev;
+ pb->notify_func(pb->notify_baton, pb->notify, rb->pool);
+ }
+
+ /* If we're parsing revision 0, only the revision are (possibly)
+ interesting to us: when loading the stream into an empty
+ filesystem, then we want new filesystem's revision 0 to have the
+ same props. Otherwise, we just ignore revision 0 in the stream. */
+
+ *revision_baton = rb;
+ return SVN_NO_ERROR;
+}
+
+
+
+/* Factorized helper func for new_node_record() */
+static svn_error_t *
+maybe_add_with_history(struct node_baton *nb,
+ struct revision_baton *rb,
+ apr_pool_t *pool)
+{
+ struct parse_baton *pb = rb->pb;
+
+ if ((nb->copyfrom_path == NULL) || (! pb->use_history))
+ {
+ /* Add empty file or dir, without history. */
+ if (nb->kind == svn_node_file)
+ SVN_ERR(svn_fs_make_file(rb->txn_root, nb->path, pool));
+
+ else if (nb->kind == svn_node_dir)
+ SVN_ERR(svn_fs_make_dir(rb->txn_root, nb->path, pool));
+ }
+ else
+ {
+ /* Hunt down the source revision in this fs. */
+ svn_fs_root_t *copy_root;
+ svn_revnum_t copyfrom_rev;
+
+ /* Try to find the copyfrom revision in the revision map;
+ failing that, fall back to the revision offset approach. */
+ copyfrom_rev = get_revision_mapping(rb->pb->rev_map, nb->copyfrom_rev);
+ if (! SVN_IS_VALID_REVNUM(copyfrom_rev))
+ copyfrom_rev = nb->copyfrom_rev - rb->rev_offset;
+
+ if (! SVN_IS_VALID_REVNUM(copyfrom_rev))
+ return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
+ _("Relative source revision %ld is not"
+ " available in current repository"),
+ copyfrom_rev);
+
+ SVN_ERR(svn_fs_revision_root(&copy_root, pb->fs, copyfrom_rev, pool));
+
+ if (nb->copy_source_checksum)
+ {
+ svn_checksum_t *checksum;
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5, copy_root,
+ nb->copyfrom_path, TRUE, pool));
+ if (!svn_checksum_match(nb->copy_source_checksum, checksum))
+ return svn_checksum_mismatch_err(nb->copy_source_checksum,
+ checksum, pool,
+ _("Copy source checksum mismatch on copy from '%s'@%ld\n"
+ "to '%s' in rev based on r%ld"),
+ nb->copyfrom_path, copyfrom_rev, nb->path, rb->rev);
+ }
+
+ SVN_ERR(svn_fs_copy(copy_root, nb->copyfrom_path,
+ rb->txn_root, nb->path, pool));
+
+ if (pb->notify_func)
+ {
+ pb->notify->action = svn_repos_notify_load_copied_node;
+ pb->notify_func(pb->notify_baton, pb->notify, rb->pool);
+ }
+ }
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+magic_header_record(int version,
+ void *parse_baton,
+ apr_pool_t *pool)
+{
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+uuid_record(const char *uuid,
+ void *parse_baton,
+ apr_pool_t *pool)
+{
+ struct parse_baton *pb = parse_baton;
+ svn_revnum_t youngest_rev;
+
+ if (pb->uuid_action == svn_repos_load_uuid_ignore)
+ return SVN_NO_ERROR;
+
+ if (pb->uuid_action != svn_repos_load_uuid_force)
+ {
+ SVN_ERR(svn_fs_youngest_rev(&youngest_rev, pb->fs, pool));
+ if (youngest_rev != 0)
+ return SVN_NO_ERROR;
+ }
+
+ return svn_fs_set_uuid(pb->fs, uuid, pool);
+}
+
+static svn_error_t *
+new_node_record(void **node_baton,
+ apr_hash_t *headers,
+ void *revision_baton,
+ apr_pool_t *pool)
+{
+ struct revision_baton *rb = revision_baton;
+ struct parse_baton *pb = rb->pb;
+ struct node_baton *nb;
+
+ if (rb->rev == 0)
+ return svn_error_create(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Malformed dumpstream: "
+ "Revision 0 must not contain node records"));
+
+ SVN_ERR(make_node_baton(&nb, headers, rb, pool));
+
+ /* If we're skipping this revision, we're done here. */
+ if (rb->skipped)
+ {
+ *node_baton = nb;
+ return SVN_NO_ERROR;
+ }
+
+ /* Make sure we have an action we recognize. */
+ if (nb->action < svn_node_action_change
+ || nb->action > svn_node_action_replace)
+ return svn_error_createf(SVN_ERR_STREAM_UNRECOGNIZED_DATA, NULL,
+ _("Unrecognized node-action on node '%s'"),
+ nb->path);
+
+ if (pb->notify_func)
+ {
+ pb->notify->action = svn_repos_notify_load_node_start;
+ pb->notify->node_action = nb->action;
+ pb->notify->path = nb->path;
+ pb->notify_func(pb->notify_baton, pb->notify, rb->pool);
+ }
+
+ switch (nb->action)
+ {
+ case svn_node_action_change:
+ break;
+
+ case svn_node_action_delete:
+ SVN_ERR(svn_fs_delete(rb->txn_root, nb->path, pool));
+ break;
+
+ case svn_node_action_add:
+ SVN_ERR(maybe_add_with_history(nb, rb, pool));
+ break;
+
+ case svn_node_action_replace:
+ SVN_ERR(svn_fs_delete(rb->txn_root, nb->path, pool));
+ SVN_ERR(maybe_add_with_history(nb, rb, pool));
+ break;
+ }
+
+ *node_baton = nb;
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+set_revision_property(void *baton,
+ const char *name,
+ const svn_string_t *value)
+{
+ struct revision_baton *rb = baton;
+
+ /* If we're skipping this revision, we're done here. */
+ if (rb->skipped)
+ return SVN_NO_ERROR;
+
+ if (rb->rev > 0)
+ {
+ if (rb->pb->validate_props)
+ SVN_ERR(svn_repos_fs_change_txn_prop(rb->txn, name, value, rb->pool));
+ else
+ SVN_ERR(svn_fs_change_txn_prop(rb->txn, name, value, rb->pool));
+
+ /* Remember any datestamp that passes through! (See comment in
+ close_revision() below.) */
+ if (! strcmp(name, SVN_PROP_REVISION_DATE))
+ rb->datestamp = svn_string_dup(value, rb->pool);
+ }
+ else if (rb->rev == 0)
+ {
+ /* Special case: set revision 0 properties when loading into an
+ 'empty' filesystem. */
+ struct parse_baton *pb = rb->pb;
+ svn_revnum_t youngest_rev;
+
+ SVN_ERR(svn_fs_youngest_rev(&youngest_rev, pb->fs, rb->pool));
+
+ if (youngest_rev == 0)
+ SVN_ERR(change_rev_prop(pb->repos, 0, name, value,
+ pb->validate_props, rb->pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+set_node_property(void *baton,
+ const char *name,
+ const svn_string_t *value)
+{
+ struct node_baton *nb = baton;
+ struct revision_baton *rb = nb->rb;
+ struct parse_baton *pb = rb->pb;
+
+ /* If we're skipping this revision, we're done here. */
+ if (rb->skipped)
+ return SVN_NO_ERROR;
+
+ if (strcmp(name, SVN_PROP_MERGEINFO) == 0)
+ {
+ svn_string_t *renumbered_mergeinfo;
+ /* ### Need to cast away const. We cannot change the declaration of
+ * ### this function since it is part of svn_repos_parse_fns2_t. */
+ svn_string_t *prop_val = (svn_string_t *)value;
+
+ /* Tolerate mergeinfo with "\r\n" line endings because some
+ dumpstream sources might contain as much. If so normalize
+ the line endings to '\n' and make a notification to
+ PARSE_BATON->FEEDBACK_STREAM that we have made this
+ correction. */
+ if (strstr(prop_val->data, "\r"))
+ {
+ const char *prop_eol_normalized;
+
+ SVN_ERR(svn_subst_translate_cstring2(prop_val->data,
+ &prop_eol_normalized,
+ "\n", /* translate to LF */
+ FALSE, /* no repair */
+ NULL, /* no keywords */
+ FALSE, /* no expansion */
+ nb->pool));
+ prop_val->data = prop_eol_normalized;
+ prop_val->len = strlen(prop_eol_normalized);
+
+ if (pb->notify_func)
+ {
+ pb->notify->action = svn_repos_notify_load_normalized_mergeinfo;
+ pb->notify_func(pb->notify_baton, pb->notify, nb->pool);
+ }
+ }
+
+ /* Renumber mergeinfo as appropriate. */
+ SVN_ERR(renumber_mergeinfo_revs(&renumbered_mergeinfo, prop_val, rb,
+ nb->pool));
+ value = renumbered_mergeinfo;
+ if (pb->parent_dir)
+ {
+ /* Prefix the merge source paths with PB->parent_dir. */
+ /* ASSUMPTION: All source paths are included in the dump stream. */
+ svn_string_t *mergeinfo_val;
+ SVN_ERR(prefix_mergeinfo_paths(&mergeinfo_val, value,
+ pb->parent_dir, nb->pool));
+ value = mergeinfo_val;
+ }
+ }
+
+ return change_node_prop(rb->txn_root, nb->path, name, value,
+ pb->validate_props, nb->pool);
+}
+
+
+static svn_error_t *
+delete_node_property(void *baton,
+ const char *name)
+{
+ struct node_baton *nb = baton;
+ struct revision_baton *rb = nb->rb;
+
+ /* If we're skipping this revision, we're done here. */
+ if (rb->skipped)
+ return SVN_NO_ERROR;
+
+ return change_node_prop(rb->txn_root, nb->path, name, NULL,
+ rb->pb->validate_props, nb->pool);
+}
+
+
+static svn_error_t *
+remove_node_props(void *baton)
+{
+ struct node_baton *nb = baton;
+ struct revision_baton *rb = nb->rb;
+ apr_hash_t *proplist;
+ apr_hash_index_t *hi;
+
+ /* If we're skipping this revision, we're done here. */
+ if (rb->skipped)
+ return SVN_NO_ERROR;
+
+ SVN_ERR(svn_fs_node_proplist(&proplist,
+ rb->txn_root, nb->path, nb->pool));
+
+ for (hi = apr_hash_first(nb->pool, proplist); hi; hi = apr_hash_next(hi))
+ {
+ const void *key;
+
+ apr_hash_this(hi, &key, NULL, NULL);
+ SVN_ERR(change_node_prop(rb->txn_root, nb->path, key, NULL,
+ rb->pb->validate_props, nb->pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+apply_textdelta(svn_txdelta_window_handler_t *handler,
+ void **handler_baton,
+ void *node_baton)
+{
+ struct node_baton *nb = node_baton;
+ struct revision_baton *rb = nb->rb;
+
+ /* If we're skipping this revision, we're done here. */
+ if (rb->skipped)
+ {
+ *handler = NULL;
+ return SVN_NO_ERROR;
+ }
+
+ return svn_fs_apply_textdelta(handler, handler_baton,
+ rb->txn_root, nb->path,
+ svn_checksum_to_cstring(nb->base_checksum,
+ nb->pool),
+ svn_checksum_to_cstring(nb->result_checksum,
+ nb->pool),
+ nb->pool);
+}
+
+
+static svn_error_t *
+set_fulltext(svn_stream_t **stream,
+ void *node_baton)
+{
+ struct node_baton *nb = node_baton;
+ struct revision_baton *rb = nb->rb;
+
+ /* If we're skipping this revision, we're done here. */
+ if (rb->skipped)
+ {
+ *stream = NULL;
+ return SVN_NO_ERROR;
+ }
+
+ return svn_fs_apply_text(stream,
+ rb->txn_root, nb->path,
+ svn_checksum_to_cstring(nb->result_checksum,
+ nb->pool),
+ nb->pool);
+}
+
+
+static svn_error_t *
+close_node(void *baton)
+{
+ struct node_baton *nb = baton;
+ struct revision_baton *rb = nb->rb;
+ struct parse_baton *pb = rb->pb;
+
+ /* If we're skipping this revision, we're done here. */
+ if (rb->skipped)
+ return SVN_NO_ERROR;
+
+ if (pb->notify_func)
+ {
+ pb->notify->action = svn_repos_notify_load_node_done;
+ pb->notify_func(pb->notify_baton, pb->notify, rb->pool);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+close_revision(void *baton)
+{
+ struct revision_baton *rb = baton;
+ struct parse_baton *pb = rb->pb;
+ const char *conflict_msg = NULL;
+ svn_revnum_t committed_rev;
+ svn_error_t *err;
+ const char *txn_name = NULL;
+ apr_hash_t *hooks_env;
+
+ /* If we're skipping this revision or it has an invalid revision
+ number, we're done here. */
+ if (rb->skipped || (rb->rev <= 0))
+ return SVN_NO_ERROR;
+
+ /* Get the txn name and hooks environment if they will be needed. */
+ if (pb->use_pre_commit_hook || pb->use_post_commit_hook)
+ {
+ SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, pb->repos->hooks_env_path,
+ rb->pool, rb->pool));
+
+ err = svn_fs_txn_name(&txn_name, rb->txn, rb->pool);
+ if (err)
+ {
+ svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool));
+ return svn_error_trace(err);
+ }
+ }
+
+ /* Run the pre-commit hook, if so commanded. */
+ if (pb->use_pre_commit_hook)
+ {
+ err = svn_repos__hooks_pre_commit(pb->repos, hooks_env,
+ txn_name, rb->pool);
+ if (err)
+ {
+ svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool));
+ return svn_error_trace(err);
+ }
+ }
+
+ /* Commit. */
+ err = svn_fs_commit_txn(&conflict_msg, &committed_rev, rb->txn, rb->pool);
+ if (SVN_IS_VALID_REVNUM(committed_rev))
+ {
+ if (err)
+ {
+ /* ### Log any error, but better yet is to rev
+ ### close_revision()'s API to allow both committed_rev and err
+ ### to be returned, see #3768. */
+ svn_error_clear(err);
+ }
+ }
+ else
+ {
+ svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool));
+ if (conflict_msg)
+ return svn_error_quick_wrap(err, conflict_msg);
+ else
+ return svn_error_trace(err);
+ }
+
+ /* Run post-commit hook, if so commanded. */
+ if (pb->use_post_commit_hook)
+ {
+ if ((err = svn_repos__hooks_post_commit(pb->repos, hooks_env,
+ committed_rev, txn_name,
+ rb->pool)))
+ return svn_error_create
+ (SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED, err,
+ _("Commit succeeded, but post-commit hook failed"));
+ }
+
+ /* After a successful commit, must record the dump-rev -> in-repos-rev
+ mapping, so that copyfrom instructions in the dump file can look up the
+ correct repository revision to copy from. */
+ set_revision_mapping(pb->rev_map, rb->rev, committed_rev);
+
+ /* If the incoming dump stream has non-contiguous revisions (e.g. from
+ using svndumpfilter --drop-empty-revs without --renumber-revs) then
+ we must account for the missing gaps in PB->REV_MAP. Otherwise we
+ might not be able to map all mergeinfo source revisions to the correct
+ revisions in the target repos. */
+ if ((pb->last_rev_mapped != SVN_INVALID_REVNUM)
+ && (rb->rev != pb->last_rev_mapped + 1))
+ {
+ svn_revnum_t i;
+
+ for (i = pb->last_rev_mapped + 1; i < rb->rev; i++)
+ {
+ set_revision_mapping(pb->rev_map, i, pb->last_rev_mapped);
+ }
+ }
+
+ /* Update our "last revision mapped". */
+ pb->last_rev_mapped = rb->rev;
+
+ /* Deltify the predecessors of paths changed in this revision. */
+ SVN_ERR(svn_fs_deltify_revision(pb->fs, committed_rev, rb->pool));
+
+ /* Grrr, svn_fs_commit_txn rewrites the datestamp property to the
+ current clock-time. We don't want that, we want to preserve
+ history exactly. Good thing revision props aren't versioned!
+ Note that if rb->datestamp is NULL, that's fine -- if the dump
+ data doesn't carry a datestamp, we want to preserve that fact in
+ the load. */
+ SVN_ERR(change_rev_prop(pb->repos, committed_rev, SVN_PROP_REVISION_DATE,
+ rb->datestamp, pb->validate_props, rb->pool));
+
+ if (pb->notify_func)
+ {
+ pb->notify->action = svn_repos_notify_load_txn_committed;
+ pb->notify->new_revision = committed_rev;
+ pb->notify->old_revision = ((committed_rev == rb->rev)
+ ? SVN_INVALID_REVNUM
+ : rb->rev);
+ pb->notify_func(pb->notify_baton, pb->notify, rb->pool);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+/*----------------------------------------------------------------------*/
+
+/** The public routines **/
+
+
+svn_error_t *
+svn_repos_get_fs_build_parser4(const svn_repos_parse_fns3_t **callbacks,
+ void **parse_baton,
+ svn_repos_t *repos,
+ svn_revnum_t start_rev,
+ svn_revnum_t end_rev,
+ svn_boolean_t use_history,
+ svn_boolean_t validate_props,
+ enum svn_repos_load_uuid uuid_action,
+ const char *parent_dir,
+ svn_repos_notify_func_t notify_func,
+ void *notify_baton,
+ apr_pool_t *pool)
+{
+ svn_repos_parse_fns3_t *parser = apr_pcalloc(pool, sizeof(*parser));
+ struct parse_baton *pb = apr_pcalloc(pool, sizeof(*pb));
+
+ if (parent_dir)
+ parent_dir = svn_relpath_canonicalize(parent_dir, pool);
+
+ SVN_ERR_ASSERT((SVN_IS_VALID_REVNUM(start_rev) &&
+ SVN_IS_VALID_REVNUM(end_rev))
+ || ((! SVN_IS_VALID_REVNUM(start_rev)) &&
+ (! SVN_IS_VALID_REVNUM(end_rev))));
+ if (SVN_IS_VALID_REVNUM(start_rev))
+ SVN_ERR_ASSERT(start_rev <= end_rev);
+
+ parser->magic_header_record = magic_header_record;
+ parser->uuid_record = uuid_record;
+ parser->new_revision_record = new_revision_record;
+ parser->new_node_record = new_node_record;
+ parser->set_revision_property = set_revision_property;
+ parser->set_node_property = set_node_property;
+ parser->remove_node_props = remove_node_props;
+ parser->set_fulltext = set_fulltext;
+ parser->close_node = close_node;
+ parser->close_revision = close_revision;
+ parser->delete_node_property = delete_node_property;
+ parser->apply_textdelta = apply_textdelta;
+
+ pb->repos = repos;
+ pb->fs = svn_repos_fs(repos);
+ pb->use_history = use_history;
+ pb->validate_props = validate_props;
+ pb->notify_func = notify_func;
+ pb->notify_baton = notify_baton;
+ pb->notify = svn_repos_notify_create(svn_repos_notify_load_txn_start, pool);
+ pb->uuid_action = uuid_action;
+ pb->parent_dir = parent_dir;
+ pb->pool = pool;
+ pb->rev_map = apr_hash_make(pool);
+ pb->oldest_old_rev = SVN_INVALID_REVNUM;
+ pb->last_rev_mapped = SVN_INVALID_REVNUM;
+ pb->start_rev = start_rev;
+ pb->end_rev = end_rev;
+
+ *callbacks = parser;
+ *parse_baton = pb;
+ return SVN_NO_ERROR;
+}
+
+
+
+svn_error_t *
+svn_repos_load_fs4(svn_repos_t *repos,
+ svn_stream_t *dumpstream,
+ svn_revnum_t start_rev,
+ svn_revnum_t end_rev,
+ enum svn_repos_load_uuid uuid_action,
+ const char *parent_dir,
+ svn_boolean_t use_pre_commit_hook,
+ svn_boolean_t use_post_commit_hook,
+ svn_boolean_t validate_props,
+ svn_repos_notify_func_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ const svn_repos_parse_fns3_t *parser;
+ void *parse_baton;
+ struct parse_baton *pb;
+
+ /* This is really simple. */
+
+ SVN_ERR(svn_repos_get_fs_build_parser4(&parser, &parse_baton,
+ repos,
+ start_rev, end_rev,
+ TRUE, /* look for copyfrom revs */
+ validate_props,
+ uuid_action,
+ parent_dir,
+ notify_func,
+ notify_baton,
+ pool));
+
+ /* Heh. We know this is a parse_baton. This file made it. So
+ cast away, and set our hook booleans. */
+ pb = parse_baton;
+ pb->use_pre_commit_hook = use_pre_commit_hook;
+ pb->use_post_commit_hook = use_post_commit_hook;
+
+ return svn_repos_parse_dumpstream3(dumpstream, parser, parse_baton, FALSE,
+ cancel_func, cancel_baton, pool);
+}
diff --git a/subversion/libsvn_repos/load.c b/subversion/libsvn_repos/load.c
new file mode 100644
index 000000000000..691ff9202504
--- /dev/null
+++ b/subversion/libsvn_repos/load.c
@@ -0,0 +1,684 @@
+/* load.c --- parsing a 'dumpfile'-formatted stream.
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+
+#include "svn_private_config.h"
+#include "svn_hash.h"
+#include "svn_pools.h"
+#include "svn_error.h"
+#include "svn_fs.h"
+#include "svn_repos.h"
+#include "svn_string.h"
+#include "svn_path.h"
+#include "svn_props.h"
+#include "repos.h"
+#include "svn_private_config.h"
+#include "svn_mergeinfo.h"
+#include "svn_checksum.h"
+#include "svn_subst.h"
+#include "svn_ctype.h"
+
+#include <apr_lib.h>
+
+#include "private/svn_dep_compat.h"
+#include "private/svn_mergeinfo_private.h"
+
+/*----------------------------------------------------------------------*/
+
+/** The parser and related helper funcs **/
+
+
+static svn_error_t *
+stream_ran_dry(void)
+{
+ return svn_error_create(SVN_ERR_INCOMPLETE_DATA, NULL,
+ _("Premature end of content data in dumpstream"));
+}
+
+static svn_error_t *
+stream_malformed(void)
+{
+ return svn_error_create(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Dumpstream data appears to be malformed"));
+}
+
+/* Allocate a new hash *HEADERS in POOL, and read a series of
+ RFC822-style headers from STREAM. Duplicate each header's name and
+ value into POOL and store in hash as a const char * ==> const char *.
+
+ The headers are assumed to be terminated by a single blank line,
+ which will be permanently sucked from the stream and tossed.
+
+ If the caller has already read in the first header line, it should
+ be passed in as FIRST_HEADER. If not, pass NULL instead.
+ */
+static svn_error_t *
+read_header_block(svn_stream_t *stream,
+ svn_stringbuf_t *first_header,
+ apr_hash_t **headers,
+ apr_pool_t *pool)
+{
+ *headers = apr_hash_make(pool);
+
+ while (1)
+ {
+ svn_stringbuf_t *header_str;
+ const char *name, *value;
+ svn_boolean_t eof;
+ apr_size_t i = 0;
+
+ if (first_header != NULL)
+ {
+ header_str = first_header;
+ first_header = NULL; /* so we never visit this block again. */
+ eof = FALSE;
+ }
+
+ else
+ /* Read the next line into a stringbuf. */
+ SVN_ERR(svn_stream_readline(stream, &header_str, "\n", &eof, pool));
+
+ if (svn_stringbuf_isempty(header_str))
+ break; /* end of header block */
+ else if (eof)
+ return stream_ran_dry();
+
+ /* Find the next colon in the stringbuf. */
+ while (header_str->data[i] != ':')
+ {
+ if (header_str->data[i] == '\0')
+ return svn_error_createf(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Dump stream contains a malformed "
+ "header (with no ':') at '%.20s'"),
+ header_str->data);
+ i++;
+ }
+ /* Create a 'name' string and point to it. */
+ header_str->data[i] = '\0';
+ name = header_str->data;
+
+ /* Skip over the NULL byte and the space following it. */
+ i += 2;
+ if (i > header_str->len)
+ return svn_error_createf(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Dump stream contains a malformed "
+ "header (with no value) at '%.20s'"),
+ header_str->data);
+
+ /* Point to the 'value' string. */
+ value = header_str->data + i;
+
+ /* Store name/value in hash. */
+ svn_hash_sets(*headers, name, value);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Set *PBUF to a string of length LEN, allocated in POOL, read from STREAM.
+ Also read a newline from STREAM and increase *ACTUAL_LEN by the total
+ number of bytes read from STREAM. */
+static svn_error_t *
+read_key_or_val(char **pbuf,
+ svn_filesize_t *actual_length,
+ svn_stream_t *stream,
+ apr_size_t len,
+ apr_pool_t *pool)
+{
+ char *buf = apr_pcalloc(pool, len + 1);
+ apr_size_t numread;
+ char c;
+
+ numread = len;
+ SVN_ERR(svn_stream_read(stream, buf, &numread));
+ *actual_length += numread;
+ if (numread != len)
+ return svn_error_trace(stream_ran_dry());
+ buf[len] = '\0';
+
+ /* Suck up extra newline after key data */
+ numread = 1;
+ SVN_ERR(svn_stream_read(stream, &c, &numread));
+ *actual_length += numread;
+ if (numread != 1)
+ return svn_error_trace(stream_ran_dry());
+ if (c != '\n')
+ return svn_error_trace(stream_malformed());
+
+ *pbuf = buf;
+ return SVN_NO_ERROR;
+}
+
+
+/* Read CONTENT_LENGTH bytes from STREAM, parsing the bytes as an
+ encoded Subversion properties hash, and making multiple calls to
+ PARSE_FNS->set_*_property on RECORD_BATON (depending on the value
+ of IS_NODE.)
+
+ Set *ACTUAL_LENGTH to the number of bytes consumed from STREAM.
+ If an error is returned, the value of *ACTUAL_LENGTH is undefined.
+
+ Use POOL for all allocations. */
+static svn_error_t *
+parse_property_block(svn_stream_t *stream,
+ svn_filesize_t content_length,
+ const svn_repos_parse_fns3_t *parse_fns,
+ void *record_baton,
+ void *parse_baton,
+ svn_boolean_t is_node,
+ svn_filesize_t *actual_length,
+ apr_pool_t *pool)
+{
+ svn_stringbuf_t *strbuf;
+ apr_pool_t *proppool = svn_pool_create(pool);
+
+ *actual_length = 0;
+ while (content_length != *actual_length)
+ {
+ char *buf; /* a pointer into the stringbuf's data */
+ svn_boolean_t eof;
+
+ svn_pool_clear(proppool);
+
+ /* Read a key length line. (Actually, it might be PROPS_END). */
+ SVN_ERR(svn_stream_readline(stream, &strbuf, "\n", &eof, proppool));
+
+ if (eof)
+ {
+ /* We could just use stream_ran_dry() or stream_malformed(),
+ but better to give a non-generic property block error. */
+ return svn_error_create
+ (SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Incomplete or unterminated property block"));
+ }
+
+ *actual_length += (strbuf->len + 1); /* +1 because we read a \n too. */
+ buf = strbuf->data;
+
+ if (! strcmp(buf, "PROPS-END"))
+ break; /* no more properties. */
+
+ else if ((buf[0] == 'K') && (buf[1] == ' '))
+ {
+ char *keybuf;
+ apr_uint64_t len;
+
+ SVN_ERR(svn_cstring_strtoui64(&len, buf + 2, 0, APR_SIZE_MAX, 10));
+ SVN_ERR(read_key_or_val(&keybuf, actual_length,
+ stream, (apr_size_t)len, proppool));
+
+ /* Read a val length line */
+ SVN_ERR(svn_stream_readline(stream, &strbuf, "\n", &eof, proppool));
+ if (eof)
+ return stream_ran_dry();
+
+ *actual_length += (strbuf->len + 1); /* +1 because we read \n too */
+ buf = strbuf->data;
+
+ if ((buf[0] == 'V') && (buf[1] == ' '))
+ {
+ svn_string_t propstring;
+ char *valbuf;
+ apr_int64_t val;
+
+ SVN_ERR(svn_cstring_atoi64(&val, buf + 2));
+ propstring.len = (apr_size_t)val;
+ SVN_ERR(read_key_or_val(&valbuf, actual_length,
+ stream, propstring.len, proppool));
+ propstring.data = valbuf;
+
+ /* Now, send the property pair to the vtable! */
+ if (is_node)
+ {
+ SVN_ERR(parse_fns->set_node_property(record_baton,
+ keybuf,
+ &propstring));
+ }
+ else
+ {
+ SVN_ERR(parse_fns->set_revision_property(record_baton,
+ keybuf,
+ &propstring));
+ }
+ }
+ else
+ return stream_malformed(); /* didn't find expected 'V' line */
+ }
+ else if ((buf[0] == 'D') && (buf[1] == ' '))
+ {
+ char *keybuf;
+ apr_uint64_t len;
+
+ SVN_ERR(svn_cstring_strtoui64(&len, buf + 2, 0, APR_SIZE_MAX, 10));
+ SVN_ERR(read_key_or_val(&keybuf, actual_length,
+ stream, (apr_size_t)len, proppool));
+
+ /* We don't expect these in revision properties, and if we see
+ one when we don't have a delete_node_property callback,
+ then we're seeing a v3 feature in a v2 dump. */
+ if (!is_node || !parse_fns->delete_node_property)
+ return stream_malformed();
+
+ SVN_ERR(parse_fns->delete_node_property(record_baton, keybuf));
+ }
+ else
+ return stream_malformed(); /* didn't find expected 'K' line */
+
+ } /* while (1) */
+
+ svn_pool_destroy(proppool);
+ return SVN_NO_ERROR;
+}
+
+
+/* Read CONTENT_LENGTH bytes from STREAM, and use
+ PARSE_FNS->set_fulltext to push those bytes as replace fulltext for
+ a node. Use BUFFER/BUFLEN to push the fulltext in "chunks".
+
+ Use POOL for all allocations. */
+static svn_error_t *
+parse_text_block(svn_stream_t *stream,
+ svn_filesize_t content_length,
+ svn_boolean_t is_delta,
+ const svn_repos_parse_fns3_t *parse_fns,
+ void *record_baton,
+ char *buffer,
+ apr_size_t buflen,
+ apr_pool_t *pool)
+{
+ svn_stream_t *text_stream = NULL;
+ apr_size_t num_to_read, rlen, wlen;
+
+ if (is_delta)
+ {
+ svn_txdelta_window_handler_t wh;
+ void *whb;
+
+ SVN_ERR(parse_fns->apply_textdelta(&wh, &whb, record_baton));
+ if (wh)
+ text_stream = svn_txdelta_parse_svndiff(wh, whb, TRUE, pool);
+ }
+ else
+ {
+ /* Get a stream to which we can push the data. */
+ SVN_ERR(parse_fns->set_fulltext(&text_stream, record_baton));
+ }
+
+ /* If there are no contents to read, just write an empty buffer
+ through our callback. */
+ if (content_length == 0)
+ {
+ wlen = 0;
+ if (text_stream)
+ SVN_ERR(svn_stream_write(text_stream, "", &wlen));
+ }
+
+ /* Regardless of whether or not we have a sink for our data, we
+ need to read it. */
+ while (content_length)
+ {
+ if (content_length >= (svn_filesize_t)buflen)
+ rlen = buflen;
+ else
+ rlen = (apr_size_t) content_length;
+
+ num_to_read = rlen;
+ SVN_ERR(svn_stream_read(stream, buffer, &rlen));
+ content_length -= rlen;
+ if (rlen != num_to_read)
+ return stream_ran_dry();
+
+ if (text_stream)
+ {
+ /* write however many bytes you read. */
+ wlen = rlen;
+ SVN_ERR(svn_stream_write(text_stream, buffer, &wlen));
+ if (wlen != rlen)
+ {
+ /* Uh oh, didn't write as many bytes as we read. */
+ return svn_error_create(SVN_ERR_STREAM_UNEXPECTED_EOF, NULL,
+ _("Unexpected EOF writing contents"));
+ }
+ }
+ }
+
+ /* If we opened a stream, we must close it. */
+ if (text_stream)
+ SVN_ERR(svn_stream_close(text_stream));
+
+ return SVN_NO_ERROR;
+}
+
+
+
+/* Parse VERSIONSTRING and verify that we support the dumpfile format
+ version number, setting *VERSION appropriately. */
+static svn_error_t *
+parse_format_version(int *version,
+ const char *versionstring)
+{
+ static const int magic_len = sizeof(SVN_REPOS_DUMPFILE_MAGIC_HEADER) - 1;
+ const char *p = strchr(versionstring, ':');
+ int value;
+
+ if (p == NULL
+ || p != (versionstring + magic_len)
+ || strncmp(versionstring,
+ SVN_REPOS_DUMPFILE_MAGIC_HEADER,
+ magic_len))
+ return svn_error_createf(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Malformed dumpfile header '%s'"),
+ versionstring);
+
+ SVN_ERR(svn_cstring_atoi(&value, p + 1));
+
+ if (value > SVN_REPOS_DUMPFILE_FORMAT_VERSION)
+ return svn_error_createf(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Unsupported dumpfile version: %d"),
+ value);
+
+ *version = value;
+ return SVN_NO_ERROR;
+}
+
+
+
+/*----------------------------------------------------------------------*/
+
+/** The public routines **/
+
+svn_error_t *
+svn_repos_parse_dumpstream3(svn_stream_t *stream,
+ const svn_repos_parse_fns3_t *parse_fns,
+ void *parse_baton,
+ svn_boolean_t deltas_are_text,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *pool)
+{
+ svn_boolean_t eof;
+ svn_stringbuf_t *linebuf;
+ void *rev_baton = NULL;
+ char *buffer = apr_palloc(pool, SVN__STREAM_CHUNK_SIZE);
+ apr_size_t buflen = SVN__STREAM_CHUNK_SIZE;
+ apr_pool_t *linepool = svn_pool_create(pool);
+ apr_pool_t *revpool = svn_pool_create(pool);
+ apr_pool_t *nodepool = svn_pool_create(pool);
+ int version;
+
+ SVN_ERR(svn_stream_readline(stream, &linebuf, "\n", &eof, linepool));
+ if (eof)
+ return stream_ran_dry();
+
+ /* The first two lines of the stream are the dumpfile-format version
+ number, and a blank line. To preserve backward compatibility,
+ don't assume the existence of newer parser-vtable functions. */
+ SVN_ERR(parse_format_version(&version, linebuf->data));
+ if (parse_fns->magic_header_record != NULL)
+ SVN_ERR(parse_fns->magic_header_record(version, parse_baton, pool));
+
+ /* A dumpfile "record" is defined to be a header-block of
+ rfc822-style headers, possibly followed by a content-block.
+
+ - A header-block is always terminated by a single blank line (\n\n)
+
+ - We know whether the record has a content-block by looking for
+ a 'Content-length:' header. The content-block will always be
+ of a specific length, plus an extra newline.
+
+ Once a record is fully sucked from the stream, an indeterminate
+ number of blank lines (or lines that begin with whitespace) may
+ follow before the next record (or the end of the stream.)
+ */
+
+ while (1)
+ {
+ apr_hash_t *headers;
+ void *node_baton;
+ svn_boolean_t found_node = FALSE;
+ svn_boolean_t old_v1_with_cl = FALSE;
+ const char *content_length;
+ const char *prop_cl;
+ const char *text_cl;
+ const char *value;
+ svn_filesize_t actual_prop_length;
+
+ /* Clear our per-line pool. */
+ svn_pool_clear(linepool);
+
+ /* Check for cancellation. */
+ if (cancel_func)
+ SVN_ERR(cancel_func(cancel_baton));
+
+ /* Keep reading blank lines until we discover a new record, or until
+ the stream runs out. */
+ SVN_ERR(svn_stream_readline(stream, &linebuf, "\n", &eof, linepool));
+
+ if (eof)
+ {
+ if (svn_stringbuf_isempty(linebuf))
+ break; /* end of stream, go home. */
+ else
+ return stream_ran_dry();
+ }
+
+ if ((linebuf->len == 0) || (svn_ctype_isspace(linebuf->data[0])))
+ continue; /* empty line ... loop */
+
+ /*** Found the beginning of a new record. ***/
+
+ /* The last line we read better be a header of some sort.
+ Read the whole header-block into a hash. */
+ SVN_ERR(read_header_block(stream, linebuf, &headers, linepool));
+
+ /*** Handle the various header blocks. ***/
+
+ /* Is this a revision record? */
+ if (svn_hash_gets(headers, SVN_REPOS_DUMPFILE_REVISION_NUMBER))
+ {
+ /* If we already have a rev_baton open, we need to close it
+ and clear the per-revision subpool. */
+ if (rev_baton != NULL)
+ {
+ SVN_ERR(parse_fns->close_revision(rev_baton));
+ svn_pool_clear(revpool);
+ }
+
+ SVN_ERR(parse_fns->new_revision_record(&rev_baton,
+ headers, parse_baton,
+ revpool));
+ }
+ /* Or is this, perhaps, a node record? */
+ else if (svn_hash_gets(headers, SVN_REPOS_DUMPFILE_NODE_PATH))
+ {
+ SVN_ERR(parse_fns->new_node_record(&node_baton,
+ headers,
+ rev_baton,
+ nodepool));
+ found_node = TRUE;
+ }
+ /* Or is this the repos UUID? */
+ else if ((value = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_UUID)))
+ {
+ SVN_ERR(parse_fns->uuid_record(value, parse_baton, pool));
+ }
+ /* Or perhaps a dumpfile format? */
+ /* ### TODO: use parse_format_version */
+ else if ((value = svn_hash_gets(headers,
+ SVN_REPOS_DUMPFILE_MAGIC_HEADER)))
+ {
+ /* ### someday, switch modes of operation here. */
+ SVN_ERR(svn_cstring_atoi(&version, value));
+ }
+ /* Or is this bogosity?! */
+ else
+ {
+ /* What the heck is this record?!? */
+ return svn_error_create(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Unrecognized record type in stream"));
+ }
+
+ /* Need 3 values below to determine v1 dump type
+
+ Old (pre 0.14?) v1 dumps don't have Prop-content-length
+ and Text-content-length fields, but always have a properties
+ block in a block with Content-Length > 0 */
+
+ content_length = svn_hash_gets(headers,
+ SVN_REPOS_DUMPFILE_CONTENT_LENGTH);
+ prop_cl = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH);
+ text_cl = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_TEXT_CONTENT_LENGTH);
+ old_v1_with_cl =
+ version == 1 && content_length && ! prop_cl && ! text_cl;
+
+ /* Is there a props content-block to parse? */
+ if (prop_cl || old_v1_with_cl)
+ {
+ const char *delta = svn_hash_gets(headers,
+ SVN_REPOS_DUMPFILE_PROP_DELTA);
+ svn_boolean_t is_delta = (delta && strcmp(delta, "true") == 0);
+
+ /* First, remove all node properties, unless this is a delta
+ property block. */
+ if (found_node && !is_delta)
+ SVN_ERR(parse_fns->remove_node_props(node_baton));
+
+ SVN_ERR(parse_property_block
+ (stream,
+ svn__atoui64(prop_cl ? prop_cl : content_length),
+ parse_fns,
+ found_node ? node_baton : rev_baton,
+ parse_baton,
+ found_node,
+ &actual_prop_length,
+ found_node ? nodepool : revpool));
+ }
+
+ /* Is there a text content-block to parse? */
+ if (text_cl)
+ {
+ const char *delta = svn_hash_gets(headers,
+ SVN_REPOS_DUMPFILE_TEXT_DELTA);
+ svn_boolean_t is_delta = FALSE;
+ if (! deltas_are_text)
+ is_delta = (delta && strcmp(delta, "true") == 0);
+
+ SVN_ERR(parse_text_block(stream,
+ svn__atoui64(text_cl),
+ is_delta,
+ parse_fns,
+ found_node ? node_baton : rev_baton,
+ buffer,
+ buflen,
+ found_node ? nodepool : revpool));
+ }
+ else if (old_v1_with_cl)
+ {
+ /* An old-v1 block with a Content-length might have a text block.
+ If the property block did not consume all the bytes of the
+ Content-length, then it clearly does have a text block.
+ If not, then we must deduce whether we have an *empty* text
+ block or an *absent* text block. The rules are:
+ - "Node-kind: file" blocks have an empty (i.e. present, but
+ zero-length) text block, since they represent a file
+ modification. Note that file-copied-text-unmodified blocks
+ have no Content-length - even if they should have contained
+ a modified property block, the pre-0.14 dumper forgets to
+ dump the modified properties.
+ - If it is not a file node, then it is a revision or directory,
+ and so has an absent text block.
+ */
+ const char *node_kind;
+ svn_filesize_t cl_value = svn__atoui64(content_length)
+ - actual_prop_length;
+
+ if (cl_value ||
+ ((node_kind = svn_hash_gets(headers,
+ SVN_REPOS_DUMPFILE_NODE_KIND))
+ && strcmp(node_kind, "file") == 0)
+ )
+ SVN_ERR(parse_text_block(stream,
+ cl_value,
+ FALSE,
+ parse_fns,
+ found_node ? node_baton : rev_baton,
+ buffer,
+ buflen,
+ found_node ? nodepool : revpool));
+ }
+
+ /* if we have a content-length header, did we read all of it?
+ in case of an old v1, we *always* read all of it, because
+ text-content-length == content-length - prop-content-length
+ */
+ if (content_length && ! old_v1_with_cl)
+ {
+ apr_size_t rlen, num_to_read;
+ svn_filesize_t remaining =
+ svn__atoui64(content_length) -
+ (prop_cl ? svn__atoui64(prop_cl) : 0) -
+ (text_cl ? svn__atoui64(text_cl) : 0);
+
+
+ if (remaining < 0)
+ return svn_error_create(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
+ _("Sum of subblock sizes larger than "
+ "total block content length"));
+
+ /* Consume remaining bytes in this content block */
+ while (remaining > 0)
+ {
+ if (remaining >= (svn_filesize_t)buflen)
+ rlen = buflen;
+ else
+ rlen = (apr_size_t) remaining;
+
+ num_to_read = rlen;
+ SVN_ERR(svn_stream_read(stream, buffer, &rlen));
+ remaining -= rlen;
+ if (rlen != num_to_read)
+ return stream_ran_dry();
+ }
+ }
+
+ /* If we just finished processing a node record, we need to
+ close the node record and clear the per-node subpool. */
+ if (found_node)
+ {
+ SVN_ERR(parse_fns->close_node(node_baton));
+ svn_pool_clear(nodepool);
+ }
+
+ /*** End of processing for one record. ***/
+
+ } /* end of stream */
+
+ /* Close out whatever revision we're in. */
+ if (rev_baton != NULL)
+ SVN_ERR(parse_fns->close_revision(rev_baton));
+
+ svn_pool_destroy(linepool);
+ svn_pool_destroy(revpool);
+ svn_pool_destroy(nodepool);
+ return SVN_NO_ERROR;
+}
diff --git a/subversion/libsvn_repos/log.c b/subversion/libsvn_repos/log.c
new file mode 100644
index 000000000000..8ca870b995e2
--- /dev/null
+++ b/subversion/libsvn_repos/log.c
@@ -0,0 +1,2369 @@
+/* log.c --- retrieving log messages
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+
+#include <stdlib.h>
+#define APR_WANT_STRFUNC
+#include <apr_want.h>
+
+#include "svn_compat.h"
+#include "svn_private_config.h"
+#include "svn_hash.h"
+#include "svn_pools.h"
+#include "svn_error.h"
+#include "svn_path.h"
+#include "svn_fs.h"
+#include "svn_repos.h"
+#include "svn_string.h"
+#include "svn_sorts.h"
+#include "svn_props.h"
+#include "svn_mergeinfo.h"
+#include "repos.h"
+#include "private/svn_fspath.h"
+#include "private/svn_mergeinfo_private.h"
+#include "private/svn_subr_private.h"
+
+
+
+svn_error_t *
+svn_repos_check_revision_access(svn_repos_revision_access_level_t *access_level,
+ svn_repos_t *repos,
+ svn_revnum_t revision,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ svn_fs_t *fs = svn_repos_fs(repos);
+ svn_fs_root_t *rev_root;
+ apr_hash_t *changes;
+ apr_hash_index_t *hi;
+ svn_boolean_t found_readable = FALSE;
+ svn_boolean_t found_unreadable = FALSE;
+ apr_pool_t *subpool;
+
+ /* By default, we'll grant full read access to REVISION. */
+ *access_level = svn_repos_revision_access_full;
+
+ /* No auth-checking function? We're done. */
+ if (! authz_read_func)
+ return SVN_NO_ERROR;
+
+ /* Fetch the changes associated with REVISION. */
+ SVN_ERR(svn_fs_revision_root(&rev_root, fs, revision, pool));
+ SVN_ERR(svn_fs_paths_changed2(&changes, rev_root, pool));
+
+ /* No changed paths? We're done. */
+ if (apr_hash_count(changes) == 0)
+ return SVN_NO_ERROR;
+
+ /* Otherwise, we have to check the readability of each changed
+ path, or at least enough to answer the question asked. */
+ subpool = svn_pool_create(pool);
+ for (hi = apr_hash_first(pool, changes); hi; hi = apr_hash_next(hi))
+ {
+ const void *key;
+ void *val;
+ svn_fs_path_change2_t *change;
+ svn_boolean_t readable;
+
+ svn_pool_clear(subpool);
+ apr_hash_this(hi, &key, NULL, &val);
+ change = val;
+
+ SVN_ERR(authz_read_func(&readable, rev_root, key,
+ authz_read_baton, subpool));
+ if (! readable)
+ found_unreadable = TRUE;
+ else
+ found_readable = TRUE;
+
+ /* If we have at least one of each (readable/unreadable), we
+ have our answer. */
+ if (found_readable && found_unreadable)
+ goto decision;
+
+ switch (change->change_kind)
+ {
+ case svn_fs_path_change_add:
+ case svn_fs_path_change_replace:
+ {
+ const char *copyfrom_path;
+ svn_revnum_t copyfrom_rev;
+
+ SVN_ERR(svn_fs_copied_from(&copyfrom_rev, &copyfrom_path,
+ rev_root, key, subpool));
+ if (copyfrom_path && SVN_IS_VALID_REVNUM(copyfrom_rev))
+ {
+ svn_fs_root_t *copyfrom_root;
+ SVN_ERR(svn_fs_revision_root(&copyfrom_root, fs,
+ copyfrom_rev, subpool));
+ SVN_ERR(authz_read_func(&readable,
+ copyfrom_root, copyfrom_path,
+ authz_read_baton, subpool));
+ if (! readable)
+ found_unreadable = TRUE;
+
+ /* If we have at least one of each (readable/unreadable), we
+ have our answer. */
+ if (found_readable && found_unreadable)
+ goto decision;
+ }
+ }
+ break;
+
+ case svn_fs_path_change_delete:
+ case svn_fs_path_change_modify:
+ default:
+ break;
+ }
+ }
+
+ decision:
+ svn_pool_destroy(subpool);
+
+ /* Either every changed path was unreadable... */
+ if (! found_readable)
+ *access_level = svn_repos_revision_access_none;
+
+ /* ... or some changed path was unreadable... */
+ else if (found_unreadable)
+ *access_level = svn_repos_revision_access_partial;
+
+ /* ... or every changed path was readable (the default). */
+ return SVN_NO_ERROR;
+}
+
+
+/* Store as keys in CHANGED the paths of all node in ROOT that show a
+ * significant change. "Significant" means that the text or
+ * properties of the node were changed, or that the node was added or
+ * deleted.
+ *
+ * The CHANGED hash set and its keys and values are allocated in POOL;
+ * keys are const char * paths and values are svn_log_changed_path_t.
+ *
+ * To prevent changes from being processed over and over again, the
+ * changed paths for ROOT may be passed in PREFETCHED_CHANGES. If the
+ * latter is NULL, we will request the list inside this function.
+ *
+ * If optional AUTHZ_READ_FUNC is non-NULL, then use it (with
+ * AUTHZ_READ_BATON and FS) to check whether each changed-path (and
+ * copyfrom_path) is readable:
+ *
+ * - If some paths are readable and some are not, then silently
+ * omit the unreadable paths from the CHANGED hash, and return
+ * SVN_ERR_AUTHZ_PARTIALLY_READABLE.
+ *
+ * - If absolutely every changed-path (and copyfrom_path) is
+ * unreadable, then return an empty CHANGED hash and
+ * SVN_ERR_AUTHZ_UNREADABLE. (This is to distinguish a revision
+ * which truly has no changed paths from a revision in which all
+ * paths are unreadable.)
+ */
+static svn_error_t *
+detect_changed(apr_hash_t **changed,
+ svn_fs_root_t *root,
+ svn_fs_t *fs,
+ apr_hash_t *prefetched_changes,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ apr_hash_t *changes = prefetched_changes;
+ apr_hash_index_t *hi;
+ apr_pool_t *subpool;
+ svn_boolean_t found_readable = FALSE;
+ svn_boolean_t found_unreadable = FALSE;
+
+ *changed = svn_hash__make(pool);
+ if (changes == NULL)
+ SVN_ERR(svn_fs_paths_changed2(&changes, root, pool));
+
+ if (apr_hash_count(changes) == 0)
+ /* No paths changed in this revision? Uh, sure, I guess the
+ revision is readable, then. */
+ return SVN_NO_ERROR;
+
+ subpool = svn_pool_create(pool);
+
+ for (hi = apr_hash_first(pool, changes); hi; hi = apr_hash_next(hi))
+ {
+ /* NOTE: Much of this loop is going to look quite similar to
+ svn_repos_check_revision_access(), but we have to do more things
+ here, so we'll live with the duplication. */
+ const void *key;
+ void *val;
+ svn_fs_path_change2_t *change;
+ const char *path;
+ char action;
+ svn_log_changed_path2_t *item;
+
+ svn_pool_clear(subpool);
+
+ /* KEY will be the path, VAL the change. */
+ apr_hash_this(hi, &key, NULL, &val);
+ path = (const char *) key;
+ change = val;
+
+ /* Skip path if unreadable. */
+ if (authz_read_func)
+ {
+ svn_boolean_t readable;
+ SVN_ERR(authz_read_func(&readable,
+ root, path,
+ authz_read_baton, subpool));
+ if (! readable)
+ {
+ found_unreadable = TRUE;
+ continue;
+ }
+ }
+
+ /* At least one changed-path was readable. */
+ found_readable = TRUE;
+
+ switch (change->change_kind)
+ {
+ case svn_fs_path_change_reset:
+ continue;
+
+ case svn_fs_path_change_add:
+ action = 'A';
+ break;
+
+ case svn_fs_path_change_replace:
+ action = 'R';
+ break;
+
+ case svn_fs_path_change_delete:
+ action = 'D';
+ break;
+
+ case svn_fs_path_change_modify:
+ default:
+ action = 'M';
+ break;
+ }
+
+ item = svn_log_changed_path2_create(pool);
+ item->action = action;
+ item->node_kind = change->node_kind;
+ item->copyfrom_rev = SVN_INVALID_REVNUM;
+ item->text_modified = change->text_mod ? svn_tristate_true
+ : svn_tristate_false;
+ item->props_modified = change->prop_mod ? svn_tristate_true
+ : svn_tristate_false;
+
+ /* Pre-1.6 revision files don't store the change path kind, so fetch
+ it manually. */
+ if (item->node_kind == svn_node_unknown)
+ {
+ svn_fs_root_t *check_root = root;
+ const char *check_path = path;
+
+ /* Deleted items don't exist so check earlier revision. We
+ know the parent must exist and could be a copy */
+ if (change->change_kind == svn_fs_path_change_delete)
+ {
+ svn_fs_history_t *history;
+ svn_revnum_t prev_rev;
+ const char *parent_path, *name;
+
+ svn_fspath__split(&parent_path, &name, path, subpool);
+
+ SVN_ERR(svn_fs_node_history(&history, root, parent_path,
+ subpool));
+
+ /* Two calls because the first call returns the original
+ revision as the deleted child means it is 'interesting' */
+ SVN_ERR(svn_fs_history_prev(&history, history, TRUE, subpool));
+ SVN_ERR(svn_fs_history_prev(&history, history, TRUE, subpool));
+
+ SVN_ERR(svn_fs_history_location(&parent_path, &prev_rev, history,
+ subpool));
+ SVN_ERR(svn_fs_revision_root(&check_root, fs, prev_rev, subpool));
+ check_path = svn_fspath__join(parent_path, name, subpool);
+ }
+
+ SVN_ERR(svn_fs_check_path(&item->node_kind, check_root, check_path,
+ subpool));
+ }
+
+
+ if ((action == 'A') || (action == 'R'))
+ {
+ const char *copyfrom_path = change->copyfrom_path;
+ svn_revnum_t copyfrom_rev = change->copyfrom_rev;
+
+ /* the following is a potentially expensive operation since on FSFS
+ we will follow the DAG from ROOT to PATH and that requires
+ actually reading the directories along the way. */
+ if (!change->copyfrom_known)
+ SVN_ERR(svn_fs_copied_from(&copyfrom_rev, &copyfrom_path,
+ root, path, subpool));
+
+ if (copyfrom_path && SVN_IS_VALID_REVNUM(copyfrom_rev))
+ {
+ svn_boolean_t readable = TRUE;
+
+ if (authz_read_func)
+ {
+ svn_fs_root_t *copyfrom_root;
+
+ SVN_ERR(svn_fs_revision_root(&copyfrom_root, fs,
+ copyfrom_rev, subpool));
+ SVN_ERR(authz_read_func(&readable,
+ copyfrom_root, copyfrom_path,
+ authz_read_baton, subpool));
+ if (! readable)
+ found_unreadable = TRUE;
+ }
+
+ if (readable)
+ {
+ item->copyfrom_path = apr_pstrdup(pool, copyfrom_path);
+ item->copyfrom_rev = copyfrom_rev;
+ }
+ }
+ }
+ svn_hash_sets(*changed, apr_pstrdup(pool, path), item);
+ }
+
+ svn_pool_destroy(subpool);
+
+ if (! found_readable)
+ /* Every changed-path was unreadable. */
+ return svn_error_create(SVN_ERR_AUTHZ_UNREADABLE,
+ NULL, NULL);
+
+ if (found_unreadable)
+ /* At least one changed-path was unreadable. */
+ return svn_error_create(SVN_ERR_AUTHZ_PARTIALLY_READABLE,
+ NULL, NULL);
+
+ /* Every changed-path was readable. */
+ return SVN_NO_ERROR;
+}
+
+/* This is used by svn_repos_get_logs to keep track of multiple
+ * path history information while working through history.
+ *
+ * The two pools are swapped after each iteration through history because
+ * to get the next history requires the previous one.
+ */
+struct path_info
+{
+ svn_stringbuf_t *path;
+ svn_revnum_t history_rev;
+ svn_boolean_t done;
+ svn_boolean_t first_time;
+
+ /* If possible, we like to keep open the history object for each path,
+ since it avoids needed to open and close it many times as we walk
+ backwards in time. To do so we need two pools, so that we can clear
+ one each time through. If we're not holding the history open for
+ this path then these three pointers will be NULL. */
+ svn_fs_history_t *hist;
+ apr_pool_t *newpool;
+ apr_pool_t *oldpool;
+};
+
+/* Advance to the next history for the path.
+ *
+ * If INFO->HIST is not NULL we do this using that existing history object,
+ * otherwise we open a new one.
+ *
+ * If no more history is available or the history revision is less
+ * (earlier) than START, or the history is not available due
+ * to authorization, then INFO->DONE is set to TRUE.
+ *
+ * A STRICT value of FALSE will indicate to follow history across copied
+ * paths.
+ *
+ * If optional AUTHZ_READ_FUNC is non-NULL, then use it (with
+ * AUTHZ_READ_BATON and FS) to check whether INFO->PATH is still readable if
+ * we do indeed find more history for the path.
+ */
+static svn_error_t *
+get_history(struct path_info *info,
+ svn_fs_t *fs,
+ svn_boolean_t strict,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ svn_revnum_t start,
+ apr_pool_t *pool)
+{
+ svn_fs_root_t *history_root = NULL;
+ svn_fs_history_t *hist;
+ apr_pool_t *subpool;
+ const char *path;
+
+ if (info->hist)
+ {
+ subpool = info->newpool;
+
+ SVN_ERR(svn_fs_history_prev(&info->hist, info->hist, ! strict, subpool));
+
+ hist = info->hist;
+ }
+ else
+ {
+ subpool = svn_pool_create(pool);
+
+ /* Open the history located at the last rev we were at. */
+ SVN_ERR(svn_fs_revision_root(&history_root, fs, info->history_rev,
+ subpool));
+
+ SVN_ERR(svn_fs_node_history(&hist, history_root, info->path->data,
+ subpool));
+
+ SVN_ERR(svn_fs_history_prev(&hist, hist, ! strict, subpool));
+
+ if (info->first_time)
+ info->first_time = FALSE;
+ else
+ SVN_ERR(svn_fs_history_prev(&hist, hist, ! strict, subpool));
+ }
+
+ if (! hist)
+ {
+ svn_pool_destroy(subpool);
+ if (info->oldpool)
+ svn_pool_destroy(info->oldpool);
+ info->done = TRUE;
+ return SVN_NO_ERROR;
+ }
+
+ /* Fetch the location information for this history step. */
+ SVN_ERR(svn_fs_history_location(&path, &info->history_rev,
+ hist, subpool));
+
+ svn_stringbuf_set(info->path, path);
+
+ /* If this history item predates our START revision then
+ don't fetch any more for this path. */
+ if (info->history_rev < start)
+ {
+ svn_pool_destroy(subpool);
+ if (info->oldpool)
+ svn_pool_destroy(info->oldpool);
+ info->done = TRUE;
+ return SVN_NO_ERROR;
+ }
+
+ /* Is the history item readable? If not, done with path. */
+ if (authz_read_func)
+ {
+ svn_boolean_t readable;
+ SVN_ERR(svn_fs_revision_root(&history_root, fs,
+ info->history_rev,
+ subpool));
+ SVN_ERR(authz_read_func(&readable, history_root,
+ info->path->data,
+ authz_read_baton,
+ subpool));
+ if (! readable)
+ info->done = TRUE;
+ }
+
+ if (! info->hist)
+ {
+ svn_pool_destroy(subpool);
+ }
+ else
+ {
+ apr_pool_t *temppool = info->oldpool;
+ info->oldpool = info->newpool;
+ svn_pool_clear(temppool);
+ info->newpool = temppool;
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Set INFO->HIST to the next history for the path *if* there is history
+ * available and INFO->HISTORY_REV is equal to or greater than CURRENT.
+ *
+ * *CHANGED is set to TRUE if the path has history in the CURRENT revision,
+ * otherwise it is not touched.
+ *
+ * If we do need to get the next history revision for the path, call
+ * get_history to do it -- see it for details.
+ */
+static svn_error_t *
+check_history(svn_boolean_t *changed,
+ struct path_info *info,
+ svn_fs_t *fs,
+ svn_revnum_t current,
+ svn_boolean_t strict,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ svn_revnum_t start,
+ apr_pool_t *pool)
+{
+ /* If we're already done with histories for this path,
+ don't try to fetch any more. */
+ if (info->done)
+ return SVN_NO_ERROR;
+
+ /* If the last rev we got for this path is less than CURRENT,
+ then just return and don't fetch history for this path.
+ The caller will get to this rev eventually or else reach
+ the limit. */
+ if (info->history_rev < current)
+ return SVN_NO_ERROR;
+
+ /* If the last rev we got for this path is equal to CURRENT
+ then set *CHANGED to true and get the next history
+ rev where this path was changed. */
+ *changed = TRUE;
+ return get_history(info, fs, strict, authz_read_func,
+ authz_read_baton, start, pool);
+}
+
+/* Return the next interesting revision in our list of HISTORIES. */
+static svn_revnum_t
+next_history_rev(const apr_array_header_t *histories)
+{
+ svn_revnum_t next_rev = SVN_INVALID_REVNUM;
+ int i;
+
+ for (i = 0; i < histories->nelts; ++i)
+ {
+ struct path_info *info = APR_ARRAY_IDX(histories, i,
+ struct path_info *);
+ if (info->done)
+ continue;
+ if (info->history_rev > next_rev)
+ next_rev = info->history_rev;
+ }
+
+ return next_rev;
+}
+
+/* Set *DELETED_MERGEINFO_CATALOG and *ADDED_MERGEINFO_CATALOG to
+ catalogs describing how mergeinfo values on paths (which are the
+ keys of those catalogs) were changed in REV. If *PREFETCHED_CAHNGES
+ already contains the changed paths for REV, use that. Otherwise,
+ request that data and return it in *PREFETCHED_CHANGES. */
+/* ### TODO: This would make a *great*, useful public function,
+ ### svn_repos_fs_mergeinfo_changed()! -- cmpilato */
+static svn_error_t *
+fs_mergeinfo_changed(svn_mergeinfo_catalog_t *deleted_mergeinfo_catalog,
+ svn_mergeinfo_catalog_t *added_mergeinfo_catalog,
+ apr_hash_t **prefetched_changes,
+ svn_fs_t *fs,
+ svn_revnum_t rev,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+
+{
+ svn_fs_root_t *root;
+ apr_pool_t *iterpool;
+ apr_hash_index_t *hi;
+
+ /* Initialize return variables. */
+ *deleted_mergeinfo_catalog = svn_hash__make(result_pool);
+ *added_mergeinfo_catalog = svn_hash__make(result_pool);
+
+ /* Revision 0 has no mergeinfo and no mergeinfo changes. */
+ if (rev == 0)
+ return SVN_NO_ERROR;
+
+ /* We're going to use the changed-paths information for REV to
+ narrow down our search. */
+ SVN_ERR(svn_fs_revision_root(&root, fs, rev, scratch_pool));
+ if (*prefetched_changes == NULL)
+ SVN_ERR(svn_fs_paths_changed2(prefetched_changes, root, scratch_pool));
+
+ /* No changed paths? We're done. */
+ if (apr_hash_count(*prefetched_changes) == 0)
+ return SVN_NO_ERROR;
+
+ /* Loop over changes, looking for anything that might carry an
+ svn:mergeinfo change and is one of our paths of interest, or a
+ child or [grand]parent directory thereof. */
+ iterpool = svn_pool_create(scratch_pool);
+ for (hi = apr_hash_first(scratch_pool, *prefetched_changes);
+ hi;
+ hi = apr_hash_next(hi))
+ {
+ const void *key;
+ void *val;
+ svn_fs_path_change2_t *change;
+ const char *changed_path, *base_path = NULL;
+ svn_revnum_t base_rev = SVN_INVALID_REVNUM;
+ svn_fs_root_t *base_root = NULL;
+ svn_string_t *prev_mergeinfo_value = NULL, *mergeinfo_value;
+
+ svn_pool_clear(iterpool);
+
+ /* KEY will be the path, VAL the change. */
+ apr_hash_this(hi, &key, NULL, &val);
+ changed_path = key;
+ change = val;
+
+ /* If there was no property change on this item, ignore it. */
+ if (! change->prop_mod)
+ continue;
+
+ switch (change->change_kind)
+ {
+
+ /* ### TODO: Can the add, replace, and modify cases be joined
+ ### together to all use svn_repos__prev_location()? The
+ ### difference would be the fallback case (path/rev-1 for
+ ### modifies, NULL otherwise). -- cmpilato */
+
+ /* If the path was added or replaced, see if it was created via
+ copy. If so, that will tell us where its previous location
+ was. If not, there's no previous location to examine. */
+ case svn_fs_path_change_add:
+ case svn_fs_path_change_replace:
+ {
+ const char *copyfrom_path;
+ svn_revnum_t copyfrom_rev;
+
+ SVN_ERR(svn_fs_copied_from(&copyfrom_rev, &copyfrom_path,
+ root, changed_path, iterpool));
+ if (copyfrom_path && SVN_IS_VALID_REVNUM(copyfrom_rev))
+ {
+ base_path = apr_pstrdup(scratch_pool, copyfrom_path);
+ base_rev = copyfrom_rev;
+ }
+ break;
+ }
+
+ /* If the path was merely modified, see if its previous
+ location was affected by a copy which happened in this
+ revision before assuming it holds the same path it did the
+ previous revision. */
+ case svn_fs_path_change_modify:
+ {
+ svn_revnum_t appeared_rev;
+
+ SVN_ERR(svn_repos__prev_location(&appeared_rev, &base_path,
+ &base_rev, fs, rev,
+ changed_path, iterpool));
+
+ /* If this path isn't the result of a copy that occurred
+ in this revision, we can find the previous version of
+ it in REV - 1 at the same path. */
+ if (! (base_path && SVN_IS_VALID_REVNUM(base_rev)
+ && (appeared_rev == rev)))
+ {
+ base_path = changed_path;
+ base_rev = rev - 1;
+ }
+ break;
+ }
+
+ /* We don't care about any of the other cases. */
+ case svn_fs_path_change_delete:
+ case svn_fs_path_change_reset:
+ default:
+ continue;
+ }
+
+ /* If there was a base location, fetch its mergeinfo property value. */
+ if (base_path && SVN_IS_VALID_REVNUM(base_rev))
+ {
+ SVN_ERR(svn_fs_revision_root(&base_root, fs, base_rev, iterpool));
+ SVN_ERR(svn_fs_node_prop(&prev_mergeinfo_value, base_root, base_path,
+ SVN_PROP_MERGEINFO, iterpool));
+ }
+
+ /* Now fetch the current (as of REV) mergeinfo property value. */
+ SVN_ERR(svn_fs_node_prop(&mergeinfo_value, root, changed_path,
+ SVN_PROP_MERGEINFO, iterpool));
+
+ /* No mergeinfo on either the new or previous location? Just
+ skip it. (If there *was* a change, it would have been in
+ inherited mergeinfo only, which should be picked up by the
+ iteration of this loop that finds the parent paths that
+ really got changed.) */
+ if (! (mergeinfo_value || prev_mergeinfo_value))
+ continue;
+
+ /* If mergeinfo was explicitly added or removed on this path, we
+ need to check to see if that was a real semantic change of
+ meaning. So, fill in the "missing" mergeinfo value with the
+ inherited mergeinfo for that path/revision. */
+ if (prev_mergeinfo_value && (! mergeinfo_value))
+ {
+ apr_array_header_t *query_paths =
+ apr_array_make(iterpool, 1, sizeof(const char *));
+ svn_mergeinfo_t tmp_mergeinfo;
+ svn_mergeinfo_catalog_t tmp_catalog;
+
+ APR_ARRAY_PUSH(query_paths, const char *) = changed_path;
+ SVN_ERR(svn_fs_get_mergeinfo2(&tmp_catalog, root,
+ query_paths, svn_mergeinfo_inherited,
+ FALSE, TRUE, iterpool, iterpool));
+ tmp_mergeinfo = svn_hash_gets(tmp_catalog, changed_path);
+ if (tmp_mergeinfo)
+ SVN_ERR(svn_mergeinfo_to_string(&mergeinfo_value,
+ tmp_mergeinfo,
+ iterpool));
+ }
+ else if (mergeinfo_value && (! prev_mergeinfo_value)
+ && base_path && SVN_IS_VALID_REVNUM(base_rev))
+ {
+ apr_array_header_t *query_paths =
+ apr_array_make(iterpool, 1, sizeof(const char *));
+ svn_mergeinfo_t tmp_mergeinfo;
+ svn_mergeinfo_catalog_t tmp_catalog;
+
+ APR_ARRAY_PUSH(query_paths, const char *) = base_path;
+ SVN_ERR(svn_fs_get_mergeinfo2(&tmp_catalog, base_root,
+ query_paths, svn_mergeinfo_inherited,
+ FALSE, TRUE, iterpool, iterpool));
+ tmp_mergeinfo = svn_hash_gets(tmp_catalog, base_path);
+ if (tmp_mergeinfo)
+ SVN_ERR(svn_mergeinfo_to_string(&prev_mergeinfo_value,
+ tmp_mergeinfo,
+ iterpool));
+ }
+
+ /* If the old and new mergeinfo differ in any way, store the
+ before and after mergeinfo values in our return hashes. */
+ if ((prev_mergeinfo_value && (! mergeinfo_value))
+ || ((! prev_mergeinfo_value) && mergeinfo_value)
+ || (prev_mergeinfo_value && mergeinfo_value
+ && (! svn_string_compare(mergeinfo_value,
+ prev_mergeinfo_value))))
+ {
+ svn_mergeinfo_t prev_mergeinfo = NULL, mergeinfo = NULL;
+ svn_mergeinfo_t deleted, added;
+ const char *hash_path;
+
+ if (mergeinfo_value)
+ SVN_ERR(svn_mergeinfo_parse(&mergeinfo,
+ mergeinfo_value->data, iterpool));
+ if (prev_mergeinfo_value)
+ SVN_ERR(svn_mergeinfo_parse(&prev_mergeinfo,
+ prev_mergeinfo_value->data, iterpool));
+ SVN_ERR(svn_mergeinfo_diff2(&deleted, &added, prev_mergeinfo,
+ mergeinfo, FALSE, result_pool,
+ iterpool));
+
+ /* Toss interesting stuff into our return catalogs. */
+ hash_path = apr_pstrdup(result_pool, changed_path);
+ svn_hash_sets(*deleted_mergeinfo_catalog, hash_path, deleted);
+ svn_hash_sets(*added_mergeinfo_catalog, hash_path, added);
+ }
+ }
+
+ svn_pool_destroy(iterpool);
+ return SVN_NO_ERROR;
+}
+
+
+/* Determine what (if any) mergeinfo for PATHS was modified in
+ revision REV, returning the differences for added mergeinfo in
+ *ADDED_MERGEINFO and deleted mergeinfo in *DELETED_MERGEINFO.
+ If *PREFETCHED_CAHNGES already contains the changed paths for
+ REV, use that. Otherwise, request that data and return it in
+ *PREFETCHED_CHANGES.
+ Use POOL for all allocations. */
+static svn_error_t *
+get_combined_mergeinfo_changes(svn_mergeinfo_t *added_mergeinfo,
+ svn_mergeinfo_t *deleted_mergeinfo,
+ apr_hash_t **prefetched_changes,
+ svn_fs_t *fs,
+ const apr_array_header_t *paths,
+ svn_revnum_t rev,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_mergeinfo_catalog_t added_mergeinfo_catalog, deleted_mergeinfo_catalog;
+ apr_hash_index_t *hi;
+ svn_fs_root_t *root;
+ apr_pool_t *iterpool;
+ int i;
+ svn_error_t *err;
+
+ /* Initialize return value. */
+ *added_mergeinfo = svn_hash__make(result_pool);
+ *deleted_mergeinfo = svn_hash__make(result_pool);
+
+ /* If we're asking about revision 0, there's no mergeinfo to be found. */
+ if (rev == 0)
+ return SVN_NO_ERROR;
+
+ /* No paths? No mergeinfo. */
+ if (! paths->nelts)
+ return SVN_NO_ERROR;
+
+ /* Create a work subpool and get a root for REV. */
+ SVN_ERR(svn_fs_revision_root(&root, fs, rev, scratch_pool));
+
+ /* Fetch the mergeinfo changes for REV. */
+ err = fs_mergeinfo_changed(&deleted_mergeinfo_catalog,
+ &added_mergeinfo_catalog,
+ prefetched_changes,
+ fs, rev, scratch_pool, scratch_pool);
+ if (err)
+ {
+ if (err->apr_err == SVN_ERR_MERGEINFO_PARSE_ERROR)
+ {
+ /* Issue #3896: If invalid mergeinfo is encountered the
+ best we can do is ignore it and act as if there were
+ no mergeinfo modifications. */
+ svn_error_clear(err);
+ return SVN_NO_ERROR;
+ }
+ else
+ {
+ return svn_error_trace(err);
+ }
+ }
+
+ /* In most revisions, there will be no mergeinfo change at all. */
+ if ( apr_hash_count(deleted_mergeinfo_catalog) == 0
+ && apr_hash_count(added_mergeinfo_catalog) == 0)
+ return SVN_NO_ERROR;
+
+ /* Check our PATHS for any changes to their inherited mergeinfo.
+ (We deal with changes to mergeinfo directly *on* the paths in the
+ following loop.) */
+ iterpool = svn_pool_create(scratch_pool);
+ for (i = 0; i < paths->nelts; i++)
+ {
+ const char *path = APR_ARRAY_IDX(paths, i, const char *);
+ const char *prev_path;
+ apr_ssize_t klen;
+ svn_revnum_t appeared_rev, prev_rev;
+ svn_fs_root_t *prev_root;
+ svn_mergeinfo_catalog_t catalog, inherited_catalog;
+ svn_mergeinfo_t prev_mergeinfo, mergeinfo, deleted, added,
+ prev_inherited_mergeinfo, inherited_mergeinfo;
+ apr_array_header_t *query_paths;
+
+ svn_pool_clear(iterpool);
+
+ /* If this path is represented in the changed-mergeinfo hashes,
+ we'll deal with it in the loop below. */
+ if (svn_hash_gets(deleted_mergeinfo_catalog, path))
+ continue;
+
+ /* Figure out what path/rev to compare against. Ignore
+ not-found errors returned by the filesystem. */
+ err = svn_repos__prev_location(&appeared_rev, &prev_path, &prev_rev,
+ fs, rev, path, iterpool);
+ if (err && (err->apr_err == SVN_ERR_FS_NOT_FOUND ||
+ err->apr_err == SVN_ERR_FS_NOT_DIRECTORY))
+ {
+ svn_error_clear(err);
+ err = SVN_NO_ERROR;
+ continue;
+ }
+ SVN_ERR(err);
+
+ /* If this path isn't the result of a copy that occurred in this
+ revision, we can find the previous version of it in REV - 1
+ at the same path. */
+ if (! (prev_path && SVN_IS_VALID_REVNUM(prev_rev)
+ && (appeared_rev == rev)))
+ {
+ prev_path = path;
+ prev_rev = rev - 1;
+ }
+
+ /* Fetch the previous mergeinfo (including inherited stuff) for
+ this path. Ignore not-found errors returned by the
+ filesystem or invalid mergeinfo (Issue #3896).*/
+ SVN_ERR(svn_fs_revision_root(&prev_root, fs, prev_rev, iterpool));
+ query_paths = apr_array_make(iterpool, 1, sizeof(const char *));
+ APR_ARRAY_PUSH(query_paths, const char *) = prev_path;
+ err = svn_fs_get_mergeinfo2(&catalog, prev_root, query_paths,
+ svn_mergeinfo_inherited, FALSE, TRUE,
+ iterpool, iterpool);
+ if (err && (err->apr_err == SVN_ERR_FS_NOT_FOUND ||
+ err->apr_err == SVN_ERR_FS_NOT_DIRECTORY ||
+ err->apr_err == SVN_ERR_MERGEINFO_PARSE_ERROR))
+ {
+ svn_error_clear(err);
+ err = SVN_NO_ERROR;
+ continue;
+ }
+ SVN_ERR(err);
+
+ /* Issue #4022 'svn log -g interprets change in inherited mergeinfo due
+ to move as a merge': A copy where the source and destination inherit
+ mergeinfo from the same parent means the inherited mergeinfo of the
+ source and destination will differ, but this diffrence is not
+ indicative of a merge unless the mergeinfo on the inherited parent
+ has actually changed.
+
+ To check for this we must fetch the "raw" previous inherited
+ mergeinfo and the "raw" mergeinfo @REV then compare these. */
+ SVN_ERR(svn_fs_get_mergeinfo2(&inherited_catalog, prev_root, query_paths,
+ svn_mergeinfo_nearest_ancestor, FALSE,
+ FALSE, /* adjust_inherited_mergeinfo */
+ iterpool, iterpool));
+
+ klen = strlen(prev_path);
+ prev_mergeinfo = apr_hash_get(catalog, prev_path, klen);
+ prev_inherited_mergeinfo = apr_hash_get(inherited_catalog, prev_path, klen);
+
+ /* Fetch the current mergeinfo (as of REV, and including
+ inherited stuff) for this path. */
+ APR_ARRAY_IDX(query_paths, 0, const char *) = path;
+ SVN_ERR(svn_fs_get_mergeinfo2(&catalog, root, query_paths,
+ svn_mergeinfo_inherited, FALSE, TRUE,
+ iterpool, iterpool));
+
+ /* Issue #4022 again, fetch the raw inherited mergeinfo. */
+ SVN_ERR(svn_fs_get_mergeinfo2(&inherited_catalog, root, query_paths,
+ svn_mergeinfo_nearest_ancestor, FALSE,
+ FALSE, /* adjust_inherited_mergeinfo */
+ iterpool, iterpool));
+
+ klen = strlen(path);
+ mergeinfo = apr_hash_get(catalog, path, klen);
+ inherited_mergeinfo = apr_hash_get(inherited_catalog, path, klen);
+
+ if (!prev_mergeinfo && !mergeinfo)
+ continue;
+
+ /* Last bit of issue #4022 checking. */
+ if (prev_inherited_mergeinfo && inherited_mergeinfo)
+ {
+ svn_boolean_t inherits_same_mergeinfo;
+
+ SVN_ERR(svn_mergeinfo__equals(&inherits_same_mergeinfo,
+ prev_inherited_mergeinfo,
+ inherited_mergeinfo,
+ TRUE, iterpool));
+ /* If a copy rather than an actual merge brought about an
+ inherited mergeinfo change then we are finished. */
+ if (inherits_same_mergeinfo)
+ continue;
+ }
+ else
+ {
+ svn_boolean_t same_mergeinfo;
+ SVN_ERR(svn_mergeinfo__equals(&same_mergeinfo,
+ prev_inherited_mergeinfo,
+ FALSE,
+ TRUE, iterpool));
+ if (same_mergeinfo)
+ continue;
+ }
+
+ /* Compare, constrast, and combine the results. */
+ SVN_ERR(svn_mergeinfo_diff2(&deleted, &added, prev_mergeinfo,
+ mergeinfo, FALSE, result_pool, iterpool));
+ SVN_ERR(svn_mergeinfo_merge2(*deleted_mergeinfo, deleted,
+ result_pool, iterpool));
+ SVN_ERR(svn_mergeinfo_merge2(*added_mergeinfo, added,
+ result_pool, iterpool));
+ }
+
+ /* Merge all the mergeinfos which are, or are children of, one of
+ our paths of interest into one giant delta mergeinfo. */
+ for (hi = apr_hash_first(scratch_pool, added_mergeinfo_catalog);
+ hi; hi = apr_hash_next(hi))
+ {
+ const void *key;
+ apr_ssize_t klen;
+ void *val;
+ const char *changed_path;
+ svn_mergeinfo_t added, deleted;
+
+ /* The path is the key, the mergeinfo delta is the value. */
+ apr_hash_this(hi, &key, &klen, &val);
+ changed_path = key;
+ added = val;
+
+ for (i = 0; i < paths->nelts; i++)
+ {
+ const char *path = APR_ARRAY_IDX(paths, i, const char *);
+ if (! svn_fspath__skip_ancestor(path, changed_path))
+ continue;
+ svn_pool_clear(iterpool);
+ deleted = apr_hash_get(deleted_mergeinfo_catalog, key, klen);
+ SVN_ERR(svn_mergeinfo_merge2(*deleted_mergeinfo,
+ svn_mergeinfo_dup(deleted, result_pool),
+ result_pool, iterpool));
+ SVN_ERR(svn_mergeinfo_merge2(*added_mergeinfo,
+ svn_mergeinfo_dup(added, result_pool),
+ result_pool, iterpool));
+
+ break;
+ }
+ }
+
+ svn_pool_destroy(iterpool);
+ return SVN_NO_ERROR;
+}
+
+
+/* Fill LOG_ENTRY with history information in FS at REV. */
+static svn_error_t *
+fill_log_entry(svn_log_entry_t *log_entry,
+ svn_revnum_t rev,
+ svn_fs_t *fs,
+ apr_hash_t *prefetched_changes,
+ svn_boolean_t discover_changed_paths,
+ const apr_array_header_t *revprops,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ apr_hash_t *r_props, *changed_paths = NULL;
+ svn_boolean_t get_revprops = TRUE, censor_revprops = FALSE;
+
+ /* Discover changed paths if the user requested them
+ or if we need to check that they are readable. */
+ if ((rev > 0)
+ && (authz_read_func || discover_changed_paths))
+ {
+ svn_fs_root_t *newroot;
+ svn_error_t *patherr;
+
+ SVN_ERR(svn_fs_revision_root(&newroot, fs, rev, pool));
+ patherr = detect_changed(&changed_paths,
+ newroot, fs, prefetched_changes,
+ authz_read_func, authz_read_baton,
+ pool);
+
+ if (patherr
+ && patherr->apr_err == SVN_ERR_AUTHZ_UNREADABLE)
+ {
+ /* All changed-paths are unreadable, so clear all fields. */
+ svn_error_clear(patherr);
+ changed_paths = NULL;
+ get_revprops = FALSE;
+ }
+ else if (patherr
+ && patherr->apr_err == SVN_ERR_AUTHZ_PARTIALLY_READABLE)
+ {
+ /* At least one changed-path was unreadable, so censor all
+ but author and date. (The unreadable paths are already
+ missing from the hash.) */
+ svn_error_clear(patherr);
+ censor_revprops = TRUE;
+ }
+ else if (patherr)
+ return patherr;
+
+ /* It may be the case that an authz func was passed in, but
+ the user still doesn't want to see any changed-paths. */
+ if (! discover_changed_paths)
+ changed_paths = NULL;
+ }
+
+ if (get_revprops)
+ {
+ /* User is allowed to see at least some revprops. */
+ SVN_ERR(svn_fs_revision_proplist(&r_props, fs, rev, pool));
+ if (revprops == NULL)
+ {
+ /* Requested all revprops... */
+ if (censor_revprops)
+ {
+ /* ... but we can only return author/date. */
+ log_entry->revprops = svn_hash__make(pool);
+ svn_hash_sets(log_entry->revprops, SVN_PROP_REVISION_AUTHOR,
+ svn_hash_gets(r_props, SVN_PROP_REVISION_AUTHOR));
+ svn_hash_sets(log_entry->revprops, SVN_PROP_REVISION_DATE,
+ svn_hash_gets(r_props, SVN_PROP_REVISION_DATE));
+ }
+ else
+ /* ... so return all we got. */
+ log_entry->revprops = r_props;
+ }
+ else
+ {
+ /* Requested only some revprops... */
+ int i;
+ for (i = 0; i < revprops->nelts; i++)
+ {
+ char *name = APR_ARRAY_IDX(revprops, i, char *);
+ svn_string_t *value = svn_hash_gets(r_props, name);
+ if (censor_revprops
+ && !(strcmp(name, SVN_PROP_REVISION_AUTHOR) == 0
+ || strcmp(name, SVN_PROP_REVISION_DATE) == 0))
+ /* ... but we can only return author/date. */
+ continue;
+ if (log_entry->revprops == NULL)
+ log_entry->revprops = svn_hash__make(pool);
+ svn_hash_sets(log_entry->revprops, name, value);
+ }
+ }
+ }
+
+ log_entry->changed_paths = changed_paths;
+ log_entry->changed_paths2 = changed_paths;
+ log_entry->revision = rev;
+
+ return SVN_NO_ERROR;
+}
+
+/* Send a log message for REV to RECEIVER with its RECEIVER_BATON.
+
+ FS is used with REV to fetch the interesting history information,
+ such as changed paths, revprops, etc.
+
+ The detect_changed function is used if either AUTHZ_READ_FUNC is
+ not NULL, or if DISCOVER_CHANGED_PATHS is TRUE. See it for details.
+
+ If DESCENDING_ORDER is true, send child messages in descending order.
+
+ If REVPROPS is NULL, retrieve all revision properties; else, retrieve
+ only the revision properties named by the (const char *) array elements
+ (i.e. retrieve none if the array is empty).
+
+ LOG_TARGET_HISTORY_AS_MERGEINFO, HANDLING_MERGED_REVISION, and
+ NESTED_MERGES are as per the arguments of the same name to DO_LOGS. If
+ HANDLING_MERGED_REVISION is true and *all* changed paths within REV are
+ already represented in LOG_TARGET_HISTORY_AS_MERGEINFO, then don't send
+ the log message for REV. If SUBTRACTIVE_MERGE is true, then REV was
+ reverse merged.
+
+ If HANDLING_MERGED_REVISIONS is FALSE then ignore NESTED_MERGES. Otherwise
+ if NESTED_MERGES is not NULL and REV is contained in it, then don't send
+ the log for REV, otherwise send it normally and add REV to
+ NESTED_MERGES. */
+static svn_error_t *
+send_log(svn_revnum_t rev,
+ svn_fs_t *fs,
+ apr_hash_t *prefetched_changes,
+ svn_mergeinfo_t log_target_history_as_mergeinfo,
+ apr_hash_t *nested_merges,
+ svn_boolean_t discover_changed_paths,
+ svn_boolean_t subtractive_merge,
+ svn_boolean_t handling_merged_revision,
+ const apr_array_header_t *revprops,
+ svn_boolean_t has_children,
+ svn_log_entry_receiver_t receiver,
+ void *receiver_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ svn_log_entry_t *log_entry;
+ /* Assume we want to send the log for REV. */
+ svn_boolean_t found_rev_of_interest = TRUE;
+
+ log_entry = svn_log_entry_create(pool);
+ SVN_ERR(fill_log_entry(log_entry, rev, fs, prefetched_changes,
+ discover_changed_paths || handling_merged_revision,
+ revprops, authz_read_func, authz_read_baton,
+ pool));
+ log_entry->has_children = has_children;
+ log_entry->subtractive_merge = subtractive_merge;
+
+ /* Is REV a merged revision that is already part of
+ LOG_TARGET_HISTORY_AS_MERGEINFO? If so then there is no
+ need to send it, since it already was (or will be) sent. */
+ if (handling_merged_revision
+ && log_entry->changed_paths2
+ && log_target_history_as_mergeinfo
+ && apr_hash_count(log_target_history_as_mergeinfo))
+ {
+ apr_hash_index_t *hi;
+ apr_pool_t *subpool = svn_pool_create(pool);
+
+ /* REV was merged in, but it might already be part of the log target's
+ natural history, so change our starting assumption. */
+ found_rev_of_interest = FALSE;
+
+ /* Look at each changed path in REV. */
+ for (hi = apr_hash_first(subpool, log_entry->changed_paths2);
+ hi;
+ hi = apr_hash_next(hi))
+ {
+ svn_boolean_t path_is_in_history = FALSE;
+ const char *changed_path = svn__apr_hash_index_key(hi);
+ apr_hash_index_t *hi2;
+ apr_pool_t *inner_subpool = svn_pool_create(subpool);
+
+ /* Look at each path on the log target's mergeinfo. */
+ for (hi2 = apr_hash_first(inner_subpool,
+ log_target_history_as_mergeinfo);
+ hi2;
+ hi2 = apr_hash_next(hi2))
+ {
+ const char *mergeinfo_path =
+ svn__apr_hash_index_key(hi2);
+ svn_rangelist_t *rangelist =
+ svn__apr_hash_index_val(hi2);
+
+ /* Check whether CHANGED_PATH at revision REV is a child of
+ a (path, revision) tuple in LOG_TARGET_HISTORY_AS_MERGEINFO. */
+ if (svn_fspath__skip_ancestor(mergeinfo_path, changed_path))
+ {
+ int i;
+
+ for (i = 0; i < rangelist->nelts; i++)
+ {
+ svn_merge_range_t *range =
+ APR_ARRAY_IDX(rangelist, i,
+ svn_merge_range_t *);
+ if (rev > range->start && rev <= range->end)
+ {
+ path_is_in_history = TRUE;
+ break;
+ }
+ }
+ }
+ if (path_is_in_history)
+ break;
+ }
+ svn_pool_destroy(inner_subpool);
+
+ if (!path_is_in_history)
+ {
+ /* If even one path in LOG_ENTRY->CHANGED_PATHS2 is not part of
+ LOG_TARGET_HISTORY_AS_MERGEINFO, then we want to send the
+ log for REV. */
+ found_rev_of_interest = TRUE;
+ break;
+ }
+ }
+ svn_pool_destroy(subpool);
+ }
+
+ /* If we only got changed paths the sake of detecting redundant merged
+ revisions, then be sure we don't send that info to the receiver. */
+ if (!discover_changed_paths && handling_merged_revision)
+ log_entry->changed_paths = log_entry->changed_paths2 = NULL;
+
+ /* Send the entry to the receiver, unless it is a redundant merged
+ revision. */
+ if (found_rev_of_interest)
+ {
+ /* Is REV a merged revision we've already sent? */
+ if (nested_merges && handling_merged_revision)
+ {
+ svn_revnum_t *merged_rev = apr_hash_get(nested_merges, &rev,
+ sizeof(svn_revnum_t *));
+
+ if (merged_rev)
+ {
+ /* We already sent REV. */
+ return SVN_NO_ERROR;
+ }
+ else
+ {
+ /* NESTED_REVS needs to last across all the send_log, do_logs,
+ handle_merged_revisions() recursions, so use the pool it
+ was created in at the top of the recursion. */
+ apr_pool_t *hash_pool = apr_hash_pool_get(nested_merges);
+ svn_revnum_t *long_lived_rev = apr_palloc(hash_pool,
+ sizeof(svn_revnum_t));
+ *long_lived_rev = rev;
+ apr_hash_set(nested_merges, long_lived_rev,
+ sizeof(svn_revnum_t *), long_lived_rev);
+ }
+ }
+
+ return (*receiver)(receiver_baton, log_entry, pool);
+ }
+ else
+ {
+ return SVN_NO_ERROR;
+ }
+}
+
+/* This controls how many history objects we keep open. For any targets
+ over this number we have to open and close their histories as needed,
+ which is CPU intensive, but keeps us from using an unbounded amount of
+ memory. */
+#define MAX_OPEN_HISTORIES 32
+
+/* Get the histories for PATHS, and store them in *HISTORIES.
+
+ If IGNORE_MISSING_LOCATIONS is set, don't treat requests for bogus
+ repository locations as fatal -- just ignore them. */
+static svn_error_t *
+get_path_histories(apr_array_header_t **histories,
+ svn_fs_t *fs,
+ const apr_array_header_t *paths,
+ svn_revnum_t hist_start,
+ svn_revnum_t hist_end,
+ svn_boolean_t strict_node_history,
+ svn_boolean_t ignore_missing_locations,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ svn_fs_root_t *root;
+ apr_pool_t *iterpool;
+ svn_error_t *err;
+ int i;
+
+ /* Create a history object for each path so we can walk through
+ them all at the same time until we have all changes or LIMIT
+ is reached.
+
+ There is some pool fun going on due to the fact that we have
+ to hold on to the old pool with the history before we can
+ get the next history.
+ */
+ *histories = apr_array_make(pool, paths->nelts,
+ sizeof(struct path_info *));
+
+ SVN_ERR(svn_fs_revision_root(&root, fs, hist_end, pool));
+
+ iterpool = svn_pool_create(pool);
+ for (i = 0; i < paths->nelts; i++)
+ {
+ const char *this_path = APR_ARRAY_IDX(paths, i, const char *);
+ struct path_info *info = apr_palloc(pool,
+ sizeof(struct path_info));
+
+ if (authz_read_func)
+ {
+ svn_boolean_t readable;
+
+ svn_pool_clear(iterpool);
+
+ SVN_ERR(authz_read_func(&readable, root, this_path,
+ authz_read_baton, iterpool));
+ if (! readable)
+ return svn_error_create(SVN_ERR_AUTHZ_UNREADABLE, NULL, NULL);
+ }
+
+ info->path = svn_stringbuf_create(this_path, pool);
+ info->done = FALSE;
+ info->history_rev = hist_end;
+ info->first_time = TRUE;
+
+ if (i < MAX_OPEN_HISTORIES)
+ {
+ err = svn_fs_node_history(&info->hist, root, this_path, pool);
+ if (err
+ && ignore_missing_locations
+ && (err->apr_err == SVN_ERR_FS_NOT_FOUND ||
+ err->apr_err == SVN_ERR_FS_NOT_DIRECTORY ||
+ err->apr_err == SVN_ERR_FS_NO_SUCH_REVISION))
+ {
+ svn_error_clear(err);
+ continue;
+ }
+ SVN_ERR(err);
+ info->newpool = svn_pool_create(pool);
+ info->oldpool = svn_pool_create(pool);
+ }
+ else
+ {
+ info->hist = NULL;
+ info->oldpool = NULL;
+ info->newpool = NULL;
+ }
+
+ err = get_history(info, fs,
+ strict_node_history,
+ authz_read_func, authz_read_baton,
+ hist_start, pool);
+ if (err
+ && ignore_missing_locations
+ && (err->apr_err == SVN_ERR_FS_NOT_FOUND ||
+ err->apr_err == SVN_ERR_FS_NOT_DIRECTORY ||
+ err->apr_err == SVN_ERR_FS_NO_SUCH_REVISION))
+ {
+ svn_error_clear(err);
+ continue;
+ }
+ SVN_ERR(err);
+ APR_ARRAY_PUSH(*histories, struct path_info *) = info;
+ }
+ svn_pool_destroy(iterpool);
+
+ return SVN_NO_ERROR;
+}
+
+/* Remove and return the first item from ARR. */
+static void *
+array_pop_front(apr_array_header_t *arr)
+{
+ void *item = arr->elts;
+
+ if (apr_is_empty_array(arr))
+ return NULL;
+
+ arr->elts += arr->elt_size;
+ arr->nelts -= 1;
+ arr->nalloc -= 1;
+ return item;
+}
+
+/* A struct which represents a single revision range, and the paths which
+ have mergeinfo in that range. */
+struct path_list_range
+{
+ apr_array_header_t *paths;
+ svn_merge_range_t range;
+
+ /* Is RANGE the result of a reverse merge? */
+ svn_boolean_t reverse_merge;
+};
+
+/* A struct which represents "inverse mergeinfo", that is, instead of having
+ a path->revision_range_list mapping, which is the way mergeinfo is commonly
+ represented, this struct enables a revision_range_list,path tuple, where
+ the paths can be accessed by revision. */
+struct rangelist_path
+{
+ svn_rangelist_t *rangelist;
+ const char *path;
+};
+
+/* Comparator function for combine_mergeinfo_path_lists(). Sorts
+ rangelist_path structs in increasing order based upon starting revision,
+ then ending revision of the first element in the rangelist.
+
+ This does not sort rangelists based upon subsequent elements, only the
+ first range. We'll sort any subsequent ranges in the correct order
+ when they get bumped up to the front by removal of earlier ones, so we
+ don't really have to sort them here. See combine_mergeinfo_path_lists()
+ for details. */
+static int
+compare_rangelist_paths(const void *a, const void *b)
+{
+ struct rangelist_path *rpa = *((struct rangelist_path *const *) a);
+ struct rangelist_path *rpb = *((struct rangelist_path *const *) b);
+ svn_merge_range_t *mra = APR_ARRAY_IDX(rpa->rangelist, 0,
+ svn_merge_range_t *);
+ svn_merge_range_t *mrb = APR_ARRAY_IDX(rpb->rangelist, 0,
+ svn_merge_range_t *);
+
+ if (mra->start < mrb->start)
+ return -1;
+ if (mra->start > mrb->start)
+ return 1;
+ if (mra->end < mrb->end)
+ return -1;
+ if (mra->end > mrb->end)
+ return 1;
+
+ return 0;
+}
+
+/* From MERGEINFO, return in *COMBINED_LIST, allocated in POOL, a list of
+ 'struct path_list_range's. This list represents the rangelists in
+ MERGEINFO and each path which has mergeinfo in that range.
+ If REVERSE_MERGE is true, then MERGEINFO represents mergeinfo removed
+ as the result of a reverse merge. */
+static svn_error_t *
+combine_mergeinfo_path_lists(apr_array_header_t **combined_list,
+ svn_mergeinfo_t mergeinfo,
+ svn_boolean_t reverse_merge,
+ apr_pool_t *pool)
+{
+ apr_hash_index_t *hi;
+ apr_array_header_t *rangelist_paths;
+ apr_pool_t *subpool = svn_pool_create(pool);
+
+ /* Create a list of (revision range, path) tuples from MERGEINFO. */
+ rangelist_paths = apr_array_make(subpool, apr_hash_count(mergeinfo),
+ sizeof(struct rangelist_path *));
+ for (hi = apr_hash_first(subpool, mergeinfo); hi;
+ hi = apr_hash_next(hi))
+ {
+ int i;
+ struct rangelist_path *rp = apr_palloc(subpool, sizeof(*rp));
+ apr_hash_this(hi, (void *) &rp->path, NULL,
+ (void *) &rp->rangelist);
+ APR_ARRAY_PUSH(rangelist_paths, struct rangelist_path *) = rp;
+
+ /* We need to make local copies of the rangelist, since we will be
+ modifying it, below. */
+ rp->rangelist = svn_rangelist_dup(rp->rangelist, subpool);
+
+ /* Make all of the rangelists inclusive, both start and end. */
+ for (i = 0; i < rp->rangelist->nelts; i++)
+ APR_ARRAY_IDX(rp->rangelist, i, svn_merge_range_t *)->start += 1;
+ }
+
+ /* Loop over the (revision range, path) tuples, chopping them into
+ (revision range, paths) tuples, and appending those to the output
+ list. */
+ if (! *combined_list)
+ *combined_list = apr_array_make(pool, 0, sizeof(struct path_list_range *));
+
+ while (rangelist_paths->nelts > 1)
+ {
+ svn_revnum_t youngest, next_youngest, tail, youngest_end;
+ struct path_list_range *plr;
+ struct rangelist_path *rp;
+ int num_revs;
+ int i;
+
+ /* First, sort the list such that the start revision of the first
+ revision arrays are sorted. */
+ qsort(rangelist_paths->elts, rangelist_paths->nelts,
+ rangelist_paths->elt_size, compare_rangelist_paths);
+
+ /* Next, find the number of revision ranges which start with the same
+ revision. */
+ rp = APR_ARRAY_IDX(rangelist_paths, 0, struct rangelist_path *);
+ youngest =
+ APR_ARRAY_IDX(rp->rangelist, 0, struct svn_merge_range_t *)->start;
+ next_youngest = youngest;
+ for (num_revs = 1; next_youngest == youngest; num_revs++)
+ {
+ if (num_revs == rangelist_paths->nelts)
+ {
+ num_revs += 1;
+ break;
+ }
+ rp = APR_ARRAY_IDX(rangelist_paths, num_revs,
+ struct rangelist_path *);
+ next_youngest = APR_ARRAY_IDX(rp->rangelist, 0,
+ struct svn_merge_range_t *)->start;
+ }
+ num_revs -= 1;
+
+ /* The start of the new range will be YOUNGEST, and we now find the end
+ of the new range, which should be either one less than the next
+ earliest start of a rangelist, or the end of the first rangelist. */
+ youngest_end =
+ APR_ARRAY_IDX(APR_ARRAY_IDX(rangelist_paths, 0,
+ struct rangelist_path *)->rangelist,
+ 0, svn_merge_range_t *)->end;
+ if ( (next_youngest == youngest) || (youngest_end < next_youngest) )
+ tail = youngest_end;
+ else
+ tail = next_youngest - 1;
+
+ /* Insert the (earliest, tail) tuple into the output list, along with
+ a list of paths which match it. */
+ plr = apr_palloc(pool, sizeof(*plr));
+ plr->reverse_merge = reverse_merge;
+ plr->range.start = youngest;
+ plr->range.end = tail;
+ plr->paths = apr_array_make(pool, num_revs, sizeof(const char *));
+ for (i = 0; i < num_revs; i++)
+ APR_ARRAY_PUSH(plr->paths, const char *) =
+ APR_ARRAY_IDX(rangelist_paths, i, struct rangelist_path *)->path;
+ APR_ARRAY_PUSH(*combined_list, struct path_list_range *) = plr;
+
+ /* Now, check to see which (rangelist path) combinations we can remove,
+ and do so. */
+ for (i = 0; i < num_revs; i++)
+ {
+ svn_merge_range_t *range;
+ rp = APR_ARRAY_IDX(rangelist_paths, i, struct rangelist_path *);
+ range = APR_ARRAY_IDX(rp->rangelist, 0, svn_merge_range_t *);
+
+ /* Set the start of the range to beyond the end of the range we
+ just built. If the range is now "inverted", we can get pop it
+ off the list. */
+ range->start = tail + 1;
+ if (range->start > range->end)
+ {
+ if (rp->rangelist->nelts == 1)
+ {
+ /* The range is the only on its list, so we should remove
+ the entire rangelist_path, adjusting our loop control
+ variables appropriately. */
+ array_pop_front(rangelist_paths);
+ i--;
+ num_revs--;
+ }
+ else
+ {
+ /* We have more than one range on the list, so just remove
+ the first one. */
+ array_pop_front(rp->rangelist);
+ }
+ }
+ }
+ }
+
+ /* Finally, add the last remaining (revision range, path) to the output
+ list. */
+ if (rangelist_paths->nelts > 0)
+ {
+ struct rangelist_path *first_rp =
+ APR_ARRAY_IDX(rangelist_paths, 0, struct rangelist_path *);
+ while (first_rp->rangelist->nelts > 0)
+ {
+ struct path_list_range *plr = apr_palloc(pool, sizeof(*plr));
+
+ plr->reverse_merge = reverse_merge;
+ plr->paths = apr_array_make(pool, 1, sizeof(const char *));
+ APR_ARRAY_PUSH(plr->paths, const char *) = first_rp->path;
+ plr->range = *APR_ARRAY_IDX(first_rp->rangelist, 0,
+ svn_merge_range_t *);
+ array_pop_front(first_rp->rangelist);
+ APR_ARRAY_PUSH(*combined_list, struct path_list_range *) = plr;
+ }
+ }
+
+ svn_pool_destroy(subpool);
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Pity that C is so ... linear. */
+static svn_error_t *
+do_logs(svn_fs_t *fs,
+ const apr_array_header_t *paths,
+ svn_mergeinfo_t log_target_history_as_mergeinfo,
+ svn_mergeinfo_t processed,
+ apr_hash_t *nested_merges,
+ svn_revnum_t hist_start,
+ svn_revnum_t hist_end,
+ int limit,
+ svn_boolean_t discover_changed_paths,
+ svn_boolean_t strict_node_history,
+ svn_boolean_t include_merged_revisions,
+ svn_boolean_t handling_merged_revisions,
+ svn_boolean_t subtractive_merge,
+ svn_boolean_t ignore_missing_locations,
+ const apr_array_header_t *revprops,
+ svn_boolean_t descending_order,
+ svn_log_entry_receiver_t receiver,
+ void *receiver_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool);
+
+/* Comparator function for handle_merged_revisions(). Sorts path_list_range
+ structs in increasing order based on the struct's RANGE.START revision,
+ then RANGE.END revision. */
+static int
+compare_path_list_range(const void *a, const void *b)
+{
+ struct path_list_range *plr_a = *((struct path_list_range *const *) a);
+ struct path_list_range *plr_b = *((struct path_list_range *const *) b);
+
+ if (plr_a->range.start < plr_b->range.start)
+ return -1;
+ if (plr_a->range.start > plr_b->range.start)
+ return 1;
+ if (plr_a->range.end < plr_b->range.end)
+ return -1;
+ if (plr_a->range.end > plr_b->range.end)
+ return 1;
+
+ return 0;
+}
+
+/* Examine the ADDED_MERGEINFO and DELETED_MERGEINFO for revision REV in FS
+ (as collected by examining paths of interest to a log operation), and
+ determine which revisions to report as having been merged or reverse-merged
+ via the commit resulting in REV.
+
+ Silently ignore some failures to find the revisions mentioned in the
+ added/deleted mergeinfos, as might happen if there is invalid mergeinfo.
+
+ Other parameters are as described by do_logs(), around which this
+ is a recursion wrapper. */
+static svn_error_t *
+handle_merged_revisions(svn_revnum_t rev,
+ svn_fs_t *fs,
+ svn_mergeinfo_t log_target_history_as_mergeinfo,
+ apr_hash_t *nested_merges,
+ svn_mergeinfo_t processed,
+ svn_mergeinfo_t added_mergeinfo,
+ svn_mergeinfo_t deleted_mergeinfo,
+ svn_boolean_t discover_changed_paths,
+ svn_boolean_t strict_node_history,
+ const apr_array_header_t *revprops,
+ svn_log_entry_receiver_t receiver,
+ void *receiver_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ apr_array_header_t *combined_list = NULL;
+ svn_log_entry_t *empty_log_entry;
+ apr_pool_t *iterpool;
+ int i;
+
+ if (apr_hash_count(added_mergeinfo) == 0
+ && apr_hash_count(deleted_mergeinfo) == 0)
+ return SVN_NO_ERROR;
+
+ if (apr_hash_count(added_mergeinfo))
+ SVN_ERR(combine_mergeinfo_path_lists(&combined_list, added_mergeinfo,
+ FALSE, pool));
+
+ if (apr_hash_count(deleted_mergeinfo))
+ SVN_ERR(combine_mergeinfo_path_lists(&combined_list, deleted_mergeinfo,
+ TRUE, pool));
+
+ SVN_ERR_ASSERT(combined_list != NULL);
+ qsort(combined_list->elts, combined_list->nelts,
+ combined_list->elt_size, compare_path_list_range);
+
+ /* Because the combined_lists are ordered youngest to oldest,
+ iterate over them in reverse. */
+ iterpool = svn_pool_create(pool);
+ for (i = combined_list->nelts - 1; i >= 0; i--)
+ {
+ struct path_list_range *pl_range
+ = APR_ARRAY_IDX(combined_list, i, struct path_list_range *);
+
+ svn_pool_clear(iterpool);
+ SVN_ERR(do_logs(fs, pl_range->paths, log_target_history_as_mergeinfo,
+ processed, nested_merges,
+ pl_range->range.start, pl_range->range.end, 0,
+ discover_changed_paths, strict_node_history,
+ TRUE, pl_range->reverse_merge, TRUE, TRUE,
+ revprops, TRUE, receiver, receiver_baton,
+ authz_read_func, authz_read_baton, iterpool));
+ }
+ svn_pool_destroy(iterpool);
+
+ /* Send the empty revision. */
+ empty_log_entry = svn_log_entry_create(pool);
+ empty_log_entry->revision = SVN_INVALID_REVNUM;
+ return (*receiver)(receiver_baton, empty_log_entry, pool);
+}
+
+/* This is used by do_logs to differentiate between forward and
+ reverse merges. */
+struct added_deleted_mergeinfo
+{
+ svn_mergeinfo_t added_mergeinfo;
+ svn_mergeinfo_t deleted_mergeinfo;
+};
+
+/* Reduce the search range PATHS, HIST_START, HIST_END by removing
+ parts already covered by PROCESSED. If reduction is possible
+ elements may be removed from PATHS and *START_REDUCED and
+ *END_REDUCED may be set to a narrower range. */
+static svn_error_t *
+reduce_search(apr_array_header_t *paths,
+ svn_revnum_t *hist_start,
+ svn_revnum_t *hist_end,
+ svn_mergeinfo_t processed,
+ apr_pool_t *scratch_pool)
+{
+ /* We add 1 to end to compensate for store_search */
+ svn_revnum_t start = *hist_start <= *hist_end ? *hist_start : *hist_end;
+ svn_revnum_t end = *hist_start <= *hist_end ? *hist_end + 1 : *hist_start + 1;
+ int i;
+
+ for (i = 0; i < paths->nelts; ++i)
+ {
+ const char *path = APR_ARRAY_IDX(paths, i, const char *);
+ svn_rangelist_t *ranges = svn_hash_gets(processed, path);
+ int j;
+
+ if (!ranges)
+ continue;
+
+ /* ranges is ordered, could we use some sort of binary search
+ rather than iterating? */
+ for (j = 0; j < ranges->nelts; ++j)
+ {
+ svn_merge_range_t *range = APR_ARRAY_IDX(ranges, j,
+ svn_merge_range_t *);
+ if (range->start <= start && range->end >= end)
+ {
+ for (j = i; j < paths->nelts - 1; ++j)
+ APR_ARRAY_IDX(paths, j, const char *)
+ = APR_ARRAY_IDX(paths, j + 1, const char *);
+
+ --paths->nelts;
+ --i;
+ break;
+ }
+
+ /* If there is only one path then we also check for a
+ partial overlap rather than the full overlap above, and
+ reduce the [hist_start, hist_end] range rather than
+ dropping the path. */
+ if (paths->nelts == 1)
+ {
+ if (range->start <= start && range->end > start)
+ {
+ if (start == *hist_start)
+ *hist_start = range->end - 1;
+ else
+ *hist_end = range->end - 1;
+ break;
+ }
+ if (range->start < end && range->end >= end)
+ {
+ if (start == *hist_start)
+ *hist_end = range->start;
+ else
+ *hist_start = range->start;
+ break;
+ }
+ }
+ }
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Extend PROCESSED to cover PATHS from HIST_START to HIST_END */
+static svn_error_t *
+store_search(svn_mergeinfo_t processed,
+ const apr_array_header_t *paths,
+ svn_revnum_t hist_start,
+ svn_revnum_t hist_end,
+ apr_pool_t *scratch_pool)
+{
+ /* We add 1 to end so that we can use the mergeinfo API to handle
+ singe revisions where HIST_START is equal to HIST_END. */
+ svn_revnum_t start = hist_start <= hist_end ? hist_start : hist_end;
+ svn_revnum_t end = hist_start <= hist_end ? hist_end + 1 : hist_start + 1;
+ svn_mergeinfo_t mergeinfo = svn_hash__make(scratch_pool);
+ apr_pool_t *processed_pool = apr_hash_pool_get(processed);
+ int i;
+
+ for (i = 0; i < paths->nelts; ++i)
+ {
+ const char *path = APR_ARRAY_IDX(paths, i, const char *);
+ svn_rangelist_t *ranges = apr_array_make(processed_pool, 1,
+ sizeof(svn_merge_range_t*));
+ svn_merge_range_t *range = apr_palloc(processed_pool,
+ sizeof(svn_merge_range_t));
+
+ range->start = start;
+ range->end = end;
+ range->inheritable = TRUE;
+ APR_ARRAY_PUSH(ranges, svn_merge_range_t *) = range;
+ svn_hash_sets(mergeinfo, apr_pstrdup(processed_pool, path), ranges);
+ }
+ SVN_ERR(svn_mergeinfo_merge2(processed, mergeinfo,
+ apr_hash_pool_get(processed), scratch_pool));
+
+ return SVN_NO_ERROR;
+}
+
+/* Find logs for PATHS from HIST_START to HIST_END in FS, and invoke
+ RECEIVER with RECEIVER_BATON on them. If DESCENDING_ORDER is TRUE, send
+ the logs back as we find them, else buffer the logs and send them back
+ in youngest->oldest order.
+
+ If IGNORE_MISSING_LOCATIONS is set, don't treat requests for bogus
+ repository locations as fatal -- just ignore them.
+
+ If LOG_TARGET_HISTORY_AS_MERGEINFO is not NULL then it contains mergeinfo
+ representing the history of PATHS between HIST_START and HIST_END.
+
+ If HANDLING_MERGED_REVISIONS is TRUE then this is a recursive call for
+ merged revisions, see INCLUDE_MERGED_REVISIONS argument to
+ svn_repos_get_logs4(). If SUBTRACTIVE_MERGE is true, then this is a
+ recursive call for reverse merged revisions.
+
+ If NESTED_MERGES is not NULL then it is a hash of revisions (svn_revnum_t *
+ mapped to svn_revnum_t *) for logs that were previously sent. On the first
+ call to do_logs it should always be NULL. If INCLUDE_MERGED_REVISIONS is
+ TRUE, then NESTED_MERGES will be created on the first call to do_logs,
+ allocated in POOL. It is then shared across
+ do_logs()/send_logs()/handle_merge_revisions() recursions, see also the
+ argument of the same name in send_logs().
+
+ PROCESSED is a mergeinfo hash that represents the paths and
+ revisions that have already been searched. Allocated like
+ NESTED_MERGES above.
+
+ All other parameters are the same as svn_repos_get_logs4().
+ */
+static svn_error_t *
+do_logs(svn_fs_t *fs,
+ const apr_array_header_t *paths,
+ svn_mergeinfo_t log_target_history_as_mergeinfo,
+ svn_mergeinfo_t processed,
+ apr_hash_t *nested_merges,
+ svn_revnum_t hist_start,
+ svn_revnum_t hist_end,
+ int limit,
+ svn_boolean_t discover_changed_paths,
+ svn_boolean_t strict_node_history,
+ svn_boolean_t include_merged_revisions,
+ svn_boolean_t subtractive_merge,
+ svn_boolean_t handling_merged_revisions,
+ svn_boolean_t ignore_missing_locations,
+ const apr_array_header_t *revprops,
+ svn_boolean_t descending_order,
+ svn_log_entry_receiver_t receiver,
+ void *receiver_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+ apr_pool_t *iterpool;
+ apr_pool_t *subpool = NULL;
+ apr_array_header_t *revs = NULL;
+ apr_hash_t *rev_mergeinfo = NULL;
+ svn_revnum_t current;
+ apr_array_header_t *histories;
+ svn_boolean_t any_histories_left = TRUE;
+ int send_count = 0;
+ int i;
+
+ if (processed)
+ {
+ /* Casting away const. This only happens on recursive calls when
+ it is known to be safe because we allocated paths. */
+ SVN_ERR(reduce_search((apr_array_header_t *)paths, &hist_start, &hist_end,
+ processed, pool));
+ }
+
+ if (!paths->nelts)
+ return SVN_NO_ERROR;
+
+ if (processed)
+ SVN_ERR(store_search(processed, paths, hist_start, hist_end, pool));
+
+ /* We have a list of paths and a revision range. But we don't care
+ about all the revisions in the range -- only the ones in which
+ one of our paths was changed. So let's go figure out which
+ revisions contain real changes to at least one of our paths. */
+ SVN_ERR(get_path_histories(&histories, fs, paths, hist_start, hist_end,
+ strict_node_history, ignore_missing_locations,
+ authz_read_func, authz_read_baton, pool));
+
+ /* Loop through all the revisions in the range and add any
+ where a path was changed to the array, or if they wanted
+ history in reverse order just send it to them right away. */
+ iterpool = svn_pool_create(pool);
+ for (current = hist_end;
+ any_histories_left;
+ current = next_history_rev(histories))
+ {
+ svn_boolean_t changed = FALSE;
+ any_histories_left = FALSE;
+ svn_pool_clear(iterpool);
+
+ for (i = 0; i < histories->nelts; i++)
+ {
+ struct path_info *info = APR_ARRAY_IDX(histories, i,
+ struct path_info *);
+
+ /* Check history for this path in current rev. */
+ SVN_ERR(check_history(&changed, info, fs, current,
+ strict_node_history, authz_read_func,
+ authz_read_baton, hist_start, pool));
+ if (! info->done)
+ any_histories_left = TRUE;
+ }
+
+ /* If any of the paths changed in this rev then add or send it. */
+ if (changed)
+ {
+ svn_mergeinfo_t added_mergeinfo = NULL;
+ svn_mergeinfo_t deleted_mergeinfo = NULL;
+ svn_boolean_t has_children = FALSE;
+ apr_hash_t *changes = NULL;
+
+ /* If we're including merged revisions, we need to calculate
+ the mergeinfo deltas committed in this revision to our
+ various paths. */
+ if (include_merged_revisions)
+ {
+ apr_array_header_t *cur_paths =
+ apr_array_make(iterpool, paths->nelts, sizeof(const char *));
+
+ /* Get the current paths of our history objects so we can
+ query mergeinfo. */
+ /* ### TODO: Should this be ignoring depleted history items? */
+ for (i = 0; i < histories->nelts; i++)
+ {
+ struct path_info *info = APR_ARRAY_IDX(histories, i,
+ struct path_info *);
+ APR_ARRAY_PUSH(cur_paths, const char *) = info->path->data;
+ }
+ SVN_ERR(get_combined_mergeinfo_changes(&added_mergeinfo,
+ &deleted_mergeinfo,
+ &changes,
+ fs, cur_paths,
+ current, iterpool,
+ iterpool));
+ has_children = (apr_hash_count(added_mergeinfo) > 0
+ || apr_hash_count(deleted_mergeinfo) > 0);
+ }
+
+ /* If our caller wants logs in descending order, we can send
+ 'em now (because that's the order we're crawling history
+ in anyway). */
+ if (descending_order)
+ {
+ SVN_ERR(send_log(current, fs, changes,
+ log_target_history_as_mergeinfo, nested_merges,
+ discover_changed_paths,
+ subtractive_merge, handling_merged_revisions,
+ revprops, has_children,
+ receiver, receiver_baton,
+ authz_read_func, authz_read_baton, iterpool));
+
+ if (has_children) /* Implies include_merged_revisions == TRUE */
+ {
+ if (!nested_merges)
+ {
+ /* We're at the start of the recursion stack, create a
+ single hash to be shared across all of the merged
+ recursions so we can track and squelch duplicates. */
+ subpool = svn_pool_create(pool);
+ nested_merges = svn_hash__make(subpool);
+ processed = svn_hash__make(subpool);
+ }
+
+ SVN_ERR(handle_merged_revisions(
+ current, fs,
+ log_target_history_as_mergeinfo, nested_merges,
+ processed,
+ added_mergeinfo, deleted_mergeinfo,
+ discover_changed_paths,
+ strict_node_history,
+ revprops,
+ receiver, receiver_baton,
+ authz_read_func,
+ authz_read_baton,
+ iterpool));
+ }
+ if (limit && ++send_count >= limit)
+ break;
+ }
+ /* Otherwise, the caller wanted logs in ascending order, so
+ we have to buffer up a list of revs and (if doing
+ mergeinfo) a hash of related mergeinfo deltas, and
+ process them later. */
+ else
+ {
+ if (! revs)
+ revs = apr_array_make(pool, 64, sizeof(svn_revnum_t));
+ APR_ARRAY_PUSH(revs, svn_revnum_t) = current;
+
+ if (added_mergeinfo || deleted_mergeinfo)
+ {
+ svn_revnum_t *cur_rev = apr_pcalloc(pool, sizeof(*cur_rev));
+ struct added_deleted_mergeinfo *add_and_del_mergeinfo =
+ apr_palloc(pool, sizeof(*add_and_del_mergeinfo));
+
+ if (added_mergeinfo)
+ add_and_del_mergeinfo->added_mergeinfo =
+ svn_mergeinfo_dup(added_mergeinfo, pool);
+
+ if (deleted_mergeinfo)
+ add_and_del_mergeinfo->deleted_mergeinfo =
+ svn_mergeinfo_dup(deleted_mergeinfo, pool);
+
+ *cur_rev = current;
+ if (! rev_mergeinfo)
+ rev_mergeinfo = svn_hash__make(pool);
+ apr_hash_set(rev_mergeinfo, cur_rev, sizeof(*cur_rev),
+ add_and_del_mergeinfo);
+ }
+ }
+ }
+ }
+ svn_pool_destroy(iterpool);
+
+ if (subpool)
+ {
+ nested_merges = NULL;
+ svn_pool_destroy(subpool);
+ }
+
+ if (revs)
+ {
+ /* Work loop for processing the revisions we found since they wanted
+ history in forward order. */
+ iterpool = svn_pool_create(pool);
+ for (i = 0; i < revs->nelts; ++i)
+ {
+ svn_mergeinfo_t added_mergeinfo;
+ svn_mergeinfo_t deleted_mergeinfo;
+ svn_boolean_t has_children = FALSE;
+
+ svn_pool_clear(iterpool);
+ current = APR_ARRAY_IDX(revs, revs->nelts - i - 1, svn_revnum_t);
+
+ /* If we've got a hash of revision mergeinfo (which can only
+ happen if INCLUDE_MERGED_REVISIONS was set), we check to
+ see if this revision is one which merged in other
+ revisions we need to handle recursively. */
+ if (rev_mergeinfo)
+ {
+ struct added_deleted_mergeinfo *add_and_del_mergeinfo =
+ apr_hash_get(rev_mergeinfo, &current, sizeof(svn_revnum_t));
+ added_mergeinfo = add_and_del_mergeinfo->added_mergeinfo;
+ deleted_mergeinfo = add_and_del_mergeinfo->deleted_mergeinfo;
+ has_children = (apr_hash_count(added_mergeinfo) > 0
+ || apr_hash_count(deleted_mergeinfo) > 0);
+ }
+
+ SVN_ERR(send_log(current, fs, NULL,
+ log_target_history_as_mergeinfo, nested_merges,
+ discover_changed_paths, subtractive_merge,
+ handling_merged_revisions, revprops, has_children,
+ receiver, receiver_baton, authz_read_func,
+ authz_read_baton, iterpool));
+ if (has_children)
+ {
+ if (!nested_merges)
+ {
+ subpool = svn_pool_create(pool);
+ nested_merges = svn_hash__make(subpool);
+ }
+
+ SVN_ERR(handle_merged_revisions(current, fs,
+ log_target_history_as_mergeinfo,
+ nested_merges,
+ processed,
+ added_mergeinfo,
+ deleted_mergeinfo,
+ discover_changed_paths,
+ strict_node_history, revprops,
+ receiver, receiver_baton,
+ authz_read_func,
+ authz_read_baton,
+ iterpool));
+ }
+ if (limit && i + 1 >= limit)
+ break;
+ }
+ svn_pool_destroy(iterpool);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+struct location_segment_baton
+{
+ apr_array_header_t *history_segments;
+ apr_pool_t *pool;
+};
+
+/* svn_location_segment_receiver_t implementation for svn_repos_get_logs4. */
+static svn_error_t *
+location_segment_receiver(svn_location_segment_t *segment,
+ void *baton,
+ apr_pool_t *pool)
+{
+ struct location_segment_baton *b = baton;
+
+ APR_ARRAY_PUSH(b->history_segments, svn_location_segment_t *) =
+ svn_location_segment_dup(segment, b->pool);
+
+ return SVN_NO_ERROR;
+}
+
+
+/* Populate *PATHS_HISTORY_MERGEINFO with mergeinfo representing the combined
+ history of each path in PATHS between START_REV and END_REV in REPOS's
+ filesystem. START_REV and END_REV must be valid revisions. RESULT_POOL
+ is used to allocate *PATHS_HISTORY_MERGEINFO, SCRATCH_POOL is used for all
+ other (temporary) allocations. Other parameters are the same as
+ svn_repos_get_logs4(). */
+static svn_error_t *
+get_paths_history_as_mergeinfo(svn_mergeinfo_t *paths_history_mergeinfo,
+ svn_repos_t *repos,
+ const apr_array_header_t *paths,
+ svn_revnum_t start_rev,
+ svn_revnum_t end_rev,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ int i;
+ svn_mergeinfo_t path_history_mergeinfo;
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+
+ SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(start_rev));
+ SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(end_rev));
+
+ /* Ensure START_REV is the youngest revision, as required by
+ svn_repos_node_location_segments, for which this is an iterative
+ wrapper. */
+ if (start_rev < end_rev)
+ {
+ svn_revnum_t tmp_rev = start_rev;
+ start_rev = end_rev;
+ end_rev = tmp_rev;
+ }
+
+ *paths_history_mergeinfo = svn_hash__make(result_pool);
+
+ for (i = 0; i < paths->nelts; i++)
+ {
+ const char *this_path = APR_ARRAY_IDX(paths, i, const char *);
+ struct location_segment_baton loc_seg_baton;
+
+ svn_pool_clear(iterpool);
+ loc_seg_baton.pool = scratch_pool;
+ loc_seg_baton.history_segments =
+ apr_array_make(iterpool, 4, sizeof(svn_location_segment_t *));
+
+ SVN_ERR(svn_repos_node_location_segments(repos, this_path, start_rev,
+ start_rev, end_rev,
+ location_segment_receiver,
+ &loc_seg_baton,
+ authz_read_func,
+ authz_read_baton,
+ iterpool));
+
+ SVN_ERR(svn_mergeinfo__mergeinfo_from_segments(
+ &path_history_mergeinfo, loc_seg_baton.history_segments, iterpool));
+ SVN_ERR(svn_mergeinfo_merge2(*paths_history_mergeinfo,
+ svn_mergeinfo_dup(path_history_mergeinfo,
+ result_pool),
+ result_pool, iterpool));
+ }
+ svn_pool_destroy(iterpool);
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_repos_get_logs4(svn_repos_t *repos,
+ const apr_array_header_t *paths,
+ svn_revnum_t start,
+ svn_revnum_t end,
+ int limit,
+ svn_boolean_t discover_changed_paths,
+ svn_boolean_t strict_node_history,
+ svn_boolean_t include_merged_revisions,
+ const apr_array_header_t *revprops,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ svn_log_entry_receiver_t receiver,
+ void *receiver_baton,
+ apr_pool_t *pool)
+{
+ svn_revnum_t head = SVN_INVALID_REVNUM;
+ svn_fs_t *fs = repos->fs;
+ svn_boolean_t descending_order;
+ svn_mergeinfo_t paths_history_mergeinfo = NULL;
+
+ /* Setup log range. */
+ SVN_ERR(svn_fs_youngest_rev(&head, fs, pool));
+
+ if (! SVN_IS_VALID_REVNUM(start))
+ start = head;
+
+ if (! SVN_IS_VALID_REVNUM(end))
+ end = head;
+
+ /* Check that revisions are sane before ever invoking receiver. */
+ if (start > head)
+ return svn_error_createf
+ (SVN_ERR_FS_NO_SUCH_REVISION, 0,
+ _("No such revision %ld"), start);
+ if (end > head)
+ return svn_error_createf
+ (SVN_ERR_FS_NO_SUCH_REVISION, 0,
+ _("No such revision %ld"), end);
+
+ /* Ensure a youngest-to-oldest revision crawl ordering using our
+ (possibly sanitized) range values. */
+ descending_order = start >= end;
+ if (descending_order)
+ {
+ svn_revnum_t tmp_rev = start;
+ start = end;
+ end = tmp_rev;
+ }
+
+ if (! paths)
+ paths = apr_array_make(pool, 0, sizeof(const char *));
+
+ /* If we're not including merged revisions, and we were given no
+ paths or a single empty (or "/") path, then we can bypass a bunch
+ of complexity because we already know in which revisions the root
+ directory was changed -- all of them. */
+ if ((! include_merged_revisions)
+ && ((! paths->nelts)
+ || ((paths->nelts == 1)
+ && (svn_path_is_empty(APR_ARRAY_IDX(paths, 0, const char *))
+ || (strcmp(APR_ARRAY_IDX(paths, 0, const char *),
+ "/") == 0)))))
+ {
+ apr_uint64_t send_count = 0;
+ int i;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+
+ /* If we are provided an authz callback function, use it to
+ verify that the user has read access to the root path in the
+ first of our revisions.
+
+ ### FIXME: Strictly speaking, we should be checking this
+ ### access in every revision along the line. But currently,
+ ### there are no known authz implementations which concern
+ ### themselves with per-revision access. */
+ if (authz_read_func)
+ {
+ svn_boolean_t readable;
+ svn_fs_root_t *rev_root;
+
+ SVN_ERR(svn_fs_revision_root(&rev_root, fs,
+ descending_order ? end : start, pool));
+ SVN_ERR(authz_read_func(&readable, rev_root, "",
+ authz_read_baton, pool));
+ if (! readable)
+ return svn_error_create(SVN_ERR_AUTHZ_UNREADABLE, NULL, NULL);
+ }
+
+ send_count = end - start + 1;
+ if (limit && send_count > limit)
+ send_count = limit;
+ for (i = 0; i < send_count; ++i)
+ {
+ svn_revnum_t rev;
+
+ svn_pool_clear(iterpool);
+
+ if (descending_order)
+ rev = end - i;
+ else
+ rev = start + i;
+ SVN_ERR(send_log(rev, fs, NULL, NULL, NULL,
+ discover_changed_paths, FALSE,
+ FALSE, revprops, FALSE, receiver,
+ receiver_baton, authz_read_func,
+ authz_read_baton, iterpool));
+ }
+ svn_pool_destroy(iterpool);
+
+ return SVN_NO_ERROR;
+ }
+
+ /* If we are including merged revisions, then create mergeinfo that
+ represents all of PATHS' history between START and END. We will use
+ this later to squelch duplicate log revisions that might exist in
+ both natural history and merged-in history. See
+ http://subversion.tigris.org/issues/show_bug.cgi?id=3650#desc5 */
+ if (include_merged_revisions)
+ {
+ apr_pool_t *subpool = svn_pool_create(pool);
+
+ SVN_ERR(get_paths_history_as_mergeinfo(&paths_history_mergeinfo,
+ repos, paths, start, end,
+ authz_read_func,
+ authz_read_baton,
+ pool, subpool));
+ svn_pool_destroy(subpool);
+ }
+
+ return do_logs(repos->fs, paths, paths_history_mergeinfo, NULL, NULL, start, end,
+ limit, discover_changed_paths, strict_node_history,
+ include_merged_revisions, FALSE, FALSE, FALSE, revprops,
+ descending_order, receiver, receiver_baton,
+ authz_read_func, authz_read_baton, pool);
+}
diff --git a/subversion/libsvn_repos/node_tree.c b/subversion/libsvn_repos/node_tree.c
new file mode 100644
index 000000000000..bd947b09210d
--- /dev/null
+++ b/subversion/libsvn_repos/node_tree.c
@@ -0,0 +1,431 @@
+/*
+ * node_tree.c: an editor for tracking repository deltas changes
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+/* ==================================================================== */
+
+
+
+
+#include <stdio.h>
+
+#define APR_WANT_STRFUNC
+#include <apr_want.h>
+#include <apr_pools.h>
+
+#include "svn_types.h"
+#include "svn_error.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_delta.h"
+#include "svn_fs.h"
+#include "svn_repos.h"
+#include "repos.h"
+#include "svn_private_config.h"
+#include "private/svn_fspath.h"
+
+/*** NOTE: This editor is unique in that it currently is hard-coded to
+ be anchored at the root directory of the filesystem. This
+ affords us the ability to use the same paths for filesystem
+ locations and editor paths. ***/
+
+
+
+/*** Node creation and assembly structures and routines. ***/
+static svn_repos_node_t *
+create_node(const char *name,
+ svn_repos_node_t *parent,
+ apr_pool_t *pool)
+{
+ svn_repos_node_t *node = apr_pcalloc(pool, sizeof(*node));
+ node->action = 'R';
+ node->kind = svn_node_unknown;
+ node->name = apr_pstrdup(pool, name);
+ node->parent = parent;
+ return node;
+}
+
+
+static svn_repos_node_t *
+create_sibling_node(svn_repos_node_t *elder,
+ const char *name,
+ apr_pool_t *pool)
+{
+ svn_repos_node_t *tmp_node;
+
+ /* No ELDER sibling? That's just not gonna work out. */
+ if (! elder)
+ return NULL;
+
+ /* Run to the end of the list of siblings of ELDER. */
+ tmp_node = elder;
+ while (tmp_node->sibling)
+ tmp_node = tmp_node->sibling;
+
+ /* Create a new youngest sibling and return that. */
+ return (tmp_node->sibling = create_node(name, elder->parent, pool));
+}
+
+
+static svn_repos_node_t *
+create_child_node(svn_repos_node_t *parent,
+ const char *name,
+ apr_pool_t *pool)
+{
+ /* No PARENT node? That's just not gonna work out. */
+ if (! parent)
+ return NULL;
+
+ /* If PARENT has no children, create its first one and return that. */
+ if (! parent->child)
+ return (parent->child = create_node(name, parent, pool));
+
+ /* If PARENT already has a child, create a new sibling for its first
+ child and return that. */
+ return create_sibling_node(parent->child, name, pool);
+}
+
+
+static svn_repos_node_t *
+find_child_by_name(svn_repos_node_t *parent,
+ const char *name)
+{
+ svn_repos_node_t *tmp_node;
+
+ /* No PARENT node, or a barren PARENT? Nothing to find. */
+ if ((! parent) || (! parent->child))
+ return NULL;
+
+ /* Look through the children for a node with a matching name. */
+ tmp_node = parent->child;
+ while (1)
+ {
+ if (! strcmp(tmp_node->name, name))
+ {
+ return tmp_node;
+ }
+ else
+ {
+ if (tmp_node->sibling)
+ tmp_node = tmp_node->sibling;
+ else
+ break;
+ }
+ }
+
+ return NULL;
+}
+
+
+static void
+find_real_base_location(const char **path_p,
+ svn_revnum_t *rev_p,
+ svn_repos_node_t *node,
+ apr_pool_t *pool)
+{
+ /* If NODE is an add-with-history, then its real base location is
+ the copy source. */
+ if ((node->action == 'A')
+ && node->copyfrom_path
+ && SVN_IS_VALID_REVNUM(node->copyfrom_rev))
+ {
+ *path_p = node->copyfrom_path;
+ *rev_p = node->copyfrom_rev;
+ return;
+ }
+
+ /* Otherwise, if NODE has a parent, we'll recurse, and add NODE's
+ name to whatever the parent's real base path turns out to be (and
+ pass the base revision on through). */
+ if (node->parent)
+ {
+ const char *path;
+ svn_revnum_t rev;
+
+ find_real_base_location(&path, &rev, node->parent, pool);
+ *path_p = svn_fspath__join(path, node->name, pool);
+ *rev_p = rev;
+ return;
+ }
+
+ /* Finally, if the node has no parent, then its name is "/", and it
+ has no interesting base revision. */
+ *path_p = "/";
+ *rev_p = SVN_INVALID_REVNUM;
+ return;
+}
+
+
+
+
+/*** Editor functions and batons. ***/
+
+struct edit_baton
+{
+ svn_fs_t *fs;
+ svn_fs_root_t *root;
+ svn_fs_root_t *base_root;
+ apr_pool_t *node_pool;
+ svn_repos_node_t *node;
+};
+
+
+struct node_baton
+{
+ struct edit_baton *edit_baton;
+ struct node_baton *parent_baton;
+ svn_repos_node_t *node;
+};
+
+
+static svn_error_t *
+delete_entry(const char *path,
+ svn_revnum_t revision,
+ void *parent_baton,
+ apr_pool_t *pool)
+{
+ struct node_baton *d = parent_baton;
+ struct edit_baton *eb = d->edit_baton;
+ svn_repos_node_t *node;
+ const char *name;
+ const char *base_path;
+ svn_revnum_t base_rev;
+ svn_fs_root_t *base_root;
+ svn_node_kind_t kind;
+
+ /* Get (or create) the change node and update it. */
+ name = svn_relpath_basename(path, pool);
+ node = find_child_by_name(d->node, name);
+ if (! node)
+ node = create_child_node(d->node, name, eb->node_pool);
+ node->action = 'D';
+
+ /* We need to look up this node's parents to see what its original
+ path in the filesystem was. Why? Because if this deletion
+ occurred underneath a copied path, the thing that was deleted
+ probably lived at a different location (relative to the copy
+ source). */
+ find_real_base_location(&base_path, &base_rev, node, pool);
+ if (! SVN_IS_VALID_REVNUM(base_rev))
+ {
+ /* No interesting base revision? We'll just look for the path
+ in our base root. */
+ base_root = eb->base_root;
+ }
+ else
+ {
+ /* Oh. Perhaps some copy goodness happened somewhere? */
+ SVN_ERR(svn_fs_revision_root(&base_root, eb->fs, base_rev, pool));
+ }
+
+ /* Now figure out if this thing was a file or a dir. */
+ SVN_ERR(svn_fs_check_path(&kind, base_root, base_path, pool));
+ if (kind == svn_node_none)
+ return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
+ _("'%s' not found in filesystem"), path);
+ node->kind = kind;
+
+ return SVN_NO_ERROR;
+}
+
+
+
+static svn_error_t *
+add_open_helper(const char *path,
+ char action,
+ svn_node_kind_t kind,
+ void *parent_baton,
+ const char *copyfrom_path,
+ svn_revnum_t copyfrom_rev,
+ apr_pool_t *pool,
+ void **child_baton)
+{
+ struct node_baton *pb = parent_baton;
+ struct edit_baton *eb = pb->edit_baton;
+ struct node_baton *nb = apr_pcalloc(pool, sizeof(*nb));
+
+ SVN_ERR_ASSERT(parent_baton && path);
+
+ nb->edit_baton = eb;
+ nb->parent_baton = pb;
+
+ /* Create and populate the node. */
+ nb->node = create_child_node(pb->node, svn_relpath_basename(path, NULL),
+ eb->node_pool);
+ nb->node->kind = kind;
+ nb->node->action = action;
+ nb->node->copyfrom_rev = copyfrom_rev;
+ nb->node->copyfrom_path =
+ copyfrom_path ? apr_pstrdup(eb->node_pool, copyfrom_path) : NULL;
+
+ *child_baton = nb;
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+open_root(void *edit_baton,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool,
+ void **root_baton)
+{
+ struct edit_baton *eb = edit_baton;
+ struct node_baton *d = apr_pcalloc(pool, sizeof(*d));
+
+ d->edit_baton = eb;
+ d->parent_baton = NULL;
+ d->node = (eb->node = create_node("", NULL, eb->node_pool));
+ d->node->kind = svn_node_dir;
+ d->node->action = 'R';
+ *root_baton = d;
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+open_directory(const char *path,
+ void *parent_baton,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool,
+ void **child_baton)
+{
+ return add_open_helper(path, 'R', svn_node_dir, parent_baton,
+ NULL, SVN_INVALID_REVNUM,
+ pool, child_baton);
+}
+
+
+static svn_error_t *
+add_directory(const char *path,
+ void *parent_baton,
+ const char *copyfrom_path,
+ svn_revnum_t copyfrom_revision,
+ apr_pool_t *pool,
+ void **child_baton)
+{
+ return add_open_helper(path, 'A', svn_node_dir, parent_baton,
+ copyfrom_path, copyfrom_revision,
+ pool, child_baton);
+}
+
+
+static svn_error_t *
+open_file(const char *path,
+ void *parent_baton,
+ svn_revnum_t base_revision,
+ apr_pool_t *pool,
+ void **file_baton)
+{
+ return add_open_helper(path, 'R', svn_node_file, parent_baton,
+ NULL, SVN_INVALID_REVNUM,
+ pool, file_baton);
+}
+
+
+static svn_error_t *
+add_file(const char *path,
+ void *parent_baton,
+ const char *copyfrom_path,
+ svn_revnum_t copyfrom_revision,
+ apr_pool_t *pool,
+ void **file_baton)
+{
+ return add_open_helper(path, 'A', svn_node_file, parent_baton,
+ copyfrom_path, copyfrom_revision,
+ pool, file_baton);
+}
+
+
+static svn_error_t *
+apply_textdelta(void *file_baton,
+ const char *base_checksum,
+ apr_pool_t *pool,
+ svn_txdelta_window_handler_t *handler,
+ void **handler_baton)
+{
+ struct node_baton *fb = file_baton;
+ fb->node->text_mod = TRUE;
+ *handler = svn_delta_noop_window_handler;
+ *handler_baton = NULL;
+ return SVN_NO_ERROR;
+}
+
+
+
+static svn_error_t *
+change_node_prop(void *node_baton,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool)
+{
+ struct node_baton *nb = node_baton;
+ nb->node->prop_mod = TRUE;
+ return SVN_NO_ERROR;
+}
+
+
+svn_error_t *
+svn_repos_node_editor(const svn_delta_editor_t **editor,
+ void **edit_baton,
+ svn_repos_t *repos,
+ svn_fs_root_t *base_root,
+ svn_fs_root_t *root,
+ apr_pool_t *node_pool,
+ apr_pool_t *pool)
+{
+ svn_delta_editor_t *my_editor;
+ struct edit_baton *my_edit_baton;
+
+ /* Set up the editor. */
+ my_editor = svn_delta_default_editor(pool);
+ my_editor->open_root = open_root;
+ my_editor->delete_entry = delete_entry;
+ my_editor->add_directory = add_directory;
+ my_editor->open_directory = open_directory;
+ my_editor->add_file = add_file;
+ my_editor->open_file = open_file;
+ my_editor->apply_textdelta = apply_textdelta;
+ my_editor->change_file_prop = change_node_prop;
+ my_editor->change_dir_prop = change_node_prop;
+
+ /* Set up the edit baton. */
+ my_edit_baton = apr_pcalloc(pool, sizeof(*my_edit_baton));
+ my_edit_baton->node_pool = node_pool;
+ my_edit_baton->fs = repos->fs;
+ my_edit_baton->root = root;
+ my_edit_baton->base_root = base_root;
+
+ *editor = my_editor;
+ *edit_baton = my_edit_baton;
+
+ return SVN_NO_ERROR;
+}
+
+
+
+svn_repos_node_t *
+svn_repos_node_from_baton(void *edit_baton)
+{
+ struct edit_baton *eb = edit_baton;
+ return eb->node;
+}
diff --git a/subversion/libsvn_repos/notify.c b/subversion/libsvn_repos/notify.c
new file mode 100644
index 000000000000..ac2bca4e26b0
--- /dev/null
+++ b/subversion/libsvn_repos/notify.c
@@ -0,0 +1,44 @@
+/* notify.c --- notifcation system
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "svn_pools.h"
+#include "svn_repos.h"
+#include "repos.h"
+#include "svn_private_config.h"
+#include "private/svn_utf_private.h"
+
+
+
+svn_repos_notify_t *
+svn_repos_notify_create(svn_repos_notify_action_t action,
+ apr_pool_t *result_pool)
+{
+ svn_repos_notify_t *notify = apr_pcalloc(result_pool, sizeof(*notify));
+
+ notify->action = action;
+
+ return notify;
+}
diff --git a/subversion/libsvn_repos/replay.c b/subversion/libsvn_repos/replay.c
new file mode 100644
index 000000000000..985a673920a9
--- /dev/null
+++ b/subversion/libsvn_repos/replay.c
@@ -0,0 +1,1591 @@
+/*
+ * replay.c: an editor driver for changes made in a given revision
+ * or transaction
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+
+#include <apr_hash.h>
+
+#include "svn_types.h"
+#include "svn_delta.h"
+#include "svn_hash.h"
+#include "svn_fs.h"
+#include "svn_checksum.h"
+#include "svn_repos.h"
+#include "svn_sorts.h"
+#include "svn_props.h"
+#include "svn_pools.h"
+#include "svn_path.h"
+#include "svn_private_config.h"
+#include "private/svn_fspath.h"
+#include "private/svn_repos_private.h"
+#include "private/svn_delta_private.h"
+
+
+/*** Backstory ***/
+
+/* The year was 2003. Subversion usage was rampant in the world, and
+ there was a rapidly growing issues database to prove it. To make
+ matters worse, svn_repos_dir_delta() had simply outgrown itself.
+ No longer content to simply describe the differences between two
+ trees, the function had been slowly bearing the added
+ responsibility of representing the actions that had been taken to
+ cause those differences -- a burden it was never meant to bear.
+ Now grown into a twisted mess of razor-sharp metal and glass, and
+ trembling with a sort of momentarily stayed spring force,
+ svn_repos_dir_delta was a timebomb poised for total annihilation of
+ the American Midwest.
+
+ Subversion needed a change.
+
+ Changes, in fact. And not just in the literary segue sense. What
+ Subversion desperately needed was a new mechanism solely
+ responsible for replaying repository actions back to some
+ interested party -- to translate and retransmit the contents of the
+ Berkeley 'changes' database file. */
+
+/*** Overview ***/
+
+/* The filesystem keeps a record of high-level actions that affect the
+ files and directories in itself. The 'changes' table records
+ additions, deletions, textual and property modifications, and so
+ on. The goal of the functions in this file is to examine those
+ change records, and use them to drive an editor interface in such a
+ way as to effectively replay those actions.
+
+ This is critically different than what svn_repos_dir_delta() was
+ designed to do. That function describes, in the simplest way it
+ can, how to transform one tree into another. It doesn't care
+ whether or not this was the same way a user might have done this
+ transformation. More to the point, it doesn't care if this is how
+ those differences *did* come into being. And it is for this reason
+ that it cannot be relied upon for tasks such as the repository
+ dumpfile-generation code, which is supposed to represent not
+ changes, but actions that cause changes.
+
+ So, what's the plan here?
+
+ First, we fetch the changes for a particular revision or
+ transaction. We get these as an array, sorted chronologically.
+ From this array we will build a hash, keyed on the path associated
+ with each change item, and whose values are arrays of changes made
+ to that path, again preserving the chronological ordering.
+
+ Once our hash is built, we then sort all the keys of the hash (the
+ paths) using a depth-first directory sort routine.
+
+ Finally, we drive an editor, moving down our list of sorted paths,
+ and manufacturing any intermediate editor calls (directory openings
+ and closures) needed to navigate between each successive path. For
+ each path, we replay the sorted actions that occurred at that path.
+
+ When we've finished the editor drive, we should have fully replayed
+ the filesystem events that occurred in that revision or transaction
+ (though not necessarily in the same order in which they
+ occurred). */
+
+/* #define USE_EV2_IMPL */
+
+
+/*** Helper functions. ***/
+
+
+/* Information for an active copy, that is a directory which we are currently
+ working on and which was added with history. */
+struct copy_info
+{
+ /* Destination relpath (relative to the root of the . */
+ const char *path;
+
+ /* Copy source path (expressed as an absolute FS path) or revision.
+ NULL and SVN_INVALID_REVNUM if this is an add without history,
+ nested inside an add with history. */
+ const char *copyfrom_path;
+ svn_revnum_t copyfrom_rev;
+};
+
+struct path_driver_cb_baton
+{
+ const svn_delta_editor_t *editor;
+ void *edit_baton;
+
+ /* The root of the revision we're replaying. */
+ svn_fs_root_t *root;
+
+ /* The root of the previous revision. If this is non-NULL it means that
+ we are supposed to generate props and text deltas relative to it. */
+ svn_fs_root_t *compare_root;
+
+ apr_hash_t *changed_paths;
+
+ svn_repos_authz_func_t authz_read_func;
+ void *authz_read_baton;
+
+ const char *base_path; /* relpath */
+
+ svn_revnum_t low_water_mark;
+ /* Stack of active copy operations. */
+ apr_array_header_t *copies;
+
+ /* The global pool for this replay operation. */
+ apr_pool_t *pool;
+};
+
+/* Recursively traverse EDIT_PATH (as it exists under SOURCE_ROOT) emitting
+ the appropriate editor calls to add it and its children without any
+ history. This is meant to be used when either a subset of the tree
+ has been ignored and we need to copy something from that subset to
+ the part of the tree we do care about, or if a subset of the tree is
+ unavailable because of authz and we need to use it as the source of
+ a copy. */
+static svn_error_t *
+add_subdir(svn_fs_root_t *source_root,
+ svn_fs_root_t *target_root,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ const char *edit_path,
+ void *parent_baton,
+ const char *source_fspath,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_hash_t *changed_paths,
+ apr_pool_t *pool,
+ void **dir_baton)
+{
+ apr_pool_t *subpool = svn_pool_create(pool);
+ apr_hash_index_t *hi, *phi;
+ apr_hash_t *dirents;
+ apr_hash_t *props;
+
+ SVN_ERR(editor->add_directory(edit_path, parent_baton, NULL,
+ SVN_INVALID_REVNUM, pool, dir_baton));
+
+ SVN_ERR(svn_fs_node_proplist(&props, target_root, edit_path, pool));
+
+ for (phi = apr_hash_first(pool, props); phi; phi = apr_hash_next(phi))
+ {
+ const void *key;
+ void *val;
+
+ svn_pool_clear(subpool);
+ apr_hash_this(phi, &key, NULL, &val);
+ SVN_ERR(editor->change_dir_prop(*dir_baton, key, val, subpool));
+ }
+
+ /* We have to get the dirents from the source path, not the target,
+ because we want nested copies from *readable* paths to be handled by
+ path_driver_cb_func, not add_subdir (in order to preserve history). */
+ SVN_ERR(svn_fs_dir_entries(&dirents, source_root, source_fspath, pool));
+
+ for (hi = apr_hash_first(pool, dirents); hi; hi = apr_hash_next(hi))
+ {
+ svn_fs_path_change2_t *change;
+ svn_boolean_t readable = TRUE;
+ svn_fs_dirent_t *dent;
+ const char *copyfrom_path = NULL;
+ svn_revnum_t copyfrom_rev = SVN_INVALID_REVNUM;
+ const char *new_edit_path;
+ void *val;
+
+ svn_pool_clear(subpool);
+
+ apr_hash_this(hi, NULL, NULL, &val);
+
+ dent = val;
+
+ new_edit_path = svn_relpath_join(edit_path, dent->name, subpool);
+
+ /* If a file or subdirectory of the copied directory is listed as a
+ changed path (because it was modified after the copy but before the
+ commit), we remove it from the changed_paths hash so that future
+ calls to path_driver_cb_func will ignore it. */
+ change = svn_hash_gets(changed_paths, new_edit_path);
+ if (change)
+ {
+ svn_hash_sets(changed_paths, new_edit_path, NULL);
+
+ /* If it's a delete, skip this entry. */
+ if (change->change_kind == svn_fs_path_change_delete)
+ continue;
+
+ /* If it's a replacement, check for copyfrom info (if we
+ don't have it already. */
+ if (change->change_kind == svn_fs_path_change_replace)
+ {
+ if (! change->copyfrom_known)
+ {
+ SVN_ERR(svn_fs_copied_from(&change->copyfrom_rev,
+ &change->copyfrom_path,
+ target_root, new_edit_path, pool));
+ change->copyfrom_known = TRUE;
+ }
+ copyfrom_path = change->copyfrom_path;
+ copyfrom_rev = change->copyfrom_rev;
+ }
+ }
+
+ if (authz_read_func)
+ SVN_ERR(authz_read_func(&readable, target_root, new_edit_path,
+ authz_read_baton, pool));
+
+ if (! readable)
+ continue;
+
+ if (dent->kind == svn_node_dir)
+ {
+ svn_fs_root_t *new_source_root;
+ const char *new_source_fspath;
+ void *new_dir_baton;
+
+ if (copyfrom_path)
+ {
+ svn_fs_t *fs = svn_fs_root_fs(source_root);
+ SVN_ERR(svn_fs_revision_root(&new_source_root, fs,
+ copyfrom_rev, pool));
+ new_source_fspath = copyfrom_path;
+ }
+ else
+ {
+ new_source_root = source_root;
+ new_source_fspath = svn_fspath__join(source_fspath, dent->name,
+ subpool);
+ }
+
+ /* ### authz considerations?
+ *
+ * I think not; when path_driver_cb_func() calls add_subdir(), it
+ * passes SOURCE_ROOT and SOURCE_FSPATH that are unreadable.
+ */
+ if (change && change->change_kind == svn_fs_path_change_replace
+ && copyfrom_path == NULL)
+ {
+ SVN_ERR(editor->add_directory(new_edit_path, *dir_baton,
+ NULL, SVN_INVALID_REVNUM,
+ subpool, &new_dir_baton));
+ }
+ else
+ {
+ SVN_ERR(add_subdir(new_source_root, target_root,
+ editor, edit_baton, new_edit_path,
+ *dir_baton, new_source_fspath,
+ authz_read_func, authz_read_baton,
+ changed_paths, subpool, &new_dir_baton));
+ }
+
+ SVN_ERR(editor->close_directory(new_dir_baton, subpool));
+ }
+ else if (dent->kind == svn_node_file)
+ {
+ svn_txdelta_window_handler_t delta_handler;
+ void *delta_handler_baton, *file_baton;
+ svn_txdelta_stream_t *delta_stream;
+ svn_checksum_t *checksum;
+
+ SVN_ERR(editor->add_file(new_edit_path, *dir_baton, NULL,
+ SVN_INVALID_REVNUM, pool, &file_baton));
+
+ SVN_ERR(svn_fs_node_proplist(&props, target_root,
+ new_edit_path, subpool));
+
+ for (phi = apr_hash_first(pool, props); phi; phi = apr_hash_next(phi))
+ {
+ const void *key;
+
+ apr_hash_this(phi, &key, NULL, &val);
+ SVN_ERR(editor->change_file_prop(file_baton, key, val, subpool));
+ }
+
+ SVN_ERR(editor->apply_textdelta(file_baton, NULL, pool,
+ &delta_handler,
+ &delta_handler_baton));
+
+ SVN_ERR(svn_fs_get_file_delta_stream(&delta_stream, NULL, NULL,
+ target_root, new_edit_path,
+ pool));
+
+ SVN_ERR(svn_txdelta_send_txstream(delta_stream,
+ delta_handler,
+ delta_handler_baton,
+ pool));
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5, target_root,
+ new_edit_path, TRUE, pool));
+ SVN_ERR(editor->close_file(file_baton,
+ svn_checksum_to_cstring(checksum, pool),
+ pool));
+ }
+ else
+ SVN_ERR_MALFUNCTION();
+ }
+
+ svn_pool_destroy(subpool);
+
+ return SVN_NO_ERROR;
+}
+
+/* Given PATH deleted under ROOT, return in READABLE whether the path was
+ readable prior to the deletion. Consult COPIES (a stack of 'struct
+ copy_info') and AUTHZ_READ_FUNC. */
+static svn_error_t *
+was_readable(svn_boolean_t *readable,
+ svn_fs_root_t *root,
+ const char *path,
+ apr_array_header_t *copies,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_fs_root_t *inquire_root;
+ const char *inquire_path;
+ struct copy_info *info = NULL;
+ const char *relpath;
+
+ /* Short circuit. */
+ if (! authz_read_func)
+ {
+ *readable = TRUE;
+ return SVN_NO_ERROR;
+ }
+
+ if (copies->nelts != 0)
+ info = APR_ARRAY_IDX(copies, copies->nelts - 1, struct copy_info *);
+
+ /* Are we under a copy? */
+ if (info && (relpath = svn_relpath_skip_ancestor(info->path, path)))
+ {
+ SVN_ERR(svn_fs_revision_root(&inquire_root, svn_fs_root_fs(root),
+ info->copyfrom_rev, scratch_pool));
+ inquire_path = svn_fspath__join(info->copyfrom_path, relpath,
+ scratch_pool);
+ }
+ else
+ {
+ /* Compute the revision that ROOT is based on. (Note that ROOT is not
+ r0's root, since this function is only called for deletions.)
+ ### Need a more succinct way to express this */
+ svn_revnum_t inquire_rev = SVN_INVALID_REVNUM;
+ if (svn_fs_is_txn_root(root))
+ inquire_rev = svn_fs_txn_root_base_revision(root);
+ if (svn_fs_is_revision_root(root))
+ inquire_rev = svn_fs_revision_root_revision(root)-1;
+ SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(inquire_rev));
+
+ SVN_ERR(svn_fs_revision_root(&inquire_root, svn_fs_root_fs(root),
+ inquire_rev, scratch_pool));
+ inquire_path = path;
+ }
+
+ SVN_ERR(authz_read_func(readable, inquire_root, inquire_path,
+ authz_read_baton, result_pool));
+
+ return SVN_NO_ERROR;
+}
+
+/* Initialize COPYFROM_ROOT, COPYFROM_PATH, and COPYFROM_REV with the
+ revision root, fspath, and revnum of the copyfrom of CHANGE, which
+ corresponds to PATH under ROOT. If the copyfrom info is valid
+ (i.e., is not (NULL, SVN_INVALID_REVNUM)), then initialize SRC_READABLE
+ too, consulting AUTHZ_READ_FUNC and AUTHZ_READ_BATON if provided.
+
+ NOTE: If the copyfrom information in CHANGE is marked as unknown
+ (meaning, its ->copyfrom_rev and ->copyfrom_path cannot be
+ trusted), this function will also update those members of the
+ CHANGE structure to carry accurate copyfrom information. */
+static svn_error_t *
+fill_copyfrom(svn_fs_root_t **copyfrom_root,
+ const char **copyfrom_path,
+ svn_revnum_t *copyfrom_rev,
+ svn_boolean_t *src_readable,
+ svn_fs_root_t *root,
+ svn_fs_path_change2_t *change,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ const char *path,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ if (! change->copyfrom_known)
+ {
+ SVN_ERR(svn_fs_copied_from(&(change->copyfrom_rev),
+ &(change->copyfrom_path),
+ root, path, result_pool));
+ change->copyfrom_known = TRUE;
+ }
+ *copyfrom_rev = change->copyfrom_rev;
+ *copyfrom_path = change->copyfrom_path;
+
+ if (*copyfrom_path && SVN_IS_VALID_REVNUM(*copyfrom_rev))
+ {
+ SVN_ERR(svn_fs_revision_root(copyfrom_root,
+ svn_fs_root_fs(root),
+ *copyfrom_rev, result_pool));
+
+ if (authz_read_func)
+ {
+ SVN_ERR(authz_read_func(src_readable, *copyfrom_root,
+ *copyfrom_path,
+ authz_read_baton, result_pool));
+ }
+ else
+ *src_readable = TRUE;
+ }
+ else
+ {
+ *copyfrom_root = NULL;
+ /* SRC_READABLE left uninitialized */
+ }
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+path_driver_cb_func(void **dir_baton,
+ void *parent_baton,
+ void *callback_baton,
+ const char *edit_path,
+ apr_pool_t *pool)
+{
+ struct path_driver_cb_baton *cb = callback_baton;
+ const svn_delta_editor_t *editor = cb->editor;
+ void *edit_baton = cb->edit_baton;
+ svn_fs_root_t *root = cb->root;
+ svn_fs_path_change2_t *change;
+ svn_boolean_t do_add = FALSE, do_delete = FALSE;
+ void *file_baton = NULL;
+ svn_revnum_t copyfrom_rev;
+ const char *copyfrom_path;
+ svn_fs_root_t *source_root = cb->compare_root;
+ const char *source_fspath = NULL;
+ const char *base_path = cb->base_path;
+
+ *dir_baton = NULL;
+
+ /* Initialize SOURCE_FSPATH. */
+ if (source_root)
+ source_fspath = svn_fspath__canonicalize(edit_path, pool);
+
+ /* First, flush the copies stack so it only contains ancestors of path. */
+ while (cb->copies->nelts > 0
+ && ! svn_dirent_is_ancestor(APR_ARRAY_IDX(cb->copies,
+ cb->copies->nelts - 1,
+ struct copy_info *)->path,
+ edit_path))
+ apr_array_pop(cb->copies);
+
+ change = svn_hash_gets(cb->changed_paths, edit_path);
+ if (! change)
+ {
+ /* This can only happen if the path was removed from cb->changed_paths
+ by an earlier call to add_subdir, which means the path was already
+ handled and we should simply ignore it. */
+ return SVN_NO_ERROR;
+ }
+ switch (change->change_kind)
+ {
+ case svn_fs_path_change_add:
+ do_add = TRUE;
+ break;
+
+ case svn_fs_path_change_delete:
+ do_delete = TRUE;
+ break;
+
+ case svn_fs_path_change_replace:
+ do_add = TRUE;
+ do_delete = TRUE;
+ break;
+
+ case svn_fs_path_change_modify:
+ default:
+ /* do nothing */
+ break;
+ }
+
+ /* Handle any deletions. */
+ if (do_delete)
+ {
+ svn_boolean_t readable;
+
+ /* Issue #4121: delete under under a copy, of a path that was unreadable
+ at its pre-copy location. */
+ SVN_ERR(was_readable(&readable, root, edit_path, cb->copies,
+ cb->authz_read_func, cb->authz_read_baton,
+ pool, pool));
+ if (readable)
+ SVN_ERR(editor->delete_entry(edit_path, SVN_INVALID_REVNUM,
+ parent_baton, pool));
+ }
+
+ /* Fetch the node kind if it makes sense to do so. */
+ if (! do_delete || do_add)
+ {
+ if (change->node_kind == svn_node_unknown)
+ SVN_ERR(svn_fs_check_path(&(change->node_kind), root, edit_path, pool));
+ if ((change->node_kind != svn_node_dir) &&
+ (change->node_kind != svn_node_file))
+ return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
+ _("Filesystem path '%s' is neither a file "
+ "nor a directory"), edit_path);
+ }
+
+ /* Handle any adds/opens. */
+ if (do_add)
+ {
+ svn_boolean_t src_readable;
+ svn_fs_root_t *copyfrom_root;
+
+ /* Was this node copied? */
+ SVN_ERR(fill_copyfrom(&copyfrom_root, &copyfrom_path, &copyfrom_rev,
+ &src_readable, root, change,
+ cb->authz_read_func, cb->authz_read_baton,
+ edit_path, pool, pool));
+
+ /* If we have a copyfrom path, and we can't read it or we're just
+ ignoring it, or the copyfrom rev is prior to the low water mark
+ then we just null them out and do a raw add with no history at
+ all. */
+ if (copyfrom_path
+ && ((! src_readable)
+ || (svn_relpath_skip_ancestor(base_path, copyfrom_path + 1) == NULL)
+ || (cb->low_water_mark > copyfrom_rev)))
+ {
+ copyfrom_path = NULL;
+ copyfrom_rev = SVN_INVALID_REVNUM;
+ }
+
+ /* Do the right thing based on the path KIND. */
+ if (change->node_kind == svn_node_dir)
+ {
+ /* If this is a copy, but we can't represent it as such,
+ then we just do a recursive add of the source path
+ contents. */
+ if (change->copyfrom_path && ! copyfrom_path)
+ {
+ SVN_ERR(add_subdir(copyfrom_root, root, editor, edit_baton,
+ edit_path, parent_baton, change->copyfrom_path,
+ cb->authz_read_func, cb->authz_read_baton,
+ cb->changed_paths, pool, dir_baton));
+ }
+ else
+ {
+ SVN_ERR(editor->add_directory(edit_path, parent_baton,
+ copyfrom_path, copyfrom_rev,
+ pool, dir_baton));
+ }
+ }
+ else
+ {
+ SVN_ERR(editor->add_file(edit_path, parent_baton, copyfrom_path,
+ copyfrom_rev, pool, &file_baton));
+ }
+
+ /* If we represent this as a copy... */
+ if (copyfrom_path)
+ {
+ /* If it is a directory, make sure descendants get the correct
+ delta source by remembering that we are operating inside a
+ (possibly nested) copy operation. */
+ if (change->node_kind == svn_node_dir)
+ {
+ struct copy_info *info = apr_pcalloc(cb->pool, sizeof(*info));
+
+ info->path = apr_pstrdup(cb->pool, edit_path);
+ info->copyfrom_path = apr_pstrdup(cb->pool, copyfrom_path);
+ info->copyfrom_rev = copyfrom_rev;
+
+ APR_ARRAY_PUSH(cb->copies, struct copy_info *) = info;
+ }
+
+ /* Save the source so that we can use it later, when we
+ need to generate text and prop deltas. */
+ source_root = copyfrom_root;
+ source_fspath = copyfrom_path;
+ }
+ else
+ /* Else, we are an add without history... */
+ {
+ /* If an ancestor is added with history, we need to forget about
+ that here, go on with life and repeat all the mistakes of our
+ past... */
+ if (change->node_kind == svn_node_dir && cb->copies->nelts > 0)
+ {
+ struct copy_info *info = apr_pcalloc(cb->pool, sizeof(*info));
+
+ info->path = apr_pstrdup(cb->pool, edit_path);
+ info->copyfrom_path = NULL;
+ info->copyfrom_rev = SVN_INVALID_REVNUM;
+
+ APR_ARRAY_PUSH(cb->copies, struct copy_info *) = info;
+ }
+ source_root = NULL;
+ source_fspath = NULL;
+ }
+ }
+ else if (! do_delete)
+ {
+ /* Do the right thing based on the path KIND (and the presence
+ of a PARENT_BATON). */
+ if (change->node_kind == svn_node_dir)
+ {
+ if (parent_baton)
+ {
+ SVN_ERR(editor->open_directory(edit_path, parent_baton,
+ SVN_INVALID_REVNUM,
+ pool, dir_baton));
+ }
+ else
+ {
+ SVN_ERR(editor->open_root(edit_baton, SVN_INVALID_REVNUM,
+ pool, dir_baton));
+ }
+ }
+ else
+ {
+ SVN_ERR(editor->open_file(edit_path, parent_baton, SVN_INVALID_REVNUM,
+ pool, &file_baton));
+ }
+ /* If we are inside an add with history, we need to adjust the
+ delta source. */
+ if (cb->copies->nelts > 0)
+ {
+ struct copy_info *info = APR_ARRAY_IDX(cb->copies,
+ cb->copies->nelts - 1,
+ struct copy_info *);
+ if (info->copyfrom_path)
+ {
+ const char *relpath = svn_relpath_skip_ancestor(info->path,
+ edit_path);
+ SVN_ERR_ASSERT(relpath && *relpath);
+ SVN_ERR(svn_fs_revision_root(&source_root,
+ svn_fs_root_fs(root),
+ info->copyfrom_rev, pool));
+ source_fspath = svn_fspath__join(info->copyfrom_path,
+ relpath, pool);
+ }
+ else
+ {
+ /* This is an add without history, nested inside an
+ add with history. We have no delta source in this case. */
+ source_root = NULL;
+ source_fspath = NULL;
+ }
+ }
+ }
+
+ if (! do_delete || do_add)
+ {
+ /* Is this a copy that was downgraded to a raw add? (If so,
+ we'll need to transmit properties and file contents and such
+ for it regardless of what the CHANGE structure's text_mod
+ and prop_mod flags say.) */
+ svn_boolean_t downgraded_copy = (change->copyfrom_known
+ && change->copyfrom_path
+ && (! copyfrom_path));
+
+ /* Handle property modifications. */
+ if (change->prop_mod || downgraded_copy)
+ {
+ if (cb->compare_root)
+ {
+ apr_array_header_t *prop_diffs;
+ apr_hash_t *old_props;
+ apr_hash_t *new_props;
+ int i;
+
+ if (source_root)
+ SVN_ERR(svn_fs_node_proplist(&old_props, source_root,
+ source_fspath, pool));
+ else
+ old_props = apr_hash_make(pool);
+
+ SVN_ERR(svn_fs_node_proplist(&new_props, root, edit_path, pool));
+
+ SVN_ERR(svn_prop_diffs(&prop_diffs, new_props, old_props,
+ pool));
+
+ for (i = 0; i < prop_diffs->nelts; ++i)
+ {
+ svn_prop_t *pc = &APR_ARRAY_IDX(prop_diffs, i, svn_prop_t);
+ if (change->node_kind == svn_node_dir)
+ SVN_ERR(editor->change_dir_prop(*dir_baton, pc->name,
+ pc->value, pool));
+ else if (change->node_kind == svn_node_file)
+ SVN_ERR(editor->change_file_prop(file_baton, pc->name,
+ pc->value, pool));
+ }
+ }
+ else
+ {
+ /* Just do a dummy prop change to signal that there are *any*
+ propmods. */
+ if (change->node_kind == svn_node_dir)
+ SVN_ERR(editor->change_dir_prop(*dir_baton, "", NULL,
+ pool));
+ else if (change->node_kind == svn_node_file)
+ SVN_ERR(editor->change_file_prop(file_baton, "", NULL,
+ pool));
+ }
+ }
+
+ /* Handle textual modifications. */
+ if (change->node_kind == svn_node_file
+ && (change->text_mod || downgraded_copy))
+ {
+ svn_txdelta_window_handler_t delta_handler;
+ void *delta_handler_baton;
+ const char *hex_digest = NULL;
+
+ if (cb->compare_root && source_root && source_fspath)
+ {
+ svn_checksum_t *checksum;
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
+ source_root, source_fspath, TRUE,
+ pool));
+ hex_digest = svn_checksum_to_cstring(checksum, pool);
+ }
+
+ SVN_ERR(editor->apply_textdelta(file_baton, hex_digest, pool,
+ &delta_handler,
+ &delta_handler_baton));
+ if (cb->compare_root)
+ {
+ svn_txdelta_stream_t *delta_stream;
+
+ SVN_ERR(svn_fs_get_file_delta_stream(&delta_stream, source_root,
+ source_fspath, root,
+ edit_path, pool));
+ SVN_ERR(svn_txdelta_send_txstream(delta_stream, delta_handler,
+ delta_handler_baton, pool));
+ }
+ else
+ SVN_ERR(delta_handler(NULL, delta_handler_baton));
+ }
+ }
+
+ /* Close the file baton if we opened it. */
+ if (file_baton)
+ {
+ svn_checksum_t *checksum;
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5, root, edit_path,
+ TRUE, pool));
+ SVN_ERR(editor->close_file(file_baton,
+ svn_checksum_to_cstring(checksum, pool),
+ pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+#ifdef USE_EV2_IMPL
+static svn_error_t *
+fetch_kind_func(svn_node_kind_t *kind,
+ void *baton,
+ const char *path,
+ svn_revnum_t base_revision,
+ apr_pool_t *scratch_pool)
+{
+ svn_fs_root_t *root = baton;
+ svn_fs_root_t *prev_root;
+ svn_fs_t *fs = svn_fs_root_fs(root);
+
+ if (!SVN_IS_VALID_REVNUM(base_revision))
+ base_revision = svn_fs_revision_root_revision(root) - 1;
+
+ SVN_ERR(svn_fs_revision_root(&prev_root, fs, base_revision, scratch_pool));
+ SVN_ERR(svn_fs_check_path(kind, prev_root, path, scratch_pool));
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+fetch_props_func(apr_hash_t **props,
+ void *baton,
+ const char *path,
+ svn_revnum_t base_revision,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_fs_root_t *root = baton;
+ svn_fs_root_t *prev_root;
+ svn_fs_t *fs = svn_fs_root_fs(root);
+
+ if (!SVN_IS_VALID_REVNUM(base_revision))
+ base_revision = svn_fs_revision_root_revision(root) - 1;
+
+ SVN_ERR(svn_fs_revision_root(&prev_root, fs, base_revision, scratch_pool));
+ SVN_ERR(svn_fs_node_proplist(props, prev_root, path, result_pool));
+
+ return SVN_NO_ERROR;
+}
+#endif
+
+
+
+
+svn_error_t *
+svn_repos_replay2(svn_fs_root_t *root,
+ const char *base_path,
+ svn_revnum_t low_water_mark,
+ svn_boolean_t send_deltas,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *pool)
+{
+#ifndef USE_EV2_IMPL
+ apr_hash_t *fs_changes;
+ apr_hash_t *changed_paths;
+ apr_hash_index_t *hi;
+ apr_array_header_t *paths;
+ struct path_driver_cb_baton cb_baton;
+
+ /* Special-case r0, which we know is an empty revision; if we don't
+ special-case it we might end up trying to compare it to "r-1". */
+ if (svn_fs_is_revision_root(root) && svn_fs_revision_root_revision(root) == 0)
+ {
+ SVN_ERR(editor->set_target_revision(edit_baton, 0, pool));
+ return SVN_NO_ERROR;
+ }
+
+ /* Fetch the paths changed under ROOT. */
+ SVN_ERR(svn_fs_paths_changed2(&fs_changes, root, pool));
+
+ if (! base_path)
+ base_path = "";
+ else if (base_path[0] == '/')
+ ++base_path;
+
+ /* Make an array from the keys of our CHANGED_PATHS hash, and copy
+ the values into a new hash whose keys have no leading slashes. */
+ paths = apr_array_make(pool, apr_hash_count(fs_changes),
+ sizeof(const char *));
+ changed_paths = apr_hash_make(pool);
+ for (hi = apr_hash_first(pool, fs_changes); hi; hi = apr_hash_next(hi))
+ {
+ const void *key;
+ void *val;
+ apr_ssize_t keylen;
+ const char *path;
+ svn_fs_path_change2_t *change;
+ svn_boolean_t allowed = TRUE;
+
+ apr_hash_this(hi, &key, &keylen, &val);
+ path = key;
+ change = val;
+
+ if (authz_read_func)
+ SVN_ERR(authz_read_func(&allowed, root, path, authz_read_baton,
+ pool));
+
+ if (allowed)
+ {
+ if (path[0] == '/')
+ {
+ path++;
+ keylen--;
+ }
+
+ /* If the base_path doesn't match the top directory of this path
+ we don't want anything to do with it... */
+ if (svn_relpath_skip_ancestor(base_path, path) != NULL)
+ {
+ APR_ARRAY_PUSH(paths, const char *) = path;
+ apr_hash_set(changed_paths, path, keylen, change);
+ }
+ /* ...unless this was a change to one of the parent directories of
+ base_path. */
+ else if (svn_relpath_skip_ancestor(path, base_path) != NULL)
+ {
+ APR_ARRAY_PUSH(paths, const char *) = path;
+ apr_hash_set(changed_paths, path, keylen, change);
+ }
+ }
+ }
+
+ /* If we were not given a low water mark, assume that everything is there,
+ all the way back to revision 0. */
+ if (! SVN_IS_VALID_REVNUM(low_water_mark))
+ low_water_mark = 0;
+
+ /* Initialize our callback baton. */
+ cb_baton.editor = editor;
+ cb_baton.edit_baton = edit_baton;
+ cb_baton.root = root;
+ cb_baton.changed_paths = changed_paths;
+ cb_baton.authz_read_func = authz_read_func;
+ cb_baton.authz_read_baton = authz_read_baton;
+ cb_baton.base_path = base_path;
+ cb_baton.low_water_mark = low_water_mark;
+ cb_baton.compare_root = NULL;
+
+ if (send_deltas)
+ {
+ SVN_ERR(svn_fs_revision_root(&cb_baton.compare_root,
+ svn_fs_root_fs(root),
+ svn_fs_is_revision_root(root)
+ ? svn_fs_revision_root_revision(root) - 1
+ : svn_fs_txn_root_base_revision(root),
+ pool));
+ }
+
+ cb_baton.copies = apr_array_make(pool, 4, sizeof(struct copy_info *));
+ cb_baton.pool = pool;
+
+ /* Determine the revision to use throughout the edit, and call
+ EDITOR's set_target_revision() function. */
+ if (svn_fs_is_revision_root(root))
+ {
+ svn_revnum_t revision = svn_fs_revision_root_revision(root);
+ SVN_ERR(editor->set_target_revision(edit_baton, revision, pool));
+ }
+
+ /* Call the path-based editor driver. */
+ return svn_delta_path_driver2(editor, edit_baton,
+ paths, TRUE,
+ path_driver_cb_func, &cb_baton, pool);
+#else
+ svn_editor_t *editorv2;
+ struct svn_delta__extra_baton *exb;
+ svn_delta__unlock_func_t unlock_func;
+ svn_boolean_t send_abs_paths;
+ const char *repos_root = "";
+ void *unlock_baton;
+
+ /* Special-case r0, which we know is an empty revision; if we don't
+ special-case it we might end up trying to compare it to "r-1". */
+ if (svn_fs_is_revision_root(root)
+ && svn_fs_revision_root_revision(root) == 0)
+ {
+ SVN_ERR(editor->set_target_revision(edit_baton, 0, pool));
+ return SVN_NO_ERROR;
+ }
+
+ /* Determine the revision to use throughout the edit, and call
+ EDITOR's set_target_revision() function. */
+ if (svn_fs_is_revision_root(root))
+ {
+ svn_revnum_t revision = svn_fs_revision_root_revision(root);
+ SVN_ERR(editor->set_target_revision(edit_baton, revision, pool));
+ }
+
+ if (! base_path)
+ base_path = "";
+ else if (base_path[0] == '/')
+ ++base_path;
+
+ /* Use the shim to convert our editor to an Ev2 editor, and pass it down
+ the stack. */
+ SVN_ERR(svn_delta__editor_from_delta(&editorv2, &exb,
+ &unlock_func, &unlock_baton,
+ editor, edit_baton,
+ &send_abs_paths,
+ repos_root, "",
+ NULL, NULL,
+ fetch_kind_func, root,
+ fetch_props_func, root,
+ pool, pool));
+
+ /* Tell the shim that we're starting the process. */
+ SVN_ERR(exb->start_edit(exb->baton, svn_fs_revision_root_revision(root)));
+
+ /* ### We're ignoring SEND_DELTAS here. */
+ SVN_ERR(svn_repos__replay_ev2(root, base_path, low_water_mark,
+ editorv2, authz_read_func, authz_read_baton,
+ pool));
+
+ return SVN_NO_ERROR;
+#endif
+}
+
+
+/*****************************************************************
+ * Ev2 Implementation *
+ *****************************************************************/
+
+/* Recursively traverse EDIT_PATH (as it exists under SOURCE_ROOT) emitting
+ the appropriate editor calls to add it and its children without any
+ history. This is meant to be used when either a subset of the tree
+ has been ignored and we need to copy something from that subset to
+ the part of the tree we do care about, or if a subset of the tree is
+ unavailable because of authz and we need to use it as the source of
+ a copy. */
+static svn_error_t *
+add_subdir_ev2(svn_fs_root_t *source_root,
+ svn_fs_root_t *target_root,
+ svn_editor_t *editor,
+ const char *repos_relpath,
+ const char *source_fspath,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_hash_t *changed_paths,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+ apr_hash_index_t *hi;
+ apr_hash_t *dirents;
+ apr_hash_t *props = NULL;
+ apr_array_header_t *children = NULL;
+
+ SVN_ERR(svn_fs_node_proplist(&props, target_root, repos_relpath,
+ scratch_pool));
+
+ SVN_ERR(svn_editor_add_directory(editor, repos_relpath, children,
+ props, SVN_INVALID_REVNUM));
+
+ /* We have to get the dirents from the source path, not the target,
+ because we want nested copies from *readable* paths to be handled by
+ path_driver_cb_func, not add_subdir (in order to preserve history). */
+ SVN_ERR(svn_fs_dir_entries(&dirents, source_root, source_fspath,
+ scratch_pool));
+
+ for (hi = apr_hash_first(scratch_pool, dirents); hi; hi = apr_hash_next(hi))
+ {
+ svn_fs_path_change2_t *change;
+ svn_boolean_t readable = TRUE;
+ svn_fs_dirent_t *dent = svn__apr_hash_index_val(hi);
+ const char *copyfrom_path = NULL;
+ svn_revnum_t copyfrom_rev = SVN_INVALID_REVNUM;
+ const char *child_relpath;
+
+ svn_pool_clear(iterpool);
+
+ child_relpath = svn_relpath_join(repos_relpath, dent->name, iterpool);
+
+ /* If a file or subdirectory of the copied directory is listed as a
+ changed path (because it was modified after the copy but before the
+ commit), we remove it from the changed_paths hash so that future
+ calls to path_driver_cb_func will ignore it. */
+ change = svn_hash_gets(changed_paths, child_relpath);
+ if (change)
+ {
+ svn_hash_sets(changed_paths, child_relpath, NULL);
+
+ /* If it's a delete, skip this entry. */
+ if (change->change_kind == svn_fs_path_change_delete)
+ continue;
+
+ /* If it's a replacement, check for copyfrom info (if we
+ don't have it already. */
+ if (change->change_kind == svn_fs_path_change_replace)
+ {
+ if (! change->copyfrom_known)
+ {
+ SVN_ERR(svn_fs_copied_from(&change->copyfrom_rev,
+ &change->copyfrom_path,
+ target_root, child_relpath,
+ result_pool));
+ change->copyfrom_known = TRUE;
+ }
+ copyfrom_path = change->copyfrom_path;
+ copyfrom_rev = change->copyfrom_rev;
+ }
+ }
+
+ if (authz_read_func)
+ SVN_ERR(authz_read_func(&readable, target_root, child_relpath,
+ authz_read_baton, iterpool));
+
+ if (! readable)
+ continue;
+
+ if (dent->kind == svn_node_dir)
+ {
+ svn_fs_root_t *new_source_root;
+ const char *new_source_fspath;
+
+ if (copyfrom_path)
+ {
+ svn_fs_t *fs = svn_fs_root_fs(source_root);
+ SVN_ERR(svn_fs_revision_root(&new_source_root, fs,
+ copyfrom_rev, result_pool));
+ new_source_fspath = copyfrom_path;
+ }
+ else
+ {
+ new_source_root = source_root;
+ new_source_fspath = svn_fspath__join(source_fspath, dent->name,
+ iterpool);
+ }
+
+ /* ### authz considerations?
+ *
+ * I think not; when path_driver_cb_func() calls add_subdir(), it
+ * passes SOURCE_ROOT and SOURCE_FSPATH that are unreadable.
+ */
+ if (change && change->change_kind == svn_fs_path_change_replace
+ && copyfrom_path == NULL)
+ {
+ SVN_ERR(svn_editor_add_directory(editor, child_relpath,
+ children, props,
+ SVN_INVALID_REVNUM));
+ }
+ else
+ {
+ SVN_ERR(add_subdir_ev2(new_source_root, target_root,
+ editor, child_relpath,
+ new_source_fspath,
+ authz_read_func, authz_read_baton,
+ changed_paths, result_pool, iterpool));
+ }
+ }
+ else if (dent->kind == svn_node_file)
+ {
+ svn_checksum_t *checksum;
+ svn_stream_t *contents;
+
+ SVN_ERR(svn_fs_node_proplist(&props, target_root,
+ child_relpath, iterpool));
+
+ SVN_ERR(svn_fs_file_contents(&contents, target_root,
+ child_relpath, iterpool));
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
+ target_root,
+ child_relpath, TRUE, iterpool));
+
+ SVN_ERR(svn_editor_add_file(editor, child_relpath, checksum,
+ contents, props, SVN_INVALID_REVNUM));
+ }
+ else
+ SVN_ERR_MALFUNCTION();
+ }
+
+ svn_pool_destroy(iterpool);
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+replay_node(svn_fs_root_t *root,
+ const char *repos_relpath,
+ svn_editor_t *editor,
+ svn_revnum_t low_water_mark,
+ const char *base_repos_relpath,
+ apr_array_header_t *copies,
+ apr_hash_t *changed_paths,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_fs_path_change2_t *change;
+ svn_boolean_t do_add = FALSE;
+ svn_boolean_t do_delete = FALSE;
+ svn_revnum_t copyfrom_rev;
+ const char *copyfrom_path;
+ svn_revnum_t replaces_rev;
+
+ /* First, flush the copies stack so it only contains ancestors of path. */
+ while (copies->nelts > 0
+ && (svn_relpath_skip_ancestor(APR_ARRAY_IDX(copies,
+ copies->nelts - 1,
+ struct copy_info *)->path,
+ repos_relpath) == NULL) )
+ apr_array_pop(copies);
+
+ change = svn_hash_gets(changed_paths, repos_relpath);
+ if (! change)
+ {
+ /* This can only happen if the path was removed from changed_paths
+ by an earlier call to add_subdir, which means the path was already
+ handled and we should simply ignore it. */
+ return SVN_NO_ERROR;
+ }
+ switch (change->change_kind)
+ {
+ case svn_fs_path_change_add:
+ do_add = TRUE;
+ break;
+
+ case svn_fs_path_change_delete:
+ do_delete = TRUE;
+ break;
+
+ case svn_fs_path_change_replace:
+ do_add = TRUE;
+ do_delete = TRUE;
+ break;
+
+ case svn_fs_path_change_modify:
+ default:
+ /* do nothing */
+ break;
+ }
+
+ /* Handle any deletions. */
+ if (do_delete && ! do_add)
+ {
+ svn_boolean_t readable;
+
+ /* Issue #4121: delete under under a copy, of a path that was unreadable
+ at its pre-copy location. */
+ SVN_ERR(was_readable(&readable, root, repos_relpath, copies,
+ authz_read_func, authz_read_baton,
+ scratch_pool, scratch_pool));
+ if (readable)
+ SVN_ERR(svn_editor_delete(editor, repos_relpath, SVN_INVALID_REVNUM));
+
+ return SVN_NO_ERROR;
+ }
+
+ /* Handle replacements. */
+ if (do_delete && do_add)
+ replaces_rev = svn_fs_revision_root_revision(root);
+ else
+ replaces_rev = SVN_INVALID_REVNUM;
+
+ /* Fetch the node kind if it makes sense to do so. */
+ if (! do_delete || do_add)
+ {
+ if (change->node_kind == svn_node_unknown)
+ SVN_ERR(svn_fs_check_path(&(change->node_kind), root, repos_relpath,
+ scratch_pool));
+ if ((change->node_kind != svn_node_dir) &&
+ (change->node_kind != svn_node_file))
+ return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
+ _("Filesystem path '%s' is neither a file "
+ "nor a directory"), repos_relpath);
+ }
+
+ /* Handle any adds/opens. */
+ if (do_add)
+ {
+ svn_boolean_t src_readable;
+ svn_fs_root_t *copyfrom_root;
+
+ /* Was this node copied? */
+ SVN_ERR(fill_copyfrom(&copyfrom_root, &copyfrom_path, &copyfrom_rev,
+ &src_readable, root, change,
+ authz_read_func, authz_read_baton,
+ repos_relpath, scratch_pool, scratch_pool));
+
+ /* If we have a copyfrom path, and we can't read it or we're just
+ ignoring it, or the copyfrom rev is prior to the low water mark
+ then we just null them out and do a raw add with no history at
+ all. */
+ if (copyfrom_path
+ && ((! src_readable)
+ || (svn_relpath_skip_ancestor(base_repos_relpath,
+ copyfrom_path + 1) == NULL)
+ || (low_water_mark > copyfrom_rev)))
+ {
+ copyfrom_path = NULL;
+ copyfrom_rev = SVN_INVALID_REVNUM;
+ }
+
+ /* Do the right thing based on the path KIND. */
+ if (change->node_kind == svn_node_dir)
+ {
+ /* If this is a copy, but we can't represent it as such,
+ then we just do a recursive add of the source path
+ contents. */
+ if (change->copyfrom_path && ! copyfrom_path)
+ {
+ SVN_ERR(add_subdir_ev2(copyfrom_root, root, editor,
+ repos_relpath, change->copyfrom_path,
+ authz_read_func, authz_read_baton,
+ changed_paths, result_pool,
+ scratch_pool));
+ }
+ else
+ {
+ if (copyfrom_path)
+ {
+ if (copyfrom_path[0] == '/')
+ ++copyfrom_path;
+ SVN_ERR(svn_editor_copy(editor, copyfrom_path, copyfrom_rev,
+ repos_relpath, replaces_rev));
+ }
+ else
+ {
+ apr_array_header_t *children;
+ apr_hash_t *props;
+ apr_hash_t *dirents;
+
+ SVN_ERR(svn_fs_dir_entries(&dirents, root, repos_relpath,
+ scratch_pool));
+ SVN_ERR(svn_hash_keys(&children, dirents, scratch_pool));
+
+ SVN_ERR(svn_fs_node_proplist(&props, root, repos_relpath,
+ scratch_pool));
+
+ SVN_ERR(svn_editor_add_directory(editor, repos_relpath,
+ children, props,
+ replaces_rev));
+ }
+ }
+ }
+ else
+ {
+ if (copyfrom_path)
+ {
+ if (copyfrom_path[0] == '/')
+ ++copyfrom_path;
+ SVN_ERR(svn_editor_copy(editor, copyfrom_path, copyfrom_rev,
+ repos_relpath, replaces_rev));
+ }
+ else
+ {
+ apr_hash_t *props;
+ svn_checksum_t *checksum;
+ svn_stream_t *contents;
+
+ SVN_ERR(svn_fs_node_proplist(&props, root, repos_relpath,
+ scratch_pool));
+
+ SVN_ERR(svn_fs_file_contents(&contents, root, repos_relpath,
+ scratch_pool));
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1, root,
+ repos_relpath, TRUE, scratch_pool));
+
+ SVN_ERR(svn_editor_add_file(editor, repos_relpath, checksum,
+ contents, props, replaces_rev));
+ }
+ }
+
+ /* If we represent this as a copy... */
+ if (copyfrom_path)
+ {
+ /* If it is a directory, make sure descendants get the correct
+ delta source by remembering that we are operating inside a
+ (possibly nested) copy operation. */
+ if (change->node_kind == svn_node_dir)
+ {
+ struct copy_info *info = apr_pcalloc(result_pool, sizeof(*info));
+
+ info->path = apr_pstrdup(result_pool, repos_relpath);
+ info->copyfrom_path = apr_pstrdup(result_pool, copyfrom_path);
+ info->copyfrom_rev = copyfrom_rev;
+
+ APR_ARRAY_PUSH(copies, struct copy_info *) = info;
+ }
+ }
+ else
+ /* Else, we are an add without history... */
+ {
+ /* If an ancestor is added with history, we need to forget about
+ that here, go on with life and repeat all the mistakes of our
+ past... */
+ if (change->node_kind == svn_node_dir && copies->nelts > 0)
+ {
+ struct copy_info *info = apr_pcalloc(result_pool, sizeof(*info));
+
+ info->path = apr_pstrdup(result_pool, repos_relpath);
+ info->copyfrom_path = NULL;
+ info->copyfrom_rev = SVN_INVALID_REVNUM;
+
+ APR_ARRAY_PUSH(copies, struct copy_info *) = info;
+ }
+ }
+ }
+ else if (! do_delete)
+ {
+ /* If we are inside an add with history, we need to adjust the
+ delta source. */
+ if (copies->nelts > 0)
+ {
+ struct copy_info *info = APR_ARRAY_IDX(copies,
+ copies->nelts - 1,
+ struct copy_info *);
+ if (info->copyfrom_path)
+ {
+ const char *relpath = svn_relpath_skip_ancestor(info->path,
+ repos_relpath);
+ SVN_ERR_ASSERT(relpath && *relpath);
+ repos_relpath = svn_relpath_join(info->copyfrom_path,
+ relpath, scratch_pool);
+ }
+ }
+ }
+
+ if (! do_delete && !do_add)
+ {
+ apr_hash_t *props = NULL;
+
+ /* Is this a copy that was downgraded to a raw add? (If so,
+ we'll need to transmit properties and file contents and such
+ for it regardless of what the CHANGE structure's text_mod
+ and prop_mod flags say.) */
+ svn_boolean_t downgraded_copy = (change->copyfrom_known
+ && change->copyfrom_path
+ && (! copyfrom_path));
+
+ /* Handle property modifications. */
+ if (change->prop_mod || downgraded_copy)
+ {
+ SVN_ERR(svn_fs_node_proplist(&props, root, repos_relpath,
+ scratch_pool));
+ }
+
+ /* Handle textual modifications. */
+ if (change->node_kind == svn_node_file
+ && (change->text_mod || change->prop_mod || downgraded_copy))
+ {
+ svn_checksum_t *checksum = NULL;
+ svn_stream_t *contents = NULL;
+
+ if (change->text_mod)
+ {
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
+ root, repos_relpath, TRUE,
+ scratch_pool));
+
+ SVN_ERR(svn_fs_file_contents(&contents, root, repos_relpath,
+ scratch_pool));
+ }
+
+ SVN_ERR(svn_editor_alter_file(editor, repos_relpath,
+ SVN_INVALID_REVNUM, props, checksum,
+ contents));
+ }
+
+ if (change->node_kind == svn_node_dir
+ && (change->prop_mod || downgraded_copy))
+ {
+ apr_array_header_t *children = NULL;
+
+ SVN_ERR(svn_editor_alter_directory(editor, repos_relpath,
+ SVN_INVALID_REVNUM, children,
+ props));
+ }
+ }
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_repos__replay_ev2(svn_fs_root_t *root,
+ const char *base_repos_relpath,
+ svn_revnum_t low_water_mark,
+ svn_editor_t *editor,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_pool_t *scratch_pool)
+{
+ apr_hash_t *fs_changes;
+ apr_hash_t *changed_paths;
+ apr_hash_index_t *hi;
+ apr_array_header_t *paths;
+ apr_array_header_t *copies;
+ apr_pool_t *iterpool;
+ svn_error_t *err = SVN_NO_ERROR;
+ int i;
+
+ SVN_ERR_ASSERT(!svn_dirent_is_absolute(base_repos_relpath));
+
+ /* Special-case r0, which we know is an empty revision; if we don't
+ special-case it we might end up trying to compare it to "r-1". */
+ if (svn_fs_is_revision_root(root)
+ && svn_fs_revision_root_revision(root) == 0)
+ {
+ return SVN_NO_ERROR;
+ }
+
+ /* Fetch the paths changed under ROOT. */
+ SVN_ERR(svn_fs_paths_changed2(&fs_changes, root, scratch_pool));
+
+ /* Make an array from the keys of our CHANGED_PATHS hash, and copy
+ the values into a new hash whose keys have no leading slashes. */
+ paths = apr_array_make(scratch_pool, apr_hash_count(fs_changes),
+ sizeof(const char *));
+ changed_paths = apr_hash_make(scratch_pool);
+ for (hi = apr_hash_first(scratch_pool, fs_changes); hi;
+ hi = apr_hash_next(hi))
+ {
+ const void *key;
+ void *val;
+ apr_ssize_t keylen;
+ const char *path;
+ svn_fs_path_change2_t *change;
+ svn_boolean_t allowed = TRUE;
+
+ apr_hash_this(hi, &key, &keylen, &val);
+ path = key;
+ change = val;
+
+ if (authz_read_func)
+ SVN_ERR(authz_read_func(&allowed, root, path, authz_read_baton,
+ scratch_pool));
+
+ if (allowed)
+ {
+ if (path[0] == '/')
+ {
+ path++;
+ keylen--;
+ }
+
+ /* If the base_path doesn't match the top directory of this path
+ we don't want anything to do with it... */
+ if (svn_relpath_skip_ancestor(base_repos_relpath, path) != NULL)
+ {
+ APR_ARRAY_PUSH(paths, const char *) = path;
+ apr_hash_set(changed_paths, path, keylen, change);
+ }
+ /* ...unless this was a change to one of the parent directories of
+ base_path. */
+ else if (svn_relpath_skip_ancestor(path, base_repos_relpath) != NULL)
+ {
+ APR_ARRAY_PUSH(paths, const char *) = path;
+ apr_hash_set(changed_paths, path, keylen, change);
+ }
+ }
+ }
+
+ /* If we were not given a low water mark, assume that everything is there,
+ all the way back to revision 0. */
+ if (! SVN_IS_VALID_REVNUM(low_water_mark))
+ low_water_mark = 0;
+
+ copies = apr_array_make(scratch_pool, 4, sizeof(struct copy_info *));
+
+ /* Sort the paths. Although not strictly required by the API, this has
+ the pleasant side effect of maintaining a consistent ordering of
+ dumpfile contents. */
+ qsort(paths->elts, paths->nelts, paths->elt_size, svn_sort_compare_paths);
+
+ /* Now actually handle the various paths. */
+ iterpool = svn_pool_create(scratch_pool);
+ for (i = 0; i < paths->nelts; i++)
+ {
+ const char *repos_relpath = APR_ARRAY_IDX(paths, i, const char *);
+
+ svn_pool_clear(iterpool);
+ err = replay_node(root, repos_relpath, editor, low_water_mark,
+ base_repos_relpath, copies, changed_paths,
+ authz_read_func, authz_read_baton,
+ scratch_pool, iterpool);
+ if (err)
+ break;
+ }
+
+ if (err)
+ return svn_error_compose_create(err, svn_editor_abort(editor));
+ else
+ SVN_ERR(svn_editor_complete(editor));
+
+ svn_pool_destroy(iterpool);
+ return SVN_NO_ERROR;
+}
diff --git a/subversion/libsvn_repos/reporter.c b/subversion/libsvn_repos/reporter.c
new file mode 100644
index 000000000000..a9d1eff5fa38
--- /dev/null
+++ b/subversion/libsvn_repos/reporter.c
@@ -0,0 +1,1610 @@
+/*
+ * reporter.c : `reporter' vtable routines for updates.
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+#include "svn_dirent_uri.h"
+#include "svn_hash.h"
+#include "svn_path.h"
+#include "svn_types.h"
+#include "svn_error.h"
+#include "svn_error_codes.h"
+#include "svn_fs.h"
+#include "svn_repos.h"
+#include "svn_pools.h"
+#include "svn_props.h"
+#include "repos.h"
+#include "svn_private_config.h"
+
+#include "private/svn_dep_compat.h"
+#include "private/svn_fspath.h"
+#include "private/svn_subr_private.h"
+#include "private/svn_string_private.h"
+
+#define NUM_CACHED_SOURCE_ROOTS 4
+
+/* Theory of operation: we write report operations out to a spill-buffer
+ as we receive them. When the report is finished, we read the
+ operations back out again, using them to guide the progression of
+ the delta between the source and target revs.
+
+ Spill-buffer content format: we use a simple ad-hoc format to store the
+ report operations. Each report operation is the concatention of
+ the following ("+/-" indicates the single character '+' or '-';
+ <length> and <revnum> are written out as decimal strings):
+
+ +/- '-' marks the end of the report
+ If previous is +:
+ <length>:<bytes> Length-counted path string
+ +/- '+' indicates the presence of link_path
+ If previous is +:
+ <length>:<bytes> Length-counted link_path string
+ +/- '+' indicates presence of revnum
+ If previous is +:
+ <revnum>: Revnum of set_path or link_path
+ +/- '+' indicates depth other than svn_depth_infinity
+ If previous is +:
+ <depth>: "X","E","F","M" =>
+ svn_depth_{exclude,empty,files,immediates}
+ +/- '+' indicates start_empty field set
+ +/- '+' indicates presence of lock_token field.
+ If previous is +:
+ <length>:<bytes> Length-counted lock_token string
+
+ Terminology: for brevity, this file frequently uses the prefixes
+ "s_" for source, "t_" for target, and "e_" for editor. Also, to
+ avoid overloading the word "target", we talk about the source
+ "anchor and operand", rather than the usual "anchor and target". */
+
+/* Describes the state of a working copy subtree, as given by a
+ report. Because we keep a lookahead pathinfo, we need to allocate
+ each one of these things in a subpool of the report baton and free
+ it when done. */
+typedef struct path_info_t
+{
+ const char *path; /* path, munged to be anchor-relative */
+ const char *link_path; /* NULL for set_path or delete_path */
+ svn_revnum_t rev; /* SVN_INVALID_REVNUM for delete_path */
+ svn_depth_t depth; /* Depth of this path, meaningless for files */
+ svn_boolean_t start_empty; /* Meaningless for delete_path */
+ const char *lock_token; /* NULL if no token */
+ apr_pool_t *pool; /* Container pool */
+} path_info_t;
+
+/* Describes the standard revision properties that are relevant for
+ reports. Since a particular revision will often show up more than
+ once in the report, we cache these properties for the time of the
+ report generation. */
+typedef struct revision_info_t
+{
+ svn_revnum_t rev; /* revision number */
+ svn_string_t* date; /* revision timestamp */
+ svn_string_t* author; /* name of the revisions' author */
+} revision_info_t;
+
+/* A structure used by the routines within the `reporter' vtable,
+ driven by the client as it describes its working copy revisions. */
+typedef struct report_baton_t
+{
+ /* Parameters remembered from svn_repos_begin_report3 */
+ svn_repos_t *repos;
+ const char *fs_base; /* fspath corresponding to wc anchor */
+ const char *s_operand; /* anchor-relative wc target (may be empty) */
+ svn_revnum_t t_rev; /* Revnum which the edit will bring the wc to */
+ const char *t_path; /* FS path the edit will bring the wc to */
+ svn_boolean_t text_deltas; /* Whether to report text deltas */
+ apr_size_t zero_copy_limit; /* Max item size that will be sent using
+ the zero-copy code path. */
+
+ /* If the client requested a specific depth, record it here; if the
+ client did not, then this is svn_depth_unknown, and the depth of
+ information transmitted from server to client will be governed
+ strictly by the path-associated depths recorded in the report. */
+ svn_depth_t requested_depth;
+
+ svn_boolean_t ignore_ancestry;
+ svn_boolean_t send_copyfrom_args;
+ svn_boolean_t is_switch;
+ const svn_delta_editor_t *editor;
+ void *edit_baton;
+ svn_repos_authz_func_t authz_read_func;
+ void *authz_read_baton;
+
+ /* The spill-buffer holding the report. */
+ svn_spillbuf_reader_t *reader;
+
+ /* For the actual editor drive, we'll need a lookahead path info
+ entry, a cache of FS roots, and a pool to store them. */
+ path_info_t *lookahead;
+ svn_fs_root_t *t_root;
+ svn_fs_root_t *s_roots[NUM_CACHED_SOURCE_ROOTS];
+
+ /* Cache for revision properties. This is used to eliminate redundant
+ revprop fetching. */
+ apr_hash_t *revision_infos;
+
+ /* This will not change. So, fetch it once and reuse it. */
+ svn_string_t *repos_uuid;
+ apr_pool_t *pool;
+} report_baton_t;
+
+/* The type of a function that accepts changes to an object's property
+ list. OBJECT is the object whose properties are being changed.
+ NAME is the name of the property to change. VALUE is the new value
+ for the property, or zero if the property should be deleted. */
+typedef svn_error_t *proplist_change_fn_t(report_baton_t *b, void *object,
+ const char *name,
+ const svn_string_t *value,
+ apr_pool_t *pool);
+
+static svn_error_t *delta_dirs(report_baton_t *b, svn_revnum_t s_rev,
+ const char *s_path, const char *t_path,
+ void *dir_baton, const char *e_path,
+ svn_boolean_t start_empty,
+ svn_depth_t wc_depth,
+ svn_depth_t requested_depth,
+ apr_pool_t *pool);
+
+/* --- READING PREVIOUSLY STORED REPORT INFORMATION --- */
+
+static svn_error_t *
+read_number(apr_uint64_t *num, svn_spillbuf_reader_t *reader, apr_pool_t *pool)
+{
+ char c;
+
+ *num = 0;
+ while (1)
+ {
+ SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
+ if (c == ':')
+ break;
+ *num = *num * 10 + (c - '0');
+ }
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+read_string(const char **str, svn_spillbuf_reader_t *reader, apr_pool_t *pool)
+{
+ apr_uint64_t len;
+ apr_size_t size;
+ apr_size_t amt;
+ char *buf;
+
+ SVN_ERR(read_number(&len, reader, pool));
+
+ /* Len can never be less than zero. But could len be so large that
+ len + 1 wraps around and we end up passing 0 to apr_palloc(),
+ thus getting a pointer to no storage? Probably not (16 exabyte
+ string, anyone?) but let's be future-proof anyway. */
+ if (len + 1 < len || len + 1 > APR_SIZE_MAX)
+ {
+ /* xgettext doesn't expand preprocessor definitions, so we must
+ pass translatable string to apr_psprintf() function to create
+ intermediate string with appropriate format specifier. */
+ return svn_error_createf(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL,
+ apr_psprintf(pool,
+ _("Invalid length (%%%s) when "
+ "about to read a string"),
+ APR_UINT64_T_FMT),
+ len);
+ }
+
+ size = (apr_size_t)len;
+ buf = apr_palloc(pool, size+1);
+ if (size > 0)
+ {
+ SVN_ERR(svn_spillbuf__reader_read(&amt, reader, buf, size, pool));
+ SVN_ERR_ASSERT(amt == size);
+ }
+ buf[len] = 0;
+ *str = buf;
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+read_rev(svn_revnum_t *rev, svn_spillbuf_reader_t *reader, apr_pool_t *pool)
+{
+ char c;
+ apr_uint64_t num;
+
+ SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
+ if (c == '+')
+ {
+ SVN_ERR(read_number(&num, reader, pool));
+ *rev = (svn_revnum_t) num;
+ }
+ else
+ *rev = SVN_INVALID_REVNUM;
+ return SVN_NO_ERROR;
+}
+
+/* Read a single character to set *DEPTH (having already read '+')
+ from READER. PATH is the path to which the depth applies, and is
+ used for error reporting only. */
+static svn_error_t *
+read_depth(svn_depth_t *depth, svn_spillbuf_reader_t *reader, const char *path,
+ apr_pool_t *pool)
+{
+ char c;
+
+ SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
+ switch (c)
+ {
+ case 'X':
+ *depth = svn_depth_exclude;
+ break;
+ case 'E':
+ *depth = svn_depth_empty;
+ break;
+ case 'F':
+ *depth = svn_depth_files;
+ break;
+ case 'M':
+ *depth = svn_depth_immediates;
+ break;
+
+ /* Note that we do not tolerate explicit representation of
+ svn_depth_infinity here, because that's not how
+ write_path_info() writes it. */
+ default:
+ return svn_error_createf(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL,
+ _("Invalid depth (%c) for path '%s'"), c, path);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Read a report operation *PI out of READER. Set *PI to NULL if we
+ have reached the end of the report. */
+static svn_error_t *
+read_path_info(path_info_t **pi,
+ svn_spillbuf_reader_t *reader,
+ apr_pool_t *pool)
+{
+ char c;
+
+ SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
+ if (c == '-')
+ {
+ *pi = NULL;
+ return SVN_NO_ERROR;
+ }
+
+ *pi = apr_palloc(pool, sizeof(**pi));
+ SVN_ERR(read_string(&(*pi)->path, reader, pool));
+ SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
+ if (c == '+')
+ SVN_ERR(read_string(&(*pi)->link_path, reader, pool));
+ else
+ (*pi)->link_path = NULL;
+ SVN_ERR(read_rev(&(*pi)->rev, reader, pool));
+ SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
+ if (c == '+')
+ SVN_ERR(read_depth(&((*pi)->depth), reader, (*pi)->path, pool));
+ else
+ (*pi)->depth = svn_depth_infinity;
+ SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
+ (*pi)->start_empty = (c == '+');
+ SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
+ if (c == '+')
+ SVN_ERR(read_string(&(*pi)->lock_token, reader, pool));
+ else
+ (*pi)->lock_token = NULL;
+ (*pi)->pool = pool;
+ return SVN_NO_ERROR;
+}
+
+/* Return true if PI's path is a child of PREFIX (which has length PLEN). */
+static svn_boolean_t
+relevant(path_info_t *pi, const char *prefix, apr_size_t plen)
+{
+ return (pi && strncmp(pi->path, prefix, plen) == 0 &&
+ (!*prefix || pi->path[plen] == '/'));
+}
+
+/* Fetch the next pathinfo from B->reader for a descendant of
+ PREFIX. If the next pathinfo is for an immediate child of PREFIX,
+ set *ENTRY to the path component of the report information and
+ *INFO to the path information for that entry. If the next pathinfo
+ is for a grandchild or other more remote descendant of PREFIX, set
+ *ENTRY to the immediate child corresponding to that descendant and
+ set *INFO to NULL. If the next pathinfo is not for a descendant of
+ PREFIX, or if we reach the end of the report, set both *ENTRY and
+ *INFO to NULL.
+
+ At all times, B->lookahead is presumed to be the next pathinfo not
+ yet returned as an immediate child, or NULL if we have reached the
+ end of the report. Because we use a lookahead element, we can't
+ rely on the usual nested pool lifetimes, so allocate each pathinfo
+ in a subpool of the report baton's pool. The caller should delete
+ (*INFO)->pool when it is done with the information. */
+static svn_error_t *
+fetch_path_info(report_baton_t *b, const char **entry, path_info_t **info,
+ const char *prefix, apr_pool_t *pool)
+{
+ apr_size_t plen = strlen(prefix);
+ const char *relpath, *sep;
+ apr_pool_t *subpool;
+
+ if (!relevant(b->lookahead, prefix, plen))
+ {
+ /* No more entries relevant to prefix. */
+ *entry = NULL;
+ *info = NULL;
+ }
+ else
+ {
+ /* Take a look at the prefix-relative part of the path. */
+ relpath = b->lookahead->path + (*prefix ? plen + 1 : 0);
+ sep = strchr(relpath, '/');
+ if (sep)
+ {
+ /* Return the immediate child part; do not advance. */
+ *entry = apr_pstrmemdup(pool, relpath, sep - relpath);
+ *info = NULL;
+ }
+ else
+ {
+ /* This is an immediate child; return it and advance. */
+ *entry = relpath;
+ *info = b->lookahead;
+ subpool = svn_pool_create(b->pool);
+ SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool));
+ }
+ }
+ return SVN_NO_ERROR;
+}
+
+/* Skip all path info entries relevant to *PREFIX. Call this when the
+ editor drive skips a directory. */
+static svn_error_t *
+skip_path_info(report_baton_t *b, const char *prefix)
+{
+ apr_size_t plen = strlen(prefix);
+ apr_pool_t *subpool;
+
+ while (relevant(b->lookahead, prefix, plen))
+ {
+ svn_pool_destroy(b->lookahead->pool);
+ subpool = svn_pool_create(b->pool);
+ SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool));
+ }
+ return SVN_NO_ERROR;
+}
+
+/* Return true if there is at least one path info entry relevant to *PREFIX. */
+static svn_boolean_t
+any_path_info(report_baton_t *b, const char *prefix)
+{
+ return relevant(b->lookahead, prefix, strlen(prefix));
+}
+
+/* --- DRIVING THE EDITOR ONCE THE REPORT IS FINISHED --- */
+
+/* While driving the editor, the target root will remain constant, but
+ we may have to jump around between source roots depending on the
+ state of the working copy. If we were to open a root each time we
+ revisit a rev, we would get no benefit from node-id caching; on the
+ other hand, if we hold open all the roots we ever visit, we'll use
+ an unbounded amount of memory. As a compromise, we maintain a
+ fixed-size LRU cache of source roots. get_source_root retrieves a
+ root from the cache, using POOL to allocate the new root if
+ necessary. Be careful not to hold onto the root for too long,
+ particularly after recursing, since another call to get_source_root
+ can close it. */
+static svn_error_t *
+get_source_root(report_baton_t *b, svn_fs_root_t **s_root, svn_revnum_t rev)
+{
+ int i;
+ svn_fs_root_t *root, *prev = NULL;
+
+ /* Look for the desired root in the cache, sliding all the unmatched
+ entries backwards a slot to make room for the right one. */
+ for (i = 0; i < NUM_CACHED_SOURCE_ROOTS; i++)
+ {
+ root = b->s_roots[i];
+ b->s_roots[i] = prev;
+ if (root && svn_fs_revision_root_revision(root) == rev)
+ break;
+ prev = root;
+ }
+
+ /* If we didn't find it, throw out the oldest root and open a new one. */
+ if (i == NUM_CACHED_SOURCE_ROOTS)
+ {
+ if (prev)
+ svn_fs_close_root(prev);
+ SVN_ERR(svn_fs_revision_root(&root, b->repos->fs, rev, b->pool));
+ }
+
+ /* Assign the desired root to the first cache slot and hand it back. */
+ b->s_roots[0] = root;
+ *s_root = root;
+ return SVN_NO_ERROR;
+}
+
+/* Call the directory property-setting function of B->editor to set
+ the property NAME to VALUE on DIR_BATON. */
+static svn_error_t *
+change_dir_prop(report_baton_t *b, void *dir_baton, const char *name,
+ const svn_string_t *value, apr_pool_t *pool)
+{
+ return svn_error_trace(b->editor->change_dir_prop(dir_baton, name, value,
+ pool));
+}
+
+/* Call the file property-setting function of B->editor to set the
+ property NAME to VALUE on FILE_BATON. */
+static svn_error_t *
+change_file_prop(report_baton_t *b, void *file_baton, const char *name,
+ const svn_string_t *value, apr_pool_t *pool)
+{
+ return svn_error_trace(b->editor->change_file_prop(file_baton, name, value,
+ pool));
+}
+
+/* For the report B, return the relevant revprop data of revision REV in
+ REVISION_INFO. The revision info will be allocated in b->pool.
+ Temporaries get allocated on SCRATCH_POOL. */
+static svn_error_t *
+get_revision_info(report_baton_t *b,
+ svn_revnum_t rev,
+ revision_info_t** revision_info,
+ apr_pool_t *scratch_pool)
+{
+ apr_hash_t *r_props;
+ svn_string_t *cdate, *author;
+ revision_info_t* info;
+
+ /* Try to find the info in the report's cache */
+ info = apr_hash_get(b->revision_infos, &rev, sizeof(rev));
+ if (!info)
+ {
+ /* Info is not available, yet.
+ Get all revprops. */
+ SVN_ERR(svn_fs_revision_proplist(&r_props,
+ b->repos->fs,
+ rev,
+ scratch_pool));
+
+ /* Extract the committed-date. */
+ cdate = svn_hash_gets(r_props, SVN_PROP_REVISION_DATE);
+
+ /* Extract the last-author. */
+ author = svn_hash_gets(r_props, SVN_PROP_REVISION_AUTHOR);
+
+ /* Create a result object */
+ info = apr_palloc(b->pool, sizeof(*info));
+ info->rev = rev;
+ info->date = cdate ? svn_string_dup(cdate, b->pool) : NULL;
+ info->author = author ? svn_string_dup(author, b->pool) : NULL;
+
+ /* Cache it */
+ apr_hash_set(b->revision_infos, &info->rev, sizeof(rev), info);
+ }
+
+ *revision_info = info;
+ return SVN_NO_ERROR;
+}
+
+
+/* Generate the appropriate property editing calls to turn the
+ properties of S_REV/S_PATH into those of B->t_root/T_PATH. If
+ S_PATH is NULL, this is an add, so assume the target starts with no
+ properties. Pass OBJECT on to the editor function wrapper
+ CHANGE_FN. */
+static svn_error_t *
+delta_proplists(report_baton_t *b, svn_revnum_t s_rev, const char *s_path,
+ const char *t_path, const char *lock_token,
+ proplist_change_fn_t *change_fn,
+ void *object, apr_pool_t *pool)
+{
+ svn_fs_root_t *s_root;
+ apr_hash_t *s_props = NULL, *t_props;
+ apr_array_header_t *prop_diffs;
+ int i;
+ svn_revnum_t crev;
+ revision_info_t *revision_info;
+ svn_boolean_t changed;
+ const svn_prop_t *pc;
+ svn_lock_t *lock;
+ apr_hash_index_t *hi;
+
+ /* Fetch the created-rev and send entry props. */
+ SVN_ERR(svn_fs_node_created_rev(&crev, b->t_root, t_path, pool));
+ if (SVN_IS_VALID_REVNUM(crev))
+ {
+ /* convert committed-rev to string */
+ char buf[SVN_INT64_BUFFER_SIZE];
+ svn_string_t cr_str;
+ cr_str.data = buf;
+ cr_str.len = svn__i64toa(buf, crev);
+
+ /* Transmit the committed-rev. */
+ SVN_ERR(change_fn(b, object,
+ SVN_PROP_ENTRY_COMMITTED_REV, &cr_str, pool));
+
+ SVN_ERR(get_revision_info(b, crev, &revision_info, pool));
+
+ /* Transmit the committed-date. */
+ if (revision_info->date || s_path)
+ SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_COMMITTED_DATE,
+ revision_info->date, pool));
+
+ /* Transmit the last-author. */
+ if (revision_info->author || s_path)
+ SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_LAST_AUTHOR,
+ revision_info->author, pool));
+
+ /* Transmit the UUID. */
+ SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_UUID,
+ b->repos_uuid, pool));
+ }
+
+ /* Update lock properties. */
+ if (lock_token)
+ {
+ SVN_ERR(svn_fs_get_lock(&lock, b->repos->fs, t_path, pool));
+
+ /* Delete a defunct lock. */
+ if (! lock || strcmp(lock_token, lock->token) != 0)
+ SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_LOCK_TOKEN,
+ NULL, pool));
+ }
+
+ if (s_path)
+ {
+ SVN_ERR(get_source_root(b, &s_root, s_rev));
+
+ /* Is this deltification worth our time? */
+ SVN_ERR(svn_fs_props_changed(&changed, b->t_root, t_path, s_root,
+ s_path, pool));
+ if (! changed)
+ return SVN_NO_ERROR;
+
+ /* If so, go ahead and get the source path's properties. */
+ SVN_ERR(svn_fs_node_proplist(&s_props, s_root, s_path, pool));
+ }
+
+ /* Get the target path's properties */
+ SVN_ERR(svn_fs_node_proplist(&t_props, b->t_root, t_path, pool));
+
+ if (s_props && apr_hash_count(s_props))
+ {
+ /* Now transmit the differences. */
+ SVN_ERR(svn_prop_diffs(&prop_diffs, t_props, s_props, pool));
+ for (i = 0; i < prop_diffs->nelts; i++)
+ {
+ pc = &APR_ARRAY_IDX(prop_diffs, i, svn_prop_t);
+ SVN_ERR(change_fn(b, object, pc->name, pc->value, pool));
+ }
+ }
+ else if (apr_hash_count(t_props))
+ {
+ /* So source, i.e. all new. Transmit all target props. */
+ for (hi = apr_hash_first(pool, t_props); hi; hi = apr_hash_next(hi))
+ {
+ const void *key;
+ void *val;
+
+ apr_hash_this(hi, &key, NULL, &val);
+ SVN_ERR(change_fn(b, object, key, val, pool));
+ }
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Baton type to be passed into send_zero_copy_delta.
+ */
+typedef struct zero_copy_baton_t
+{
+ /* don't process data larger than this limit */
+ apr_size_t zero_copy_limit;
+
+ /* window handler and baton to send the data to */
+ svn_txdelta_window_handler_t dhandler;
+ void *dbaton;
+
+ /* return value: will be set to TRUE, if the data was processed. */
+ svn_boolean_t zero_copy_succeeded;
+} zero_copy_baton_t;
+
+/* Implement svn_fs_process_contents_func_t. If LEN is smaller than the
+ * limit given in *BATON, send the CONTENTS as an delta windows to the
+ * handler given in BATON and set the ZERO_COPY_SUCCEEDED flag in that
+ * BATON. Otherwise, reset it to FALSE.
+ * Use POOL for temporary allocations.
+ */
+static svn_error_t *
+send_zero_copy_delta(const unsigned char *contents,
+ apr_size_t len,
+ void *baton,
+ apr_pool_t *pool)
+{
+ zero_copy_baton_t *zero_copy_baton = baton;
+
+ /* if the item is too large, the caller must revert to traditional
+ streaming code. */
+ if (len > zero_copy_baton->zero_copy_limit)
+ {
+ zero_copy_baton->zero_copy_succeeded = FALSE;
+ return SVN_NO_ERROR;
+ }
+
+ SVN_ERR(svn_txdelta_send_contents(contents, len,
+ zero_copy_baton->dhandler,
+ zero_copy_baton->dbaton, pool));
+
+ /* all fine now */
+ zero_copy_baton->zero_copy_succeeded = TRUE;
+ return SVN_NO_ERROR;
+}
+
+
+/* Make the appropriate edits on FILE_BATON to change its contents and
+ properties from those in S_REV/S_PATH to those in B->t_root/T_PATH,
+ possibly using LOCK_TOKEN to determine if the client's lock on the file
+ is defunct. */
+static svn_error_t *
+delta_files(report_baton_t *b, void *file_baton, svn_revnum_t s_rev,
+ const char *s_path, const char *t_path, const char *lock_token,
+ apr_pool_t *pool)
+{
+ svn_boolean_t changed;
+ svn_fs_root_t *s_root = NULL;
+ svn_txdelta_stream_t *dstream = NULL;
+ svn_checksum_t *s_checksum;
+ const char *s_hex_digest = NULL;
+ svn_txdelta_window_handler_t dhandler;
+ void *dbaton;
+
+ /* Compare the files' property lists. */
+ SVN_ERR(delta_proplists(b, s_rev, s_path, t_path, lock_token,
+ change_file_prop, file_baton, pool));
+
+ if (s_path)
+ {
+ SVN_ERR(get_source_root(b, &s_root, s_rev));
+
+ /* We're not interested in the theoretical difference between "has
+ contents which have not changed with respect to" and "has the same
+ actual contents as" when sending text-deltas. If we know the
+ delta is an empty one, we avoiding sending it in either case. */
+ SVN_ERR(svn_repos__compare_files(&changed, b->t_root, t_path,
+ s_root, s_path, pool));
+
+ if (!changed)
+ return SVN_NO_ERROR;
+
+ SVN_ERR(svn_fs_file_checksum(&s_checksum, svn_checksum_md5, s_root,
+ s_path, TRUE, pool));
+ s_hex_digest = svn_checksum_to_cstring(s_checksum, pool);
+ }
+
+ /* Send the delta stream if desired, or just a NULL window if not. */
+ SVN_ERR(b->editor->apply_textdelta(file_baton, s_hex_digest, pool,
+ &dhandler, &dbaton));
+
+ if (dhandler != svn_delta_noop_window_handler)
+ {
+ if (b->text_deltas)
+ {
+ /* if we send deltas against empty streams, we may use our
+ zero-copy code. */
+ if (b->zero_copy_limit > 0 && s_path == NULL)
+ {
+ zero_copy_baton_t baton;
+ svn_boolean_t called = FALSE;
+
+ baton.zero_copy_limit = b->zero_copy_limit;
+ baton.dhandler = dhandler;
+ baton.dbaton = dbaton;
+ baton.zero_copy_succeeded = FALSE;
+ SVN_ERR(svn_fs_try_process_file_contents(&called,
+ b->t_root, t_path,
+ send_zero_copy_delta,
+ &baton, pool));
+
+ /* data has been available and small enough,
+ i.e. been processed? */
+ if (called && baton.zero_copy_succeeded)
+ return SVN_NO_ERROR;
+ }
+
+ SVN_ERR(svn_fs_get_file_delta_stream(&dstream, s_root, s_path,
+ b->t_root, t_path, pool));
+ SVN_ERR(svn_txdelta_send_txstream(dstream, dhandler, dbaton, pool));
+ }
+ else
+ SVN_ERR(dhandler(NULL, dbaton));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Determine if the user is authorized to view B->t_root/PATH. */
+static svn_error_t *
+check_auth(report_baton_t *b, svn_boolean_t *allowed, const char *path,
+ apr_pool_t *pool)
+{
+ if (b->authz_read_func)
+ return svn_error_trace(b->authz_read_func(allowed, b->t_root, path,
+ b->authz_read_baton, pool));
+ *allowed = TRUE;
+ return SVN_NO_ERROR;
+}
+
+/* Create a dirent in *ENTRY for the given ROOT and PATH. We use this to
+ replace the source or target dirent when a report pathinfo tells us to
+ change paths or revisions. */
+static svn_error_t *
+fake_dirent(const svn_fs_dirent_t **entry, svn_fs_root_t *root,
+ const char *path, apr_pool_t *pool)
+{
+ svn_node_kind_t kind;
+ svn_fs_dirent_t *ent;
+
+ SVN_ERR(svn_fs_check_path(&kind, root, path, pool));
+ if (kind == svn_node_none)
+ *entry = NULL;
+ else
+ {
+ ent = apr_palloc(pool, sizeof(**entry));
+ /* ### All callers should be updated to pass just one of these
+ formats */
+ ent->name = (*path == '/') ? svn_fspath__basename(path, pool)
+ : svn_relpath_basename(path, pool);
+ SVN_ERR(svn_fs_node_id(&ent->id, root, path, pool));
+ ent->kind = kind;
+ *entry = ent;
+ }
+ return SVN_NO_ERROR;
+}
+
+
+/* Given REQUESTED_DEPTH, WC_DEPTH and the current entry's KIND,
+ determine whether we need to send the whole entry, not just deltas.
+ Please refer to delta_dirs' docstring for an explanation of the
+ conditionals below. */
+static svn_boolean_t
+is_depth_upgrade(svn_depth_t wc_depth,
+ svn_depth_t requested_depth,
+ svn_node_kind_t kind)
+{
+ if (requested_depth == svn_depth_unknown
+ || requested_depth <= wc_depth
+ || wc_depth == svn_depth_immediates)
+ return FALSE;
+
+ if (kind == svn_node_file
+ && wc_depth == svn_depth_files)
+ return FALSE;
+
+ if (kind == svn_node_dir
+ && wc_depth == svn_depth_empty
+ && requested_depth == svn_depth_files)
+ return FALSE;
+
+ return TRUE;
+}
+
+
+/* Call the B->editor's add_file() function to create PATH as a child
+ of PARENT_BATON, returning a new baton in *NEW_FILE_BATON.
+ However, make an attempt to send 'copyfrom' arguments if they're
+ available, by examining the closest copy of the original file
+ O_PATH within B->t_root. If any copyfrom args are discovered,
+ return those in *COPYFROM_PATH and *COPYFROM_REV; otherwise leave
+ those return args untouched. */
+static svn_error_t *
+add_file_smartly(report_baton_t *b,
+ const char *path,
+ void *parent_baton,
+ const char *o_path,
+ void **new_file_baton,
+ const char **copyfrom_path,
+ svn_revnum_t *copyfrom_rev,
+ apr_pool_t *pool)
+{
+ /* ### TODO: use a subpool to do this work, clear it at the end? */
+ svn_fs_t *fs = svn_repos_fs(b->repos);
+ svn_fs_root_t *closest_copy_root = NULL;
+ const char *closest_copy_path = NULL;
+
+ /* Pre-emptively assume no copyfrom args exist. */
+ *copyfrom_path = NULL;
+ *copyfrom_rev = SVN_INVALID_REVNUM;
+
+ if (b->send_copyfrom_args)
+ {
+ /* Find the destination of the nearest 'copy event' which may have
+ caused o_path@t_root to exist. svn_fs_closest_copy only returns paths
+ starting with '/', so make sure o_path always starts with a '/'
+ too. */
+ if (*o_path != '/')
+ o_path = apr_pstrcat(pool, "/", o_path, (char *)NULL);
+
+ SVN_ERR(svn_fs_closest_copy(&closest_copy_root, &closest_copy_path,
+ b->t_root, o_path, pool));
+ if (closest_copy_root != NULL)
+ {
+ /* If the destination of the copy event is the same path as
+ o_path, then we've found something interesting that should
+ have 'copyfrom' history. */
+ if (strcmp(closest_copy_path, o_path) == 0)
+ {
+ SVN_ERR(svn_fs_copied_from(copyfrom_rev, copyfrom_path,
+ closest_copy_root, closest_copy_path,
+ pool));
+ if (b->authz_read_func)
+ {
+ svn_boolean_t allowed;
+ svn_fs_root_t *copyfrom_root;
+ SVN_ERR(svn_fs_revision_root(&copyfrom_root, fs,
+ *copyfrom_rev, pool));
+ SVN_ERR(b->authz_read_func(&allowed, copyfrom_root,
+ *copyfrom_path, b->authz_read_baton,
+ pool));
+ if (! allowed)
+ {
+ *copyfrom_path = NULL;
+ *copyfrom_rev = SVN_INVALID_REVNUM;
+ }
+ }
+ }
+ }
+ }
+
+ return svn_error_trace(b->editor->add_file(path, parent_baton,
+ *copyfrom_path, *copyfrom_rev,
+ pool, new_file_baton));
+}
+
+
+/* Emit a series of editing operations to transform a source entry to
+ a target entry.
+
+ S_REV and S_PATH specify the source entry. S_ENTRY contains the
+ already-looked-up information about the node-revision existing at
+ that location. S_PATH and S_ENTRY may be NULL if the entry does
+ not exist in the source. S_PATH may be non-NULL and S_ENTRY may be
+ NULL if the caller expects INFO to modify the source to an existing
+ location.
+
+ B->t_root and T_PATH specify the target entry. T_ENTRY contains
+ the already-looked-up information about the node-revision existing
+ at that location. T_PATH and T_ENTRY may be NULL if the entry does
+ not exist in the target.
+
+ DIR_BATON and E_PATH contain the parameters which should be passed
+ to the editor calls--DIR_BATON for the parent directory baton and
+ E_PATH for the pathname. (E_PATH is the anchor-relative working
+ copy pathname, which may differ from the source and target
+ pathnames if the report contains a link_path.)
+
+ INFO contains the report information for this working copy path, or
+ NULL if there is none. This function will internally modify the
+ source and target entries as appropriate based on the report
+ information.
+
+ WC_DEPTH and REQUESTED_DEPTH are propagated to delta_dirs() if
+ necessary. Refer to delta_dirs' docstring to find out what
+ should happen for various combinations of WC_DEPTH/REQUESTED_DEPTH. */
+static svn_error_t *
+update_entry(report_baton_t *b, svn_revnum_t s_rev, const char *s_path,
+ const svn_fs_dirent_t *s_entry, const char *t_path,
+ const svn_fs_dirent_t *t_entry, void *dir_baton,
+ const char *e_path, path_info_t *info, svn_depth_t wc_depth,
+ svn_depth_t requested_depth, apr_pool_t *pool)
+{
+ svn_fs_root_t *s_root;
+ svn_boolean_t allowed, related;
+ void *new_baton;
+ svn_checksum_t *checksum;
+ const char *hex_digest;
+
+ /* For non-switch operations, follow link_path in the target. */
+ if (info && info->link_path && !b->is_switch)
+ {
+ t_path = info->link_path;
+ SVN_ERR(fake_dirent(&t_entry, b->t_root, t_path, pool));
+ }
+
+ if (info && !SVN_IS_VALID_REVNUM(info->rev))
+ {
+ /* Delete this entry in the source. */
+ s_path = NULL;
+ s_entry = NULL;
+ }
+ else if (info && s_path)
+ {
+ /* Follow the rev and possibly path in this entry. */
+ s_path = (info->link_path) ? info->link_path : s_path;
+ s_rev = info->rev;
+ SVN_ERR(get_source_root(b, &s_root, s_rev));
+ SVN_ERR(fake_dirent(&s_entry, s_root, s_path, pool));
+ }
+
+ /* Don't let the report carry us somewhere nonexistent. */
+ if (s_path && !s_entry)
+ return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
+ _("Working copy path '%s' does not exist in "
+ "repository"), e_path);
+
+ /* If the source and target both exist and are of the same kind,
+ then find out whether they're related. If they're exactly the
+ same, then we don't have to do anything (unless the report has
+ changes to the source). If we're ignoring ancestry, then any two
+ nodes of the same type are related enough for us. */
+ related = FALSE;
+ if (s_entry && t_entry && s_entry->kind == t_entry->kind)
+ {
+ int distance = svn_fs_compare_ids(s_entry->id, t_entry->id);
+ if (distance == 0 && !any_path_info(b, e_path)
+ && (requested_depth <= wc_depth || t_entry->kind == svn_node_file))
+ {
+ if (!info)
+ return SVN_NO_ERROR;
+
+ if (!info->start_empty)
+ {
+ svn_lock_t *lock;
+
+ if (!info->lock_token)
+ return SVN_NO_ERROR;
+
+ SVN_ERR(svn_fs_get_lock(&lock, b->repos->fs, t_path, pool));
+ if (lock && (strcmp(lock->token, info->lock_token) == 0))
+ return SVN_NO_ERROR;
+ }
+ }
+
+ related = (distance != -1 || b->ignore_ancestry);
+ }
+
+ /* If there's a source and it's not related to the target, nuke it. */
+ if (s_entry && !related)
+ {
+ svn_revnum_t deleted_rev;
+
+ SVN_ERR(svn_repos_deleted_rev(svn_fs_root_fs(b->t_root), t_path,
+ s_rev, b->t_rev, &deleted_rev,
+ pool));
+
+ if (!SVN_IS_VALID_REVNUM(deleted_rev))
+ {
+ /* Two possibilities: either the thing doesn't exist in S_REV; or
+ it wasn't deleted between S_REV and B->T_REV. In the first case,
+ I think we should leave DELETED_REV as SVN_INVALID_REVNUM, but
+ in the second, it should be set to B->T_REV-1 for the call to
+ delete_entry() below. */
+ svn_node_kind_t kind;
+
+ SVN_ERR(svn_fs_check_path(&kind, b->t_root, t_path, pool));
+ if (kind != svn_node_none)
+ deleted_rev = b->t_rev - 1;
+ }
+
+ SVN_ERR(b->editor->delete_entry(e_path, deleted_rev, dir_baton,
+ pool));
+ s_path = NULL;
+ }
+
+ /* If there's no target, we have nothing more to do. */
+ if (!t_entry)
+ return svn_error_trace(skip_path_info(b, e_path));
+
+ /* Check if the user is authorized to find out about the target. */
+ SVN_ERR(check_auth(b, &allowed, t_path, pool));
+ if (!allowed)
+ {
+ if (t_entry->kind == svn_node_dir)
+ SVN_ERR(b->editor->absent_directory(e_path, dir_baton, pool));
+ else
+ SVN_ERR(b->editor->absent_file(e_path, dir_baton, pool));
+ return svn_error_trace(skip_path_info(b, e_path));
+ }
+
+ if (t_entry->kind == svn_node_dir)
+ {
+ if (related)
+ SVN_ERR(b->editor->open_directory(e_path, dir_baton, s_rev, pool,
+ &new_baton));
+ else
+ SVN_ERR(b->editor->add_directory(e_path, dir_baton, NULL,
+ SVN_INVALID_REVNUM, pool,
+ &new_baton));
+
+ SVN_ERR(delta_dirs(b, s_rev, s_path, t_path, new_baton, e_path,
+ info ? info->start_empty : FALSE,
+ wc_depth, requested_depth, pool));
+ return svn_error_trace(b->editor->close_directory(new_baton, pool));
+ }
+ else
+ {
+ if (related)
+ {
+ SVN_ERR(b->editor->open_file(e_path, dir_baton, s_rev, pool,
+ &new_baton));
+ SVN_ERR(delta_files(b, new_baton, s_rev, s_path, t_path,
+ info ? info->lock_token : NULL, pool));
+ }
+ else
+ {
+ svn_revnum_t copyfrom_rev = SVN_INVALID_REVNUM;
+ const char *copyfrom_path = NULL;
+ SVN_ERR(add_file_smartly(b, e_path, dir_baton, t_path, &new_baton,
+ &copyfrom_path, &copyfrom_rev, pool));
+ if (! copyfrom_path)
+ /* Send txdelta between empty file (s_path@s_rev doesn't
+ exist) and added file (t_path@t_root). */
+ SVN_ERR(delta_files(b, new_baton, s_rev, s_path, t_path,
+ info ? info->lock_token : NULL, pool));
+ else
+ /* Send txdelta between copied file (copyfrom_path@copyfrom_rev)
+ and added file (tpath@t_root). */
+ SVN_ERR(delta_files(b, new_baton, copyfrom_rev, copyfrom_path,
+ t_path, info ? info->lock_token : NULL, pool));
+ }
+
+ SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5, b->t_root,
+ t_path, TRUE, pool));
+ hex_digest = svn_checksum_to_cstring(checksum, pool);
+ return svn_error_trace(b->editor->close_file(new_baton, hex_digest,
+ pool));
+ }
+}
+
+/* A helper macro for when we have to recurse into subdirectories. */
+#define DEPTH_BELOW_HERE(depth) ((depth) == svn_depth_immediates) ? \
+ svn_depth_empty : (depth)
+
+/* Emit edits within directory DIR_BATON (with corresponding path
+ E_PATH) with the changes from the directory S_REV/S_PATH to the
+ directory B->t_rev/T_PATH. S_PATH may be NULL if the entry does
+ not exist in the source.
+
+ WC_DEPTH is this path's depth as reported by set_path/link_path.
+ REQUESTED_DEPTH is derived from the depth set by
+ svn_repos_begin_report().
+
+ When iterating over this directory's entries, the following tables
+ describe what happens for all possible combinations
+ of WC_DEPTH/REQUESTED_DEPTH (rows represent WC_DEPTH, columns
+ represent REQUESTED_DEPTH):
+
+ Legend:
+ X: ignore this entry (it's either below the requested depth, or
+ if the requested depth is svn_depth_unknown, below the working
+ copy depth)
+ o: handle this entry normally
+ U: handle the entry as if it were a newly added repository path
+ (the client is upgrading to a deeper wc and doesn't currently
+ have this entry, but it should be there after the upgrade, so we
+ need to send the whole thing, not just deltas)
+
+ For files:
+ ______________________________________________________________
+ | req. depth| unknown | empty | files | immediates | infinity |
+ |wc. depth | | | | | |
+ |___________|_________|_______|_______|____________|__________|
+ |empty | X | X | U | U | U |
+ |___________|_________|_______|_______|____________|__________|
+ |files | o | X | o | o | o |
+ |___________|_________|_______|_______|____________|__________|
+ |immediates | o | X | o | o | o |
+ |___________|_________|_______|_______|____________|__________|
+ |infinity | o | X | o | o | o |
+ |___________|_________|_______|_______|____________|__________|
+
+ For directories:
+ ______________________________________________________________
+ | req. depth| unknown | empty | files | immediates | infinity |
+ |wc. depth | | | | | |
+ |___________|_________|_______|_______|____________|__________|
+ |empty | X | X | X | U | U |
+ |___________|_________|_______|_______|____________|__________|
+ |files | X | X | X | U | U |
+ |___________|_________|_______|_______|____________|__________|
+ |immediates | o | X | X | o | o |
+ |___________|_________|_______|_______|____________|__________|
+ |infinity | o | X | X | o | o |
+ |___________|_________|_______|_______|____________|__________|
+
+ These rules are enforced by the is_depth_upgrade() function and by
+ various other checks below.
+*/
+static svn_error_t *
+delta_dirs(report_baton_t *b, svn_revnum_t s_rev, const char *s_path,
+ const char *t_path, void *dir_baton, const char *e_path,
+ svn_boolean_t start_empty, svn_depth_t wc_depth,
+ svn_depth_t requested_depth, apr_pool_t *pool)
+{
+ svn_fs_root_t *s_root;
+ apr_hash_t *s_entries = NULL, *t_entries;
+ apr_hash_index_t *hi;
+ apr_pool_t *subpool;
+ const char *name, *s_fullpath, *t_fullpath, *e_fullpath;
+ path_info_t *info;
+
+ /* Compare the property lists. If we're starting empty, pass a NULL
+ source path so that we add all the properties.
+
+ When we support directory locks, we must pass the lock token here. */
+ SVN_ERR(delta_proplists(b, s_rev, start_empty ? NULL : s_path, t_path,
+ NULL, change_dir_prop, dir_baton, pool));
+
+ if (requested_depth > svn_depth_empty
+ || requested_depth == svn_depth_unknown)
+ {
+ /* Get the list of entries in each of source and target. */
+ if (s_path && !start_empty)
+ {
+ SVN_ERR(get_source_root(b, &s_root, s_rev));
+ SVN_ERR(svn_fs_dir_entries(&s_entries, s_root, s_path, pool));
+ }
+ SVN_ERR(svn_fs_dir_entries(&t_entries, b->t_root, t_path, pool));
+
+ /* Iterate over the report information for this directory. */
+ subpool = svn_pool_create(pool);
+
+ while (1)
+ {
+ const svn_fs_dirent_t *s_entry, *t_entry;
+
+ svn_pool_clear(subpool);
+ SVN_ERR(fetch_path_info(b, &name, &info, e_path, subpool));
+ if (!name)
+ break;
+
+ /* Invalid revnum means we should delete, unless this is
+ just an excluded subpath. */
+ if (info
+ && !SVN_IS_VALID_REVNUM(info->rev)
+ && info->depth != svn_depth_exclude)
+ {
+ /* We want to perform deletes before non-replacement adds,
+ for graceful handling of case-only renames on
+ case-insensitive client filesystems. So, if the report
+ item is a delete, remove the entry from the source hash,
+ but don't update the entry yet. */
+ if (s_entries)
+ svn_hash_sets(s_entries, name, NULL);
+ continue;
+ }
+
+ e_fullpath = svn_relpath_join(e_path, name, subpool);
+ t_fullpath = svn_fspath__join(t_path, name, subpool);
+ t_entry = svn_hash_gets(t_entries, name);
+ s_fullpath = s_path ? svn_fspath__join(s_path, name, subpool) : NULL;
+ s_entry = s_entries ?
+ svn_hash_gets(s_entries, name) : NULL;
+
+ /* The only special cases here are
+
+ - When requested_depth is files but the reported path is
+ a directory. This is technically a client error, but we
+ handle it anyway, by skipping the entry.
+
+ - When the reported depth is svn_depth_exclude.
+ */
+ if ((! info || info->depth != svn_depth_exclude)
+ && (requested_depth != svn_depth_files
+ || ((! t_entry || t_entry->kind != svn_node_dir)
+ && (! s_entry || s_entry->kind != svn_node_dir))))
+ SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, t_fullpath,
+ t_entry, dir_baton, e_fullpath, info,
+ info ? info->depth
+ : DEPTH_BELOW_HERE(wc_depth),
+ DEPTH_BELOW_HERE(requested_depth), subpool));
+
+ /* Don't revisit this name in the target or source entries. */
+ svn_hash_sets(t_entries, name, NULL);
+ if (s_entries
+ /* Keep the entry for later process if it is reported as
+ excluded and got deleted in repos. */
+ && (! info || info->depth != svn_depth_exclude || t_entry))
+ svn_hash_sets(s_entries, name, NULL);
+
+ /* pathinfo entries live in their own subpools due to lookahead,
+ so we need to clear each one out as we finish with it. */
+ if (info)
+ svn_pool_destroy(info->pool);
+ }
+
+ /* Remove any deleted entries. Do this before processing the
+ target, for graceful handling of case-only renames. */
+ if (s_entries)
+ {
+ for (hi = apr_hash_first(pool, s_entries);
+ hi;
+ hi = apr_hash_next(hi))
+ {
+ const svn_fs_dirent_t *s_entry;
+
+ svn_pool_clear(subpool);
+ s_entry = svn__apr_hash_index_val(hi);
+
+ if (svn_hash_gets(t_entries, s_entry->name) == NULL)
+ {
+ svn_revnum_t deleted_rev;
+
+ if (s_entry->kind == svn_node_file
+ && wc_depth < svn_depth_files)
+ continue;
+
+ if (s_entry->kind == svn_node_dir
+ && (wc_depth < svn_depth_immediates
+ || requested_depth == svn_depth_files))
+ continue;
+
+ /* There is no corresponding target entry, so delete. */
+ e_fullpath = svn_relpath_join(e_path, s_entry->name, subpool);
+ SVN_ERR(svn_repos_deleted_rev(svn_fs_root_fs(b->t_root),
+ svn_fspath__join(t_path,
+ s_entry->name,
+ subpool),
+ s_rev, b->t_rev,
+ &deleted_rev, subpool));
+
+ SVN_ERR(b->editor->delete_entry(e_fullpath,
+ deleted_rev,
+ dir_baton, subpool));
+ }
+ }
+ }
+
+ /* Loop over the dirents in the target. */
+ for (hi = apr_hash_first(pool, t_entries); hi; hi = apr_hash_next(hi))
+ {
+ const svn_fs_dirent_t *s_entry, *t_entry;
+
+ svn_pool_clear(subpool);
+ t_entry = svn__apr_hash_index_val(hi);
+
+ if (is_depth_upgrade(wc_depth, requested_depth, t_entry->kind))
+ {
+ /* We're making the working copy deeper, pretend the source
+ doesn't exist. */
+ s_entry = NULL;
+ s_fullpath = NULL;
+ }
+ else
+ {
+ if (t_entry->kind == svn_node_file
+ && requested_depth == svn_depth_unknown
+ && wc_depth < svn_depth_files)
+ continue;
+
+ if (t_entry->kind == svn_node_dir
+ && (wc_depth < svn_depth_immediates
+ || requested_depth == svn_depth_files))
+ continue;
+
+ /* Look for an entry with the same name
+ in the source dirents. */
+ s_entry = s_entries ?
+ svn_hash_gets(s_entries, t_entry->name)
+ : NULL;
+ s_fullpath = s_entry ?
+ svn_fspath__join(s_path, t_entry->name, subpool) : NULL;
+ }
+
+ /* Compose the report, editor, and target paths for this entry. */
+ e_fullpath = svn_relpath_join(e_path, t_entry->name, subpool);
+ t_fullpath = svn_fspath__join(t_path, t_entry->name, subpool);
+
+ SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, t_fullpath,
+ t_entry, dir_baton, e_fullpath, NULL,
+ DEPTH_BELOW_HERE(wc_depth),
+ DEPTH_BELOW_HERE(requested_depth),
+ subpool));
+ }
+
+
+ /* Destroy iteration subpool. */
+ svn_pool_destroy(subpool);
+ }
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+drive(report_baton_t *b, svn_revnum_t s_rev, path_info_t *info,
+ apr_pool_t *pool)
+{
+ const char *t_anchor, *s_fullpath;
+ svn_boolean_t allowed, info_is_set_path;
+ svn_fs_root_t *s_root;
+ const svn_fs_dirent_t *s_entry, *t_entry;
+ void *root_baton;
+
+ /* Compute the target path corresponding to the working copy anchor,
+ and check its authorization. */
+ t_anchor = *b->s_operand ? svn_fspath__dirname(b->t_path, pool) : b->t_path;
+ SVN_ERR(check_auth(b, &allowed, t_anchor, pool));
+ if (!allowed)
+ return svn_error_create
+ (SVN_ERR_AUTHZ_ROOT_UNREADABLE, NULL,
+ _("Not authorized to open root of edit operation"));
+
+ /* Collect information about the source and target nodes. */
+ s_fullpath = svn_fspath__join(b->fs_base, b->s_operand, pool);
+ SVN_ERR(get_source_root(b, &s_root, s_rev));
+ SVN_ERR(fake_dirent(&s_entry, s_root, s_fullpath, pool));
+ SVN_ERR(fake_dirent(&t_entry, b->t_root, b->t_path, pool));
+
+ /* If the operand is a locally added file or directory, it won't
+ exist in the source, so accept that. */
+ info_is_set_path = (SVN_IS_VALID_REVNUM(info->rev) && !info->link_path);
+ if (info_is_set_path && !s_entry)
+ s_fullpath = NULL;
+
+ /* Check if the target path exists first. */
+ if (!*b->s_operand && !(t_entry))
+ return svn_error_createf(SVN_ERR_FS_PATH_SYNTAX, NULL,
+ _("Target path '%s' does not exist"),
+ b->t_path);
+
+ /* If the anchor is the operand, the source and target must be dirs.
+ Check this before opening the root to avoid modifying the wc. */
+ else if (!*b->s_operand && (!s_entry || s_entry->kind != svn_node_dir
+ || t_entry->kind != svn_node_dir))
+ return svn_error_create(SVN_ERR_FS_PATH_SYNTAX, NULL,
+ _("Cannot replace a directory from within"));
+
+ SVN_ERR(b->editor->set_target_revision(b->edit_baton, b->t_rev, pool));
+ SVN_ERR(b->editor->open_root(b->edit_baton, s_rev, pool, &root_baton));
+
+ /* If the anchor is the operand, diff the two directories; otherwise
+ update the operand within the anchor directory. */
+ if (!*b->s_operand)
+ SVN_ERR(delta_dirs(b, s_rev, s_fullpath, b->t_path, root_baton,
+ "", info->start_empty, info->depth, b->requested_depth,
+ pool));
+ else
+ SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, b->t_path,
+ t_entry, root_baton, b->s_operand, info,
+ info->depth, b->requested_depth, pool));
+
+ return svn_error_trace(b->editor->close_directory(root_baton, pool));
+}
+
+/* Initialize the baton fields for editor-driving, and drive the editor. */
+static svn_error_t *
+finish_report(report_baton_t *b, apr_pool_t *pool)
+{
+ path_info_t *info;
+ apr_pool_t *subpool;
+ svn_revnum_t s_rev;
+ int i;
+
+ /* Save our pool to manage the lookahead and fs_root cache with. */
+ b->pool = pool;
+
+ /* Add the end marker. */
+ SVN_ERR(svn_spillbuf__reader_write(b->reader, "-", 1, pool));
+
+ /* Read the first pathinfo from the report and verify that it is a top-level
+ set_path entry. */
+ SVN_ERR(read_path_info(&info, b->reader, pool));
+ if (!info || strcmp(info->path, b->s_operand) != 0
+ || info->link_path || !SVN_IS_VALID_REVNUM(info->rev))
+ return svn_error_create(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL,
+ _("Invalid report for top level of working copy"));
+ s_rev = info->rev;
+
+ /* Initialize the lookahead pathinfo. */
+ subpool = svn_pool_create(pool);
+ SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool));
+
+ if (b->lookahead && strcmp(b->lookahead->path, b->s_operand) == 0)
+ {
+ /* If the operand of the wc operation is switched or deleted,
+ then info above is just a place-holder, and the only thing we
+ have to do is pass the revision it contains to open_root.
+ The next pathinfo actually describes the target. */
+ if (!*b->s_operand)
+ return svn_error_create(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL,
+ _("Two top-level reports with no target"));
+ /* If the client issued a set-path followed by a delete-path, we need
+ to respect the depth set by the initial set-path. */
+ if (! SVN_IS_VALID_REVNUM(b->lookahead->rev))
+ {
+ b->lookahead->depth = info->depth;
+ }
+ info = b->lookahead;
+ SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool));
+ }
+
+ /* Open the target root and initialize the source root cache. */
+ SVN_ERR(svn_fs_revision_root(&b->t_root, b->repos->fs, b->t_rev, pool));
+ for (i = 0; i < NUM_CACHED_SOURCE_ROOTS; i++)
+ b->s_roots[i] = NULL;
+
+ {
+ svn_error_t *err = svn_error_trace(drive(b, s_rev, info, pool));
+
+ if (err == SVN_NO_ERROR)
+ return svn_error_trace(b->editor->close_edit(b->edit_baton, pool));
+
+ return svn_error_trace(
+ svn_error_compose_create(err,
+ b->editor->abort_edit(b->edit_baton,
+ pool)));
+ }
+}
+
+/* --- COLLECTING THE REPORT INFORMATION --- */
+
+/* Record a report operation into the spill buffer. Return an error
+ if DEPTH is svn_depth_unknown. */
+static svn_error_t *
+write_path_info(report_baton_t *b, const char *path, const char *lpath,
+ svn_revnum_t rev, svn_depth_t depth,
+ svn_boolean_t start_empty,
+ const char *lock_token, apr_pool_t *pool)
+{
+ const char *lrep, *rrep, *drep, *ltrep, *rep;
+
+ /* Munge the path to be anchor-relative, so that we can use edit paths
+ as report paths. */
+ path = svn_relpath_join(b->s_operand, path, pool);
+
+ lrep = lpath ? apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s",
+ strlen(lpath), lpath) : "-";
+ rrep = (SVN_IS_VALID_REVNUM(rev)) ?
+ apr_psprintf(pool, "+%ld:", rev) : "-";
+
+ if (depth == svn_depth_exclude)
+ drep = "+X";
+ else if (depth == svn_depth_empty)
+ drep = "+E";
+ else if (depth == svn_depth_files)
+ drep = "+F";
+ else if (depth == svn_depth_immediates)
+ drep = "+M";
+ else if (depth == svn_depth_infinity)
+ drep = "-";
+ else
+ return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("Unsupported report depth '%s'"),
+ svn_depth_to_word(depth));
+
+ ltrep = lock_token ? apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s",
+ strlen(lock_token), lock_token) : "-";
+ rep = apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s%s%s%s%c%s",
+ strlen(path), path, lrep, rrep, drep,
+ start_empty ? '+' : '-', ltrep);
+ return svn_error_trace(
+ svn_spillbuf__reader_write(b->reader, rep, strlen(rep), pool));
+}
+
+svn_error_t *
+svn_repos_set_path3(void *baton, const char *path, svn_revnum_t rev,
+ svn_depth_t depth, svn_boolean_t start_empty,
+ const char *lock_token, apr_pool_t *pool)
+{
+ return svn_error_trace(
+ write_path_info(baton, path, NULL, rev, depth, start_empty,
+ lock_token, pool));
+}
+
+svn_error_t *
+svn_repos_link_path3(void *baton, const char *path, const char *link_path,
+ svn_revnum_t rev, svn_depth_t depth,
+ svn_boolean_t start_empty,
+ const char *lock_token, apr_pool_t *pool)
+{
+ if (depth == svn_depth_exclude)
+ return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("Depth 'exclude' not supported for link"));
+
+ return svn_error_trace(
+ write_path_info(baton, path, link_path, rev, depth,
+ start_empty, lock_token, pool));
+}
+
+svn_error_t *
+svn_repos_delete_path(void *baton, const char *path, apr_pool_t *pool)
+{
+ /* We pass svn_depth_infinity because deletion of a path always
+ deletes everything underneath it. */
+ return svn_error_trace(
+ write_path_info(baton, path, NULL, SVN_INVALID_REVNUM,
+ svn_depth_infinity, FALSE, NULL, pool));
+}
+
+svn_error_t *
+svn_repos_finish_report(void *baton, apr_pool_t *pool)
+{
+ report_baton_t *b = baton;
+
+ return svn_error_trace(finish_report(b, pool));
+}
+
+svn_error_t *
+svn_repos_abort_report(void *baton, apr_pool_t *pool)
+{
+ return SVN_NO_ERROR;
+}
+
+/* --- BEGINNING THE REPORT --- */
+
+
+svn_error_t *
+svn_repos_begin_report3(void **report_baton,
+ svn_revnum_t revnum,
+ svn_repos_t *repos,
+ const char *fs_base,
+ const char *s_operand,
+ const char *switch_path,
+ svn_boolean_t text_deltas,
+ svn_depth_t depth,
+ svn_boolean_t ignore_ancestry,
+ svn_boolean_t send_copyfrom_args,
+ const svn_delta_editor_t *editor,
+ void *edit_baton,
+ svn_repos_authz_func_t authz_read_func,
+ void *authz_read_baton,
+ apr_size_t zero_copy_limit,
+ apr_pool_t *pool)
+{
+ report_baton_t *b;
+ const char *uuid;
+
+ if (depth == svn_depth_exclude)
+ return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL,
+ _("Request depth 'exclude' not supported"));
+
+ SVN_ERR(svn_fs_get_uuid(repos->fs, &uuid, pool));
+
+ /* Build a reporter baton. Copy strings in case the caller doesn't
+ keep track of them. */
+ b = apr_palloc(pool, sizeof(*b));
+ b->repos = repos;
+ b->fs_base = svn_fspath__canonicalize(fs_base, pool);
+ b->s_operand = apr_pstrdup(pool, s_operand);
+ b->t_rev = revnum;
+ b->t_path = switch_path ? svn_fspath__canonicalize(switch_path, pool)
+ : svn_fspath__join(b->fs_base, s_operand, pool);
+ b->text_deltas = text_deltas;
+ b->zero_copy_limit = zero_copy_limit;
+ b->requested_depth = depth;
+ b->ignore_ancestry = ignore_ancestry;
+ b->send_copyfrom_args = send_copyfrom_args;
+ b->is_switch = (switch_path != NULL);
+ b->editor = editor;
+ b->edit_baton = edit_baton;
+ b->authz_read_func = authz_read_func;
+ b->authz_read_baton = authz_read_baton;
+ b->revision_infos = apr_hash_make(pool);
+ b->pool = pool;
+ b->reader = svn_spillbuf__reader_create(1000 /* blocksize */,
+ 1000000 /* maxsize */,
+ pool);
+ b->repos_uuid = svn_string_create(uuid, pool);
+
+ /* Hand reporter back to client. */
+ *report_baton = b;
+ return SVN_NO_ERROR;
+}
diff --git a/subversion/libsvn_repos/repos.c b/subversion/libsvn_repos/repos.c
new file mode 100644
index 000000000000..9f10c068e677
--- /dev/null
+++ b/subversion/libsvn_repos/repos.c
@@ -0,0 +1,2132 @@
+/* repos.c : repository creation; shared and exclusive repository locking
+ *
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ */
+
+#include <apr_pools.h>
+#include <apr_file_io.h>
+
+#include "svn_pools.h"
+#include "svn_error.h"
+#include "svn_dirent_uri.h"
+#include "svn_path.h"
+#include "svn_utf.h"
+#include "svn_time.h"
+#include "svn_fs.h"
+#include "svn_ra.h" /* for SVN_RA_CAPABILITY_* */
+#include "svn_repos.h"
+#include "svn_hash.h"
+#include "svn_version.h"
+#include "svn_config.h"
+
+#include "private/svn_repos_private.h"
+#include "private/svn_subr_private.h"
+#include "svn_private_config.h" /* for SVN_TEMPLATE_ROOT_DIR */
+
+#include "repos.h"
+
+/* Used to terminate lines in large multi-line string literals. */
+#define NL APR_EOL_STR
+
+
+/* Path accessor functions. */
+
+
+const char *
+svn_repos_path(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return apr_pstrdup(pool, repos->path);
+}
+
+
+const char *
+svn_repos_db_env(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return apr_pstrdup(pool, repos->db_path);
+}
+
+
+const char *
+svn_repos_conf_dir(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return apr_pstrdup(pool, repos->conf_path);
+}
+
+
+const char *
+svn_repos_svnserve_conf(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->conf_path, SVN_REPOS__CONF_SVNSERVE_CONF, pool);
+}
+
+
+const char *
+svn_repos_lock_dir(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return apr_pstrdup(pool, repos->lock_path);
+}
+
+
+const char *
+svn_repos_db_lockfile(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->lock_path, SVN_REPOS__DB_LOCKFILE, pool);
+}
+
+
+const char *
+svn_repos_db_logs_lockfile(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->lock_path, SVN_REPOS__DB_LOGS_LOCKFILE, pool);
+}
+
+const char *
+svn_repos_hook_dir(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return apr_pstrdup(pool, repos->hook_path);
+}
+
+
+const char *
+svn_repos_start_commit_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_START_COMMIT, pool);
+}
+
+
+const char *
+svn_repos_pre_commit_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_PRE_COMMIT, pool);
+}
+
+
+const char *
+svn_repos_pre_lock_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_PRE_LOCK, pool);
+}
+
+
+const char *
+svn_repos_pre_unlock_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_PRE_UNLOCK, pool);
+}
+
+const char *
+svn_repos_post_lock_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_POST_LOCK, pool);
+}
+
+
+const char *
+svn_repos_post_unlock_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_POST_UNLOCK, pool);
+}
+
+
+const char *
+svn_repos_post_commit_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_POST_COMMIT, pool);
+}
+
+
+const char *
+svn_repos_pre_revprop_change_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_PRE_REVPROP_CHANGE,
+ pool);
+}
+
+
+const char *
+svn_repos_post_revprop_change_hook(svn_repos_t *repos, apr_pool_t *pool)
+{
+ return svn_dirent_join(repos->hook_path, SVN_REPOS__HOOK_POST_REVPROP_CHANGE,
+ pool);
+}
+
+static svn_error_t *
+create_repos_dir(const char *path, apr_pool_t *pool)
+{
+ svn_error_t *err;
+
+ err = svn_io_dir_make(path, APR_OS_DEFAULT, pool);
+ if (err && (APR_STATUS_IS_EEXIST(err->apr_err)))
+ {
+ svn_boolean_t is_empty;
+
+ svn_error_clear(err);
+
+ SVN_ERR(svn_io_dir_empty(&is_empty, path, pool));
+
+ if (is_empty)
+ err = NULL;
+ else
+ err = svn_error_createf(SVN_ERR_DIR_NOT_EMPTY, 0,
+ _("'%s' exists and is non-empty"),
+ svn_dirent_local_style(path, pool));
+ }
+
+ return svn_error_trace(err);
+}
+
+static const char * bdb_lock_file_contents =
+ "DB lock file, representing locks on the versioned filesystem." NL
+ "" NL
+ "All accessors -- both readers and writers -- of the repository's" NL
+ "Berkeley DB environment take out shared locks on this file, and" NL
+ "each accessor removes its lock when done. If and when the DB" NL
+ "recovery procedure is run, the recovery code takes out an" NL
+ "exclusive lock on this file, so we can be sure no one else is" NL
+ "using the DB during the recovery." NL
+ "" NL
+ "You should never have to edit or remove this file." NL;
+
+static const char * bdb_logs_lock_file_contents =
+ "DB logs lock file, representing locks on the versioned filesystem logs." NL
+ "" NL
+ "All log manipulators of the repository's Berkeley DB environment" NL
+ "take out exclusive locks on this file to ensure that only one" NL
+ "accessor manipulates the logs at a time." NL
+ "" NL
+ "You should never have to edit or remove this file." NL;
+
+static const char * pre12_compat_unneeded_file_contents =
+ "This file is not used by Subversion 1.3.x or later." NL
+ "However, its existence is required for compatibility with" NL
+ "Subversion 1.2.x or earlier." NL;
+
+/* Create the DB logs lockfile. */
+static svn_error_t *
+create_db_logs_lock(svn_repos_t *repos, apr_pool_t *pool) {
+ const char *contents;
+ const char *lockfile_path;
+
+ lockfile_path = svn_repos_db_logs_lockfile(repos, pool);
+ if (strcmp(repos->fs_type, SVN_FS_TYPE_BDB) == 0)
+ contents = bdb_logs_lock_file_contents;
+ else
+ contents = pre12_compat_unneeded_file_contents;
+
+ SVN_ERR_W(svn_io_file_create(lockfile_path, contents, pool),
+ _("Creating db logs lock file"));
+
+ return SVN_NO_ERROR;
+}
+
+/* Create the DB lockfile. */
+static svn_error_t *
+create_db_lock(svn_repos_t *repos, apr_pool_t *pool) {
+ const char *contents;
+ const char *lockfile_path;
+
+ lockfile_path = svn_repos_db_lockfile(repos, pool);
+ if (strcmp(repos->fs_type, SVN_FS_TYPE_BDB) == 0)
+ contents = bdb_lock_file_contents;
+ else
+ contents = pre12_compat_unneeded_file_contents;
+
+ SVN_ERR_W(svn_io_file_create(lockfile_path, contents, pool),
+ _("Creating db lock file"));
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+create_locks(svn_repos_t *repos, apr_pool_t *pool)
+{
+ /* Create the locks directory. */
+ SVN_ERR_W(create_repos_dir(repos->lock_path, pool),
+ _("Creating lock dir"));
+
+ SVN_ERR(create_db_lock(repos, pool));
+ return create_db_logs_lock(repos, pool);
+}
+
+
+#define HOOKS_ENVIRONMENT_TEXT \
+ "# The hook program typically does not inherit the environment of" NL \
+ "# its parent process. For example, a common problem is for the" NL \
+ "# PATH environment variable to not be set to its usual value, so" NL \
+ "# that subprograms fail to launch unless invoked via absolute path." NL \
+ "# If you're having unexpected problems with a hook program, the" NL \
+ "# culprit may be unusual (or missing) environment variables." NL
+
+#define PREWRITTEN_HOOKS_TEXT \
+ "# For more examples and pre-written hooks, see those in" NL \
+ "# the Subversion repository at" NL \
+ "# http://svn.apache.org/repos/asf/subversion/trunk/tools/hook-scripts/ and" NL \
+ "# http://svn.apache.org/repos/asf/subversion/trunk/contrib/hook-scripts/" NL
+
+
+static svn_error_t *
+create_hooks(svn_repos_t *repos, apr_pool_t *pool)
+{
+ const char *this_path, *contents;
+
+ /* Create the hook directory. */
+ SVN_ERR_W(create_repos_dir(repos->hook_path, pool),
+ _("Creating hook directory"));
+
+ /*** Write a default template for each standard hook file. */
+
+ /* Start-commit hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_start_commit_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_START_COMMIT
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# START-COMMIT HOOK" NL
+"#" NL
+"# The start-commit hook is invoked immediately after a Subversion txn is" NL
+"# created and populated with initial revprops in the process of doing a" NL
+"# commit. Subversion runs this hook by invoking a program (script, " NL
+"# executable, binary, etc.) named '"SCRIPT_NAME"' (for which this file" NL
+"# is a template) with the following ordered arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] USER (the authenticated user attempting to commit)" NL
+"# [3] CAPABILITIES (a colon-separated list of capabilities reported" NL
+"# by the client; see note below)" NL
+"# [4] TXN-NAME (the name of the commit txn just created)" NL
+"#" NL
+"# Note: The CAPABILITIES parameter is new in Subversion 1.5, and 1.5" NL
+"# clients will typically report at least the \"" \
+ SVN_RA_CAPABILITY_MERGEINFO "\" capability." NL
+"# If there are other capabilities, then the list is colon-separated," NL
+"# e.g.: \"" SVN_RA_CAPABILITY_MERGEINFO ":some-other-capability\" " \
+ "(the order is undefined)." NL
+"#" NL
+"# Note: The TXN-NAME parameter is new in Subversion 1.8. Prior to version" NL
+"# 1.8, the start-commit hook was invoked before the commit txn was even" NL
+"# created, so the ability to inspect the commit txn and its metadata from" NL
+"# within the start-commit hook was not possible." NL
+"# " NL
+"# The list is self-reported by the client. Therefore, you should not" NL
+"# make security assumptions based on the capabilities list, nor should" NL
+"# you assume that clients reliably report every capability they have." NL
+"#" NL
+"# The working directory for this hook program's invocation is undefined," NL
+"# so the program should set one explicitly if it cares." NL
+"#" NL
+"# If the hook program exits with success, the commit continues; but" NL
+"# if it exits with failure (non-zero), the commit is stopped before" NL
+"# a Subversion txn is created, and STDERR is returned to the client." NL
+"#" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"# " NL
+HOOKS_ENVIRONMENT_TEXT
+"# " NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter." NL
+PREWRITTEN_HOOKS_TEXT
+"" NL
+"" NL
+"REPOS=\"$1\"" NL
+"USER=\"$2\"" NL
+"" NL
+"commit-allower.pl --repository \"$REPOS\" --user \"$USER\" || exit 1" NL
+"special-auth-check.py --user \"$USER\" --auth-level 3 || exit 1" NL
+"" NL
+"# All checks passed, so allow the commit." NL
+"exit 0" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ _("Creating start-commit hook"));
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end start-commit hook */
+
+ /* Pre-commit hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_pre_commit_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_PRE_COMMIT
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# PRE-COMMIT HOOK" NL
+"#" NL
+"# The pre-commit hook is invoked before a Subversion txn is" NL
+"# committed. Subversion runs this hook by invoking a program" NL
+"# (script, executable, binary, etc.) named '"SCRIPT_NAME"' (for which" NL
+"# this file is a template), with the following ordered arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] TXN-NAME (the name of the txn about to be committed)" NL
+"#" NL
+"# [STDIN] LOCK-TOKENS ** the lock tokens are passed via STDIN." NL
+"#" NL
+"# If STDIN contains the line \"LOCK-TOKENS:\\n\" (the \"\\n\" denotes a" NL
+"# single newline), the lines following it are the lock tokens for" NL
+"# this commit. The end of the list is marked by a line containing" NL
+"# only a newline character." NL
+"#" NL
+"# Each lock token line consists of a URI-escaped path, followed" NL
+"# by the separator character '|', followed by the lock token string," NL
+"# followed by a newline." NL
+"#" NL
+"# The default working directory for the invocation is undefined, so" NL
+"# the program should set one explicitly if it cares." NL
+"#" NL
+"# If the hook program exits with success, the txn is committed; but" NL
+"# if it exits with failure (non-zero), the txn is aborted, no commit" NL
+"# takes place, and STDERR is returned to the client. The hook" NL
+"# program can use the 'svnlook' utility to help it examine the txn." NL
+"#" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# *** NOTE: THE HOOK PROGRAM MUST NOT MODIFY THE TXN, EXCEPT ***" NL
+"# *** FOR REVISION PROPERTIES (like svn:log or svn:author). ***" NL
+"#" NL
+"# This is why we recommend using the read-only 'svnlook' utility." NL
+"# In the future, Subversion may enforce the rule that pre-commit" NL
+"# hooks should not modify the versioned data in txns, or else come" NL
+"# up with a mechanism to make it safe to do so (by informing the" NL
+"# committing client of the changes). However, right now neither" NL
+"# mechanism is implemented, so hook writers just have to be careful." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"#" NL
+HOOKS_ENVIRONMENT_TEXT
+"# " NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter." NL
+PREWRITTEN_HOOKS_TEXT
+"" NL
+"" NL
+"REPOS=\"$1\"" NL
+"TXN=\"$2\"" NL
+"" NL
+"# Make sure that the log message contains some text." NL
+"SVNLOOK=" SVN_BINDIR "/svnlook" NL
+"$SVNLOOK log -t \"$TXN\" \"$REPOS\" | \\" NL
+" grep \"[a-zA-Z0-9]\" > /dev/null || exit 1" NL
+"" NL
+"# Check that the author of this commit has the rights to perform" NL
+"# the commit on the files and directories being modified." NL
+"commit-access-control.pl \"$REPOS\" \"$TXN\" commit-access-control.cfg || exit 1"
+ NL
+"" NL
+"# All checks passed, so allow the commit." NL
+"exit 0" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ _("Creating pre-commit hook"));
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end pre-commit hook */
+
+
+ /* Pre-revprop-change hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_pre_revprop_change_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_PRE_REVPROP_CHANGE
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# PRE-REVPROP-CHANGE HOOK" NL
+"#" NL
+"# The pre-revprop-change hook is invoked before a revision property" NL
+"# is added, modified or deleted. Subversion runs this hook by invoking" NL
+"# a program (script, executable, binary, etc.) named '"SCRIPT_NAME"'" NL
+"# (for which this file is a template), with the following ordered" NL
+"# arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] REV (the revision being tweaked)" NL
+"# [3] USER (the username of the person tweaking the property)" NL
+"# [4] PROPNAME (the property being set on the revision)" NL
+"# [5] ACTION (the property is being 'A'dded, 'M'odified, or 'D'eleted)"
+ NL
+"#" NL
+"# [STDIN] PROPVAL ** the new property value is passed via STDIN." NL
+"#" NL
+"# If the hook program exits with success, the propchange happens; but" NL
+"# if it exits with failure (non-zero), the propchange doesn't happen." NL
+"# The hook program can use the 'svnlook' utility to examine the " NL
+"# existing value of the revision property." NL
+"#" NL
+"# WARNING: unlike other hooks, this hook MUST exist for revision" NL
+"# properties to be changed. If the hook does not exist, Subversion " NL
+"# will behave as if the hook were present, but failed. The reason" NL
+"# for this is that revision properties are UNVERSIONED, meaning that" NL
+"# a successful propchange is destructive; the old value is gone" NL
+"# forever. We recommend the hook back up the old value somewhere." NL
+"#" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"#" NL
+HOOKS_ENVIRONMENT_TEXT
+"# " NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter." NL
+PREWRITTEN_HOOKS_TEXT
+"" NL
+"" NL
+"REPOS=\"$1\"" NL
+"REV=\"$2\"" NL
+"USER=\"$3\"" NL
+"PROPNAME=\"$4\"" NL
+"ACTION=\"$5\"" NL
+"" NL
+"if [ \"$ACTION\" = \"M\" -a \"$PROPNAME\" = \"svn:log\" ]; then exit 0; fi" NL
+"" NL
+"echo \"Changing revision properties other than svn:log is prohibited\" >&2" NL
+"exit 1" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ _("Creating pre-revprop-change hook"));
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end pre-revprop-change hook */
+
+
+ /* Pre-lock hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_pre_lock_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_PRE_LOCK
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# PRE-LOCK HOOK" NL
+"#" NL
+"# The pre-lock hook is invoked before an exclusive lock is" NL
+"# created. Subversion runs this hook by invoking a program " NL
+"# (script, executable, binary, etc.) named '"SCRIPT_NAME"' (for which" NL
+"# this file is a template), with the following ordered arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] PATH (the path in the repository about to be locked)" NL
+"# [3] USER (the user creating the lock)" NL
+"# [4] COMMENT (the comment of the lock)" NL
+"# [5] STEAL-LOCK (1 if the user is trying to steal the lock, else 0)" NL
+"#" NL
+"# If the hook program outputs anything on stdout, the output string will" NL
+"# be used as the lock token for this lock operation. If you choose to use" NL
+"# this feature, you must guarantee the tokens generated are unique across" NL
+"# the repository each time." NL
+"#" NL
+"# The default working directory for the invocation is undefined, so" NL
+"# the program should set one explicitly if it cares." NL
+"#" NL
+"# If the hook program exits with success, the lock is created; but" NL
+"# if it exits with failure (non-zero), the lock action is aborted" NL
+"# and STDERR is returned to the client." NL
+"" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"#" NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter:" NL
+"" NL
+"REPOS=\"$1\"" NL
+"PATH=\"$2\"" NL
+"USER=\"$3\"" NL
+"COMMENT=\"$4\"" NL
+"STEAL=\"$5\"" NL
+"" NL
+"# If a lock exists and is owned by a different person, don't allow it" NL
+"# to be stolen (e.g., with 'svn lock --force ...')." NL
+"" NL
+"# (Maybe this script could send email to the lock owner?)" NL
+"SVNLOOK=" SVN_BINDIR "/svnlook" NL
+"GREP=/bin/grep" NL
+"SED=/bin/sed" NL
+"" NL
+"LOCK_OWNER=`$SVNLOOK lock \"$REPOS\" \"$PATH\" | \\" NL
+" $GREP '^Owner: ' | $SED 's/Owner: //'`" NL
+"" NL
+"# If we get no result from svnlook, there's no lock, allow the lock to" NL
+"# happen:" NL
+"if [ \"$LOCK_OWNER\" = \"\" ]; then" NL
+" exit 0" NL
+"fi" NL
+"" NL
+"# If the person locking matches the lock's owner, allow the lock to" NL
+"# happen:" NL
+"if [ \"$LOCK_OWNER\" = \"$USER\" ]; then" NL
+" exit 0" NL
+"fi" NL
+"" NL
+"# Otherwise, we've got an owner mismatch, so return failure:" NL
+"echo \"Error: $PATH already locked by ${LOCK_OWNER}.\" 1>&2" NL
+"exit 1" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ "Creating pre-lock hook");
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end pre-lock hook */
+
+
+ /* Pre-unlock hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_pre_unlock_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_PRE_UNLOCK
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# PRE-UNLOCK HOOK" NL
+"#" NL
+"# The pre-unlock hook is invoked before an exclusive lock is" NL
+"# destroyed. Subversion runs this hook by invoking a program " NL
+"# (script, executable, binary, etc.) named '"SCRIPT_NAME"' (for which" NL
+"# this file is a template), with the following ordered arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] PATH (the path in the repository about to be unlocked)" NL
+"# [3] USER (the user destroying the lock)" NL
+"# [4] TOKEN (the lock token to be destroyed)" NL
+"# [5] BREAK-UNLOCK (1 if the user is breaking the lock, else 0)" NL
+"#" NL
+"# The default working directory for the invocation is undefined, so" NL
+"# the program should set one explicitly if it cares." NL
+"#" NL
+"# If the hook program exits with success, the lock is destroyed; but" NL
+"# if it exits with failure (non-zero), the unlock action is aborted" NL
+"# and STDERR is returned to the client." NL
+"" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"#" NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter:" NL
+"" NL
+"REPOS=\"$1\"" NL
+"PATH=\"$2\"" NL
+"USER=\"$3\"" NL
+"TOKEN=\"$4\"" NL
+"BREAK=\"$5\"" NL
+"" NL
+"# If a lock is owned by a different person, don't allow it be broken." NL
+"# (Maybe this script could send email to the lock owner?)" NL
+"" NL
+"SVNLOOK=" SVN_BINDIR "/svnlook" NL
+"GREP=/bin/grep" NL
+"SED=/bin/sed" NL
+"" NL
+"LOCK_OWNER=`$SVNLOOK lock \"$REPOS\" \"$PATH\" | \\" NL
+" $GREP '^Owner: ' | $SED 's/Owner: //'`" NL
+"" NL
+"# If we get no result from svnlook, there's no lock, return success:" NL
+"if [ \"$LOCK_OWNER\" = \"\" ]; then" NL
+" exit 0" NL
+"fi" NL
+"" NL
+"# If the person unlocking matches the lock's owner, return success:" NL
+"if [ \"$LOCK_OWNER\" = \"$USER\" ]; then" NL
+" exit 0" NL
+"fi" NL
+"" NL
+"# Otherwise, we've got an owner mismatch, so return failure:" NL
+"echo \"Error: $PATH locked by ${LOCK_OWNER}.\" 1>&2" NL
+"exit 1" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ "Creating pre-unlock hook");
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end pre-unlock hook */
+
+
+
+ /* Post-commit hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_post_commit_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_POST_COMMIT
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# POST-COMMIT HOOK" NL
+"#" NL
+"# The post-commit hook is invoked after a commit. Subversion runs" NL
+"# this hook by invoking a program (script, executable, binary, etc.)" NL
+"# named '"SCRIPT_NAME"' (for which this file is a template) with the " NL
+"# following ordered arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] REV (the number of the revision just committed)" NL
+"# [3] TXN-NAME (the name of the transaction that has become REV)" NL
+"#" NL
+"# The default working directory for the invocation is undefined, so" NL
+"# the program should set one explicitly if it cares." NL
+"#" NL
+"# Because the commit has already completed and cannot be undone," NL
+"# the exit code of the hook program is ignored. The hook program" NL
+"# can use the 'svnlook' utility to help it examine the" NL
+"# newly-committed tree." NL
+"#" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"# " NL
+HOOKS_ENVIRONMENT_TEXT
+"# " NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter." NL
+PREWRITTEN_HOOKS_TEXT
+"" NL
+"" NL
+"REPOS=\"$1\"" NL
+"REV=\"$2\"" NL
+"TXN_NAME=\"$3\"" NL
+ NL
+"mailer.py commit \"$REPOS\" \"$REV\" /path/to/mailer.conf" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ _("Creating post-commit hook"));
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end post-commit hook */
+
+
+ /* Post-lock hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_post_lock_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_POST_LOCK
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# POST-LOCK HOOK" NL
+"#" NL
+"# The post-lock hook is run after a path is locked. Subversion runs" NL
+"# this hook by invoking a program (script, executable, binary, etc.)" NL
+"# named '"SCRIPT_NAME"' (for which this file is a template) with the " NL
+"# following ordered arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] USER (the user who created the lock)" NL
+"#" NL
+"# The paths that were just locked are passed to the hook via STDIN (as" NL
+"# of Subversion 1.2, only one path is passed per invocation, but the" NL
+"# plan is to pass all locked paths at once, so the hook program" NL
+"# should be written accordingly)." NL
+"#" NL
+"# The default working directory for the invocation is undefined, so" NL
+"# the program should set one explicitly if it cares." NL
+"#" NL
+"# Because the lock has already been created and cannot be undone," NL
+"# the exit code of the hook program is ignored. The hook program" NL
+"# can use the 'svnlook' utility to help it examine the" NL
+"# newly-created lock." NL
+"#" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"# " NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter:" NL
+"" NL
+"REPOS=\"$1\"" NL
+"USER=\"$2\"" NL
+"" NL
+"# Send email to interested parties, let them know a lock was created:" NL
+"mailer.py lock \"$REPOS\" \"$USER\" /path/to/mailer.conf" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ "Creating post-lock hook");
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end post-lock hook */
+
+
+ /* Post-unlock hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_post_unlock_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_POST_UNLOCK
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# POST-UNLOCK HOOK" NL
+"#" NL
+"# The post-unlock hook runs after a path is unlocked. Subversion runs" NL
+"# this hook by invoking a program (script, executable, binary, etc.)" NL
+"# named '"SCRIPT_NAME"' (for which this file is a template) with the " NL
+"# following ordered arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] USER (the user who destroyed the lock)" NL
+"#" NL
+"# The paths that were just unlocked are passed to the hook via STDIN" NL
+"# (as of Subversion 1.2, only one path is passed per invocation, but" NL
+"# the plan is to pass all unlocked paths at once, so the hook program" NL
+"# should be written accordingly)." NL
+"#" NL
+"# The default working directory for the invocation is undefined, so" NL
+"# the program should set one explicitly if it cares." NL
+"#" NL
+"# Because the lock has already been destroyed and cannot be undone," NL
+"# the exit code of the hook program is ignored." NL
+"#" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"# " NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter:" NL
+"" NL
+"REPOS=\"$1\"" NL
+"USER=\"$2\"" NL
+"" NL
+"# Send email to interested parties, let them know a lock was removed:" NL
+"mailer.py unlock \"$REPOS\" \"$USER\" /path/to/mailer.conf" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ "Creating post-unlock hook");
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end post-unlock hook */
+
+
+ /* Post-revprop-change hook. */
+ {
+ this_path = apr_psprintf(pool, "%s%s",
+ svn_repos_post_revprop_change_hook(repos, pool),
+ SVN_REPOS__HOOK_DESC_EXT);
+
+#define SCRIPT_NAME SVN_REPOS__HOOK_POST_REVPROP_CHANGE
+
+ contents =
+"#!/bin/sh" NL
+"" NL
+"# POST-REVPROP-CHANGE HOOK" NL
+"#" NL
+"# The post-revprop-change hook is invoked after a revision property" NL
+"# has been added, modified or deleted. Subversion runs this hook by" NL
+"# invoking a program (script, executable, binary, etc.) named" NL
+"# '"SCRIPT_NAME"' (for which this file is a template), with the" NL
+"# following ordered arguments:" NL
+"#" NL
+"# [1] REPOS-PATH (the path to this repository)" NL
+"# [2] REV (the revision that was tweaked)" NL
+"# [3] USER (the username of the person tweaking the property)" NL
+"# [4] PROPNAME (the property that was changed)" NL
+"# [5] ACTION (the property was 'A'dded, 'M'odified, or 'D'eleted)" NL
+"#" NL
+"# [STDIN] PROPVAL ** the old property value is passed via STDIN." NL
+"#" NL
+"# Because the propchange has already completed and cannot be undone," NL
+"# the exit code of the hook program is ignored. The hook program" NL
+"# can use the 'svnlook' utility to help it examine the" NL
+"# new property value." NL
+"#" NL
+"# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
+"# invoke other programs to do the real work, though it may do the" NL
+"# work itself too." NL
+"#" NL
+"# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
+"# invoke it (typically the user httpd runs as), and that user must" NL
+"# have filesystem-level permission to access the repository." NL
+"#" NL
+"# On a Windows system, you should name the hook program" NL
+"# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
+"# but the basic idea is the same." NL
+"# " NL
+HOOKS_ENVIRONMENT_TEXT
+"# " NL
+"# Here is an example hook script, for a Unix /bin/sh interpreter." NL
+PREWRITTEN_HOOKS_TEXT
+"" NL
+"" NL
+"REPOS=\"$1\"" NL
+"REV=\"$2\"" NL
+"USER=\"$3\"" NL
+"PROPNAME=\"$4\"" NL
+"ACTION=\"$5\"" NL
+"" NL
+"mailer.py propchange2 \"$REPOS\" \"$REV\" \"$USER\" \"$PROPNAME\" "
+"\"$ACTION\" /path/to/mailer.conf" NL;
+
+#undef SCRIPT_NAME
+
+ SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
+ _("Creating post-revprop-change hook"));
+
+ SVN_ERR(svn_io_set_file_executable(this_path, TRUE, FALSE, pool));
+ } /* end post-revprop-change hook */
+
+ return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+create_conf(svn_repos_t *repos, apr_pool_t *pool)
+{
+ SVN_ERR_W(create_repos_dir(repos->conf_path, pool),
+ _("Creating conf directory"));
+
+ /* Write a default template for svnserve.conf. */
+ {
+ static const char * const svnserve_conf_contents =
+"### This file controls the configuration of the svnserve daemon, if you" NL
+"### use it to allow access to this repository. (If you only allow" NL
+"### access through http: and/or file: URLs, then this file is" NL
+"### irrelevant.)" NL
+"" NL
+"### Visit http://subversion.apache.org/ for more information." NL
+"" NL
+"[general]" NL
+"### The anon-access and auth-access options control access to the" NL
+"### repository for unauthenticated (a.k.a. anonymous) users and" NL
+"### authenticated users, respectively." NL
+"### Valid values are \"write\", \"read\", and \"none\"." NL
+"### Setting the value to \"none\" prohibits both reading and writing;" NL
+"### \"read\" allows read-only access, and \"write\" allows complete " NL
+"### read/write access to the repository." NL
+"### The sample settings below are the defaults and specify that anonymous" NL
+"### users have read-only access to the repository, while authenticated" NL
+"### users have read and write access to the repository." NL
+"# anon-access = read" NL
+"# auth-access = write" NL
+"### The password-db option controls the location of the password" NL
+"### database file. Unless you specify a path starting with a /," NL
+"### the file's location is relative to the directory containing" NL
+"### this configuration file." NL
+"### If SASL is enabled (see below), this file will NOT be used." NL
+"### Uncomment the line below to use the default password file." NL
+"# password-db = passwd" NL
+"### The authz-db option controls the location of the authorization" NL
+"### rules for path-based access control. Unless you specify a path" NL
+"### starting with a /, the file's location is relative to the" NL
+"### directory containing this file. The specified path may be a" NL
+"### repository relative URL (^/) or an absolute file:// URL to a text" NL
+"### file in a Subversion repository. If you don't specify an authz-db," NL
+"### no path-based access control is done." NL
+"### Uncomment the line below to use the default authorization file." NL
+"# authz-db = " SVN_REPOS__CONF_AUTHZ NL
+"### The groups-db option controls the location of the groups file." NL
+"### Unless you specify a path starting with a /, the file's location is" NL
+"### relative to the directory containing this file. The specified path" NL
+"### may be a repository relative URL (^/) or an absolute file:// URL to a" NL
+"### text file in a Subversion repository." NL
+"# groups-db = " SVN_REPOS__CONF_GROUPS NL
+"### This option specifies the authentication realm of the repository." NL
+"### If two repositories have the same authentication realm, they should" NL
+"### have the same password database, and vice versa. The default realm" NL
+"### is repository's uuid." NL
+"# realm = My First Repository" NL
+"### The force-username-case option causes svnserve to case-normalize" NL
+"### usernames before comparing them against the authorization rules in the" NL
+"### authz-db file configured above. Valid values are \"upper\" (to upper-" NL
+"### case the usernames), \"lower\" (to lowercase the usernames), and" NL
+"### \"none\" (to compare usernames as-is without case conversion, which" NL
+"### is the default behavior)." NL
+"# force-username-case = none" NL
+"### The hooks-env options specifies a path to the hook script environment " NL
+"### configuration file. This option overrides the per-repository default" NL
+"### and can be used to configure the hook script environment for multiple " NL
+"### repositories in a single file, if an absolute path is specified." NL
+"### Unless you specify an absolute path, the file's location is relative" NL
+"### to the directory containing this file." NL
+"# hooks-env = " SVN_REPOS__CONF_HOOKS_ENV NL
+"" NL
+"[sasl]" NL
+"### This option specifies whether you want to use the Cyrus SASL" NL
+"### library for authentication. Default is false." NL
+"### This section will be ignored if svnserve is not built with Cyrus" NL
+"### SASL support; to check, run 'svnserve --version' and look for a line" NL
+"### reading 'Cyrus SASL authentication is available.'" NL
+"# use-sasl = true" NL
+"### These options specify the desired strength of the security layer" NL
+"### that you want SASL to provide. 0 means no encryption, 1 means" NL
+"### integrity-checking only, values larger than 1 are correlated" NL
+"### to the effective key length for encryption (e.g. 128 means 128-bit" NL
+"### encryption). The values below are the defaults." NL
+"# min-encryption = 0" NL
+"# max-encryption = 256" NL;
+
+ SVN_ERR_W(svn_io_file_create(svn_repos_svnserve_conf(repos, pool),
+ svnserve_conf_contents, pool),
+ _("Creating svnserve.conf file"));
+ }
+
+ {
+ static const char * const passwd_contents =
+"### This file is an example password file for svnserve." NL
+"### Its format is similar to that of svnserve.conf. As shown in the" NL
+"### example below it contains one section labelled [users]." NL
+"### The name and password for each user follow, one account per line." NL
+"" NL
+"[users]" NL
+"# harry = harryssecret" NL
+"# sally = sallyssecret" NL;
+
+ SVN_ERR_W(svn_io_file_create(svn_dirent_join(repos->conf_path,
+ SVN_REPOS__CONF_PASSWD,
+ pool),
+ passwd_contents, pool),
+ _("Creating passwd file"));
+ }
+
+ {
+ static const char * const authz_contents =
+"### This file is an example authorization file for svnserve." NL
+"### Its format is identical to that of mod_authz_svn authorization" NL
+"### files." NL
+"### As shown below each section defines authorizations for the path and" NL
+"### (optional) repository specified by the section name." NL
+"### The authorizations follow. An authorization line can refer to:" NL
+"### - a single user," NL
+"### - a group of users defined in a special [groups] section," NL
+"### - an alias defined in a special [aliases] section," NL
+"### - all authenticated users, using the '$authenticated' token," NL
+"### - only anonymous users, using the '$anonymous' token," NL
+"### - anyone, using the '*' wildcard." NL
+"###" NL
+"### A match can be inverted by prefixing the rule with '~'. Rules can" NL
+"### grant read ('r') access, read-write ('rw') access, or no access" NL
+"### ('')." NL
+"" NL
+"[aliases]" NL
+"# joe = /C=XZ/ST=Dessert/L=Snake City/O=Snake Oil, Ltd./OU=Research Institute/CN=Joe Average" NL
+"" NL
+"[groups]" NL
+"# harry_and_sally = harry,sally" NL
+"# harry_sally_and_joe = harry,sally,&joe" NL