Imported from /home/lorry/working-area/delta_subversion-tarball/subversion-1.8.13.tar.gz.subversion-1.8.13

1 files changed, 369 insertions, 70 deletions

diff --git a/subversion/libsvn_client/list.c b/subversion/libsvn_client/list.c
index 15250eb..4093893 100644
--- a/subversion/libsvn_client/list.c
+++ b/subversion/libsvn_client/list.c
@@ -23,6 +23,7 @@
 
 #include "svn_client.h"
 #include "svn_dirent_uri.h"
+#include "svn_hash.h"
 #include "svn_path.h"
 #include "svn_pools.h"
 #include "svn_time.h"
@@ -32,8 +33,37 @@
 #include "client.h"
 
 #include "private/svn_fspath.h"
+#include "private/svn_ra_private.h"
+#include "private/svn_wc_private.h"
 #include "svn_private_config.h"
 
+/* Prototypes for referencing before declaration */
+static svn_error_t *
+list_externals(apr_hash_t *externals,
+               svn_depth_t depth,
+               apr_uint32_t dirent_fields,
+               svn_boolean_t fetch_locks,
+               svn_client_list_func2_t list_func,
+               void *baton,
+               svn_client_ctx_t *ctx,
+               apr_pool_t *scratch_pool);
+
+static svn_error_t *
+list_internal(const char *path_or_url,
+              const svn_opt_revision_t *peg_revision,
+              const svn_opt_revision_t *revision,
+              svn_depth_t depth,
+              apr_uint32_t dirent_fields,
+              svn_boolean_t fetch_locks,
+              svn_boolean_t include_externals,
+              const char *external_parent_url,
+              const char *external_target,
+              svn_client_list_func2_t list_func,
+              void *baton,
+              svn_client_ctx_t *ctx,
+              apr_pool_t *pool);
+
+
 /* Get the directory entries of DIR at REV (relative to the root of
    RA_SESSION), getting at least the fields specified by DIRENT_FIELDS.
    Use the cancellation function/baton of CTX to check for cancellation.
@@ -46,7 +76,15 @@
 
    LOCKS, if non-NULL, is a hash mapping const char * paths to svn_lock_t
    objects and FS_PATH is the absolute filesystem path of the RA session.
-   Use POOL for temporary allocations.
+   Use SCRATCH_POOL for temporary allocations.
+
+   If the caller passes EXTERNALS as non-NULL, populate the EXTERNALS
+   hash table whose keys are URLs of the directory which has externals
+   definitions, and whose values are the externals description text.
+   Allocate the hash's keys and values in RESULT_POOL.
+
+   EXTERNAL_PARENT_URL and EXTERNAL_TARGET are set when external items
+   are listed, otherwise both are set to NULL by the caller.
 */
 static svn_error_t *
 get_dir_contents(apr_uint32_t dirent_fields,
@@ -57,23 +95,31 @@ get_dir_contents(apr_uint32_t dirent_fields,
                  const char *fs_path,
                  svn_depth_t depth,
                  svn_client_ctx_t *ctx,
-                 svn_client_list_func_t list_func,
+                 apr_hash_t *externals,
+                 const char *external_parent_url,
+                 const char *external_target,
+                 svn_client_list_func2_t list_func,
                  void *baton,
-                 apr_pool_t *pool)
+                 apr_pool_t *result_pool,
+                 apr_pool_t *scratch_pool)
 {
   apr_hash_t *tmpdirents;
-  apr_pool_t *iterpool = svn_pool_create(pool);
+  apr_pool_t *iterpool = svn_pool_create(scratch_pool);
   apr_array_header_t *array;
   svn_error_t *err;
+  apr_hash_t *prop_hash = NULL;
+  const svn_string_t *prop_val = NULL;
   int i;
 
   if (depth == svn_depth_empty)
     return SVN_NO_ERROR;
 
-  /* Get the directory's entries, but not its props.  Ignore any
-     not-authorized errors.  */
-  err = svn_ra_get_dir2(ra_session, &tmpdirents, NULL, NULL,
-                        dir, rev, dirent_fields, pool);
+  /* Get the directory's entries. If externals hash is non-NULL, get its
+     properties also. Ignore any not-authorized errors.  */
+  err = svn_ra_get_dir2(ra_session, &tmpdirents, NULL,
+                        externals ? &prop_hash : NULL,
+                        dir, rev, dirent_fields, scratch_pool);
+
   if (err && ((err->apr_err == SVN_ERR_RA_NOT_AUTHORIZED) ||
               (err->apr_err == SVN_ERR_RA_DAV_FORBIDDEN)))
     {
@@ -82,16 +128,31 @@ get_dir_contents(apr_uint32_t dirent_fields,
     }
   SVN_ERR(err);
 
+ /* Filter out svn:externals from all properties hash. */
+  if (prop_hash)
+    prop_val = svn_hash_gets(prop_hash, SVN_PROP_EXTERNALS);
+  if (prop_val)
+    {
+      const char *url;
+
+      SVN_ERR(svn_ra_get_session_url(ra_session, &url, scratch_pool));
+
+      svn_hash_sets(externals,
+                    svn_path_url_add_component2(url, dir, result_pool),
+                    svn_string_dup(prop_val, result_pool));
+    }
+
   if (ctx->cancel_func)
     SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
 
   /* Sort the hash, so we can call the callback in a "deterministic" order. */
-  array = svn_sort__hash(tmpdirents, svn_sort_compare_items_lexically, pool);
+  array = svn_sort__hash(tmpdirents, svn_sort_compare_items_lexically,
+                         scratch_pool);
   for (i = 0; i < array->nelts; ++i)
     {
       svn_sort__item_t *item = &APR_ARRAY_IDX(array, i, svn_sort__item_t);
       const char *path;
-      svn_dirent_t *the_ent = apr_hash_get(tmpdirents, item->key, item->klen);
+      svn_dirent_t *the_ent = item->value;
       svn_lock_t *lock;
 
       svn_pool_clear(iterpool);
@@ -101,7 +162,7 @@ get_dir_contents(apr_uint32_t dirent_fields,
       if (locks)
         {
           const char *abs_path = svn_fspath__join(fs_path, path, iterpool);
-          lock = apr_hash_get(locks, abs_path, APR_HASH_KEY_STRING);
+          lock = svn_hash_gets(locks, abs_path);
         }
       else
         lock = NULL;
@@ -109,91 +170,83 @@ get_dir_contents(apr_uint32_t dirent_fields,
       if (the_ent->kind == svn_node_file
           || depth == svn_depth_immediates
           || depth == svn_depth_infinity)
-        SVN_ERR(list_func(baton, path, the_ent, lock, fs_path, iterpool));
+        SVN_ERR(list_func(baton, path, the_ent, lock, fs_path,
+                          external_parent_url, external_target, iterpool));
 
+      /* If externals is non-NULL, populate the externals hash table
+         recursively for all directory entries. */
       if (depth == svn_depth_infinity && the_ent->kind == svn_node_dir)
         SVN_ERR(get_dir_contents(dirent_fields, path, rev,
                                  ra_session, locks, fs_path, depth, ctx,
-                                 list_func, baton, iterpool));
+                                 externals, external_parent_url,
+                                 external_target, list_func, baton,
+                                 result_pool, iterpool));
     }
 
   svn_pool_destroy(iterpool);
   return SVN_NO_ERROR;
 }
 
+/* Like svn_ra_stat() but with a compatibility hack for pre-1.2 svnserve. */
+/* ### Maybe we should move this behavior into the svn_ra_stat wrapper? */
 svn_error_t *
-svn_client_list2(const char *path_or_url,
-                 const svn_opt_revision_t *peg_revision,
-                 const svn_opt_revision_t *revision,
-                 svn_depth_t depth,
-                 apr_uint32_t dirent_fields,
-                 svn_boolean_t fetch_locks,
-                 svn_client_list_func_t list_func,
-                 void *baton,
-                 svn_client_ctx_t *ctx,
-                 apr_pool_t *pool)
+svn_client__ra_stat_compatible(svn_ra_session_t *ra_session,
+                               svn_revnum_t rev,
+                               svn_dirent_t **dirent_p,
+                               apr_uint32_t dirent_fields,
+                               svn_client_ctx_t *ctx,
+                               apr_pool_t *pool)
 {
-  svn_ra_session_t *ra_session;
-  svn_revnum_t rev;
-  svn_dirent_t *dirent;
-  const char *url;
-  const char *repos_root;
-  const char *fs_path;
   svn_error_t *err;
-  apr_hash_t *locks;
-
-  /* We use the kind field to determine if we should recurse, so we
-     always need it. */
-  dirent_fields |= SVN_DIRENT_KIND;
-
-  /* Get an RA plugin for this filesystem object. */
-  SVN_ERR(svn_client__ra_session_from_path(&ra_session, &rev,
-                                           &url, path_or_url, NULL,
-                                           peg_revision,
-                                           revision, ctx, pool));
-
-  SVN_ERR(svn_ra_get_repos_root2(ra_session, &repos_root, pool));
 
-  SVN_ERR(svn_client__path_relative_to_root(&fs_path, ctx->wc_ctx, url,
-                                            repos_root, TRUE, ra_session,
-                                            pool, pool));
-
-  err = svn_ra_stat(ra_session, "", rev, &dirent, pool);
+  err = svn_ra_stat(ra_session, "", rev, dirent_p, pool);
 
   /* svnserve before 1.2 doesn't support the above, so fall back on
      a less efficient method. */
   if (err && err->apr_err == SVN_ERR_RA_NOT_IMPLEMENTED)
     {
+      const char *repos_root_url;
+      const char *session_url;
       svn_node_kind_t kind;
+      svn_dirent_t *dirent;
 
       svn_error_clear(err);
 
+      SVN_ERR(svn_ra_get_repos_root2(ra_session, &repos_root_url, pool));
+      SVN_ERR(svn_ra_get_session_url(ra_session, &session_url, pool));
+
       SVN_ERR(svn_ra_check_path(ra_session, "", rev, &kind, pool));
 
       if (kind != svn_node_none)
         {
-          if (strcmp(url, repos_root) != 0)
+          if (strcmp(session_url, repos_root_url) != 0)
             {
               svn_ra_session_t *parent_session;
               apr_hash_t *parent_ents;
               const char *parent_url, *base_name;
+              apr_pool_t *subpool = svn_pool_create(pool);
 
               /* Open another session to the path's parent.  This server
                  doesn't support svn_ra_reparent anyway, so don't try it. */
-              svn_uri_split(&parent_url, &base_name, url, pool);
+              svn_uri_split(&parent_url, &base_name, session_url, subpool);
 
-              SVN_ERR(svn_client__open_ra_session_internal(&parent_session,
-                                                           NULL, parent_url,
-                                                           NULL, NULL, FALSE,
-                                                           TRUE, ctx, pool));
+              SVN_ERR(svn_client_open_ra_session2(&parent_session, parent_url,
+                                                  NULL, ctx,
+                                                  subpool, subpool));
 
               /* Get all parent's entries, no props. */
               SVN_ERR(svn_ra_get_dir2(parent_session, &parent_ents, NULL,
-                                      NULL, "", rev, dirent_fields, pool));
+                                      NULL, "", rev, dirent_fields, subpool));
 
               /* Get the relevant entry. */
-              dirent = apr_hash_get(parent_ents, base_name,
-                                    APR_HASH_KEY_STRING);
+              dirent = svn_hash_gets(parent_ents, base_name);
+
+              if (dirent)
+                *dirent_p = svn_dirent_dup(dirent, pool);
+              else
+                *dirent_p = NULL;
+
+              svn_pool_destroy(subpool); /* Close RA session */
             }
           else
             {
@@ -203,7 +256,7 @@ svn_client_list2(const char *path_or_url,
                  be rev. */
               dirent = apr_palloc(pool, sizeof(*dirent));
               dirent->kind = kind;
-              dirent->size = 0;
+              dirent->size = SVN_INVALID_FILESIZE;
               if (dirent_fields & SVN_DIRENT_HAS_PROPS)
                 {
                   apr_hash_t *props;
@@ -220,30 +273,108 @@ svn_client_list2(const char *path_or_url,
 
                   SVN_ERR(svn_ra_rev_proplist(ra_session, rev, &props,
                                               pool));
-                  val = apr_hash_get(props, SVN_PROP_REVISION_DATE,
-                                     APR_HASH_KEY_STRING);
+                  val = svn_hash_gets(props, SVN_PROP_REVISION_DATE);
                   if (val)
                     SVN_ERR(svn_time_from_cstring(&dirent->time, val->data,
                                                   pool));
                   else
                     dirent->time = 0;
 
-                  val = apr_hash_get(props, SVN_PROP_REVISION_AUTHOR,
-                                     APR_HASH_KEY_STRING);
+                  val = svn_hash_gets(props, SVN_PROP_REVISION_AUTHOR);
                   dirent->last_author = val ? val->data : NULL;
                 }
+
+              *dirent_p = dirent;
             }
         }
       else
-        dirent = NULL;
+        *dirent_p = NULL;
     }
-  else if (err)
-    return svn_error_trace(err);
+  else
+    SVN_ERR(err);
+
+  return SVN_NO_ERROR;
+}
+
+/* List the file/directory entries for PATH_OR_URL at REVISION.
+   The actual node revision selected is determined by the path as
+   it exists in PEG_REVISION.
+
+   If DEPTH is svn_depth_infinity, then list all file and directory entries
+   recursively.  Else if DEPTH is svn_depth_files, list all files under
+   PATH_OR_URL (if any), but not subdirectories.  Else if DEPTH is
+   svn_depth_immediates, list all files and include immediate
+   subdirectories (at svn_depth_empty).  Else if DEPTH is
+   svn_depth_empty, just list PATH_OR_URL with none of its entries.
+
+   DIRENT_FIELDS controls which fields in the svn_dirent_t's are
+   filled in.  To have them totally filled in use SVN_DIRENT_ALL,
+   otherwise simply bitwise OR together the combination of SVN_DIRENT_*
+   fields you care about.
+
+   If FETCH_LOCKS is TRUE, include locks when reporting directory entries.
+
+   If INCLUDE_EXTERNALS is TRUE, also list all external items
+   reached by recursion.  DEPTH value passed to the original list target
+   applies for the externals also.  EXTERNAL_PARENT_URL is url of the
+   directory which has the externals definitions.  EXTERNAL_TARGET is the
+   target subdirectory of externals definitions.
+
+   Report directory entries by invoking LIST_FUNC/BATON.
+   Pass EXTERNAL_PARENT_URL and EXTERNAL_TARGET to LIST_FUNC when external
+   items are listed, otherwise both are set to NULL.
+
+   Use authentication baton cached in CTX to authenticate against the
+   repository.
 
+   Use POOL for all allocations.
+*/
+static svn_error_t *
+list_internal(const char *path_or_url,
+              const svn_opt_revision_t *peg_revision,
+              const svn_opt_revision_t *revision,
+              svn_depth_t depth,
+              apr_uint32_t dirent_fields,
+              svn_boolean_t fetch_locks,
+              svn_boolean_t include_externals,
+              const char *external_parent_url,
+              const char *external_target,
+              svn_client_list_func2_t list_func,
+              void *baton,
+              svn_client_ctx_t *ctx,
+              apr_pool_t *pool)
+{
+  svn_ra_session_t *ra_session;
+  svn_client__pathrev_t *loc;
+  svn_dirent_t *dirent;
+  const char *fs_path;
+  svn_error_t *err;
+  apr_hash_t *locks;
+  apr_hash_t *externals;
+
+  if (include_externals)
+    externals = apr_hash_make(pool);
+  else
+    externals = NULL;
+
+  /* We use the kind field to determine if we should recurse, so we
+     always need it. */
+  dirent_fields |= SVN_DIRENT_KIND;
+
+  /* Get an RA plugin for this filesystem object. */
+  SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &loc,
+                                            path_or_url, NULL,
+                                            peg_revision,
+                                            revision, ctx, pool));
+
+  fs_path = svn_client__pathrev_fspath(loc, pool);
+
+  SVN_ERR(svn_client__ra_stat_compatible(ra_session, loc->rev, &dirent,
+                                         dirent_fields, ctx, pool));
   if (! dirent)
     return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
                              _("URL '%s' non-existent in revision %ld"),
-                             url, rev);
+                             loc->url, loc->rev);
 
   /* Maybe get all locks under url. */
   if (fetch_locks)
@@ -265,16 +396,184 @@ svn_client_list2(const char *path_or_url,
 
   /* Report the dirent for the target. */
   SVN_ERR(list_func(baton, "", dirent, locks
-                    ? (apr_hash_get(locks, fs_path,
-                                    APR_HASH_KEY_STRING))
-                    : NULL, fs_path, pool));
+                    ? (svn_hash_gets(locks, fs_path))
+                    : NULL, fs_path, external_parent_url,
+                    external_target, pool));
 
   if (dirent->kind == svn_node_dir
       && (depth == svn_depth_files
           || depth == svn_depth_immediates
           || depth == svn_depth_infinity))
-    SVN_ERR(get_dir_contents(dirent_fields, "", rev, ra_session, locks,
-                             fs_path, depth, ctx, list_func, baton, pool));
+    SVN_ERR(get_dir_contents(dirent_fields, "", loc->rev, ra_session, locks,
+                             fs_path, depth, ctx, externals,
+                             external_parent_url, external_target, list_func,
+                             baton, pool, pool));
+
+  /* We handle externals after listing entries under path_or_url, so that
+     handling external items (and any errors therefrom) doesn't delay
+     the primary operation. */
+  if (include_externals && apr_hash_count(externals))
+    {
+      /* The 'externals' hash populated by get_dir_contents() is processed
+         here. */
+      SVN_ERR(list_externals(externals, depth, dirent_fields,
+                             fetch_locks, list_func, baton,
+                             ctx, pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+wrap_list_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;
+}
+
+
+/* Walk through all the external items and list them. */
+static svn_error_t *
+list_external_items(apr_array_header_t *external_items,
+                    const char *externals_parent_url,
+                    svn_depth_t depth,
+                    apr_uint32_t dirent_fields,
+                    svn_boolean_t fetch_locks,
+                    svn_client_list_func2_t list_func,
+                    void *baton,
+                    svn_client_ctx_t *ctx,
+                    apr_pool_t *scratch_pool)
+{
+  const char *externals_parent_repos_root_url;
+  apr_pool_t *iterpool;
+  int i;
+
+  SVN_ERR(svn_client_get_repos_root(&externals_parent_repos_root_url,
+                                    NULL /* uuid */,
+                                    externals_parent_url, ctx,
+                                    scratch_pool, scratch_pool));
+
+  iterpool = svn_pool_create(scratch_pool);
+
+  for (i = 0; i < external_items->nelts; i++)
+    {
+      const char *resolved_url;
+
+      svn_wc_external_item2_t *item =
+          APR_ARRAY_IDX(external_items, i, svn_wc_external_item2_t *);
+
+      svn_pool_clear(iterpool);
+
+      SVN_ERR(svn_wc__resolve_relative_external_url(
+                  &resolved_url,
+                  item,
+                  externals_parent_repos_root_url,
+                  externals_parent_url,
+                  iterpool, iterpool));
+
+      /* List the external */
+      SVN_ERR(wrap_list_error(ctx, item->target_dir,
+                              list_internal(resolved_url,
+                                            &item->peg_revision,
+                                            &item->revision,
+                                            depth, dirent_fields,
+                                            fetch_locks,
+                                            TRUE,
+                                            externals_parent_url,
+                                            item->target_dir,
+                                            list_func, baton, ctx,
+                                            iterpool),
+                              iterpool));
+
+    }
+  svn_pool_destroy(iterpool);
+
+  return SVN_NO_ERROR;
+}
+
+/* List external items defined on each external in EXTERNALS, a const char *
+   externals_parent_url(url of the directory which has the externals
+   definitions) of all externals mapping to the svn_string_t * externals_desc
+   (externals description text). All other options are the same as those
+   passed to svn_client_list(). */
+static svn_error_t *
+list_externals(apr_hash_t *externals,
+               svn_depth_t depth,
+               apr_uint32_t dirent_fields,
+               svn_boolean_t fetch_locks,
+               svn_client_list_func2_t list_func,
+               void *baton,
+               svn_client_ctx_t *ctx,
+               apr_pool_t *scratch_pool)
+{
+  apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+  apr_hash_index_t *hi;
+
+  for (hi = apr_hash_first(scratch_pool, externals);
+       hi;
+       hi = apr_hash_next(hi))
+    {
+      const char *externals_parent_url = svn__apr_hash_index_key(hi);
+      svn_string_t *externals_desc = svn__apr_hash_index_val(hi);
+      apr_array_header_t *external_items;
+
+      svn_pool_clear(iterpool);
+
+      SVN_ERR(svn_wc_parse_externals_description3(&external_items,
+                                                  externals_parent_url,
+                                                  externals_desc->data,
+                                                  FALSE, iterpool));
+
+      if (! external_items->nelts)
+        continue;
+
+      SVN_ERR(list_external_items(external_items, externals_parent_url, depth,
+                                  dirent_fields, fetch_locks, list_func,
+                                  baton, ctx, iterpool));
+
+    }
+  svn_pool_destroy(iterpool);
 
   return SVN_NO_ERROR;
 }
+
+
+svn_error_t *
+svn_client_list3(const char *path_or_url,
+                 const svn_opt_revision_t *peg_revision,
+                 const svn_opt_revision_t *revision,
+                 svn_depth_t depth,
+                 apr_uint32_t dirent_fields,
+                 svn_boolean_t fetch_locks,
+                 svn_boolean_t include_externals,
+                 svn_client_list_func2_t list_func,
+                 void *baton,
+                 svn_client_ctx_t *ctx,
+                 apr_pool_t *pool)
+{
+
+  return svn_error_trace(list_internal(path_or_url, peg_revision,
+                                       revision,
+                                       depth, dirent_fields,
+                                       fetch_locks,
+                                       include_externals,
+                                       NULL, NULL, list_func,
+                                       baton, ctx, pool));
+}