deprecated.c revision 299742
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 40 41/*** From commit.c ***/ 42 43svn_error_t * 44svn_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 72svn_error_t * 73svn_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 102svn_error_t * 103svn_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 122svn_error_t * 123svn_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 140svn_error_t * 141svn_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 149svn_error_t * 150svn_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 ***/ 159struct recover_baton 160{ 161 svn_error_t *(*start_callback)(void *baton); 162 void *start_callback_baton; 163}; 164 165static void 166recovery_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 177svn_error_t * 178svn_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 194svn_error_t * 195svn_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 207svn_error_t * 208svn_repos_recover(const char *path, 209 apr_pool_t *pool) 210{ 211 return svn_repos_recover2(path, FALSE, NULL, NULL, pool); 212} 213 214svn_error_t * 215svn_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 229svn_error_t * 230svn_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 243svn_error_t * 244svn_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 ***/ 254svn_error_t * 255svn_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 288svn_error_t * 289svn_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 323svn_error_t * 324svn_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 332svn_error_t * 333svn_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 339svn_error_t * 340svn_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 348svn_error_t * 349svn_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 ***/ 358svn_error_t * 359svn_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 ***/ 391svn_error_t * 392svn_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 ***/ 408svn_error_t * 409svn_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 428svn_error_t * 429svn_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 445svn_error_t * 446svn_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 457struct pack_notify_wrapper_baton 458{ 459 svn_fs_pack_notify_t notify_func; 460 void *notify_baton; 461}; 462 463static void 464pack_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 474svn_error_t * 475svn_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 492svn_error_t * 493svn_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 ***/ 508svn_error_t * 509svn_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 537svn_error_t * 538svn_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 557svn_error_t * 558svn_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 ***/ 575svn_error_t * 576svn_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 590svn_error_t * 591svn_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 ***/ 613svn_error_t * 614svn_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() */ 631static void 632repos_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 735svn_error_t * 736svn_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 762svn_error_t * 763svn_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 785svn_error_t * 786svn_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 808svn_error_t * 809svn_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 832svn_error_t * 833svn_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 854svn_error_t * 855svn_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 873static svn_repos_parser_fns_t * 874fns_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 892static svn_repos_parser_fns2_t * 893fns2_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 913static svn_repos_parse_fns2_t * 914fns2_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 934static svn_repos_parse_fns3_t * 935fns3_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 956svn_error_t * 957svn_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 970svn_error_t * 971svn_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 984svn_error_t * 985svn_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 999svn_error_t * 1000svn_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 1028svn_error_t * 1029svn_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 1053svn_error_t * 1054svn_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 1069svn_error_t * 1070svn_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 1090svn_error_t * 1091svn_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 1120svn_error_t * 1121svn_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} 1127