contrib/subversion/subversion/libsvn_repos/deprecated.c

   1 /*
   2  * deprecated.c:  holding file for all deprecated APIs.
   3  *                "we can't lose 'em, but we can shun 'em!"
   4  *
   5  * ====================================================================
   6  *    Licensed to the Apache Software Foundation (ASF) under one
   7  *    or more contributor license agreements.  See the NOTICE file
   8  *    distributed with this work for additional information
   9  *    regarding copyright ownership.  The ASF licenses this file
  10  *    to you under the Apache License, Version 2.0 (the
  11  *    "License"); you may not use this file except in compliance
  12  *    with the License.  You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  *    Unless required by applicable law or agreed to in writing,
  17  *    software distributed under the License is distributed on an
  18  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  19  *    KIND, either express or implied.  See the License for the
  20  *    specific language governing permissions and limitations
  21  *    under the License.
  22  * ====================================================================
  23  */
  24
  25 /* We define this here to remove any further warnings about the usage of
  26    deprecated functions in this file. */
  27 #define SVN_DEPRECATED
  28
  29 #include "svn_repos.h"
  30 #include "svn_compat.h"
  31 #include "svn_hash.h"
  32 #include "svn_props.h"
  33
  34 #include "svn_private_config.h"
  35
  36 #include "repos.h"
  37
  38
  39 \f
  40
  41 /*** From commit.c ***/
  42
  43 svn_error_t *
  44 svn_repos_get_commit_editor4(const svn_delta_editor_t **editor,
  45                              void **edit_baton,
  46                              svn_repos_t *repos,
  47                              svn_fs_txn_t *txn,
  48                              const char *repos_url,
  49                              const char *base_path,
  50                              const char *user,
  51                              const char *log_msg,
  52                              svn_commit_callback2_t commit_callback,
  53                              void *commit_baton,
  54                              svn_repos_authz_callback_t authz_callback,
  55                              void *authz_baton,
  56                              apr_pool_t *pool)
  57 {
  58   apr_hash_t *revprop_table = apr_hash_make(pool);
  59   if (user)
  60     svn_hash_sets(revprop_table, SVN_PROP_REVISION_AUTHOR,
  61                   svn_string_create(user, pool));
  62   if (log_msg)
  63     svn_hash_sets(revprop_table, SVN_PROP_REVISION_LOG,
  64                   svn_string_create(log_msg, pool));
  65   return svn_repos_get_commit_editor5(editor, edit_baton, repos, txn,
  66                                       repos_url, base_path, revprop_table,
  67                                       commit_callback, commit_baton,
  68                                       authz_callback, authz_baton, pool);
  69 }
  70
  71
  72 svn_error_t *
  73 svn_repos_get_commit_editor3(const svn_delta_editor_t **editor,
  74                              void **edit_baton,
  75                              svn_repos_t *repos,
  76                              svn_fs_txn_t *txn,
  77                              const char *repos_url,
  78                              const char *base_path,
  79                              const char *user,
  80                              const char *log_msg,
  81                              svn_commit_callback_t callback,
  82                              void *callback_baton,
  83                              svn_repos_authz_callback_t authz_callback,
  84                              void *authz_baton,
  85                              apr_pool_t *pool)
  86 {
  87   svn_commit_callback2_t callback2;
  88   void *callback2_baton;
  89
  90   svn_compat_wrap_commit_callback(&callback2, &callback2_baton,
  91                                   callback, callback_baton,
  92                                   pool);
  93
  94   return svn_repos_get_commit_editor4(editor, edit_baton, repos, txn,
  95                                       repos_url, base_path, user,
  96                                       log_msg, callback2,
  97                                       callback2_baton, authz_callback,
  98                                       authz_baton, pool);
  99 }
 100
 101
 102 svn_error_t *
 103 svn_repos_get_commit_editor2(const svn_delta_editor_t **editor,
 104                              void **edit_baton,
 105                              svn_repos_t *repos,
 106                              svn_fs_txn_t *txn,
 107                              const char *repos_url,
 108                              const char *base_path,
 109                              const char *user,
 110                              const char *log_msg,
 111                              svn_commit_callback_t callback,
 112                              void *callback_baton,
 113                              apr_pool_t *pool)
 114 {
 115   return svn_repos_get_commit_editor3(editor, edit_baton, repos, txn,
 116                                       repos_url, base_path, user,
 117                                       log_msg, callback, callback_baton,
 118                                       NULL, NULL, pool);
 119 }
 120
 121
 122 svn_error_t *
 123 svn_repos_get_commit_editor(const svn_delta_editor_t **editor,
 124                             void **edit_baton,
 125                             svn_repos_t *repos,
 126                             const char *repos_url,
 127                             const char *base_path,
 128                             const char *user,
 129                             const char *log_msg,
 130                             svn_commit_callback_t callback,
 131                             void *callback_baton,
 132                             apr_pool_t *pool)
 133 {
 134   return svn_repos_get_commit_editor2(editor, edit_baton, repos, NULL,
 135                                       repos_url, base_path, user,
 136                                       log_msg, callback,
 137                                       callback_baton, pool);
 138 }
 139
 140 svn_error_t *
 141 svn_repos_open2(svn_repos_t **repos_p,
 142                 const char *path,
 143                 apr_hash_t *fs_config,
 144                 apr_pool_t *pool)
 145 {
 146   return svn_repos_open3(repos_p, path, fs_config, pool, pool);
 147 }
 148
 149 svn_error_t *
 150 svn_repos_open(svn_repos_t **repos_p,
 151                const char *path,
 152                apr_pool_t *pool)
 153 {
 154   return svn_repos_open2(repos_p, path, NULL, pool);
 155 }
 156
 157
 158 /*** From repos.c ***/
 159 struct recover_baton
 160 {
 161   svn_error_t *(*start_callback)(void *baton);
 162   void *start_callback_baton;
 163 };
 164
 165 static void
 166 recovery_started(void *baton,
 167                  const svn_repos_notify_t *notify,
 168                  apr_pool_t *scratch_pool)
 169 {
 170   struct recover_baton *rb = baton;
 171
 172   if (notify->action == svn_repos_notify_mutex_acquired
 173       && rb->start_callback != NULL)
 174     svn_error_clear(rb->start_callback(rb->start_callback_baton));
 175 }
 176
 177 svn_error_t *
 178 svn_repos_recover3(const char *path,
 179                    svn_boolean_t nonblocking,
 180                    svn_error_t *(*start_callback)(void *baton),
 181                    void *start_callback_baton,
 182                    svn_cancel_func_t cancel_func, void *cancel_baton,
 183                    apr_pool_t *pool)
 184 {
 185   struct recover_baton rb;
 186
 187   rb.start_callback = start_callback;
 188   rb.start_callback_baton = start_callback_baton;
 189
 190   return svn_repos_recover4(path, nonblocking, recovery_started, &rb,
 191                             cancel_func, cancel_baton, pool);
 192 }
 193
 194 svn_error_t *
 195 svn_repos_recover2(const char *path,
 196                    svn_boolean_t nonblocking,
 197                    svn_error_t *(*start_callback)(void *baton),
 198                    void *start_callback_baton,
 199                    apr_pool_t *pool)
 200 {
 201   return svn_repos_recover3(path, nonblocking,
 202                             start_callback, start_callback_baton,
 203                             NULL, NULL,
 204                             pool);
 205 }
 206
 207 svn_error_t *
 208 svn_repos_recover(const char *path,
 209                   apr_pool_t *pool)
 210 {
 211   return svn_repos_recover2(path, FALSE, NULL, NULL, pool);
 212 }
 213
 214 svn_error_t *
 215 svn_repos_upgrade(const char *path,
 216                   svn_boolean_t nonblocking,
 217                   svn_error_t *(*start_callback)(void *baton),
 218                   void *start_callback_baton,
 219                   apr_pool_t *pool)
 220 {
 221   struct recover_baton rb;
 222
 223   rb.start_callback = start_callback;
 224   rb.start_callback_baton = start_callback_baton;
 225
 226   return svn_repos_upgrade2(path, nonblocking, recovery_started, &rb, pool);
 227 }
 228
 229 svn_error_t *
 230 svn_repos_hotcopy2(const char *src_path,
 231                    const char *dst_path,
 232                    svn_boolean_t clean_logs,
 233                    svn_boolean_t incremental,
 234                    svn_cancel_func_t cancel_func,
 235                    void *cancel_baton,
 236                    apr_pool_t *pool)
 237 {
 238   return svn_error_trace(svn_repos_hotcopy3(src_path, dst_path, clean_logs,
 239                                             incremental, NULL, NULL,
 240                                             cancel_func, cancel_baton, pool));
 241 }
 242
 243 svn_error_t *
 244 svn_repos_hotcopy(const char *src_path,
 245                   const char *dst_path,
 246                   svn_boolean_t clean_logs,
 247                   apr_pool_t *pool)
 248 {
 249   return svn_error_trace(svn_repos_hotcopy2(src_path, dst_path, clean_logs,
 250                                             FALSE, NULL, NULL, pool));
 251 }
 252
 253 /*** From reporter.c ***/
 254 svn_error_t *
 255 svn_repos_begin_report(void **report_baton,
 256                        svn_revnum_t revnum,
 257                        const char *username,
 258                        svn_repos_t *repos,
 259                        const char *fs_base,
 260                        const char *s_operand,
 261                        const char *switch_path,
 262                        svn_boolean_t text_deltas,
 263                        svn_boolean_t recurse,
 264                        svn_boolean_t ignore_ancestry,
 265                        const svn_delta_editor_t *editor,
 266                        void *edit_baton,
 267                        svn_repos_authz_func_t authz_read_func,
 268                        void *authz_read_baton,
 269                        apr_pool_t *pool)
 270 {
 271   return svn_repos_begin_report2(report_baton,
 272                                  revnum,
 273                                  repos,
 274                                  fs_base,
 275                                  s_operand,
 276                                  switch_path,
 277                                  text_deltas,
 278                                  SVN_DEPTH_INFINITY_OR_FILES(recurse),
 279                                  ignore_ancestry,
 280                                  FALSE, /* don't send copyfrom args */
 281                                  editor,
 282                                  edit_baton,
 283                                  authz_read_func,
 284                                  authz_read_baton,
 285                                  pool);
 286 }
 287
 288 svn_error_t *
 289 svn_repos_begin_report2(void **report_baton,
 290                         svn_revnum_t revnum,
 291                         svn_repos_t *repos,
 292                         const char *fs_base,
 293                         const char *target,
 294                         const char *tgt_path,
 295                         svn_boolean_t text_deltas,
 296                         svn_depth_t depth,
 297                         svn_boolean_t ignore_ancestry,
 298                         svn_boolean_t send_copyfrom_args,
 299                         const svn_delta_editor_t *editor,
 300                         void *edit_baton,
 301                         svn_repos_authz_func_t authz_read_func,
 302                         void *authz_read_baton,
 303                         apr_pool_t *pool)
 304 {
 305   return svn_repos_begin_report3(report_baton,
 306                                  revnum,
 307                                  repos,
 308                                  fs_base,
 309                                  target,
 310                                  tgt_path,
 311                                  text_deltas,
 312                                  depth,
 313                                  ignore_ancestry,
 314                                  send_copyfrom_args,
 315                                  editor,
 316                                  edit_baton,
 317                                  authz_read_func,
 318                                  authz_read_baton,
 319                                  0,     /* disable zero-copy code path */
 320                                  pool);
 321 }
 322
 323 svn_error_t *
 324 svn_repos_set_path2(void *baton, const char *path, svn_revnum_t rev,
 325                     svn_boolean_t start_empty, const char *lock_token,
 326                     apr_pool_t *pool)
 327 {
 328   return svn_repos_set_path3(baton, path, rev, svn_depth_infinity,
 329                              start_empty, lock_token, pool);
 330 }
 331
 332 svn_error_t *
 333 svn_repos_set_path(void *baton, const char *path, svn_revnum_t rev,
 334                    svn_boolean_t start_empty, apr_pool_t *pool)
 335 {
 336   return svn_repos_set_path2(baton, path, rev, start_empty, NULL, pool);
 337 }
 338
 339 svn_error_t *
 340 svn_repos_link_path2(void *baton, const char *path, const char *link_path,
 341                      svn_revnum_t rev, svn_boolean_t start_empty,
 342                      const char *lock_token, apr_pool_t *pool)
 343 {
 344   return svn_repos_link_path3(baton, path, link_path, rev, svn_depth_infinity,
 345                               start_empty, lock_token, pool);
 346 }
 347
 348 svn_error_t *
 349 svn_repos_link_path(void *baton, const char *path, const char *link_path,
 350                     svn_revnum_t rev, svn_boolean_t start_empty,
 351                     apr_pool_t *pool)
 352 {
 353   return svn_repos_link_path2(baton, path, link_path, rev, start_empty,
 354                               NULL, pool);
 355 }
 356
 357 /*** From dir-delta.c ***/
 358 svn_error_t *
 359 svn_repos_dir_delta(svn_fs_root_t *src_root,
 360                     const char *src_parent_dir,
 361                     const char *src_entry,
 362                     svn_fs_root_t *tgt_root,
 363                     const char *tgt_fullpath,
 364                     const svn_delta_editor_t *editor,
 365                     void *edit_baton,
 366                     svn_repos_authz_func_t authz_read_func,
 367                     void *authz_read_baton,
 368                     svn_boolean_t text_deltas,
 369                     svn_boolean_t recurse,
 370                     svn_boolean_t entry_props,
 371                     svn_boolean_t ignore_ancestry,
 372                     apr_pool_t *pool)
 373 {
 374   return svn_repos_dir_delta2(src_root,
 375                               src_parent_dir,
 376                               src_entry,
 377                               tgt_root,
 378                               tgt_fullpath,
 379                               editor,
 380                               edit_baton,
 381                               authz_read_func,
 382                               authz_read_baton,
 383                               text_deltas,
 384                               SVN_DEPTH_INFINITY_OR_FILES(recurse),
 385                               entry_props,
 386                               ignore_ancestry,
 387                               pool);
 388 }
 389
 390 /*** From replay.c ***/
 391 svn_error_t *
 392 svn_repos_replay(svn_fs_root_t *root,
 393                  const svn_delta_editor_t *editor,
 394                  void *edit_baton,
 395                  apr_pool_t *pool)
 396 {
 397   return svn_repos_replay2(root,
 398                            "" /* the whole tree */,
 399                            SVN_INVALID_REVNUM, /* no low water mark */
 400                            FALSE /* no text deltas */,
 401                            editor, edit_baton,
 402                            NULL /* no authz func */,
 403                            NULL /* no authz baton */,
 404                            pool);
 405 }
 406
 407 /*** From fs-wrap.c ***/
 408 svn_error_t *
 409 svn_repos_fs_change_rev_prop3(svn_repos_t *repos,
 410                               svn_revnum_t rev,
 411                               const char *author,
 412                               const char *name,
 413                               const svn_string_t *new_value,
 414                               svn_boolean_t use_pre_revprop_change_hook,
 415                               svn_boolean_t use_post_revprop_change_hook,
 416                               svn_repos_authz_func_t authz_read_func,
 417                               void *authz_read_baton,
 418                               apr_pool_t *pool)
 419 {
 420   return svn_repos_fs_change_rev_prop4(repos, rev, author, name, NULL,
 421                                        new_value,
 422                                        use_pre_revprop_change_hook,
 423                                        use_post_revprop_change_hook,
 424                                        authz_read_func,
 425                                        authz_read_baton, pool);
 426 }
 427
 428 svn_error_t *
 429 svn_repos_fs_change_rev_prop2(svn_repos_t *repos,
 430                               svn_revnum_t rev,
 431                               const char *author,
 432                               const char *name,
 433                               const svn_string_t *new_value,
 434                               svn_repos_authz_func_t authz_read_func,
 435                               void *authz_read_baton,
 436                               apr_pool_t *pool)
 437 {
 438   return svn_repos_fs_change_rev_prop3(repos, rev, author, name, new_value,
 439                                        TRUE, TRUE, authz_read_func,
 440                                        authz_read_baton, pool);
 441 }
 442
 443
 444
 445 svn_error_t *
 446 svn_repos_fs_change_rev_prop(svn_repos_t *repos,
 447                              svn_revnum_t rev,
 448                              const char *author,
 449                              const char *name,
 450                              const svn_string_t *new_value,
 451                              apr_pool_t *pool)
 452 {
 453   return svn_repos_fs_change_rev_prop2(repos, rev, author, name, new_value,
 454                                        NULL, NULL, pool);
 455 }
 456
 457 struct pack_notify_wrapper_baton
 458 {
 459   svn_fs_pack_notify_t notify_func;
 460   void *notify_baton;
 461 };
 462
 463 static void
 464 pack_notify_wrapper_func(void *baton,
 465                          const svn_repos_notify_t *notify,
 466                          apr_pool_t *scratch_pool)
 467 {
 468   struct pack_notify_wrapper_baton *pnwb = baton;
 469
 470   svn_error_clear(pnwb->notify_func(pnwb->notify_baton, notify->shard,
 471                                     notify->action - 3, scratch_pool));
 472 }
 473
 474 svn_error_t *
 475 svn_repos_fs_pack(svn_repos_t *repos,
 476                   svn_fs_pack_notify_t notify_func,
 477                   void *notify_baton,
 478                   svn_cancel_func_t cancel_func,
 479                   void *cancel_baton,
 480                   apr_pool_t *pool)
 481 {
 482   struct pack_notify_wrapper_baton pnwb;
 483
 484   pnwb.notify_func = notify_func;
 485   pnwb.notify_baton = notify_baton;
 486
 487   return svn_repos_fs_pack2(repos, pack_notify_wrapper_func, &pnwb,
 488                             cancel_func, cancel_baton, pool);
 489 }
 490
 491
 492 svn_error_t *
 493 svn_repos_fs_get_locks(apr_hash_t **locks,
 494                        svn_repos_t *repos,
 495                        const char *path,
 496                        svn_repos_authz_func_t authz_read_func,
 497                        void *authz_read_baton,
 498                        apr_pool_t *pool)
 499 {
 500   return svn_error_trace(svn_repos_fs_get_locks2(locks, repos, path,
 501                                                  svn_depth_infinity,
 502                                                  authz_read_func,
 503                                                  authz_read_baton, pool));
 504 }
 505
 506
 507 /*** From logs.c ***/
 508 svn_error_t *
 509 svn_repos_get_logs3(svn_repos_t *repos,
 510                     const apr_array_header_t *paths,
 511                     svn_revnum_t start,
 512                     svn_revnum_t end,
 513                     int limit,
 514                     svn_boolean_t discover_changed_paths,
 515                     svn_boolean_t strict_node_history,
 516                     svn_repos_authz_func_t authz_read_func,
 517                     void *authz_read_baton,
 518                     svn_log_message_receiver_t receiver,
 519                     void *receiver_baton,
 520                     apr_pool_t *pool)
 521 {
 522   svn_log_entry_receiver_t receiver2;
 523   void *receiver2_baton;
 524
 525   svn_compat_wrap_log_receiver(&receiver2, &receiver2_baton,
 526                                receiver, receiver_baton,
 527                                pool);
 528
 529   return svn_repos_get_logs4(repos, paths, start, end, limit,
 530                              discover_changed_paths, strict_node_history,
 531                              FALSE, svn_compat_log_revprops_in(pool),
 532                              authz_read_func, authz_read_baton,
 533                              receiver2, receiver2_baton,
 534                              pool);
 535 }
 536
 537 svn_error_t *
 538 svn_repos_get_logs2(svn_repos_t *repos,
 539                     const apr_array_header_t *paths,
 540                     svn_revnum_t start,
 541                     svn_revnum_t end,
 542                     svn_boolean_t discover_changed_paths,
 543                     svn_boolean_t strict_node_history,
 544                     svn_repos_authz_func_t authz_read_func,
 545                     void *authz_read_baton,
 546                     svn_log_message_receiver_t receiver,
 547                     void *receiver_baton,
 548                     apr_pool_t *pool)
 549 {
 550   return svn_repos_get_logs3(repos, paths, start, end, 0,
 551                              discover_changed_paths, strict_node_history,
 552                              authz_read_func, authz_read_baton, receiver,
 553                              receiver_baton, pool);
 554 }
 555
 556
 557 svn_error_t *
 558 svn_repos_get_logs(svn_repos_t *repos,
 559                    const apr_array_header_t *paths,
 560                    svn_revnum_t start,
 561                    svn_revnum_t end,
 562                    svn_boolean_t discover_changed_paths,
 563                    svn_boolean_t strict_node_history,
 564                    svn_log_message_receiver_t receiver,
 565                    void *receiver_baton,
 566                    apr_pool_t *pool)
 567 {
 568   return svn_repos_get_logs3(repos, paths, start, end, 0,
 569                              discover_changed_paths, strict_node_history,
 570                              NULL, NULL, /* no authz stuff */
 571                              receiver, receiver_baton, pool);
 572 }
 573
 574 /*** From rev_hunt.c ***/
 575 svn_error_t *
 576 svn_repos_history(svn_fs_t *fs,
 577                   const char *path,
 578                   svn_repos_history_func_t history_func,
 579                   void *history_baton,
 580                   svn_revnum_t start,
 581                   svn_revnum_t end,
 582                   svn_boolean_t cross_copies,
 583                   apr_pool_t *pool)
 584 {
 585   return svn_repos_history2(fs, path, history_func, history_baton,
 586                             NULL, NULL,
 587                             start, end, cross_copies, pool);
 588 }
 589
 590 svn_error_t *
 591 svn_repos_get_file_revs(svn_repos_t *repos,
 592                         const char *path,
 593                         svn_revnum_t start,
 594                         svn_revnum_t end,
 595                         svn_repos_authz_func_t authz_read_func,
 596                         void *authz_read_baton,
 597                         svn_repos_file_rev_handler_t handler,
 598                         void *handler_baton,
 599                         apr_pool_t *pool)
 600 {
 601   svn_file_rev_handler_t handler2;
 602   void *handler2_baton;
 603
 604   svn_compat_wrap_file_rev_handler(&handler2, &handler2_baton, handler,
 605                                    handler_baton, pool);
 606
 607   return svn_repos_get_file_revs2(repos, path, start, end, FALSE,
 608                                   authz_read_func, authz_read_baton,
 609                                   handler2, handler2_baton, pool);
 610 }
 611
 612 /*** From dump.c ***/
 613 svn_error_t *
 614 svn_repos_dump_fs(svn_repos_t *repos,
 615                   svn_stream_t *stream,
 616                   svn_stream_t *feedback_stream,
 617                   svn_revnum_t start_rev,
 618                   svn_revnum_t end_rev,
 619                   svn_boolean_t incremental,
 620                   svn_cancel_func_t cancel_func,
 621                   void *cancel_baton,
 622                   apr_pool_t *pool)
 623 {
 624   return svn_repos_dump_fs2(repos, stream, feedback_stream, start_rev,
 625                             end_rev, incremental, FALSE, cancel_func,
 626                             cancel_baton, pool);
 627 }
 628
 629 /* Implementation of svn_repos_notify_func_t to wrap the output to a
 630    response stream for svn_repos_dump_fs2() and svn_repos_verify_fs() */
 631 static void
 632 repos_notify_handler(void *baton,
 633                      const svn_repos_notify_t *notify,
 634                      apr_pool_t *scratch_pool)
 635 {
 636   svn_stream_t *feedback_stream = baton;
 637   apr_size_t len;
 638
 639   switch (notify->action)
 640   {
 641     case svn_repos_notify_warning:
 642       svn_error_clear(svn_stream_puts(feedback_stream, notify->warning_str));
 643       return;
 644
 645     case svn_repos_notify_dump_rev_end:
 646       svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 647                                         _("* Dumped revision %ld.\n"),
 648                                         notify->revision));
 649       return;
 650
 651     case svn_repos_notify_verify_rev_end:
 652       svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 653                                         _("* Verified revision %ld.\n"),
 654                                         notify->revision));
 655       return;
 656
 657     case svn_repos_notify_load_txn_committed:
 658       if (notify->old_revision == SVN_INVALID_REVNUM)
 659         {
 660           svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 661                             _("\n------- Committed revision %ld >>>\n\n"),
 662                             notify->new_revision));
 663         }
 664       else
 665         {
 666           svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 667                             _("\n------- Committed new rev %ld"
 668                               " (loaded from original rev %ld"
 669                               ") >>>\n\n"), notify->new_revision,
 670                               notify->old_revision));
 671         }
 672       return;
 673
 674     case svn_repos_notify_load_node_start:
 675       {
 676         switch (notify->node_action)
 677         {
 678           case svn_node_action_change:
 679             svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 680                                   _("     * editing path : %s ..."),
 681                                   notify->path));
 682             break;
 683
 684           case svn_node_action_delete:
 685             svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 686                                   _("     * deleting path : %s ..."),
 687                                   notify->path));
 688             break;
 689
 690           case svn_node_action_add:
 691             svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 692                                   _("     * adding path : %s ..."),
 693                                   notify->path));
 694             break;
 695
 696           case svn_node_action_replace:
 697             svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 698                                   _("     * replacing path : %s ..."),
 699                                   notify->path));
 700             break;
 701
 702         }
 703       }
 704       return;
 705
 706     case svn_repos_notify_load_node_done:
 707       len = 7;
 708       svn_error_clear(svn_stream_write(feedback_stream, _(" done.\n"), &len));
 709       return;
 710
 711     case svn_repos_notify_load_copied_node:
 712       len = 9;
 713       svn_error_clear(svn_stream_write(feedback_stream, "COPIED...", &len));
 714       return;
 715
 716     case svn_repos_notify_load_txn_start:
 717       svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 718                                 _("<<< Started new transaction, based on "
 719                                   "original revision %ld\n"),
 720                                 notify->old_revision));
 721       return;
 722
 723     case svn_repos_notify_load_normalized_mergeinfo:
 724       svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
 725                                 _(" removing '\\r' from %s ..."),
 726                                 SVN_PROP_MERGEINFO));
 727       return;
 728
 729     default:
 730       return;
 731   }
 732 }
 733
 734
 735 svn_error_t *
 736 svn_repos_dump_fs2(svn_repos_t *repos,
 737                    svn_stream_t *stream,
 738                    svn_stream_t *feedback_stream,
 739                    svn_revnum_t start_rev,
 740                    svn_revnum_t end_rev,
 741                    svn_boolean_t incremental,
 742                    svn_boolean_t use_deltas,
 743                    svn_cancel_func_t cancel_func,
 744                    void *cancel_baton,
 745                    apr_pool_t *pool)
 746 {
 747   return svn_error_trace(svn_repos_dump_fs3(repos,
 748                                             stream,
 749                                             start_rev,
 750                                             end_rev,
 751                                             incremental,
 752                                             use_deltas,
 753                                             feedback_stream
 754                                               ? repos_notify_handler
 755                                               : NULL,
 756                                             feedback_stream,
 757                                             cancel_func,
 758                                             cancel_baton,
 759                                             pool));
 760 }
 761
 762 svn_error_t *
 763 svn_repos_verify_fs2(svn_repos_t *repos,
 764                      svn_revnum_t start_rev,
 765                      svn_revnum_t end_rev,
 766                      svn_repos_notify_func_t notify_func,
 767                      void *notify_baton,
 768                      svn_cancel_func_t cancel_func,
 769                      void *cancel_baton,
 770                      apr_pool_t *pool)
 771 {
 772   return svn_error_trace(svn_repos_verify_fs3(repos,
 773                                               start_rev,
 774                                               end_rev,
 775                                               FALSE,
 776                                               FALSE,
 777                                               notify_func,
 778                                               notify_baton,
 779                                               NULL, NULL,
 780                                               cancel_func,
 781                                               cancel_baton,
 782                                               pool));
 783 }
 784
 785 svn_error_t *
 786 svn_repos_verify_fs(svn_repos_t *repos,
 787                     svn_stream_t *feedback_stream,
 788                     svn_revnum_t start_rev,
 789                     svn_revnum_t end_rev,
 790                     svn_cancel_func_t cancel_func,
 791                     void *cancel_baton,
 792                     apr_pool_t *pool)
 793 {
 794   return svn_error_trace(svn_repos_verify_fs2(repos,
 795                                               start_rev,
 796                                               end_rev,
 797                                               feedback_stream
 798                                                 ? repos_notify_handler
 799                                                 : NULL,
 800                                               feedback_stream,
 801                                               cancel_func,
 802                                               cancel_baton,
 803                                               pool));
 804 }
 805
 806 /*** From load.c ***/
 807
 808 svn_error_t *
 809 svn_repos_load_fs4(svn_repos_t *repos,
 810                    svn_stream_t *dumpstream,
 811                    svn_revnum_t start_rev,
 812                    svn_revnum_t end_rev,
 813                    enum svn_repos_load_uuid uuid_action,
 814                    const char *parent_dir,
 815                    svn_boolean_t use_pre_commit_hook,
 816                    svn_boolean_t use_post_commit_hook,
 817                    svn_boolean_t validate_props,
 818                    svn_repos_notify_func_t notify_func,
 819                    void *notify_baton,
 820                    svn_cancel_func_t cancel_func,
 821                    void *cancel_baton,
 822                    apr_pool_t *pool)
 823 {
 824   return svn_repos_load_fs5(repos, dumpstream, start_rev, end_rev,
 825                             uuid_action, parent_dir,
 826                             use_post_commit_hook, use_post_commit_hook,
 827                             validate_props, FALSE,
 828                             notify_func, notify_baton,
 829                             cancel_func, cancel_baton, pool);
 830 }
 831
 832 svn_error_t *
 833 svn_repos_load_fs3(svn_repos_t *repos,
 834                    svn_stream_t *dumpstream,
 835                    enum svn_repos_load_uuid uuid_action,
 836                    const char *parent_dir,
 837                    svn_boolean_t use_pre_commit_hook,
 838                    svn_boolean_t use_post_commit_hook,
 839                    svn_boolean_t validate_props,
 840                    svn_repos_notify_func_t notify_func,
 841                    void *notify_baton,
 842                    svn_cancel_func_t cancel_func,
 843                    void *cancel_baton,
 844                    apr_pool_t *pool)
 845 {
 846   return svn_repos_load_fs4(repos, dumpstream,
 847                             SVN_INVALID_REVNUM, SVN_INVALID_REVNUM,
 848                             uuid_action, parent_dir,
 849                             use_pre_commit_hook, use_post_commit_hook,
 850                             validate_props, notify_func, notify_baton,
 851                             cancel_func, cancel_baton, pool);
 852 }
 853
 854 svn_error_t *
 855 svn_repos_load_fs2(svn_repos_t *repos,
 856                    svn_stream_t *dumpstream,
 857                    svn_stream_t *feedback_stream,
 858                    enum svn_repos_load_uuid uuid_action,
 859                    const char *parent_dir,
 860                    svn_boolean_t use_pre_commit_hook,
 861                    svn_boolean_t use_post_commit_hook,
 862                    svn_cancel_func_t cancel_func,
 863                    void *cancel_baton,
 864                    apr_pool_t *pool)
 865 {
 866   return svn_repos_load_fs3(repos, dumpstream, uuid_action, parent_dir,
 867                             use_pre_commit_hook, use_post_commit_hook, FALSE,
 868                             feedback_stream ? repos_notify_handler : NULL,
 869                             feedback_stream, cancel_func, cancel_baton, pool);
 870 }
 871
 872
 873 static svn_repos_parser_fns_t *
 874 fns_from_fns2(const svn_repos_parse_fns2_t *fns2,
 875               apr_pool_t *pool)
 876 {
 877   svn_repos_parser_fns_t *fns;
 878
 879   fns = apr_palloc(pool, sizeof(*fns));
 880   fns->new_revision_record = fns2->new_revision_record;
 881   fns->uuid_record = fns2->uuid_record;
 882   fns->new_node_record = fns2->new_node_record;
 883   fns->set_revision_property = fns2->set_revision_property;
 884   fns->set_node_property = fns2->set_node_property;
 885   fns->remove_node_props = fns2->remove_node_props;
 886   fns->set_fulltext = fns2->set_fulltext;
 887   fns->close_node = fns2->close_node;
 888   fns->close_revision = fns2->close_revision;
 889   return fns;
 890 }
 891
 892 static svn_repos_parser_fns2_t *
 893 fns2_from_fns3(const svn_repos_parse_fns3_t *fns3,
 894               apr_pool_t *pool)
 895 {
 896   svn_repos_parser_fns2_t *fns2;
 897
 898   fns2 = apr_palloc(pool, sizeof(*fns2));
 899   fns2->new_revision_record = fns3->new_revision_record;
 900   fns2->uuid_record = fns3->uuid_record;
 901   fns2->new_node_record = fns3->new_node_record;
 902   fns2->set_revision_property = fns3->set_revision_property;
 903   fns2->set_node_property = fns3->set_node_property;
 904   fns2->remove_node_props = fns3->remove_node_props;
 905   fns2->set_fulltext = fns3->set_fulltext;
 906   fns2->close_node = fns3->close_node;
 907   fns2->close_revision = fns3->close_revision;
 908   fns2->delete_node_property = fns3->delete_node_property;
 909   fns2->apply_textdelta = fns3->apply_textdelta;
 910   return fns2;
 911 }
 912
 913 static svn_repos_parse_fns2_t *
 914 fns2_from_fns(const svn_repos_parser_fns_t *fns,
 915               apr_pool_t *pool)
 916 {
 917   svn_repos_parse_fns2_t *fns2;
 918
 919   fns2 = apr_palloc(pool, sizeof(*fns2));
 920   fns2->new_revision_record = fns->new_revision_record;
 921   fns2->uuid_record = fns->uuid_record;
 922   fns2->new_node_record = fns->new_node_record;
 923   fns2->set_revision_property = fns->set_revision_property;
 924   fns2->set_node_property = fns->set_node_property;
 925   fns2->remove_node_props = fns->remove_node_props;
 926   fns2->set_fulltext = fns->set_fulltext;
 927   fns2->close_node = fns->close_node;
 928   fns2->close_revision = fns->close_revision;
 929   fns2->delete_node_property = NULL;
 930   fns2->apply_textdelta = NULL;
 931   return fns2;
 932 }
 933
 934 static svn_repos_parse_fns3_t *
 935 fns3_from_fns2(const svn_repos_parser_fns2_t *fns2,
 936                apr_pool_t *pool)
 937 {
 938   svn_repos_parse_fns3_t *fns3;
 939
 940   fns3 = apr_palloc(pool, sizeof(*fns3));
 941   fns3->magic_header_record = NULL;
 942   fns3->uuid_record = fns2->uuid_record;
 943   fns3->new_revision_record = fns2->new_revision_record;
 944   fns3->new_node_record = fns2->new_node_record;
 945   fns3->set_revision_property = fns2->set_revision_property;
 946   fns3->set_node_property = fns2->set_node_property;
 947   fns3->remove_node_props = fns2->remove_node_props;
 948   fns3->set_fulltext = fns2->set_fulltext;
 949   fns3->close_node = fns2->close_node;
 950   fns3->close_revision = fns2->close_revision;
 951   fns3->delete_node_property = fns2->delete_node_property;
 952   fns3->apply_textdelta = fns2->apply_textdelta;
 953   return fns3;
 954 }
 955
 956 svn_error_t *
 957 svn_repos_parse_dumpstream2(svn_stream_t *stream,
 958                             const svn_repos_parser_fns2_t *parse_fns,
 959                             void *parse_baton,
 960                             svn_cancel_func_t cancel_func,
 961                             void *cancel_baton,
 962                             apr_pool_t *pool)
 963 {
 964   svn_repos_parse_fns3_t *fns3 = fns3_from_fns2(parse_fns, pool);
 965
 966   return svn_repos_parse_dumpstream3(stream, fns3, parse_baton, FALSE,
 967                                      cancel_func, cancel_baton, pool);
 968 }
 969
 970 svn_error_t *
 971 svn_repos_parse_dumpstream(svn_stream_t *stream,
 972                            const svn_repos_parser_fns_t *parse_fns,
 973                            void *parse_baton,
 974                            svn_cancel_func_t cancel_func,
 975                            void *cancel_baton,
 976                            apr_pool_t *pool)
 977 {
 978   svn_repos_parse_fns2_t *fns2 = fns2_from_fns(parse_fns, pool);
 979
 980   return svn_repos_parse_dumpstream2(stream, fns2, parse_baton,
 981                                      cancel_func, cancel_baton, pool);
 982 }
 983
 984 svn_error_t *
 985 svn_repos_load_fs(svn_repos_t *repos,
 986                   svn_stream_t *dumpstream,
 987                   svn_stream_t *feedback_stream,
 988                   enum svn_repos_load_uuid uuid_action,
 989                   const char *parent_dir,
 990                   svn_cancel_func_t cancel_func,
 991                   void *cancel_baton,
 992                   apr_pool_t *pool)
 993 {
 994   return svn_repos_load_fs2(repos, dumpstream, feedback_stream,
 995                             uuid_action, parent_dir, FALSE, FALSE,
 996                             cancel_func, cancel_baton, pool);
 997 }
 998
 999 svn_error_t *
1000 svn_repos_get_fs_build_parser4(const svn_repos_parse_fns3_t **callbacks,
1001                                void **parse_baton,
1002                                svn_repos_t *repos,
1003                                svn_revnum_t start_rev,
1004                                svn_revnum_t end_rev,
1005                                svn_boolean_t use_history,
1006                                svn_boolean_t validate_props,
1007                                enum svn_repos_load_uuid uuid_action,
1008                                const char *parent_dir,
1009                                svn_repos_notify_func_t notify_func,
1010                                void *notify_baton,
1011                                apr_pool_t *pool)
1012 {
1013   SVN_ERR(svn_repos_get_fs_build_parser5(callbacks, parse_baton,
1014                                          repos,
1015                                          start_rev, end_rev,
1016                                          use_history,
1017                                          validate_props,
1018                                          uuid_action,
1019                                          parent_dir,
1020                                          FALSE, FALSE, /*hooks */
1021                                          FALSE /*ignore_dates*/,
1022                                          notify_func,
1023                                          notify_baton,
1024                                          pool));
1025   return SVN_NO_ERROR;
1026 }
1027
1028 svn_error_t *
1029 svn_repos_get_fs_build_parser3(const svn_repos_parse_fns2_t **callbacks,
1030                                void **parse_baton,
1031                                svn_repos_t *repos,
1032                                svn_boolean_t use_history,
1033                                svn_boolean_t validate_props,
1034                                enum svn_repos_load_uuid uuid_action,
1035                                const char *parent_dir,
1036                                svn_repos_notify_func_t notify_func,
1037                                void *notify_baton,
1038                                apr_pool_t *pool)
1039 {
1040   const svn_repos_parse_fns3_t *fns3;
1041
1042   SVN_ERR(svn_repos_get_fs_build_parser4(&fns3, parse_baton, repos,
1043                                          SVN_INVALID_REVNUM,
1044                                          SVN_INVALID_REVNUM,
1045                                          use_history, validate_props,
1046                                          uuid_action, parent_dir,
1047                                          notify_func, notify_baton, pool));
1048
1049   *callbacks = fns2_from_fns3(fns3, pool);
1050   return SVN_NO_ERROR;
1051 }
1052
1053 svn_error_t *
1054 svn_repos_get_fs_build_parser2(const svn_repos_parse_fns2_t **parser,
1055                                void **parse_baton,
1056                                svn_repos_t *repos,
1057                                svn_boolean_t use_history,
1058                                enum svn_repos_load_uuid uuid_action,
1059                                svn_stream_t *outstream,
1060                                const char *parent_dir,
1061                                apr_pool_t *pool)
1062 {
1063   return svn_repos_get_fs_build_parser3(parser, parse_baton, repos, use_history,
1064                                         FALSE, uuid_action, parent_dir,
1065                                         outstream ? repos_notify_handler : NULL,
1066                                         outstream, pool);
1067 }
1068
1069 svn_error_t *
1070 svn_repos_get_fs_build_parser(const svn_repos_parser_fns_t **parser_callbacks,
1071                               void **parse_baton,
1072                               svn_repos_t *repos,
1073                               svn_boolean_t use_history,
1074                               enum svn_repos_load_uuid uuid_action,
1075                               svn_stream_t *outstream,
1076                               const char *parent_dir,
1077                               apr_pool_t *pool)
1078 {
1079   const svn_repos_parse_fns2_t *fns2;
1080
1081   SVN_ERR(svn_repos_get_fs_build_parser2(&fns2, parse_baton, repos,
1082                                          use_history, uuid_action, outstream,
1083                                          parent_dir, pool));
1084
1085   *parser_callbacks = fns_from_fns2(fns2, pool);
1086   return SVN_NO_ERROR;
1087 }
1088
1089
1090 svn_error_t *
1091 svn_repos_fs_begin_txn_for_update(svn_fs_txn_t **txn_p,
1092                                   svn_repos_t *repos,
1093                                   svn_revnum_t rev,
1094                                   const char *author,
1095                                   apr_pool_t *pool)
1096 {
1097   /* ### someday, we might run a read-hook here. */
1098
1099   /* Begin the transaction. */
1100   SVN_ERR(svn_fs_begin_txn2(txn_p, repos->fs, rev, 0, pool));
1101
1102   /* We pass the author to the filesystem by adding it as a property
1103      on the txn. */
1104
1105   /* User (author). */
1106   if (author)
1107     {
1108       svn_string_t val;
1109       val.data = author;
1110       val.len = strlen(author);
1111       SVN_ERR(svn_fs_change_txn_prop(*txn_p, SVN_PROP_REVISION_AUTHOR,
1112                                      &val, pool));
1113     }
1114
1115   return SVN_NO_ERROR;
1116 }
1117
1118 /*** From authz.c ***/
1119
1120 svn_error_t *
1121 svn_repos_authz_read(svn_authz_t **authz_p, const char *file,
1122                      svn_boolean_t must_exist, apr_pool_t *pool)
1123 {
1124   return svn_repos__authz_read(authz_p, file, NULL, must_exist,
1125                                FALSE, pool);
1126 }