subversion-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "SpArkx (JIRA)" <j...@apache.org>
Subject [jira] [Updated] (SVN-4809) GitHub Customer Data Protection
Date Fri, 08 Mar 2019 16:05:00 GMT

     [ https://issues.apache.org/jira/browse/SVN-4809?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

SpArkx updated SVN-4809:
------------------------
    Priority: Minor  (was: Major)

> GitHub Customer Data Protection 
> --------------------------------
>
>                 Key: SVN-4809
>                 URL: https://issues.apache.org/jira/browse/SVN-4809
>             Project: Subversion
>          Issue Type: Test
>          Components: contrib/svnmerge.py, svnsync, svnversion
>    Affects Versions: 2.0-consider
>         Environment:    A description of GIT's unidiff-compatible patch extensions, which we might use for "svn patch" format. Copied from Augie Fackler's email <[http://subversion.tigris.org/ds/viewMessage.do?dsForumId=462&dsMessageId=2388540]>. Documentation for the format is pretty sparse. Here's an overview (now  that I've written this out, it might be more like "everything you need  to know to support this format other than specifics of how base85  works"): Copies and renames are both handled like this: diff --git a/\{oldname} b/\{newname} copy from \{oldname} copy to \{newname} \{normal unidiff data here if there was a difference, only for how new  is different from old} (naturally, with copy instead of rename if that was the case} New files: diff --git a/alpha b/alpha new file mode 100644 — /dev/null +++ b/alpha @@ -0,0 +1,1 @@ +alpha (the longer file mode is used for representing symlinks, they come in  with mode 120000, and the contents are listed as *just* the path of  the symlink, that is, svn's symlink format without the leading 'link ') Removals: diff --git a/README b/README deleted file mode 100644 — a/README +++ /dev/null @@ -1,77 +0,0 @@ \{pile of unidiff data} File mode changes: diff --git a/README b/README old mode 100644 new mode 100755 (I think it's normal for patch implementations to not care about the  old mode, and just apply the new one blindly - the old mode I believe  is more for human consumption or reverse-patching than anything else.  Also, you don't really ever see any modes other than these two - the  first is just "not executable", the second is executable. I've never  *seen* any other modes for regular files). Binaries (this is for literals, which I believe is the new binary in  its entirety. I think there's a delta format which Mercurial does not  support, per a "TODO: deltas" in the code): index \{old hash}..\{new hash} GIT binary patch literal \{file length} \{base85-encoded zlib-compressed data} The hashes are either the nullid (40 0's) if there was (or is) no  text, and are sha1('blob %d\0%s' % (len(text), text, )) (using python syntax). The base85 encoding seems to use a leading z to indicate this isn't  the last line of data, and a leading e to indicate this is the last  line of data. There's more to base85 than that, and I'd gladly take  some time to write down how it works for those interested in  reimplementing it. It appears at first glance to be the part that  requries the most detailed documentation. Supporting binary deltas is something that can obviously come later,  since Mercurial doesn't appear to implement it at all right now. Note  that with binary literals it does not appear that patch -R is  possible. That's really a minor limitation, since you're never using  this on non-version-controlled files anyway. It should be possible to add your own hunk types to this format (once  the base format is supported) that would allow you to transmit  property modifications inline as well (other than symlink and  executable, which are already handled sanely). For those interested in some source code (GPLv2): [http://mercurial.selenic.com/hg/hg/file/ac02b43bc08a/mercurial/patch.py#l195] [http://mercurial.selenic.com/hg/hg/file/ac02b43bc08a/mercurial/patch.py#l710] [http://mercurial.selenic.com/hg/hg/file/ac02b43bc08a/mercurial/pure/base85.py]
>            Reporter: SpArkx
>            Priority: Minor
>              Labels: SpArkx, eysz7x
>             Fix For: trunk
>
>         Attachments: README.md
>
>
> {code:java}
> /*
>  * externals.c:  handle the svn:externals property
>  *
>  * ====================================================================
>  *    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_uri.h>
> #include "svn_hash.h"
> #include "svn_wc.h"
> #include "svn_pools.h"
> #include "svn_client.h"
> #include "svn_types.h"
> #include "svn_error.h"
> #include "svn_dirent_uri.h"
> #include "svn_path.h"
> #include "svn_props.h"
> #include "svn_config.h"
> #include "client.h"
> #include "svn_private_config.h"
> #include "private/svn_wc_private.h"
> /* Remove the directory at LOCAL_ABSPATH from revision control, and do the
>  * same to any revision controlled directories underneath LOCAL_ABSPATH
>  * (including directories not referred to by parent svn administrative areas);
>  * then if LOCAL_ABSPATH is empty afterwards, remove it, else rename it to a
>  * unique name in the same parent directory.
>  *
>  * Pass CANCEL_FUNC, CANCEL_BATON to svn_wc_remove_from_revision_control.
>  *
>  * Use SCRATCH_POOL for all temporary allocation.
>  */
> static svn_error_t *
> relegate_dir_external(svn_wc_context_t *wc_ctx,
>                       const char *wri_abspath,
>                       const char *local_abspath,
>                       svn_cancel_func_t cancel_func,
>                       void *cancel_baton,
>                       svn_wc_notify_func2_t notify_func,
>                       void *notify_baton,
>                       apr_pool_t *scratch_pool)
> {
>   svn_error_t *err = SVN_NO_ERROR;
>   SVN_ERR(svn_wc__acquire_write_lock(NULL, wc_ctx, local_abspath,
>                                      FALSE, scratch_pool, scratch_pool));
>   err = svn_wc__external_remove(wc_ctx, wri_abspath, local_abspath, FALSE,
>                                 cancel_func, cancel_baton, scratch_pool);
>   if (err && (err->apr_err == SVN_ERR_WC_LEFT_LOCAL_MOD))
>     {
>       const char *parent_dir;
>       const char *dirname;
>       const char *new_path;
>       svn_error_clear(err);
>       err = SVN_NO_ERROR;
>       svn_dirent_split(&parent_dir, &dirname, local_abspath, scratch_pool);
>       /* Reserve the new dir name. */
>       SVN_ERR(svn_io_open_uniquely_named(NULL, &new_path,
>                                          parent_dir, dirname, ".OLD",
>                                          svn_io_file_del_none,
>                                          scratch_pool, scratch_pool));
>       /* Sigh...  We must fall ever so slightly from grace.
>          Ideally, there would be no window, however brief, when we
>          don't have a reservation on the new name.  Unfortunately,
>          at least in the Unix (Linux?) version of apr_file_rename(),
>          you can't rename a directory over a file, because it's just
>          calling stdio rename(), which says:
>             ENOTDIR
>               A  component used as a directory in oldpath or newpath
>               path is not, in fact, a directory.  Or, oldpath  is
>               a directory, and newpath exists but is not a directory
>          So instead, we get the name, then remove the file (ugh), then
>          rename the directory, hoping that nobody has gotten that name
>          in the meantime -- which would never happen in real life, so
>          no big deal.
>       */
>       /* Do our best, but no biggy if it fails. The rename will fail. */
>       svn_error_clear(svn_io_remove_file2(new_path, TRUE, scratch_pool));
>       /* Rename. If this is still a working copy we should use the working
>          copy rename function (to release open handles) */
>       err = svn_wc__rename_wc(wc_ctx, local_abspath, new_path,
>                               scratch_pool);
>       if (err && err->apr_err == SVN_ERR_WC_PATH_UNEXPECTED_STATUS)
>         {
>           svn_error_clear(err);
>           /* And if it is no longer a working copy, we should just rename
>              it */
>           err = svn_io_file_rename2(local_abspath, new_path, FALSE, scratch_pool);
>         }
>       /* ### TODO: We should notify the user about the rename */
>       if (notify_func)
>         {
>           svn_wc_notify_t *notify;
>           notify = svn_wc_create_notify(err ? local_abspath : new_path,
>                                         svn_wc_notify_left_local_modifications,
>                                         scratch_pool);
>           notify->kind = svn_node_dir;
>           notify->err = err;
>           notify_func(notify_baton, notify, scratch_pool);
>         }
>     }
>   return svn_error_trace(err);
> }
> /* Try to update a directory external at PATH to URL at REVISION.
>    Use POOL for temporary allocations, and use the client context CTX. */
> static svn_error_t *
> switch_dir_external(const char *local_abspath,
>                     const char *url,
>                     const char *url_from_externals_definition,
>                     const svn_opt_revision_t *peg_revision,
>                     const svn_opt_revision_t *revision,
>                     const char *defining_abspath,
>                     svn_boolean_t *timestamp_sleep,
>                     svn_ra_session_t *ra_session,
>                     svn_client_ctx_t *ctx,
>                     apr_pool_t *pool)
> {
>   svn_node_kind_t kind;
>   svn_error_t *err;
>   svn_revnum_t external_peg_rev = SVN_INVALID_REVNUM;
>   svn_revnum_t external_rev = SVN_INVALID_REVNUM;
>   apr_pool_t *subpool = svn_pool_create(pool);
>   const char *repos_root_url;
>   const char *repos_uuid;
>   SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
>   if (peg_revision->kind == svn_opt_revision_number)
>     external_peg_rev = peg_revision->value.number;
>   if (revision->kind == svn_opt_revision_number)
>     external_rev = revision->value.number;
>   /*
>    * The code below assumes existing versioned paths are *not* part of
>    * the external's defining working copy.
>    * The working copy library does not support registering externals
>    * on top of existing BASE nodes and will error out if we try.
>    * So if the external target is part of the defining working copy's
>    * BASE tree, don't attempt to create the external. Doing so would
>    * leave behind a switched path instead of an external (since the
>    * switch succeeds but registration of the external in the DB fails).
>    * The working copy then cannot be updated until the path is switched back.
>    * See issue #4085.
>    */
>   SVN_ERR(svn_wc__node_get_base(&kind, NULL, NULL,
>                                 &repos_root_url, &repos_uuid,
>                                 NULL, ctx->wc_ctx, local_abspath,
>                                 TRUE, /* ignore_enoent */
>                                 pool, pool));
>   if (kind != svn_node_unknown)
>     {
>       const char *wcroot_abspath;
>       const char *defining_wcroot_abspath;
>       SVN_ERR(svn_wc__get_wcroot(&wcroot_abspath, ctx->wc_ctx,
>                                  local_abspath, pool, pool));
>       SVN_ERR(svn_wc__get_wcroot(&defining_wcroot_abspath, ctx->wc_ctx,
>                                  defining_abspath, pool, pool));
>       if (strcmp(wcroot_abspath, defining_wcroot_abspath) == 0)
>         return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
>                                  _("The external '%s' defined in %s at '%s' "
>                                    "cannot be checked out because '%s' is "
>                                    "already a versioned path."),
>                                    url_from_externals_definition,
>                                    SVN_PROP_EXTERNALS,
>                                    svn_dirent_local_style(defining_abspath,
>                                                           pool),
>                                    svn_dirent_local_style(local_abspath,
>                                                           pool));
>     }
>   /* If path is a directory, try to update/switch to the correct URL
>      and revision. */
>   SVN_ERR(svn_io_check_path(local_abspath, &kind, pool));
>   if (kind == svn_node_dir)
>     {
>       const char *node_url;
>       /* Doubles as an "is versioned" check. */
>       err = svn_wc__node_get_url(&node_url, ctx->wc_ctx, local_abspath,
>                                  pool, subpool);
>       if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
>         {
>           svn_error_clear(err);
>           err = SVN_NO_ERROR;
>           goto relegate;
>         }
>       else if (err)
>         return svn_error_trace(err);
>       if (node_url)
>         {
>           svn_boolean_t is_wcroot;
>           SVN_ERR(svn_wc__is_wcroot(&is_wcroot, ctx->wc_ctx, local_abspath,
>                                     pool));
>           if (! is_wcroot)
>           {
>             /* This can't be a directory external! */
>             err = svn_wc__external_remove(ctx->wc_ctx, defining_abspath,
>                                           local_abspath,
>                                           TRUE /* declaration_only */,
>                                           ctx->cancel_func, ctx->cancel_baton,
>                                           pool);
>             if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
>               {
>                 /* New external... No problem that we can't remove it */
>                 svn_error_clear(err);
>                 err = NULL;
>               }
>             else if (err)
>               return svn_error_trace(err);
>             return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
>                                      _("The external '%s' defined in %s at '%s' "
>                                        "cannot be checked out because '%s' is "
>                                        "already a versioned path."),
>                                      url_from_externals_definition,
>                                      SVN_PROP_EXTERNALS,
>                                      svn_dirent_local_style(defining_abspath,
>                                                             pool),
>                                      svn_dirent_local_style(local_abspath,
>                                                             pool));
>           }
>           /* If we have what appears to be a version controlled
>              subdir, and its top-level URL matches that of our
>              externals definition, perform an update. */
>           if (strcmp(node_url, url) == 0)
>             {
>               SVN_ERR(svn_client__update_internal(NULL, timestamp_sleep,
>                                                   local_abspath,
>                                                   revision, svn_depth_unknown,
>                                                   FALSE, FALSE, FALSE, TRUE,
>                                                   FALSE, TRUE,
>                                                   ra_session, ctx, subpool));
>               /* We just decided that this existing directory is an external,
>                  so update the external registry with this information, like
>                  when checking out an external */
>               SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
>                                     defining_abspath,
>                                     local_abspath, svn_node_dir,
>                                     repos_root_url, repos_uuid,
>                                     svn_uri_skip_ancestor(repos_root_url,
>                                                           url, pool),
>                                     external_peg_rev,
>                                     external_rev,
>                                     pool));
>               svn_pool_destroy(subpool);
>               goto cleanup;
>             }
>           /* We'd really prefer not to have to do a brute-force
>              relegation -- blowing away the current external working
>              copy and checking it out anew -- so we'll first see if we
>              can get away with a generally cheaper relocation (if
>              required) and switch-style update.
>              To do so, we need to know the repository root URL of the
>              external working copy as it currently sits. */
>           err = svn_wc__node_get_repos_info(NULL, NULL,
>                                             &repos_root_url, &repos_uuid,
>                                             ctx->wc_ctx, local_abspath,
>                                             pool, subpool);
>           if (err)
>             {
>               if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND
>                   && err->apr_err != SVN_ERR_WC_NOT_WORKING_COPY)
>                 return svn_error_trace(err);
>               svn_error_clear(err);
>               repos_root_url = NULL;
>               repos_uuid = NULL;
>             }
>           if (repos_root_url)
>             {
>               /* If the new external target URL is not obviously a
>                  child of the external working copy's current
>                  repository root URL... */
>               if (! svn_uri__is_ancestor(repos_root_url, url))
>                 {
>                   const char *repos_root;
>                   /* ... then figure out precisely which repository
>                       root URL that target URL *is* a child of ... */
>                   SVN_ERR(svn_client_get_repos_root(&repos_root, NULL, url,
>                                                     ctx, subpool, subpool));
>                   /* ... and use that to try to relocate the external
>                      working copy to the target location.  */
>                   err = svn_client_relocate2(local_abspath, repos_root_url,
>                                              repos_root, FALSE, ctx, subpool);
>                   /* If the relocation failed because the new URL
>                      points to a totally different repository, we've
>                      no choice but to relegate and check out a new WC. */
>                   if (err
>                       && (err->apr_err == SVN_ERR_WC_INVALID_RELOCATION
>                           || (err->apr_err
>                               == SVN_ERR_CLIENT_INVALID_RELOCATION)))
>                     {
>                       svn_error_clear(err);
>                       goto relegate;
>                     }
>                   else if (err)
>                     return svn_error_trace(err);
>                   /* If the relocation went without a hitch, we should
>                      have a new repository root URL. */
>                   repos_root_url = repos_root;
>                 }
>               SVN_ERR(svn_client__switch_internal(NULL, local_abspath, url,
>                                                   peg_revision, revision,
>                                                   svn_depth_infinity,
>                                                   TRUE, FALSE, FALSE,
>                                                   TRUE /* ignore_ancestry */,
>                                                   timestamp_sleep,
>                                                   ctx, subpool));
>               SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
>                                                 defining_abspath,
>                                                 local_abspath, svn_node_dir,
>                                                 repos_root_url, repos_uuid,
>                                                 svn_uri_skip_ancestor(
>                                                             repos_root_url,
>                                                             url, subpool),
>                                                 external_peg_rev,
>                                                 external_rev,
>                                                 subpool));
>               svn_pool_destroy(subpool);
>               goto cleanup;
>             }
>         }
>     }
>  relegate:
>   /* Fall back on removing the WC and checking out a new one. */
>   /* Ensure that we don't have any RA sessions or WC locks from failed
>      operations above. */
>   svn_pool_destroy(subpool);
>   if (kind == svn_node_dir)
>     {
>       /* Buh-bye, old and busted ... */
>       SVN_ERR(relegate_dir_external(ctx->wc_ctx, defining_abspath,
>                                     local_abspath,
>                                     ctx->cancel_func, ctx->cancel_baton,
>                                     ctx->notify_func2, ctx->notify_baton2,
>                                     pool));
>     }
>   else
>     {
>       /* The target dir might have multiple components.  Guarantee
>          the path leading down to the last component. */
>       const char *parent = svn_dirent_dirname(local_abspath, pool);
>       SVN_ERR(svn_io_make_dir_recursively(parent, pool));
>     }
>   /* ... Hello, new hotness. */
>   SVN_ERR(svn_client__checkout_internal(NULL, timestamp_sleep,
>                                         url, local_abspath, peg_revision,
>                                         revision, svn_depth_infinity,
>                                         FALSE, FALSE,
>                                         ra_session,
>                                         ctx, pool));
>   SVN_ERR(svn_wc__node_get_repos_info(NULL, NULL,
>                                       &repos_root_url,
>                                       &repos_uuid,
>                                       ctx->wc_ctx, local_abspath,
>                                       pool, pool));
>   SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
>                                     defining_abspath,
>                                     local_abspath, svn_node_dir,
>                                     repos_root_url, repos_uuid,
>                                     svn_uri_skip_ancestor(repos_root_url,
>                                                           url, pool),
>                                     external_peg_rev,
>                                     external_rev,
>                                     pool));
>  cleanup:
>   /* Issues #4123 and #4130: We don't need to keep the newly checked
>      out external's DB open. */
>   SVN_ERR(svn_wc__close_db(local_abspath, ctx->wc_ctx, pool));
>   return SVN_NO_ERROR;
> }
> /* Try to update a file external at LOCAL_ABSPATH to SWITCH_LOC. This function
>    assumes caller has a write lock in CTX.  Use SCRATCH_POOL for temporary
>    allocations, and use the client context CTX. */
> static svn_error_t *
> switch_file_external(const char *local_abspath,
>                      const svn_client__pathrev_t *switch_loc,
>                      const char *record_url,
>                      const svn_opt_revision_t *record_peg_revision,
>                      const svn_opt_revision_t *record_revision,
>                      const char *def_dir_abspath,
>                      svn_ra_session_t *ra_session,
>                      svn_client_ctx_t *ctx,
>                      apr_pool_t *scratch_pool)
> {
>   svn_config_t *cfg = ctx->config
>                       ? svn_hash_gets(ctx->config, SVN_CONFIG_CATEGORY_CONFIG)
>                       : NULL;
>   svn_boolean_t use_commit_times;
>   const char *diff3_cmd;
>   const char *preserved_exts_str;
>   const apr_array_header_t *preserved_exts;
>   svn_node_kind_t kind, external_kind;
>   SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
>   /* See if the user wants last-commit timestamps instead of current ones. */
>   SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
>                               SVN_CONFIG_SECTION_MISCELLANY,
>                               SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
>   /* Get the external diff3, if any. */
>   svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
>                  SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
>   if (diff3_cmd != NULL)
>     SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, scratch_pool));
>   /* See which files the user wants to preserve the extension of when
>      conflict files are made. */
>   svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
>                  SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
>   preserved_exts = *preserved_exts_str
>     ? svn_cstring_split(preserved_exts_str, "\n\r\t\v ", FALSE, scratch_pool)
>     : NULL;
>   {
>     const char *wcroot_abspath;
>     SVN_ERR(svn_wc__get_wcroot(&wcroot_abspath, ctx->wc_ctx, local_abspath,
>                                scratch_pool, scratch_pool));
>     /* File externals can only be installed inside the current working copy.
>        So verify if the working copy that contains/will contain the target
>        is the defining abspath, or one of its ancestors */
>     if (!svn_dirent_is_ancestor(wcroot_abspath, def_dir_abspath))
>         return svn_error_createf(
>                         SVN_ERR_WC_BAD_PATH, NULL,
>                         _("Cannot insert a file external defined on '%s' "
>                           "into the working copy '%s'."),
>                         svn_dirent_local_style(def_dir_abspath,
>                                                scratch_pool),
>                         svn_dirent_local_style(wcroot_abspath,
>                                                scratch_pool));
>   }
>   SVN_ERR(svn_wc_read_kind2(&kind, ctx->wc_ctx, local_abspath,
>                             TRUE, FALSE, scratch_pool));
>   SVN_ERR(svn_wc__read_external_info(&external_kind, NULL, NULL, NULL, NULL,
>                                      ctx->wc_ctx, local_abspath, local_abspath,
>                                      TRUE, scratch_pool, scratch_pool));
>   /* If there is a versioned item with this name, ensure it's a file
>      external before working with it.  If there is no entry in the
>      working copy, then create an empty file and add it to the working
>      copy. */
>   if (kind != svn_node_none && kind != svn_node_unknown)
>     {
>       if (external_kind != svn_node_file)
>         {
>           return svn_error_createf(
>               SVN_ERR_CLIENT_FILE_EXTERNAL_OVERWRITE_VERSIONED, 0,
>              _("The file external from '%s' cannot overwrite the existing "
>                "versioned item at '%s'"),
>              switch_loc->url,
>              svn_dirent_local_style(local_abspath, scratch_pool));
>         }
>     }
>   else
>     {
>       svn_node_kind_t disk_kind;
>       SVN_ERR(svn_io_check_path(local_abspath, &disk_kind, scratch_pool));
>       if (disk_kind == svn_node_file || disk_kind == svn_node_dir)
>         return svn_error_createf(SVN_ERR_WC_PATH_FOUND, NULL,
>                                  _("The file external '%s' can not be "
>                                    "created because the node exists."),
>                                  svn_dirent_local_style(local_abspath,
>                                                         scratch_pool));
>     }
>   {
>     const svn_ra_reporter3_t *reporter;
>     void *report_baton;
>     const svn_delta_editor_t *switch_editor;
>     void *switch_baton;
>     svn_revnum_t revnum;
>     apr_array_header_t *inherited_props;
>     const char *target = svn_dirent_basename(local_abspath, scratch_pool);
>     /* Get the external file's iprops. */
>     SVN_ERR(svn_ra_get_inherited_props(ra_session, &inherited_props, "",
>                                        switch_loc->rev,
>                                        scratch_pool, scratch_pool));
>     SVN_ERR(svn_ra_reparent(ra_session,
>                             svn_uri_dirname(switch_loc->url, scratch_pool),
>                             scratch_pool));
>     SVN_ERR(svn_wc__get_file_external_editor(&switch_editor, &switch_baton,
>                                              &revnum, ctx->wc_ctx,
>                                              local_abspath,
>                                              def_dir_abspath,
>                                              switch_loc->url,
>                                              switch_loc->repos_root_url,
>                                              switch_loc->repos_uuid,
>                                              inherited_props,
>                                              use_commit_times,
>                                              diff3_cmd, preserved_exts,
>                                              def_dir_abspath,
>                                              record_url,
>                                              record_peg_revision,
>                                              record_revision,
>                                              ctx->conflict_func2,
>                                              ctx->conflict_baton2,
>                                              ctx->cancel_func,
>                                              ctx->cancel_baton,
>                                              ctx->notify_func2,
>                                              ctx->notify_baton2,
>                                              scratch_pool, scratch_pool));
>     /* Tell RA to do an update of URL+TARGET to REVISION; if we pass an
>      invalid revnum, that means RA will use the latest revision. */
>     SVN_ERR(svn_ra_do_switch3(ra_session, &reporter, &report_baton,
>                               switch_loc->rev,
>                               target, svn_depth_unknown, switch_loc->url,
>                               FALSE /* send_copyfrom */,
>                               TRUE /* ignore_ancestry */,
>                               switch_editor, switch_baton,
>                               scratch_pool, scratch_pool));
>     SVN_ERR(svn_wc__crawl_file_external(ctx->wc_ctx, local_abspath,
>                                         reporter, report_baton,
>                                         TRUE,  use_commit_times,
>                                         ctx->cancel_func, ctx->cancel_baton,
>                                         ctx->notify_func2, ctx->notify_baton2,
>                                         scratch_pool));
>     if (ctx->notify_func2)
>       {
>         svn_wc_notify_t *notify
>           = svn_wc_create_notify(local_abspath, svn_wc_notify_update_completed,
>                                  scratch_pool);
>         notify->kind = svn_node_none;
>         notify->content_state = notify->prop_state
>           = svn_wc_notify_state_inapplicable;
>         notify->lock_state = svn_wc_notify_lock_state_inapplicable;
>         notify->revision = revnum;
>         ctx->notify_func2(ctx->notify_baton2, notify, scratch_pool);
>       }
>   }
>   return SVN_NO_ERROR;
> }
> /* Wrappers around svn_wc__external_remove, obtaining and releasing a lock for
>    directory externals */
> static svn_error_t *
> remove_external2(svn_boolean_t *removed,
>                 svn_wc_context_t *wc_ctx,
>                 const char *wri_abspath,
>                 const char *local_abspath,
>                 svn_node_kind_t external_kind,
>                 svn_cancel_func_t cancel_func,
>                 void *cancel_baton,
>                 apr_pool_t *scratch_pool)
> {
>   SVN_ERR(svn_wc__external_remove(wc_ctx, wri_abspath,
>                                   local_abspath,
>                                   (external_kind == svn_node_none),
>                                   cancel_func, cancel_baton,
>                                   scratch_pool));
>   *removed = TRUE;
>   return SVN_NO_ERROR;
> }
> static svn_error_t *
> remove_external(svn_boolean_t *removed,
>                 svn_wc_context_t *wc_ctx,
>                 const char *wri_abspath,
>                 const char *local_abspath,
>                 svn_node_kind_t external_kind,
>                 svn_cancel_func_t cancel_func,
>                 void *cancel_baton,
>                 apr_pool_t *scratch_pool)
> {
>   *removed = FALSE;
>   switch (external_kind)
>     {
>       case svn_node_dir:
>         SVN_WC__CALL_WITH_WRITE_LOCK(
>             remove_external2(removed,
>                              wc_ctx, wri_abspath,
>                              local_abspath, external_kind,
>                              cancel_func, cancel_baton,
>                              scratch_pool),
>             wc_ctx, local_abspath, FALSE, scratch_pool);
>         break;
>       case svn_node_file:
>       default:
>         SVN_ERR(remove_external2(removed,
>                                  wc_ctx, wri_abspath,
>                                  local_abspath, external_kind,
>                                  cancel_func, cancel_baton,
>                                  scratch_pool));
>         break;
>     }
>   return SVN_NO_ERROR;
> }
> /* Called when an external that is in the EXTERNALS table is no longer
>    referenced from an svn:externals property */
> static svn_error_t *
> handle_external_item_removal(const svn_client_ctx_t *ctx,
>                              const char *defining_abspath,
>                              const char *local_abspath,
>                              apr_pool_t *scratch_pool)
> {
>   svn_error_t *err;
>   svn_node_kind_t external_kind;
>   svn_node_kind_t kind;
>   svn_boolean_t removed = FALSE;
>   /* local_abspath should be a wcroot or a file external */
>   SVN_ERR(svn_wc__read_external_info(&external_kind, NULL, NULL, NULL, NULL,
>                                      ctx->wc_ctx, defining_abspath,
>                                      local_abspath, FALSE,
>                                      scratch_pool, scratch_pool));
>   SVN_ERR(svn_wc_read_kind2(&kind, ctx->wc_ctx, local_abspath, TRUE, FALSE,
>                            scratch_pool));
>   if (external_kind != kind)
>     external_kind = svn_node_none; /* Only remove the registration */
>   err = remove_external(&removed,
>                         ctx->wc_ctx, defining_abspath, local_abspath,
>                         external_kind,
>                         ctx->cancel_func, ctx->cancel_baton,
>                         scratch_pool);
>   if (err && err->apr_err == SVN_ERR_WC_NOT_LOCKED && removed)
>     {
>       svn_error_clear(err);
>       err = NULL; /* We removed the working copy, so we can't release the
>                      lock that was stored inside */
>     }
>   if (ctx->notify_func2)
>     {
>       svn_wc_notify_t *notify =
>           svn_wc_create_notify(local_abspath,
>                                svn_wc_notify_update_external_removed,
>                                scratch_pool);
>       notify->kind = kind;
>       notify->err = err;
>       ctx->notify_func2(ctx->notify_baton2, notify, scratch_pool);
>       if (err && err->apr_err == SVN_ERR_WC_LEFT_LOCAL_MOD)
>         {
>           notify = svn_wc_create_notify(local_abspath,
>                                       svn_wc_notify_left_local_modifications,
>                                       scratch_pool);
>           notify->kind = svn_node_dir;
>           notify->err = err;
>           ctx->notify_func2(ctx->notify_baton2, notify, scratch_pool);
>         }
>     }
>   if (err && err->apr_err == SVN_ERR_WC_LEFT_LOCAL_MOD)
>     {
>       svn_error_clear(err);
>       err = NULL;
>     }
>   return svn_error_trace(err);
> }
> static svn_error_t *
> handle_external_item_change(svn_client_ctx_t *ctx,
>                             const char *repos_root_url,
>                             const char *parent_dir_abspath,
>                             const char *parent_dir_url,
>                             const char *local_abspath,
>                             const char *old_defining_abspath,
>                             const svn_wc_external_item2_t *new_item,
>                             svn_ra_session_t *ra_session,
>                             svn_boolean_t *timestamp_sleep,
>                             apr_pool_t *scratch_pool)
> {
>   svn_client__pathrev_t *new_loc;
>   const char *new_url;
>   svn_node_kind_t ext_kind;
>   SVN_ERR_ASSERT(repos_root_url && parent_dir_url);
>   SVN_ERR_ASSERT(new_item != NULL);
>   /* Don't bother to check status, since we'll get that for free by
>      attempting to retrieve the hash values anyway.  */
>   /* When creating the absolute URL, use the pool and not the
>      iterpool, since the hash table values outlive the iterpool and
>      any pointers they have should also outlive the iterpool.  */
>   SVN_ERR(svn_wc__resolve_relative_external_url(&new_url,
>                                                 new_item, repos_root_url,
>                                                 parent_dir_url,
>                                                 scratch_pool, scratch_pool));
>   /* Determine if the external is a file or directory. */
>   /* Get the RA connection, if needed. */
>   if (ra_session)
>     {
>       svn_error_t *err = svn_ra_reparent(ra_session, new_url, scratch_pool);
>       if (err)
>         {
>           if (err->apr_err == SVN_ERR_RA_ILLEGAL_URL)
>             {
>               svn_error_clear(err);
>               ra_session = NULL;
>             }
>           else
>             return svn_error_trace(err);
>         }
>       else
>         {
>           SVN_ERR(svn_client__resolve_rev_and_url(&new_loc,
>                                                   ra_session, new_url,
>                                                   &(new_item->peg_revision),
>                                                   &(new_item->revision), ctx,
>                                                   scratch_pool));
>           SVN_ERR(svn_ra_reparent(ra_session, new_loc->url, scratch_pool));
>         }
>     }
>   if (!ra_session)
>     SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &new_loc,
>                                               new_url, NULL,
>                                               &(new_item->peg_revision),
>                                               &(new_item->revision), ctx,
>                                               scratch_pool));
>   SVN_ERR(svn_ra_check_path(ra_session, "", new_loc->rev, &ext_kind,
>                             scratch_pool));
>   if (svn_node_none == ext_kind)
>     return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
>                              _("URL '%s' at revision %ld doesn't exist"),
>                              new_loc->url, new_loc->rev);
>   if (svn_node_dir != ext_kind && svn_node_file != ext_kind)
>     return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
>                              _("URL '%s' at revision %ld is not a file "
>                                "or a directory"),
>                              new_loc->url, new_loc->rev);
>   /* Not protecting against recursive externals.  Detecting them in
>      the global case is hard, and it should be pretty obvious to a
>      user when it happens.  Worst case: your disk fills up :-). */
>   /* First notify that we're about to handle an external. */
>   if (ctx->notify_func2)
>     {
>       ctx->notify_func2(
>          ctx->notify_baton2,
>          svn_wc_create_notify(local_abspath,
>                               svn_wc_notify_update_external,
>                               scratch_pool),
>          scratch_pool);
>     }
>   if (! old_defining_abspath)
>     {
>       /* The target dir might have multiple components.  Guarantee the path
>          leading down to the last component. */
>       SVN_ERR(svn_io_make_dir_recursively(svn_dirent_dirname(local_abspath,
>                                                              scratch_pool),
>                                           scratch_pool));
>     }
>   switch (ext_kind)
>     {
>       case svn_node_dir:
>         SVN_ERR(switch_dir_external(local_abspath, new_loc->url,
>                                     new_item->url,
>                                     &(new_item->peg_revision),
>                                     &(new_item->revision),
>                                     parent_dir_abspath,
>                                     timestamp_sleep, ra_session, ctx,
>                                     scratch_pool));
>         break;
>       case svn_node_file:
>         if (strcmp(repos_root_url, new_loc->repos_root_url))
>           {
>             const char *local_repos_root_url;
>             const char *local_repos_uuid;
>             const char *ext_repos_relpath;
>             svn_error_t *err;
>             /*
>              * The working copy library currently requires that all files
>              * in the working copy have the same repository root URL.
>              * The URL from the file external's definition differs from the
>              * one used by the working copy. As a workaround, replace the
>              * root URL portion of the file external's URL, after making
>              * sure both URLs point to the same repository. See issue #4087.
>              */
>             err = svn_wc__node_get_repos_info(NULL, NULL,
>                                               &local_repos_root_url,
>                                               &local_repos_uuid,
>                                               ctx->wc_ctx, parent_dir_abspath,
>                                               scratch_pool, scratch_pool);
>             if (err)
>               {
>                 if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND
>                     && err->apr_err != SVN_ERR_WC_NOT_WORKING_COPY)
>                   return svn_error_trace(err);
>                 svn_error_clear(err);
>                 local_repos_root_url = NULL;
>                 local_repos_uuid = NULL;
>               }
>             ext_repos_relpath = svn_uri_skip_ancestor(new_loc->repos_root_url,
>                                                       new_url, scratch_pool);
>             if (local_repos_uuid == NULL || local_repos_root_url == NULL ||
>                 ext_repos_relpath == NULL ||
>                 strcmp(local_repos_uuid, new_loc->repos_uuid) != 0)
>               return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
>                         _("Unsupported external: URL of file external '%s' "
>                           "is not in repository '%s'"),
>                         new_url, repos_root_url);
>             new_url = svn_path_url_add_component2(local_repos_root_url,
>                                                   ext_repos_relpath,
>                                                   scratch_pool);
>             SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &new_loc,
>                                                       new_url,
>                                                       NULL,
>                                                       &(new_item->peg_revision),
>                                                       &(new_item->revision),
>                                                       ctx, scratch_pool));
>           }
>         SVN_ERR(switch_file_external(local_abspath,
>                                      new_loc,
>                                      new_url,
>                                      &new_item->peg_revision,
>                                      &new_item->revision,
>                                      parent_dir_abspath,
>                                      ra_session,
>                                      ctx,
>                                      scratch_pool));
>         break;
>       default:
>         SVN_ERR_MALFUNCTION();
>         break;
>     }
>   return SVN_NO_ERROR;
> }
> static svn_error_t *
> wrap_external_error(const svn_client_ctx_t *ctx,
>                     const char *target_abspath,
>                     svn_error_t *err,
>                     apr_pool_t *scratch_pool)
> {
>   if (err && err->apr_err != SVN_ERR_CANCELLED)
>     {
>       if (ctx->notify_func2)
>         {
>           svn_wc_notify_t *notifier = svn_wc_create_notify(
>                                             target_abspath,
>                                             svn_wc_notify_failed_external,
>                                             scratch_pool);
>           notifier->err = err;
>           ctx->notify_func2(ctx->notify_baton2, notifier, scratch_pool);
>         }
>       svn_error_clear(err);
>       return SVN_NO_ERROR;
>     }
>   return err;
> }
> static svn_error_t *
> handle_externals_change(svn_client_ctx_t *ctx,
>                         const char *repos_root_url,
>                         svn_boolean_t *timestamp_sleep,
>                         const char *local_abspath,
>                         const char *new_desc_text,
>                         apr_hash_t *old_externals,
>                         svn_depth_t ambient_depth,
>                         svn_depth_t requested_depth,
>                         svn_ra_session_t *ra_session,
>                         apr_pool_t *scratch_pool)
> {
>   apr_array_header_t *new_desc;
>   int i;
>   apr_pool_t *iterpool;
>   const char *url;
>   iterpool = svn_pool_create(scratch_pool);
>   SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
>   /* Bag out if the depth here is too shallow for externals action. */
>   if ((requested_depth < svn_depth_infinity
>        && requested_depth != svn_depth_unknown)
>       || (ambient_depth < svn_depth_infinity
>           && requested_depth < svn_depth_infinity))
>     return SVN_NO_ERROR;
>   if (new_desc_text)
>     SVN_ERR(svn_wc_parse_externals_description3(&new_desc, local_abspath,
>                                                 new_desc_text,
>                                                 FALSE, scratch_pool));
>   else
>     new_desc = NULL;
>   SVN_ERR(svn_wc__node_get_url(&url, ctx->wc_ctx, local_abspath,
>                                scratch_pool, iterpool));
>   SVN_ERR_ASSERT(url);
>   for (i = 0; new_desc && (i < new_desc->nelts); i++)
>     {
>       const char *old_defining_abspath;
>       svn_wc_external_item2_t *new_item;
>       const char *target_abspath;
>       svn_boolean_t under_root;
>       new_item = APR_ARRAY_IDX(new_desc, i, svn_wc_external_item2_t *);
>       svn_pool_clear(iterpool);
>       if (ctx->cancel_func)
>         SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
>       SVN_ERR(svn_dirent_is_under_root(&under_root, &target_abspath,
>                                        local_abspath, new_item->target_dir,
>                                        iterpool));
>       if (! under_root)
>         {
>           return svn_error_createf(
>                     SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
>                     _("Path '%s' is not in the working copy"),
>                     svn_dirent_local_style(
>                         svn_dirent_join(local_abspath, new_item->target_dir,
>                                         iterpool),
>                         iterpool));
>         }
>       old_defining_abspath = svn_hash_gets(old_externals, target_abspath);
>       SVN_ERR(wrap_external_error(
>                       ctx, target_abspath,
>                       handle_external_item_change(ctx,
>                                                   repos_root_url,
>                                                   local_abspath, url,
>                                                   target_abspath,
>                                                   old_defining_abspath,
>                                                   new_item, ra_session,
>                                                   timestamp_sleep,
>                                                   iterpool),
>                       iterpool));
>       /* And remove already processed items from the to-remove hash */
>       if (old_defining_abspath)
>         svn_hash_sets(old_externals, target_abspath, NULL);
>     }
>   svn_pool_destroy(iterpool);
>   return SVN_NO_ERROR;
> }
> svn_error_t *
> svn_client__handle_externals(apr_hash_t *externals_new,
>                              apr_hash_t *ambient_depths,
>                              const char *repos_root_url,
>                              const char *target_abspath,
>                              svn_depth_t requested_depth,
>                              svn_boolean_t *timestamp_sleep,
>                              svn_ra_session_t *ra_session,
>                              svn_client_ctx_t *ctx,
>                              apr_pool_t *scratch_pool)
> {
>   apr_hash_t *old_external_defs;
>   apr_hash_index_t *hi;
>   apr_pool_t *iterpool;
>   SVN_ERR_ASSERT(repos_root_url);
>   iterpool = svn_pool_create(scratch_pool);
>   SVN_ERR(svn_wc__externals_defined_below(&old_external_defs,
>                                           ctx->wc_ctx, target_abspath,
>                                           scratch_pool, iterpool));
>   for (hi = apr_hash_first(scratch_pool, externals_new);
>        hi;
>        hi = apr_hash_next(hi))
>     {
>       const char *local_abspath = apr_hash_this_key(hi);
>       const char *desc_text = apr_hash_this_val(hi);
>       svn_depth_t ambient_depth = svn_depth_infinity;
>       svn_pool_clear(iterpool);
>       if (ambient_depths)
>         {
>           const char *ambient_depth_w;
>           ambient_depth_w = apr_hash_get(ambient_depths, local_abspath,
>                                          apr_hash_this_key_len(hi));
>           if (ambient_depth_w == NULL)
>             {
>               return svn_error_createf(
>                         SVN_ERR_WC_CORRUPT, NULL,
>                         _("Traversal of '%s' found no ambient depth"),
>                         svn_dirent_local_style(local_abspath, scratch_pool));
>             }
>           else
>             {
>               ambient_depth = svn_depth_from_word(ambient_depth_w);
>             }
>         }
>       SVN_ERR(handle_externals_change(ctx, repos_root_url, timestamp_sleep,
>                                       local_abspath,
>                                       desc_text, old_external_defs,
>                                       ambient_depth, requested_depth,
>                                       ra_session, iterpool));
>     }
>   /* Remove the remaining externals */
>   for (hi = apr_hash_first(scratch_pool, old_external_defs);
>        hi;
>        hi = apr_hash_next(hi))
>     {
>       const char *item_abspath = apr_hash_this_key(hi);
>       const char *defining_abspath = apr_hash_this_val(hi);
>       const char *parent_abspath;
>       svn_pool_clear(iterpool);
>       SVN_ERR(wrap_external_error(
>                           ctx, item_abspath,
>                           handle_external_item_removal(ctx, defining_abspath,
>                                                        item_abspath, iterpool),
>                           iterpool));
>       /* Are there any unversioned directories between the removed
>        * external and the DEFINING_ABSPATH which we can remove? */
>       parent_abspath = item_abspath;
>       do {
>         svn_node_kind_t kind;
>         parent_abspath = svn_dirent_dirname(parent_abspath, iterpool);
>         SVN_ERR(svn_wc_read_kind2(&kind, ctx->wc_ctx, parent_abspath,
>                                   FALSE /* show_deleted*/,
>                                   FALSE /* show_hidden */,
>                                   iterpool));
>         if (kind == svn_node_none)
>           {
>             svn_error_t *err;
>             err = svn_io_dir_remove_nonrecursive(parent_abspath, iterpool);
>             if (err)
>               {
>                 if (APR_STATUS_IS_ENOTEMPTY(err->apr_err))
>                   {
>                     svn_error_clear(err);
>                     break; /* No parents to delete */
>                   }
>                 else if (APR_STATUS_IS_ENOENT(err->apr_err)
>                          || APR_STATUS_IS_ENOTDIR(err->apr_err))
>                   {
>                     svn_error_clear(err);
>                     /* Fall through; parent dir might be unversioned */
>                   }
>                 else
>                   return svn_error_trace(err);
>               }
>           }
>       } while (strcmp(parent_abspath, defining_abspath) != 0);
>     }
>   svn_pool_destroy(iterpool);
>   return SVN_NO_ERROR;
> }
> svn_error_t *
> svn_client__export_externals(apr_hash_t *externals,
>                              const char *from_url,
>                              const char *to_abspath,
>                              const char *repos_root_url,
>                              svn_depth_t requested_depth,
>                              const char *native_eol,
>                              svn_boolean_t ignore_keywords,
>                              svn_client_ctx_t *ctx,
>                              apr_pool_t *scratch_pool)
> {
>   apr_pool_t *iterpool = svn_pool_create(scratch_pool);
>   apr_pool_t *sub_iterpool = svn_pool_create(scratch_pool);
>   apr_hash_index_t *hi;
>   SVN_ERR_ASSERT(svn_dirent_is_absolute(to_abspath));
>   for (hi = apr_hash_first(scratch_pool, externals);
>        hi;
>        hi = apr_hash_next(hi))
>     {
>       const char *local_abspath = apr_hash_this_key(hi);
>       const char *desc_text = apr_hash_this_val(hi);
>       const char *local_relpath;
>       const char *dir_url;
>       apr_array_header_t *items;
>       int i;
>       svn_pool_clear(iterpool);
>       SVN_ERR(svn_wc_parse_externals_description3(&items, local_abspath,
>                                                   desc_text, FALSE,
>                                                   iterpool));
>       if (! items->nelts)
>         continue;
>       local_relpath = svn_dirent_skip_ancestor(to_abspath, local_abspath);
>       dir_url = svn_path_url_add_component2(from_url, local_relpath,
>                                             scratch_pool);
>       for (i = 0; i < items->nelts; i++)
>         {
>           const char *item_abspath;
>           const char *new_url;
>           svn_boolean_t under_root;
>           svn_wc_external_item2_t *item = APR_ARRAY_IDX(items, i,
>                                                 svn_wc_external_item2_t *);
>           svn_pool_clear(sub_iterpool);
>           SVN_ERR(svn_dirent_is_under_root(&under_root, &item_abspath,
>                                            local_abspath, item->target_dir,
>                                            sub_iterpool));
>           if (! under_root)
>             {
>               return svn_error_createf(
>                         SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
>                         _("Path '%s' is not in the working copy"),
>                         svn_dirent_local_style(
>                             svn_dirent_join(local_abspath, item->target_dir,
>                                             sub_iterpool),
>                             sub_iterpool));
>             }
>           SVN_ERR(svn_wc__resolve_relative_external_url(&new_url, item,
>                                                         repos_root_url,
>                                                         dir_url, sub_iterpool,
>                                                         sub_iterpool));
>           /* The target dir might have multiple components.  Guarantee
>              the path leading down to the last component. */
>           SVN_ERR(svn_io_make_dir_recursively(svn_dirent_dirname(item_abspath,
>                                                                  sub_iterpool),
>                                               sub_iterpool));
>           /* First notify that we're about to handle an external. */
>           if (ctx->notify_func2)
>             {
>               ctx->notify_func2(
>                        ctx->notify_baton2,
>                        svn_wc_create_notify(item_abspath,
>                                             svn_wc_notify_update_external,
>                                             sub_iterpool),
>                        sub_iterpool);
>             }
>           SVN_ERR(wrap_external_error(
>                           ctx, item_abspath,
>                           svn_client_export5(NULL, new_url, item_abspath,
>                                              &item->peg_revision,
>                                              &item->revision,
>                                              TRUE, FALSE, ignore_keywords,
>                                              svn_depth_infinity,
>                                              native_eol,
>                                              ctx, sub_iterpool),
>                           sub_iterpool));
>         }
>     }
>   svn_pool_destroy(sub_iterpool);
>   svn_pool_destroy(iterpool);
>   return SVN_NO_ERROR;
> }
> {code}



--
This message was sent by Atlassian JIRA
(v7.6.3#76005)

Mime
View raw message