contrib/subversion/subversion/libsvn_wc/util.c

   1 /*
   2  * util.c:  general routines defying categorization; eventually I
   3  *          suspect they'll end up in libsvn_subr, but don't want to
   4  *          pollute that right now.  Note that nothing in here is
   5  *          specific to working copies.
   6  *
   7  * ====================================================================
   8  *    Licensed to the Apache Software Foundation (ASF) under one
   9  *    or more contributor license agreements.  See the NOTICE file
  10  *    distributed with this work for additional information
  11  *    regarding copyright ownership.  The ASF licenses this file
  12  *    to you under the Apache License, Version 2.0 (the
  13  *    "License"); you may not use this file except in compliance
  14  *    with the License.  You may obtain a copy of the License at
  15  *
  16  *      http://www.apache.org/licenses/LICENSE-2.0
  17  *
  18  *    Unless required by applicable law or agreed to in writing,
  19  *    software distributed under the License is distributed on an
  20  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  21  *    KIND, either express or implied.  See the License for the
  22  *    specific language governing permissions and limitations
  23  *    under the License.
  24  * ====================================================================
  25  */
  26
  27 #include <apr_pools.h>
  28 #include <apr_file_io.h>
  29
  30 #include "svn_io.h"
  31 #include "svn_types.h"
  32 #include "svn_error.h"
  33 #include "svn_dirent_uri.h"
  34 #include "svn_path.h"
  35 #include "svn_props.h"
  36 #include "svn_version.h"
  37
  38 #include "wc.h"   /* just for prototypes of things in this .c file */
  39 #include "entries.h"
  40 #include "private/svn_wc_private.h"
  41
  42 #include "svn_private_config.h"
  43
  44 \f
  45 svn_error_t *
  46 svn_wc__ensure_directory(const char *path,
  47                          apr_pool_t *pool)
  48 {
  49   svn_node_kind_t kind;
  50
  51   SVN_ERR(svn_io_check_path(path, &kind, pool));
  52
  53   if (kind != svn_node_none && kind != svn_node_dir)
  54     {
  55       /* If got an error other than dir non-existence, then we can't
  56          ensure this directory's existence, so just return the error.
  57          Might happen if there's a file in the way, for example. */
  58       return svn_error_createf(APR_ENOTDIR, NULL,
  59                                _("'%s' is not a directory"),
  60                                svn_dirent_local_style(path, pool));
  61     }
  62   else if (kind == svn_node_none)
  63     {
  64       /* The dir doesn't exist, and it's our job to change that. */
  65       SVN_ERR(svn_io_make_dir_recursively(path, pool));
  66     }
  67   else  /* No problem, the dir already existed, so just leave. */
  68     SVN_ERR_ASSERT(kind == svn_node_dir);
  69
  70   return SVN_NO_ERROR;
  71 }
  72
  73 /* Return the library version number. */
  74 const svn_version_t *
  75 svn_wc_version(void)
  76 {
  77   SVN_VERSION_BODY;
  78 }
  79
  80 svn_wc_notify_t *
  81 svn_wc_create_notify(const char *path,
  82                      svn_wc_notify_action_t action,
  83                      apr_pool_t *pool)
  84 {
  85   svn_wc_notify_t *ret = apr_pcalloc(pool, sizeof(*ret));
  86   ret->path = path;
  87   ret->action = action;
  88   ret->kind = svn_node_unknown;
  89   ret->content_state = ret->prop_state = svn_wc_notify_state_unknown;
  90   ret->lock_state = svn_wc_notify_lock_state_unknown;
  91   ret->revision = SVN_INVALID_REVNUM;
  92   ret->old_revision = SVN_INVALID_REVNUM;
  93
  94   return ret;
  95 }
  96
  97 svn_wc_notify_t *
  98 svn_wc_create_notify_url(const char *url,
  99                          svn_wc_notify_action_t action,
 100                          apr_pool_t *pool)
 101 {
 102   svn_wc_notify_t *ret = svn_wc_create_notify(".", action, pool);
 103   ret->url = url;
 104
 105   return ret;
 106 }
 107
 108 /* Pool cleanup function to clear an svn_error_t *. */
 109 static apr_status_t err_cleanup(void *data)
 110 {
 111   svn_error_clear(data);
 112
 113   return APR_SUCCESS;
 114 }
 115
 116 svn_wc_notify_t *
 117 svn_wc_dup_notify(const svn_wc_notify_t *notify,
 118                   apr_pool_t *pool)
 119 {
 120   svn_wc_notify_t *ret = apr_palloc(pool, sizeof(*ret));
 121
 122   *ret = *notify;
 123
 124   if (ret->path)
 125     ret->path = apr_pstrdup(pool, ret->path);
 126   if (ret->mime_type)
 127     ret->mime_type = apr_pstrdup(pool, ret->mime_type);
 128   if (ret->lock)
 129     ret->lock = svn_lock_dup(ret->lock, pool);
 130   if (ret->err)
 131     {
 132       ret->err = svn_error_dup(ret->err);
 133       apr_pool_cleanup_register(pool, ret->err, err_cleanup,
 134                                 apr_pool_cleanup_null);
 135     }
 136   if (ret->changelist_name)
 137     ret->changelist_name = apr_pstrdup(pool, ret->changelist_name);
 138   if (ret->merge_range)
 139     ret->merge_range = svn_merge_range_dup(ret->merge_range, pool);
 140   if (ret->url)
 141     ret->url = apr_pstrdup(pool, ret->url);
 142   if (ret->path_prefix)
 143     ret->path_prefix = apr_pstrdup(pool, ret->path_prefix);
 144   if (ret->prop_name)
 145     ret->prop_name = apr_pstrdup(pool, ret->prop_name);
 146   if (ret->rev_props)
 147     ret->rev_props = svn_prop_hash_dup(ret->rev_props, pool);
 148
 149   return ret;
 150 }
 151
 152 svn_error_t *
 153 svn_wc_external_item2_create(svn_wc_external_item2_t **item,
 154                              apr_pool_t *pool)
 155 {
 156   *item = apr_pcalloc(pool, sizeof(svn_wc_external_item2_t));
 157   return SVN_NO_ERROR;
 158 }
 159
 160
 161 svn_wc_external_item2_t *
 162 svn_wc_external_item2_dup(const svn_wc_external_item2_t *item,
 163                           apr_pool_t *pool)
 164 {
 165   svn_wc_external_item2_t *new_item = apr_palloc(pool, sizeof(*new_item));
 166
 167   *new_item = *item;
 168
 169   if (new_item->target_dir)
 170     new_item->target_dir = apr_pstrdup(pool, new_item->target_dir);
 171
 172   if (new_item->url)
 173     new_item->url = apr_pstrdup(pool, new_item->url);
 174
 175   return new_item;
 176 }
 177
 178
 179 svn_boolean_t
 180 svn_wc_match_ignore_list(const char *str, const apr_array_header_t *list,
 181                          apr_pool_t *pool)
 182 {
 183   /* For now, we simply forward to svn_cstring_match_glob_list. In the
 184      future, if we support more complex ignore patterns, we would iterate
 185      over 'list' ourselves, and decide for each pattern how to handle
 186      it. */
 187
 188   return svn_cstring_match_glob_list(str, list);
 189 }
 190
 191 svn_wc_conflict_description2_t *
 192 svn_wc_conflict_description_create_text2(const char *local_abspath,
 193                                          apr_pool_t *result_pool)
 194 {
 195   svn_wc_conflict_description2_t *conflict;
 196
 197   SVN_ERR_ASSERT_NO_RETURN(svn_dirent_is_absolute(local_abspath));
 198
 199   conflict = apr_pcalloc(result_pool, sizeof(*conflict));
 200   conflict->local_abspath = apr_pstrdup(result_pool, local_abspath);
 201   conflict->node_kind = svn_node_file;
 202   conflict->kind = svn_wc_conflict_kind_text;
 203   conflict->action = svn_wc_conflict_action_edit;
 204   conflict->reason = svn_wc_conflict_reason_edited;
 205   return conflict;
 206 }
 207
 208 svn_wc_conflict_description2_t *
 209 svn_wc_conflict_description_create_prop2(const char *local_abspath,
 210                                          svn_node_kind_t node_kind,
 211                                          const char *property_name,
 212                                          apr_pool_t *result_pool)
 213 {
 214   svn_wc_conflict_description2_t *conflict;
 215
 216   SVN_ERR_ASSERT_NO_RETURN(svn_dirent_is_absolute(local_abspath));
 217
 218   conflict = apr_pcalloc(result_pool, sizeof(*conflict));
 219   conflict->local_abspath = apr_pstrdup(result_pool, local_abspath);
 220   conflict->node_kind = node_kind;
 221   conflict->kind = svn_wc_conflict_kind_property;
 222   conflict->property_name = apr_pstrdup(result_pool, property_name);
 223   return conflict;
 224 }
 225
 226 svn_wc_conflict_description2_t *
 227 svn_wc_conflict_description_create_tree2(
 228   const char *local_abspath,
 229   svn_node_kind_t node_kind,
 230   svn_wc_operation_t operation,
 231   const svn_wc_conflict_version_t *src_left_version,
 232   const svn_wc_conflict_version_t *src_right_version,
 233   apr_pool_t *result_pool)
 234 {
 235   svn_wc_conflict_description2_t *conflict;
 236
 237   SVN_ERR_ASSERT_NO_RETURN(svn_dirent_is_absolute(local_abspath));
 238
 239   conflict = apr_pcalloc(result_pool, sizeof(*conflict));
 240   conflict->local_abspath = apr_pstrdup(result_pool, local_abspath);
 241   conflict->node_kind = node_kind;
 242   conflict->kind = svn_wc_conflict_kind_tree;
 243   conflict->operation = operation;
 244   conflict->src_left_version = svn_wc_conflict_version_dup(src_left_version,
 245                                                            result_pool);
 246   conflict->src_right_version = svn_wc_conflict_version_dup(src_right_version,
 247                                                             result_pool);
 248   return conflict;
 249 }
 250
 251
 252 svn_wc_conflict_description2_t *
 253 svn_wc__conflict_description2_dup(const svn_wc_conflict_description2_t *conflict,
 254                                   apr_pool_t *pool)
 255 {
 256   svn_wc_conflict_description2_t *new_conflict;
 257
 258   new_conflict = apr_pcalloc(pool, sizeof(*new_conflict));
 259
 260   /* Shallow copy all members. */
 261   *new_conflict = *conflict;
 262
 263   if (conflict->local_abspath)
 264     new_conflict->local_abspath = apr_pstrdup(pool, conflict->local_abspath);
 265   if (conflict->property_name)
 266     new_conflict->property_name = apr_pstrdup(pool, conflict->property_name);
 267   if (conflict->mime_type)
 268     new_conflict->mime_type = apr_pstrdup(pool, conflict->mime_type);
 269   if (conflict->base_abspath)
 270     new_conflict->base_abspath = apr_pstrdup(pool, conflict->base_abspath);
 271   if (conflict->their_abspath)
 272     new_conflict->their_abspath = apr_pstrdup(pool, conflict->their_abspath);
 273   if (conflict->my_abspath)
 274     new_conflict->my_abspath = apr_pstrdup(pool, conflict->my_abspath);
 275   if (conflict->merged_file)
 276     new_conflict->merged_file = apr_pstrdup(pool, conflict->merged_file);
 277   if (conflict->src_left_version)
 278     new_conflict->src_left_version =
 279       svn_wc_conflict_version_dup(conflict->src_left_version, pool);
 280   if (conflict->src_right_version)
 281     new_conflict->src_right_version =
 282       svn_wc_conflict_version_dup(conflict->src_right_version, pool);
 283
 284   return new_conflict;
 285 }
 286
 287 svn_wc_conflict_version_t *
 288 svn_wc_conflict_version_create2(const char *repos_url,
 289                                 const char *repos_uuid,
 290                                 const char *repos_relpath,
 291                                 svn_revnum_t revision,
 292                                 svn_node_kind_t kind,
 293                                 apr_pool_t *result_pool)
 294 {
 295   svn_wc_conflict_version_t *version;
 296
 297   version = apr_pcalloc(result_pool, sizeof(*version));
 298
 299     SVN_ERR_ASSERT_NO_RETURN(svn_uri_is_canonical(repos_url, result_pool)
 300                              && svn_relpath_is_canonical(repos_relpath)
 301                              && SVN_IS_VALID_REVNUM(revision)
 302                              /* ### repos_uuid can be NULL :( */);
 303
 304   version->repos_url = repos_url;
 305   version->peg_rev = revision;
 306   version->path_in_repos = repos_relpath;
 307   version->node_kind = kind;
 308   version->repos_uuid = repos_uuid;
 309
 310   return version;
 311 }
 312
 313
 314 svn_wc_conflict_version_t *
 315 svn_wc_conflict_version_dup(const svn_wc_conflict_version_t *version,
 316                             apr_pool_t *result_pool)
 317 {
 318
 319   svn_wc_conflict_version_t *new_version;
 320
 321   if (version == NULL)
 322     return NULL;
 323
 324   new_version = apr_pcalloc(result_pool, sizeof(*new_version));
 325
 326   /* Shallow copy all members. */
 327   *new_version = *version;
 328
 329   if (version->repos_url)
 330     new_version->repos_url = apr_pstrdup(result_pool, version->repos_url);
 331
 332   if (version->path_in_repos)
 333     new_version->path_in_repos = apr_pstrdup(result_pool,
 334                                              version->path_in_repos);
 335
 336   if (version->repos_uuid)
 337     new_version->repos_uuid = apr_pstrdup(result_pool, version->repos_uuid);
 338
 339   return new_version;
 340 }
 341
 342
 343 svn_wc_conflict_description_t *
 344 svn_wc__cd2_to_cd(const svn_wc_conflict_description2_t *conflict,
 345                   apr_pool_t *result_pool)
 346 {
 347   svn_wc_conflict_description_t *new_conflict;
 348
 349   if (conflict == NULL)
 350     return NULL;
 351
 352   new_conflict = apr_pcalloc(result_pool, sizeof(*new_conflict));
 353
 354   new_conflict->path = apr_pstrdup(result_pool, conflict->local_abspath);
 355   new_conflict->node_kind = conflict->node_kind;
 356   new_conflict->kind = conflict->kind;
 357   new_conflict->action = conflict->action;
 358   new_conflict->reason = conflict->reason;
 359   if (conflict->src_left_version)
 360     new_conflict->src_left_version =
 361           svn_wc_conflict_version_dup(conflict->src_left_version, result_pool);
 362   if (conflict->src_right_version)
 363     new_conflict->src_right_version =
 364           svn_wc_conflict_version_dup(conflict->src_right_version, result_pool);
 365
 366   switch (conflict->kind)
 367     {
 368
 369       case svn_wc_conflict_kind_property:
 370         new_conflict->property_name = apr_pstrdup(result_pool,
 371                                                   conflict->property_name);
 372         /* Falling through. */
 373
 374       case svn_wc_conflict_kind_text:
 375         new_conflict->is_binary = conflict->is_binary;
 376         if (conflict->mime_type)
 377           new_conflict->mime_type = apr_pstrdup(result_pool,
 378                                                 conflict->mime_type);
 379         if (conflict->base_abspath)
 380           new_conflict->base_file = apr_pstrdup(result_pool,
 381                                                 conflict->base_abspath);
 382         if (conflict->their_abspath)
 383           new_conflict->their_file = apr_pstrdup(result_pool,
 384                                                  conflict->their_abspath);
 385         if (conflict->my_abspath)
 386           new_conflict->my_file = apr_pstrdup(result_pool,
 387                                               conflict->my_abspath);
 388         if (conflict->merged_file)
 389           new_conflict->merged_file = apr_pstrdup(result_pool,
 390                                                   conflict->merged_file);
 391         break;
 392
 393       case svn_wc_conflict_kind_tree:
 394         new_conflict->operation = conflict->operation;
 395         break;
 396     }
 397
 398   /* A NULL access baton is allowable by the API. */
 399   new_conflict->access = NULL;
 400
 401   return new_conflict;
 402 }
 403
 404
 405 svn_error_t *
 406 svn_wc__status2_from_3(svn_wc_status2_t **status,
 407                        const svn_wc_status3_t *old_status,
 408                        svn_wc_context_t *wc_ctx,
 409                        const char *local_abspath,
 410                        apr_pool_t *result_pool,
 411                        apr_pool_t *scratch_pool)
 412 {
 413   const svn_wc_entry_t *entry = NULL;
 414
 415   if (old_status == NULL)
 416     {
 417       *status = NULL;
 418       return SVN_NO_ERROR;
 419     }
 420
 421   *status = apr_pcalloc(result_pool, sizeof(**status));
 422
 423   if (old_status->versioned)
 424     {
 425       svn_error_t *err;
 426       err= svn_wc__get_entry(&entry, wc_ctx->db, local_abspath, FALSE,
 427                              svn_node_unknown, result_pool, scratch_pool);
 428
 429       if (err && err->apr_err == SVN_ERR_NODE_UNEXPECTED_KIND)
 430         svn_error_clear(err);
 431       else
 432         SVN_ERR(err);
 433     }
 434
 435   (*status)->entry = entry;
 436   (*status)->copied = old_status->copied;
 437   (*status)->repos_lock = svn_lock_dup(old_status->repos_lock, result_pool);
 438
 439   if (old_status->repos_relpath)
 440     (*status)->url = svn_path_url_add_component2(old_status->repos_root_url,
 441                                                  old_status->repos_relpath,
 442                                                  result_pool);
 443   (*status)->ood_last_cmt_rev = old_status->ood_changed_rev;
 444   (*status)->ood_last_cmt_date = old_status->ood_changed_date;
 445   (*status)->ood_kind = old_status->ood_kind;
 446   (*status)->ood_last_cmt_author = old_status->ood_changed_author;
 447
 448   if (old_status->conflicted)
 449     {
 450       const svn_wc_conflict_description2_t *tree_conflict;
 451       SVN_ERR(svn_wc__get_tree_conflict(&tree_conflict, wc_ctx, local_abspath,
 452                                         scratch_pool, scratch_pool));
 453       (*status)->tree_conflict = svn_wc__cd2_to_cd(tree_conflict, result_pool);
 454     }
 455
 456   (*status)->switched = old_status->switched;
 457
 458   (*status)->text_status = old_status->node_status;
 459   (*status)->prop_status = old_status->prop_status;
 460
 461   (*status)->repos_text_status = old_status->repos_node_status;
 462   (*status)->repos_prop_status = old_status->repos_prop_status;
 463
 464   /* Some values might be inherited from properties */
 465   if (old_status->node_status == svn_wc_status_modified
 466       || old_status->node_status == svn_wc_status_conflicted)
 467     (*status)->text_status = old_status->text_status;
 468
 469   /* (Currently a no-op, but just make sure it is ok) */
 470   if (old_status->repos_node_status == svn_wc_status_modified
 471       || old_status->repos_node_status == svn_wc_status_conflicted)
 472     (*status)->repos_text_status = old_status->repos_text_status;
 473
 474   if (old_status->node_status == svn_wc_status_added)
 475     (*status)->prop_status = svn_wc_status_none; /* No separate info */
 476
 477   /* Find pristine_text_status value */
 478   switch (old_status->text_status)
 479     {
 480       case svn_wc_status_none:
 481       case svn_wc_status_normal:
 482       case svn_wc_status_modified:
 483         (*status)->pristine_text_status = old_status->text_status;
 484         break;
 485       case svn_wc_status_conflicted:
 486       default:
 487         /* ### Fetch compare data, or fall back to the documented
 488                not retrieved behavior? */
 489         (*status)->pristine_text_status = svn_wc_status_none;
 490         break;
 491     }
 492
 493   /* Find pristine_prop_status value */
 494   switch (old_status->prop_status)
 495     {
 496       case svn_wc_status_none:
 497       case svn_wc_status_normal:
 498       case svn_wc_status_modified:
 499         if (old_status->node_status != svn_wc_status_added
 500             && old_status->node_status != svn_wc_status_deleted
 501             && old_status->node_status != svn_wc_status_replaced)
 502           {
 503             (*status)->pristine_prop_status = old_status->prop_status;
 504           }
 505         else
 506           (*status)->pristine_prop_status = svn_wc_status_none;
 507         break;
 508       case svn_wc_status_conflicted:
 509       default:
 510         /* ### Fetch compare data, or fall back to the documented
 511                not retrieved behavior? */
 512         (*status)->pristine_prop_status = svn_wc_status_none;
 513         break;
 514     }
 515
 516   if (old_status->versioned
 517       && old_status->conflicted
 518       && old_status->node_status != svn_wc_status_obstructed
 519       && (old_status->kind == svn_node_file
 520           || old_status->node_status != svn_wc_status_missing))
 521     {
 522       svn_boolean_t text_conflict_p, prop_conflict_p;
 523
 524       /* The entry says there was a conflict, but the user might have
 525          marked it as resolved by deleting the artifact files, so check
 526          for that. */
 527       SVN_ERR(svn_wc__internal_conflicted_p(&text_conflict_p,
 528                                             &prop_conflict_p,
 529                                             NULL,
 530                                             wc_ctx->db, local_abspath,
 531                                             scratch_pool));
 532
 533       if (text_conflict_p)
 534         (*status)->text_status = svn_wc_status_conflicted;
 535
 536       if (prop_conflict_p)
 537         (*status)->prop_status = svn_wc_status_conflicted;
 538     }
 539
 540   return SVN_NO_ERROR;
 541 }
 542
 543
 544 svn_error_t *
 545 svn_wc__fetch_kind_func(svn_node_kind_t *kind,
 546                         void *baton,
 547                         const char *path,
 548                         svn_revnum_t base_revision,
 549                         apr_pool_t *scratch_pool)
 550 {
 551   struct svn_wc__shim_fetch_baton_t *sfb = baton;
 552   const char *local_abspath = svn_dirent_join(sfb->base_abspath, path,
 553                                               scratch_pool);
 554
 555   SVN_ERR(svn_wc__db_read_kind(kind, sfb->db, local_abspath,
 556                                FALSE /* allow_missing */,
 557                                TRUE /* show_deleted */,
 558                                FALSE /* show_hidden */,
 559                                scratch_pool));
 560
 561   return SVN_NO_ERROR;
 562 }
 563
 564
 565 svn_error_t *
 566 svn_wc__fetch_props_func(apr_hash_t **props,
 567                          void *baton,
 568                          const char *path,
 569                          svn_revnum_t base_revision,
 570                          apr_pool_t *result_pool,
 571                          apr_pool_t *scratch_pool)
 572 {
 573   struct svn_wc__shim_fetch_baton_t *sfb = baton;
 574   const char *local_abspath = svn_dirent_join(sfb->base_abspath, path,
 575                                               scratch_pool);
 576   svn_error_t *err;
 577
 578   if (sfb->fetch_base)
 579     err = svn_wc__db_base_get_props(props, sfb->db, local_abspath, result_pool,
 580                                     scratch_pool);
 581   else
 582     err = svn_wc__db_read_props(props, sfb->db, local_abspath,
 583                                 result_pool, scratch_pool);
 584
 585   /* If the path doesn't exist, just return an empty set of props. */
 586   if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
 587     {
 588       svn_error_clear(err);
 589       *props = apr_hash_make(result_pool);
 590     }
 591   else if (err)
 592     return svn_error_trace(err);
 593
 594   return SVN_NO_ERROR;
 595 }
 596
 597
 598 svn_error_t *
 599 svn_wc__fetch_base_func(const char **filename,
 600                         void *baton,
 601                         const char *path,
 602                         svn_revnum_t base_revision,
 603                         apr_pool_t *result_pool,
 604                         apr_pool_t *scratch_pool)
 605 {
 606   struct svn_wc__shim_fetch_baton_t *sfb = baton;
 607   const svn_checksum_t *checksum;
 608   svn_error_t *err;
 609   const char *local_abspath = svn_dirent_join(sfb->base_abspath, path,
 610                                               scratch_pool);
 611
 612   err = svn_wc__db_base_get_info(NULL, NULL, NULL, NULL, NULL, NULL,
 613                                  NULL, NULL, NULL, NULL, &checksum,
 614                                  NULL, NULL, NULL, NULL, NULL,
 615                                  sfb->db, local_abspath,
 616                                  scratch_pool, scratch_pool);
 617   if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
 618     {
 619       svn_error_clear(err);
 620       *filename = NULL;
 621       return SVN_NO_ERROR;
 622     }
 623   else if (err)
 624     return svn_error_trace(err);
 625
 626   if (checksum == NULL)
 627     {
 628       *filename = NULL;
 629       return SVN_NO_ERROR;
 630     }
 631
 632   SVN_ERR(svn_wc__db_pristine_get_path(filename, sfb->db, local_abspath,
 633                                        checksum, scratch_pool, scratch_pool));
 634
 635   return SVN_NO_ERROR;
 636 }