reporter.c revision 309512
1/* 2 * reporter.c : `reporter' vtable routines for updates. 3 * 4 * ==================================================================== 5 * Licensed to the Apache Software Foundation (ASF) under one 6 * or more contributor license agreements. See the NOTICE file 7 * distributed with this work for additional information 8 * regarding copyright ownership. The ASF licenses this file 9 * to you under the Apache License, Version 2.0 (the 10 * "License"); you may not use this file except in compliance 11 * with the License. You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, 16 * software distributed under the License is distributed on an 17 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 18 * KIND, either express or implied. See the License for the 19 * specific language governing permissions and limitations 20 * under the License. 21 * ==================================================================== 22 */ 23 24#include "svn_dirent_uri.h" 25#include "svn_hash.h" 26#include "svn_path.h" 27#include "svn_types.h" 28#include "svn_error.h" 29#include "svn_error_codes.h" 30#include "svn_fs.h" 31#include "svn_repos.h" 32#include "svn_pools.h" 33#include "svn_props.h" 34#include "repos.h" 35#include "svn_private_config.h" 36 37#include "private/svn_dep_compat.h" 38#include "private/svn_fspath.h" 39#include "private/svn_subr_private.h" 40#include "private/svn_string_private.h" 41 42#define NUM_CACHED_SOURCE_ROOTS 4 43 44/* Theory of operation: we write report operations out to a spill-buffer 45 as we receive them. When the report is finished, we read the 46 operations back out again, using them to guide the progression of 47 the delta between the source and target revs. 48 49 Spill-buffer content format: we use a simple ad-hoc format to store the 50 report operations. Each report operation is the concatention of 51 the following ("+/-" indicates the single character '+' or '-'; 52 <length> and <revnum> are written out as decimal strings): 53 54 +/- '-' marks the end of the report 55 If previous is +: 56 <length>:<bytes> Length-counted path string 57 +/- '+' indicates the presence of link_path 58 If previous is +: 59 <length>:<bytes> Length-counted link_path string 60 +/- '+' indicates presence of revnum 61 If previous is +: 62 <revnum>: Revnum of set_path or link_path 63 +/- '+' indicates depth other than svn_depth_infinity 64 If previous is +: 65 <depth>: "X","E","F","M" => 66 svn_depth_{exclude,empty,files,immediates} 67 +/- '+' indicates start_empty field set 68 +/- '+' indicates presence of lock_token field. 69 If previous is +: 70 <length>:<bytes> Length-counted lock_token string 71 72 Terminology: for brevity, this file frequently uses the prefixes 73 "s_" for source, "t_" for target, and "e_" for editor. Also, to 74 avoid overloading the word "target", we talk about the source 75 "anchor and operand", rather than the usual "anchor and target". */ 76 77/* Describes the state of a working copy subtree, as given by a 78 report. Because we keep a lookahead pathinfo, we need to allocate 79 each one of these things in a subpool of the report baton and free 80 it when done. */ 81typedef struct path_info_t 82{ 83 const char *path; /* path, munged to be anchor-relative */ 84 const char *link_path; /* NULL for set_path or delete_path */ 85 svn_revnum_t rev; /* SVN_INVALID_REVNUM for delete_path */ 86 svn_depth_t depth; /* Depth of this path, meaningless for files */ 87 svn_boolean_t start_empty; /* Meaningless for delete_path */ 88 const char *lock_token; /* NULL if no token */ 89 apr_pool_t *pool; /* Container pool */ 90} path_info_t; 91 92/* Describes the standard revision properties that are relevant for 93 reports. Since a particular revision will often show up more than 94 once in the report, we cache these properties for the time of the 95 report generation. */ 96typedef struct revision_info_t 97{ 98 svn_revnum_t rev; /* revision number */ 99 svn_string_t* date; /* revision timestamp */ 100 svn_string_t* author; /* name of the revisions' author */ 101} revision_info_t; 102 103/* A structure used by the routines within the `reporter' vtable, 104 driven by the client as it describes its working copy revisions. */ 105typedef struct report_baton_t 106{ 107 /* Parameters remembered from svn_repos_begin_report3 */ 108 svn_repos_t *repos; 109 const char *fs_base; /* fspath corresponding to wc anchor */ 110 const char *s_operand; /* anchor-relative wc target (may be empty) */ 111 svn_revnum_t t_rev; /* Revnum which the edit will bring the wc to */ 112 const char *t_path; /* FS path the edit will bring the wc to */ 113 svn_boolean_t text_deltas; /* Whether to report text deltas */ 114 apr_size_t zero_copy_limit; /* Max item size that will be sent using 115 the zero-copy code path. */ 116 117 /* If the client requested a specific depth, record it here; if the 118 client did not, then this is svn_depth_unknown, and the depth of 119 information transmitted from server to client will be governed 120 strictly by the path-associated depths recorded in the report. */ 121 svn_depth_t requested_depth; 122 123 svn_boolean_t ignore_ancestry; 124 svn_boolean_t send_copyfrom_args; 125 svn_boolean_t is_switch; 126 const svn_delta_editor_t *editor; 127 void *edit_baton; 128 svn_repos_authz_func_t authz_read_func; 129 void *authz_read_baton; 130 131 /* The spill-buffer holding the report. */ 132 svn_spillbuf_reader_t *reader; 133 134 /* For the actual editor drive, we'll need a lookahead path info 135 entry, a cache of FS roots, and a pool to store them. */ 136 path_info_t *lookahead; 137 svn_fs_root_t *t_root; 138 svn_fs_root_t *s_roots[NUM_CACHED_SOURCE_ROOTS]; 139 140 /* Cache for revision properties. This is used to eliminate redundant 141 revprop fetching. */ 142 apr_hash_t *revision_infos; 143 144 /* This will not change. So, fetch it once and reuse it. */ 145 svn_string_t *repos_uuid; 146 apr_pool_t *pool; 147} report_baton_t; 148 149/* The type of a function that accepts changes to an object's property 150 list. OBJECT is the object whose properties are being changed. 151 NAME is the name of the property to change. VALUE is the new value 152 for the property, or zero if the property should be deleted. */ 153typedef svn_error_t *proplist_change_fn_t(report_baton_t *b, void *object, 154 const char *name, 155 const svn_string_t *value, 156 apr_pool_t *pool); 157 158static svn_error_t *delta_dirs(report_baton_t *b, svn_revnum_t s_rev, 159 const char *s_path, const char *t_path, 160 void *dir_baton, const char *e_path, 161 svn_boolean_t start_empty, 162 svn_depth_t wc_depth, 163 svn_depth_t requested_depth, 164 apr_pool_t *pool); 165 166/* --- READING PREVIOUSLY STORED REPORT INFORMATION --- */ 167 168static svn_error_t * 169read_number(apr_uint64_t *num, svn_spillbuf_reader_t *reader, apr_pool_t *pool) 170{ 171 char c; 172 173 *num = 0; 174 while (1) 175 { 176 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool)); 177 if (c == ':') 178 break; 179 *num = *num * 10 + (c - '0'); 180 } 181 return SVN_NO_ERROR; 182} 183 184static svn_error_t * 185read_string(const char **str, svn_spillbuf_reader_t *reader, apr_pool_t *pool) 186{ 187 apr_uint64_t len; 188 apr_size_t size; 189 apr_size_t amt; 190 char *buf; 191 192 SVN_ERR(read_number(&len, reader, pool)); 193 194 /* Len can never be less than zero. But could len be so large that 195 len + 1 wraps around and we end up passing 0 to apr_palloc(), 196 thus getting a pointer to no storage? Probably not (16 exabyte 197 string, anyone?) but let's be future-proof anyway. */ 198 if (len + 1 < len || len + 1 > APR_SIZE_MAX) 199 { 200 /* xgettext doesn't expand preprocessor definitions, so we must 201 pass translatable string to apr_psprintf() function to create 202 intermediate string with appropriate format specifier. */ 203 return svn_error_createf(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL, 204 apr_psprintf(pool, 205 _("Invalid length (%%%s) when " 206 "about to read a string"), 207 APR_UINT64_T_FMT), 208 len); 209 } 210 211 size = (apr_size_t)len; 212 buf = apr_palloc(pool, size+1); 213 if (size > 0) 214 { 215 SVN_ERR(svn_spillbuf__reader_read(&amt, reader, buf, size, pool)); 216 SVN_ERR_ASSERT(amt == size); 217 } 218 buf[len] = 0; 219 *str = buf; 220 return SVN_NO_ERROR; 221} 222 223static svn_error_t * 224read_rev(svn_revnum_t *rev, svn_spillbuf_reader_t *reader, apr_pool_t *pool) 225{ 226 char c; 227 apr_uint64_t num; 228 229 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool)); 230 if (c == '+') 231 { 232 SVN_ERR(read_number(&num, reader, pool)); 233 *rev = (svn_revnum_t) num; 234 } 235 else 236 *rev = SVN_INVALID_REVNUM; 237 return SVN_NO_ERROR; 238} 239 240/* Read a single character to set *DEPTH (having already read '+') 241 from READER. PATH is the path to which the depth applies, and is 242 used for error reporting only. */ 243static svn_error_t * 244read_depth(svn_depth_t *depth, svn_spillbuf_reader_t *reader, const char *path, 245 apr_pool_t *pool) 246{ 247 char c; 248 249 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool)); 250 switch (c) 251 { 252 case 'X': 253 *depth = svn_depth_exclude; 254 break; 255 case 'E': 256 *depth = svn_depth_empty; 257 break; 258 case 'F': 259 *depth = svn_depth_files; 260 break; 261 case 'M': 262 *depth = svn_depth_immediates; 263 break; 264 265 /* Note that we do not tolerate explicit representation of 266 svn_depth_infinity here, because that's not how 267 write_path_info() writes it. */ 268 default: 269 return svn_error_createf(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL, 270 _("Invalid depth (%c) for path '%s'"), c, path); 271 } 272 273 return SVN_NO_ERROR; 274} 275 276/* Read a report operation *PI out of READER. Set *PI to NULL if we 277 have reached the end of the report. */ 278static svn_error_t * 279read_path_info(path_info_t **pi, 280 svn_spillbuf_reader_t *reader, 281 apr_pool_t *pool) 282{ 283 char c; 284 285 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool)); 286 if (c == '-') 287 { 288 *pi = NULL; 289 return SVN_NO_ERROR; 290 } 291 292 *pi = apr_palloc(pool, sizeof(**pi)); 293 SVN_ERR(read_string(&(*pi)->path, reader, pool)); 294 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool)); 295 if (c == '+') 296 SVN_ERR(read_string(&(*pi)->link_path, reader, pool)); 297 else 298 (*pi)->link_path = NULL; 299 SVN_ERR(read_rev(&(*pi)->rev, reader, pool)); 300 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool)); 301 if (c == '+') 302 SVN_ERR(read_depth(&((*pi)->depth), reader, (*pi)->path, pool)); 303 else 304 (*pi)->depth = svn_depth_infinity; 305 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool)); 306 (*pi)->start_empty = (c == '+'); 307 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool)); 308 if (c == '+') 309 SVN_ERR(read_string(&(*pi)->lock_token, reader, pool)); 310 else 311 (*pi)->lock_token = NULL; 312 (*pi)->pool = pool; 313 return SVN_NO_ERROR; 314} 315 316/* Return true if PI's path is a child of PREFIX (which has length PLEN). */ 317static svn_boolean_t 318relevant(path_info_t *pi, const char *prefix, apr_size_t plen) 319{ 320 return (pi && strncmp(pi->path, prefix, plen) == 0 && 321 (!*prefix || pi->path[plen] == '/')); 322} 323 324/* Fetch the next pathinfo from B->reader for a descendant of 325 PREFIX. If the next pathinfo is for an immediate child of PREFIX, 326 set *ENTRY to the path component of the report information and 327 *INFO to the path information for that entry. If the next pathinfo 328 is for a grandchild or other more remote descendant of PREFIX, set 329 *ENTRY to the immediate child corresponding to that descendant and 330 set *INFO to NULL. If the next pathinfo is not for a descendant of 331 PREFIX, or if we reach the end of the report, set both *ENTRY and 332 *INFO to NULL. 333 334 At all times, B->lookahead is presumed to be the next pathinfo not 335 yet returned as an immediate child, or NULL if we have reached the 336 end of the report. Because we use a lookahead element, we can't 337 rely on the usual nested pool lifetimes, so allocate each pathinfo 338 in a subpool of the report baton's pool. The caller should delete 339 (*INFO)->pool when it is done with the information. */ 340static svn_error_t * 341fetch_path_info(report_baton_t *b, const char **entry, path_info_t **info, 342 const char *prefix, apr_pool_t *pool) 343{ 344 apr_size_t plen = strlen(prefix); 345 const char *relpath, *sep; 346 apr_pool_t *subpool; 347 348 if (!relevant(b->lookahead, prefix, plen)) 349 { 350 /* No more entries relevant to prefix. */ 351 *entry = NULL; 352 *info = NULL; 353 } 354 else 355 { 356 /* Take a look at the prefix-relative part of the path. */ 357 relpath = b->lookahead->path + (*prefix ? plen + 1 : 0); 358 sep = strchr(relpath, '/'); 359 if (sep) 360 { 361 /* Return the immediate child part; do not advance. */ 362 *entry = apr_pstrmemdup(pool, relpath, sep - relpath); 363 *info = NULL; 364 } 365 else 366 { 367 /* This is an immediate child; return it and advance. */ 368 *entry = relpath; 369 *info = b->lookahead; 370 subpool = svn_pool_create(b->pool); 371 SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool)); 372 } 373 } 374 return SVN_NO_ERROR; 375} 376 377/* Skip all path info entries relevant to *PREFIX. Call this when the 378 editor drive skips a directory. */ 379static svn_error_t * 380skip_path_info(report_baton_t *b, const char *prefix) 381{ 382 apr_size_t plen = strlen(prefix); 383 apr_pool_t *subpool; 384 385 while (relevant(b->lookahead, prefix, plen)) 386 { 387 svn_pool_destroy(b->lookahead->pool); 388 subpool = svn_pool_create(b->pool); 389 SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool)); 390 } 391 return SVN_NO_ERROR; 392} 393 394/* Return true if there is at least one path info entry relevant to *PREFIX. */ 395static svn_boolean_t 396any_path_info(report_baton_t *b, const char *prefix) 397{ 398 return relevant(b->lookahead, prefix, strlen(prefix)); 399} 400 401/* --- DRIVING THE EDITOR ONCE THE REPORT IS FINISHED --- */ 402 403/* While driving the editor, the target root will remain constant, but 404 we may have to jump around between source roots depending on the 405 state of the working copy. If we were to open a root each time we 406 revisit a rev, we would get no benefit from node-id caching; on the 407 other hand, if we hold open all the roots we ever visit, we'll use 408 an unbounded amount of memory. As a compromise, we maintain a 409 fixed-size LRU cache of source roots. get_source_root retrieves a 410 root from the cache, using POOL to allocate the new root if 411 necessary. Be careful not to hold onto the root for too long, 412 particularly after recursing, since another call to get_source_root 413 can close it. */ 414static svn_error_t * 415get_source_root(report_baton_t *b, svn_fs_root_t **s_root, svn_revnum_t rev) 416{ 417 int i; 418 svn_fs_root_t *root, *prev = NULL; 419 420 /* Look for the desired root in the cache, sliding all the unmatched 421 entries backwards a slot to make room for the right one. */ 422 for (i = 0; i < NUM_CACHED_SOURCE_ROOTS; i++) 423 { 424 root = b->s_roots[i]; 425 b->s_roots[i] = prev; 426 if (root && svn_fs_revision_root_revision(root) == rev) 427 break; 428 prev = root; 429 } 430 431 /* If we didn't find it, throw out the oldest root and open a new one. */ 432 if (i == NUM_CACHED_SOURCE_ROOTS) 433 { 434 if (prev) 435 svn_fs_close_root(prev); 436 SVN_ERR(svn_fs_revision_root(&root, b->repos->fs, rev, b->pool)); 437 } 438 439 /* Assign the desired root to the first cache slot and hand it back. */ 440 b->s_roots[0] = root; 441 *s_root = root; 442 return SVN_NO_ERROR; 443} 444 445/* Call the directory property-setting function of B->editor to set 446 the property NAME to VALUE on DIR_BATON. */ 447static svn_error_t * 448change_dir_prop(report_baton_t *b, void *dir_baton, const char *name, 449 const svn_string_t *value, apr_pool_t *pool) 450{ 451 return svn_error_trace(b->editor->change_dir_prop(dir_baton, name, value, 452 pool)); 453} 454 455/* Call the file property-setting function of B->editor to set the 456 property NAME to VALUE on FILE_BATON. */ 457static svn_error_t * 458change_file_prop(report_baton_t *b, void *file_baton, const char *name, 459 const svn_string_t *value, apr_pool_t *pool) 460{ 461 return svn_error_trace(b->editor->change_file_prop(file_baton, name, value, 462 pool)); 463} 464 465/* For the report B, return the relevant revprop data of revision REV in 466 REVISION_INFO. The revision info will be allocated in b->pool. 467 Temporaries get allocated on SCRATCH_POOL. */ 468static svn_error_t * 469get_revision_info(report_baton_t *b, 470 svn_revnum_t rev, 471 revision_info_t** revision_info, 472 apr_pool_t *scratch_pool) 473{ 474 apr_hash_t *r_props; 475 svn_string_t *cdate, *author; 476 revision_info_t* info; 477 478 /* Try to find the info in the report's cache */ 479 info = apr_hash_get(b->revision_infos, &rev, sizeof(rev)); 480 if (!info) 481 { 482 /* Info is not available, yet. 483 Get all revprops. */ 484 SVN_ERR(svn_fs_revision_proplist(&r_props, 485 b->repos->fs, 486 rev, 487 scratch_pool)); 488 489 /* Extract the committed-date. */ 490 cdate = svn_hash_gets(r_props, SVN_PROP_REVISION_DATE); 491 492 /* Extract the last-author. */ 493 author = svn_hash_gets(r_props, SVN_PROP_REVISION_AUTHOR); 494 495 /* Create a result object */ 496 info = apr_palloc(b->pool, sizeof(*info)); 497 info->rev = rev; 498 info->date = svn_string_dup(cdate, b->pool); 499 info->author = svn_string_dup(author, b->pool); 500 501 /* Cache it */ 502 apr_hash_set(b->revision_infos, &info->rev, sizeof(info->rev), info); 503 } 504 505 *revision_info = info; 506 return SVN_NO_ERROR; 507} 508 509 510/* Generate the appropriate property editing calls to turn the 511 properties of S_REV/S_PATH into those of B->t_root/T_PATH. If 512 S_PATH is NULL, this is an add, so assume the target starts with no 513 properties. Pass OBJECT on to the editor function wrapper 514 CHANGE_FN. */ 515static svn_error_t * 516delta_proplists(report_baton_t *b, svn_revnum_t s_rev, const char *s_path, 517 const char *t_path, const char *lock_token, 518 proplist_change_fn_t *change_fn, 519 void *object, apr_pool_t *pool) 520{ 521 svn_fs_root_t *s_root; 522 apr_hash_t *s_props = NULL, *t_props; 523 apr_array_header_t *prop_diffs; 524 int i; 525 svn_revnum_t crev; 526 revision_info_t *revision_info; 527 svn_boolean_t changed; 528 const svn_prop_t *pc; 529 svn_lock_t *lock; 530 apr_hash_index_t *hi; 531 532 /* Fetch the created-rev and send entry props. */ 533 SVN_ERR(svn_fs_node_created_rev(&crev, b->t_root, t_path, pool)); 534 if (SVN_IS_VALID_REVNUM(crev)) 535 { 536 /* convert committed-rev to string */ 537 char buf[SVN_INT64_BUFFER_SIZE]; 538 svn_string_t cr_str; 539 cr_str.data = buf; 540 cr_str.len = svn__i64toa(buf, crev); 541 542 /* Transmit the committed-rev. */ 543 SVN_ERR(change_fn(b, object, 544 SVN_PROP_ENTRY_COMMITTED_REV, &cr_str, pool)); 545 546 SVN_ERR(get_revision_info(b, crev, &revision_info, pool)); 547 548 /* Transmit the committed-date. */ 549 if (revision_info->date || s_path) 550 SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_COMMITTED_DATE, 551 revision_info->date, pool)); 552 553 /* Transmit the last-author. */ 554 if (revision_info->author || s_path) 555 SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_LAST_AUTHOR, 556 revision_info->author, pool)); 557 558 /* Transmit the UUID. */ 559 SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_UUID, 560 b->repos_uuid, pool)); 561 } 562 563 /* Update lock properties. */ 564 if (lock_token) 565 { 566 SVN_ERR(svn_fs_get_lock(&lock, b->repos->fs, t_path, pool)); 567 568 /* Delete a defunct lock. */ 569 if (! lock || strcmp(lock_token, lock->token) != 0) 570 SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_LOCK_TOKEN, 571 NULL, pool)); 572 } 573 574 if (s_path) 575 { 576 SVN_ERR(get_source_root(b, &s_root, s_rev)); 577 578 /* Is this deltification worth our time? */ 579 SVN_ERR(svn_fs_props_different(&changed, b->t_root, t_path, s_root, 580 s_path, pool)); 581 if (! changed) 582 return SVN_NO_ERROR; 583 584 /* If so, go ahead and get the source path's properties. */ 585 SVN_ERR(svn_fs_node_proplist(&s_props, s_root, s_path, pool)); 586 } 587 588 /* Get the target path's properties */ 589 SVN_ERR(svn_fs_node_proplist(&t_props, b->t_root, t_path, pool)); 590 591 if (s_props && apr_hash_count(s_props)) 592 { 593 /* Now transmit the differences. */ 594 SVN_ERR(svn_prop_diffs(&prop_diffs, t_props, s_props, pool)); 595 for (i = 0; i < prop_diffs->nelts; i++) 596 { 597 pc = &APR_ARRAY_IDX(prop_diffs, i, svn_prop_t); 598 SVN_ERR(change_fn(b, object, pc->name, pc->value, pool)); 599 } 600 } 601 else if (apr_hash_count(t_props)) 602 { 603 /* So source, i.e. all new. Transmit all target props. */ 604 for (hi = apr_hash_first(pool, t_props); hi; hi = apr_hash_next(hi)) 605 { 606 const char *key = apr_hash_this_key(hi); 607 svn_string_t *val = apr_hash_this_val(hi); 608 609 SVN_ERR(change_fn(b, object, key, val, pool)); 610 } 611 } 612 613 return SVN_NO_ERROR; 614} 615 616/* Baton type to be passed into send_zero_copy_delta. 617 */ 618typedef struct zero_copy_baton_t 619{ 620 /* don't process data larger than this limit */ 621 apr_size_t zero_copy_limit; 622 623 /* window handler and baton to send the data to */ 624 svn_txdelta_window_handler_t dhandler; 625 void *dbaton; 626 627 /* return value: will be set to TRUE, if the data was processed. */ 628 svn_boolean_t zero_copy_succeeded; 629} zero_copy_baton_t; 630 631/* Implement svn_fs_process_contents_func_t. If LEN is smaller than the 632 * limit given in *BATON, send the CONTENTS as an delta windows to the 633 * handler given in BATON and set the ZERO_COPY_SUCCEEDED flag in that 634 * BATON. Otherwise, reset it to FALSE. 635 * Use POOL for temporary allocations. 636 */ 637static svn_error_t * 638send_zero_copy_delta(const unsigned char *contents, 639 apr_size_t len, 640 void *baton, 641 apr_pool_t *pool) 642{ 643 zero_copy_baton_t *zero_copy_baton = baton; 644 645 /* if the item is too large, the caller must revert to traditional 646 streaming code. */ 647 if (len > zero_copy_baton->zero_copy_limit) 648 { 649 zero_copy_baton->zero_copy_succeeded = FALSE; 650 return SVN_NO_ERROR; 651 } 652 653 SVN_ERR(svn_txdelta_send_contents(contents, len, 654 zero_copy_baton->dhandler, 655 zero_copy_baton->dbaton, pool)); 656 657 /* all fine now */ 658 zero_copy_baton->zero_copy_succeeded = TRUE; 659 return SVN_NO_ERROR; 660} 661 662 663/* Make the appropriate edits on FILE_BATON to change its contents and 664 properties from those in S_REV/S_PATH to those in B->t_root/T_PATH, 665 possibly using LOCK_TOKEN to determine if the client's lock on the file 666 is defunct. */ 667static svn_error_t * 668delta_files(report_baton_t *b, void *file_baton, svn_revnum_t s_rev, 669 const char *s_path, const char *t_path, const char *lock_token, 670 apr_pool_t *pool) 671{ 672 svn_boolean_t changed; 673 svn_fs_root_t *s_root = NULL; 674 svn_txdelta_stream_t *dstream = NULL; 675 svn_checksum_t *s_checksum; 676 const char *s_hex_digest = NULL; 677 svn_txdelta_window_handler_t dhandler; 678 void *dbaton; 679 680 /* Compare the files' property lists. */ 681 SVN_ERR(delta_proplists(b, s_rev, s_path, t_path, lock_token, 682 change_file_prop, file_baton, pool)); 683 684 if (s_path) 685 { 686 SVN_ERR(get_source_root(b, &s_root, s_rev)); 687 688 /* We're not interested in the theoretical difference between "has 689 contents which have not changed with respect to" and "has the same 690 actual contents as" when sending text-deltas. If we know the 691 delta is an empty one, we avoiding sending it in either case. */ 692 SVN_ERR(svn_repos__compare_files(&changed, b->t_root, t_path, 693 s_root, s_path, pool)); 694 695 if (!changed) 696 return SVN_NO_ERROR; 697 698 SVN_ERR(svn_fs_file_checksum(&s_checksum, svn_checksum_md5, s_root, 699 s_path, TRUE, pool)); 700 s_hex_digest = svn_checksum_to_cstring(s_checksum, pool); 701 } 702 703 /* Send the delta stream if desired, or just a NULL window if not. */ 704 SVN_ERR(b->editor->apply_textdelta(file_baton, s_hex_digest, pool, 705 &dhandler, &dbaton)); 706 707 if (dhandler != svn_delta_noop_window_handler) 708 { 709 if (b->text_deltas) 710 { 711 /* if we send deltas against empty streams, we may use our 712 zero-copy code. */ 713 if (b->zero_copy_limit > 0 && s_path == NULL) 714 { 715 zero_copy_baton_t baton; 716 svn_boolean_t called = FALSE; 717 718 baton.zero_copy_limit = b->zero_copy_limit; 719 baton.dhandler = dhandler; 720 baton.dbaton = dbaton; 721 baton.zero_copy_succeeded = FALSE; 722 SVN_ERR(svn_fs_try_process_file_contents(&called, 723 b->t_root, t_path, 724 send_zero_copy_delta, 725 &baton, pool)); 726 727 /* data has been available and small enough, 728 i.e. been processed? */ 729 if (called && baton.zero_copy_succeeded) 730 return SVN_NO_ERROR; 731 } 732 733 SVN_ERR(svn_fs_get_file_delta_stream(&dstream, s_root, s_path, 734 b->t_root, t_path, pool)); 735 SVN_ERR(svn_txdelta_send_txstream(dstream, dhandler, dbaton, pool)); 736 } 737 else 738 SVN_ERR(dhandler(NULL, dbaton)); 739 } 740 741 return SVN_NO_ERROR; 742} 743 744/* Determine if the user is authorized to view B->t_root/PATH. */ 745static svn_error_t * 746check_auth(report_baton_t *b, svn_boolean_t *allowed, const char *path, 747 apr_pool_t *pool) 748{ 749 if (b->authz_read_func) 750 return svn_error_trace(b->authz_read_func(allowed, b->t_root, path, 751 b->authz_read_baton, pool)); 752 *allowed = TRUE; 753 return SVN_NO_ERROR; 754} 755 756/* Create a dirent in *ENTRY for the given ROOT and PATH. We use this to 757 replace the source or target dirent when a report pathinfo tells us to 758 change paths or revisions. */ 759static svn_error_t * 760fake_dirent(const svn_fs_dirent_t **entry, svn_fs_root_t *root, 761 const char *path, apr_pool_t *pool) 762{ 763 svn_node_kind_t kind; 764 svn_fs_dirent_t *ent; 765 766 SVN_ERR(svn_fs_check_path(&kind, root, path, pool)); 767 if (kind == svn_node_none) 768 *entry = NULL; 769 else 770 { 771 ent = apr_palloc(pool, sizeof(**entry)); 772 /* ### All callers should be updated to pass just one of these 773 formats */ 774 ent->name = (*path == '/') ? svn_fspath__basename(path, pool) 775 : svn_relpath_basename(path, pool); 776 SVN_ERR(svn_fs_node_id(&ent->id, root, path, pool)); 777 ent->kind = kind; 778 *entry = ent; 779 } 780 return SVN_NO_ERROR; 781} 782 783 784/* Given REQUESTED_DEPTH, WC_DEPTH and the current entry's KIND, 785 determine whether we need to send the whole entry, not just deltas. 786 Please refer to delta_dirs' docstring for an explanation of the 787 conditionals below. */ 788static svn_boolean_t 789is_depth_upgrade(svn_depth_t wc_depth, 790 svn_depth_t requested_depth, 791 svn_node_kind_t kind) 792{ 793 if (requested_depth == svn_depth_unknown 794 || requested_depth <= wc_depth 795 || wc_depth == svn_depth_immediates) 796 return FALSE; 797 798 if (kind == svn_node_file 799 && wc_depth == svn_depth_files) 800 return FALSE; 801 802 if (kind == svn_node_dir 803 && wc_depth == svn_depth_empty 804 && requested_depth == svn_depth_files) 805 return FALSE; 806 807 return TRUE; 808} 809 810 811/* Call the B->editor's add_file() function to create PATH as a child 812 of PARENT_BATON, returning a new baton in *NEW_FILE_BATON. 813 However, make an attempt to send 'copyfrom' arguments if they're 814 available, by examining the closest copy of the original file 815 O_PATH within B->t_root. If any copyfrom args are discovered, 816 return those in *COPYFROM_PATH and *COPYFROM_REV; otherwise leave 817 those return args untouched. */ 818static svn_error_t * 819add_file_smartly(report_baton_t *b, 820 const char *path, 821 void *parent_baton, 822 const char *o_path, 823 void **new_file_baton, 824 const char **copyfrom_path, 825 svn_revnum_t *copyfrom_rev, 826 apr_pool_t *pool) 827{ 828 /* ### TODO: use a subpool to do this work, clear it at the end? */ 829 svn_fs_t *fs = svn_repos_fs(b->repos); 830 svn_fs_root_t *closest_copy_root = NULL; 831 const char *closest_copy_path = NULL; 832 833 /* Pre-emptively assume no copyfrom args exist. */ 834 *copyfrom_path = NULL; 835 *copyfrom_rev = SVN_INVALID_REVNUM; 836 837 if (b->send_copyfrom_args) 838 { 839 /* Find the destination of the nearest 'copy event' which may have 840 caused o_path@t_root to exist. svn_fs_closest_copy only returns paths 841 starting with '/', so make sure o_path always starts with a '/' 842 too. */ 843 if (*o_path != '/') 844 o_path = apr_pstrcat(pool, "/", o_path, SVN_VA_NULL); 845 846 SVN_ERR(svn_fs_closest_copy(&closest_copy_root, &closest_copy_path, 847 b->t_root, o_path, pool)); 848 if (closest_copy_root != NULL) 849 { 850 /* If the destination of the copy event is the same path as 851 o_path, then we've found something interesting that should 852 have 'copyfrom' history. */ 853 if (strcmp(closest_copy_path, o_path) == 0) 854 { 855 SVN_ERR(svn_fs_copied_from(copyfrom_rev, copyfrom_path, 856 closest_copy_root, closest_copy_path, 857 pool)); 858 if (b->authz_read_func) 859 { 860 svn_boolean_t allowed; 861 svn_fs_root_t *copyfrom_root; 862 SVN_ERR(svn_fs_revision_root(©from_root, fs, 863 *copyfrom_rev, pool)); 864 SVN_ERR(b->authz_read_func(&allowed, copyfrom_root, 865 *copyfrom_path, b->authz_read_baton, 866 pool)); 867 if (! allowed) 868 { 869 *copyfrom_path = NULL; 870 *copyfrom_rev = SVN_INVALID_REVNUM; 871 } 872 } 873 } 874 } 875 } 876 877 return svn_error_trace(b->editor->add_file(path, parent_baton, 878 *copyfrom_path, *copyfrom_rev, 879 pool, new_file_baton)); 880} 881 882 883/* Emit a series of editing operations to transform a source entry to 884 a target entry. 885 886 S_REV and S_PATH specify the source entry. S_ENTRY contains the 887 already-looked-up information about the node-revision existing at 888 that location. S_PATH and S_ENTRY may be NULL if the entry does 889 not exist in the source. S_PATH may be non-NULL and S_ENTRY may be 890 NULL if the caller expects INFO to modify the source to an existing 891 location. 892 893 B->t_root and T_PATH specify the target entry. T_ENTRY contains 894 the already-looked-up information about the node-revision existing 895 at that location. T_PATH and T_ENTRY may be NULL if the entry does 896 not exist in the target. 897 898 DIR_BATON and E_PATH contain the parameters which should be passed 899 to the editor calls--DIR_BATON for the parent directory baton and 900 E_PATH for the pathname. (E_PATH is the anchor-relative working 901 copy pathname, which may differ from the source and target 902 pathnames if the report contains a link_path.) 903 904 INFO contains the report information for this working copy path, or 905 NULL if there is none. This function will internally modify the 906 source and target entries as appropriate based on the report 907 information. 908 909 WC_DEPTH and REQUESTED_DEPTH are propagated to delta_dirs() if 910 necessary. Refer to delta_dirs' docstring to find out what 911 should happen for various combinations of WC_DEPTH/REQUESTED_DEPTH. */ 912static svn_error_t * 913update_entry(report_baton_t *b, svn_revnum_t s_rev, const char *s_path, 914 const svn_fs_dirent_t *s_entry, const char *t_path, 915 const svn_fs_dirent_t *t_entry, void *dir_baton, 916 const char *e_path, path_info_t *info, svn_depth_t wc_depth, 917 svn_depth_t requested_depth, apr_pool_t *pool) 918{ 919 svn_fs_root_t *s_root = NULL; 920 svn_boolean_t allowed, related; 921 void *new_baton; 922 svn_checksum_t *checksum; 923 const char *hex_digest; 924 925 /* For non-switch operations, follow link_path in the target. */ 926 if (info && info->link_path && !b->is_switch) 927 { 928 t_path = info->link_path; 929 SVN_ERR(fake_dirent(&t_entry, b->t_root, t_path, pool)); 930 } 931 932 if (info && !SVN_IS_VALID_REVNUM(info->rev)) 933 { 934 /* Delete this entry in the source. */ 935 s_path = NULL; 936 s_entry = NULL; 937 } 938 else if (info && s_path) 939 { 940 /* Follow the rev and possibly path in this entry. */ 941 s_path = (info->link_path) ? info->link_path : s_path; 942 s_rev = info->rev; 943 SVN_ERR(get_source_root(b, &s_root, s_rev)); 944 SVN_ERR(fake_dirent(&s_entry, s_root, s_path, pool)); 945 } 946 947 /* Don't let the report carry us somewhere nonexistent. */ 948 if (s_path && !s_entry) 949 return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL, 950 _("Working copy path '%s' does not exist in " 951 "repository"), e_path); 952 953 /* If the source and target both exist and are of the same kind, 954 then find out whether they're related. If they're exactly the 955 same, then we don't have to do anything (unless the report has 956 changes to the source). If we're ignoring ancestry, then any two 957 nodes of the same type are related enough for us. */ 958 related = FALSE; 959 if (s_entry && t_entry && s_entry->kind == t_entry->kind) 960 { 961 int distance = svn_fs_compare_ids(s_entry->id, t_entry->id); 962 svn_boolean_t changed = TRUE; 963 964 /* Check related files for content changes to avoid reporting 965 * unchanged copies of files to the client as an open_file() call 966 * and change_file_prop()/apply_textdelta() calls with no-op changes. 967 * The client will otherwise raise unnecessary tree conflicts. */ 968 if (!b->ignore_ancestry && t_entry->kind == svn_node_file && 969 distance == 1) 970 { 971 if (s_root == NULL) 972 SVN_ERR(get_source_root(b, &s_root, s_rev)); 973 974 SVN_ERR(svn_fs_props_different(&changed, s_root, s_path, 975 b->t_root, t_path, pool)); 976 if (!changed) 977 SVN_ERR(svn_fs_contents_different(&changed, s_root, s_path, 978 b->t_root, t_path, pool)); 979 } 980 981 if ((distance == 0 || !changed) && !any_path_info(b, e_path) 982 && (requested_depth <= wc_depth || t_entry->kind == svn_node_file)) 983 { 984 if (!info) 985 return SVN_NO_ERROR; 986 987 if (!info->start_empty) 988 { 989 svn_lock_t *lock; 990 991 if (!info->lock_token) 992 return SVN_NO_ERROR; 993 994 SVN_ERR(svn_fs_get_lock(&lock, b->repos->fs, t_path, pool)); 995 if (lock && (strcmp(lock->token, info->lock_token) == 0)) 996 return SVN_NO_ERROR; 997 } 998 } 999 1000 related = (distance != -1 || b->ignore_ancestry); 1001 } 1002 1003 /* If there's a source and it's not related to the target, nuke it. */ 1004 if (s_entry && !related) 1005 { 1006 svn_revnum_t deleted_rev; 1007 1008 SVN_ERR(svn_repos_deleted_rev(svn_fs_root_fs(b->t_root), t_path, 1009 s_rev, b->t_rev, &deleted_rev, 1010 pool)); 1011 1012 if (!SVN_IS_VALID_REVNUM(deleted_rev)) 1013 { 1014 /* Two possibilities: either the thing doesn't exist in S_REV; or 1015 it wasn't deleted between S_REV and B->T_REV. In the first case, 1016 I think we should leave DELETED_REV as SVN_INVALID_REVNUM, but 1017 in the second, it should be set to B->T_REV-1 for the call to 1018 delete_entry() below. */ 1019 svn_node_kind_t kind; 1020 1021 SVN_ERR(svn_fs_check_path(&kind, b->t_root, t_path, pool)); 1022 if (kind != svn_node_none) 1023 deleted_rev = b->t_rev - 1; 1024 } 1025 1026 SVN_ERR(b->editor->delete_entry(e_path, deleted_rev, dir_baton, 1027 pool)); 1028 s_path = NULL; 1029 } 1030 1031 /* If there's no target, we have nothing more to do. */ 1032 if (!t_entry) 1033 return svn_error_trace(skip_path_info(b, e_path)); 1034 1035 /* Check if the user is authorized to find out about the target. */ 1036 SVN_ERR(check_auth(b, &allowed, t_path, pool)); 1037 if (!allowed) 1038 { 1039 if (t_entry->kind == svn_node_dir) 1040 SVN_ERR(b->editor->absent_directory(e_path, dir_baton, pool)); 1041 else 1042 SVN_ERR(b->editor->absent_file(e_path, dir_baton, pool)); 1043 return svn_error_trace(skip_path_info(b, e_path)); 1044 } 1045 1046 if (t_entry->kind == svn_node_dir) 1047 { 1048 if (related) 1049 SVN_ERR(b->editor->open_directory(e_path, dir_baton, s_rev, pool, 1050 &new_baton)); 1051 else 1052 SVN_ERR(b->editor->add_directory(e_path, dir_baton, NULL, 1053 SVN_INVALID_REVNUM, pool, 1054 &new_baton)); 1055 1056 SVN_ERR(delta_dirs(b, s_rev, s_path, t_path, new_baton, e_path, 1057 info ? info->start_empty : FALSE, 1058 wc_depth, requested_depth, pool)); 1059 return svn_error_trace(b->editor->close_directory(new_baton, pool)); 1060 } 1061 else 1062 { 1063 if (related) 1064 { 1065 SVN_ERR(b->editor->open_file(e_path, dir_baton, s_rev, pool, 1066 &new_baton)); 1067 SVN_ERR(delta_files(b, new_baton, s_rev, s_path, t_path, 1068 info ? info->lock_token : NULL, pool)); 1069 } 1070 else 1071 { 1072 svn_revnum_t copyfrom_rev = SVN_INVALID_REVNUM; 1073 const char *copyfrom_path = NULL; 1074 SVN_ERR(add_file_smartly(b, e_path, dir_baton, t_path, &new_baton, 1075 ©from_path, ©from_rev, pool)); 1076 if (! copyfrom_path) 1077 /* Send txdelta between empty file (s_path@s_rev doesn't 1078 exist) and added file (t_path@t_root). */ 1079 SVN_ERR(delta_files(b, new_baton, s_rev, s_path, t_path, 1080 info ? info->lock_token : NULL, pool)); 1081 else 1082 /* Send txdelta between copied file (copyfrom_path@copyfrom_rev) 1083 and added file (tpath@t_root). */ 1084 SVN_ERR(delta_files(b, new_baton, copyfrom_rev, copyfrom_path, 1085 t_path, info ? info->lock_token : NULL, pool)); 1086 } 1087 1088 SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5, b->t_root, 1089 t_path, TRUE, pool)); 1090 hex_digest = svn_checksum_to_cstring(checksum, pool); 1091 return svn_error_trace(b->editor->close_file(new_baton, hex_digest, 1092 pool)); 1093 } 1094} 1095 1096/* A helper macro for when we have to recurse into subdirectories. */ 1097#define DEPTH_BELOW_HERE(depth) ((depth) == svn_depth_immediates) ? \ 1098 svn_depth_empty : (depth) 1099 1100/* Emit edits within directory DIR_BATON (with corresponding path 1101 E_PATH) with the changes from the directory S_REV/S_PATH to the 1102 directory B->t_rev/T_PATH. S_PATH may be NULL if the entry does 1103 not exist in the source. 1104 1105 WC_DEPTH is this path's depth as reported by set_path/link_path. 1106 REQUESTED_DEPTH is derived from the depth set by 1107 svn_repos_begin_report(). 1108 1109 When iterating over this directory's entries, the following tables 1110 describe what happens for all possible combinations 1111 of WC_DEPTH/REQUESTED_DEPTH (rows represent WC_DEPTH, columns 1112 represent REQUESTED_DEPTH): 1113 1114 Legend: 1115 X: ignore this entry (it's either below the requested depth, or 1116 if the requested depth is svn_depth_unknown, below the working 1117 copy depth) 1118 o: handle this entry normally 1119 U: handle the entry as if it were a newly added repository path 1120 (the client is upgrading to a deeper wc and doesn't currently 1121 have this entry, but it should be there after the upgrade, so we 1122 need to send the whole thing, not just deltas) 1123 1124 For files: 1125 ______________________________________________________________ 1126 | req. depth| unknown | empty | files | immediates | infinity | 1127 |wc. depth | | | | | | 1128 |___________|_________|_______|_______|____________|__________| 1129 |empty | X | X | U | U | U | 1130 |___________|_________|_______|_______|____________|__________| 1131 |files | o | X | o | o | o | 1132 |___________|_________|_______|_______|____________|__________| 1133 |immediates | o | X | o | o | o | 1134 |___________|_________|_______|_______|____________|__________| 1135 |infinity | o | X | o | o | o | 1136 |___________|_________|_______|_______|____________|__________| 1137 1138 For directories: 1139 ______________________________________________________________ 1140 | req. depth| unknown | empty | files | immediates | infinity | 1141 |wc. depth | | | | | | 1142 |___________|_________|_______|_______|____________|__________| 1143 |empty | X | X | X | U | U | 1144 |___________|_________|_______|_______|____________|__________| 1145 |files | X | X | X | U | U | 1146 |___________|_________|_______|_______|____________|__________| 1147 |immediates | o | X | X | o | o | 1148 |___________|_________|_______|_______|____________|__________| 1149 |infinity | o | X | X | o | o | 1150 |___________|_________|_______|_______|____________|__________| 1151 1152 These rules are enforced by the is_depth_upgrade() function and by 1153 various other checks below. 1154*/ 1155static svn_error_t * 1156delta_dirs(report_baton_t *b, svn_revnum_t s_rev, const char *s_path, 1157 const char *t_path, void *dir_baton, const char *e_path, 1158 svn_boolean_t start_empty, svn_depth_t wc_depth, 1159 svn_depth_t requested_depth, apr_pool_t *pool) 1160{ 1161 apr_hash_t *s_entries = NULL, *t_entries; 1162 apr_hash_index_t *hi; 1163 apr_pool_t *subpool = svn_pool_create(pool); 1164 apr_array_header_t *t_ordered_entries = NULL; 1165 int i; 1166 1167 /* Compare the property lists. If we're starting empty, pass a NULL 1168 source path so that we add all the properties. 1169 1170 When we support directory locks, we must pass the lock token here. */ 1171 SVN_ERR(delta_proplists(b, s_rev, start_empty ? NULL : s_path, t_path, 1172 NULL, change_dir_prop, dir_baton, subpool)); 1173 svn_pool_clear(subpool); 1174 1175 if (requested_depth > svn_depth_empty 1176 || requested_depth == svn_depth_unknown) 1177 { 1178 apr_pool_t *iterpool; 1179 1180 /* Get the list of entries in each of source and target. */ 1181 if (s_path && !start_empty) 1182 { 1183 svn_fs_root_t *s_root; 1184 1185 SVN_ERR(get_source_root(b, &s_root, s_rev)); 1186 SVN_ERR(svn_fs_dir_entries(&s_entries, s_root, s_path, subpool)); 1187 } 1188 SVN_ERR(svn_fs_dir_entries(&t_entries, b->t_root, t_path, subpool)); 1189 1190 /* Iterate over the report information for this directory. */ 1191 iterpool = svn_pool_create(subpool); 1192 1193 while (1) 1194 { 1195 path_info_t *info; 1196 const char *name, *s_fullpath, *t_fullpath, *e_fullpath; 1197 const svn_fs_dirent_t *s_entry, *t_entry; 1198 1199 svn_pool_clear(iterpool); 1200 SVN_ERR(fetch_path_info(b, &name, &info, e_path, iterpool)); 1201 if (!name) 1202 break; 1203 1204 /* Invalid revnum means we should delete, unless this is 1205 just an excluded subpath. */ 1206 if (info 1207 && !SVN_IS_VALID_REVNUM(info->rev) 1208 && info->depth != svn_depth_exclude) 1209 { 1210 /* We want to perform deletes before non-replacement adds, 1211 for graceful handling of case-only renames on 1212 case-insensitive client filesystems. So, if the report 1213 item is a delete, remove the entry from the source hash, 1214 but don't update the entry yet. */ 1215 if (s_entries) 1216 svn_hash_sets(s_entries, name, NULL); 1217 1218 svn_pool_destroy(info->pool); 1219 continue; 1220 } 1221 1222 e_fullpath = svn_relpath_join(e_path, name, iterpool); 1223 t_fullpath = svn_fspath__join(t_path, name, iterpool); 1224 t_entry = svn_hash_gets(t_entries, name); 1225 s_fullpath = s_path ? svn_fspath__join(s_path, name, iterpool) : NULL; 1226 s_entry = s_entries ? svn_hash_gets(s_entries, name) : NULL; 1227 1228 /* The only special cases where we don't process the entry are 1229 1230 - When requested_depth is files but the reported path is 1231 a directory. This is technically a client error, but we 1232 handle it anyway, by skipping the entry. 1233 1234 - When the reported depth is svn_depth_exclude. 1235 */ 1236 if (! ((requested_depth == svn_depth_files 1237 && ((t_entry && t_entry->kind == svn_node_dir) 1238 || (s_entry && s_entry->kind == svn_node_dir))) 1239 || (info && info->depth == svn_depth_exclude))) 1240 SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, t_fullpath, 1241 t_entry, dir_baton, e_fullpath, info, 1242 info ? info->depth 1243 : DEPTH_BELOW_HERE(wc_depth), 1244 DEPTH_BELOW_HERE(requested_depth), iterpool)); 1245 1246 /* Don't revisit this name in the target or source entries. */ 1247 svn_hash_sets(t_entries, name, NULL); 1248 if (s_entries 1249 /* Keep the entry for later process if it is reported as 1250 excluded and got deleted in repos. */ 1251 && (! info || info->depth != svn_depth_exclude || t_entry)) 1252 svn_hash_sets(s_entries, name, NULL); 1253 1254 /* pathinfo entries live in their own subpools due to lookahead, 1255 so we need to clear each one out as we finish with it. */ 1256 if (info) 1257 svn_pool_destroy(info->pool); 1258 } 1259 1260 /* Remove any deleted entries. Do this before processing the 1261 target, for graceful handling of case-only renames. */ 1262 if (s_entries) 1263 { 1264 for (hi = apr_hash_first(subpool, s_entries); 1265 hi; 1266 hi = apr_hash_next(hi)) 1267 { 1268 const svn_fs_dirent_t *s_entry = apr_hash_this_val(hi); 1269 1270 svn_pool_clear(iterpool); 1271 1272 if (svn_hash_gets(t_entries, s_entry->name) == NULL) 1273 { 1274 const char *e_fullpath; 1275 svn_revnum_t deleted_rev; 1276 1277 if (s_entry->kind == svn_node_file 1278 && wc_depth < svn_depth_files) 1279 continue; 1280 1281 if (s_entry->kind == svn_node_dir 1282 && (wc_depth < svn_depth_immediates 1283 || requested_depth == svn_depth_files)) 1284 continue; 1285 1286 /* There is no corresponding target entry, so delete. */ 1287 e_fullpath = svn_relpath_join(e_path, s_entry->name, iterpool); 1288 SVN_ERR(svn_repos_deleted_rev(svn_fs_root_fs(b->t_root), 1289 svn_fspath__join(t_path, 1290 s_entry->name, 1291 iterpool), 1292 s_rev, b->t_rev, 1293 &deleted_rev, iterpool)); 1294 1295 SVN_ERR(b->editor->delete_entry(e_fullpath, 1296 deleted_rev, 1297 dir_baton, iterpool)); 1298 } 1299 } 1300 } 1301 1302 /* Loop over the dirents in the target. */ 1303 SVN_ERR(svn_fs_dir_optimal_order(&t_ordered_entries, b->t_root, 1304 t_entries, subpool, iterpool)); 1305 for (i = 0; i < t_ordered_entries->nelts; ++i) 1306 { 1307 const svn_fs_dirent_t *t_entry 1308 = APR_ARRAY_IDX(t_ordered_entries, i, svn_fs_dirent_t *); 1309 const svn_fs_dirent_t *s_entry; 1310 const char *s_fullpath, *t_fullpath, *e_fullpath; 1311 1312 svn_pool_clear(iterpool); 1313 1314 if (is_depth_upgrade(wc_depth, requested_depth, t_entry->kind)) 1315 { 1316 /* We're making the working copy deeper, pretend the source 1317 doesn't exist. */ 1318 s_entry = NULL; 1319 s_fullpath = NULL; 1320 } 1321 else 1322 { 1323 if (t_entry->kind == svn_node_file 1324 && requested_depth == svn_depth_unknown 1325 && wc_depth < svn_depth_files) 1326 continue; 1327 1328 if (t_entry->kind == svn_node_dir 1329 && (wc_depth < svn_depth_immediates 1330 || requested_depth == svn_depth_files)) 1331 continue; 1332 1333 /* Look for an entry with the same name in the source dirents. */ 1334 s_entry = s_entries ? 1335 svn_hash_gets(s_entries, t_entry->name) : NULL; 1336 s_fullpath = s_entry ? 1337 svn_fspath__join(s_path, t_entry->name, iterpool) : NULL; 1338 } 1339 1340 /* Compose the report, editor, and target paths for this entry. */ 1341 e_fullpath = svn_relpath_join(e_path, t_entry->name, iterpool); 1342 t_fullpath = svn_fspath__join(t_path, t_entry->name, iterpool); 1343 1344 SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, t_fullpath, 1345 t_entry, dir_baton, e_fullpath, NULL, 1346 DEPTH_BELOW_HERE(wc_depth), 1347 DEPTH_BELOW_HERE(requested_depth), 1348 iterpool)); 1349 } 1350 1351 /* iterpool is destroyed by destroying its parent (subpool) below */ 1352 } 1353 1354 svn_pool_destroy(subpool); 1355 1356 return SVN_NO_ERROR; 1357} 1358 1359static svn_error_t * 1360drive(report_baton_t *b, svn_revnum_t s_rev, path_info_t *info, 1361 apr_pool_t *pool) 1362{ 1363 const char *t_anchor, *s_fullpath; 1364 svn_boolean_t allowed, info_is_set_path; 1365 svn_fs_root_t *s_root; 1366 const svn_fs_dirent_t *s_entry, *t_entry; 1367 void *root_baton; 1368 1369 /* Compute the target path corresponding to the working copy anchor, 1370 and check its authorization. */ 1371 t_anchor = *b->s_operand ? svn_fspath__dirname(b->t_path, pool) : b->t_path; 1372 SVN_ERR(check_auth(b, &allowed, t_anchor, pool)); 1373 if (!allowed) 1374 return svn_error_create 1375 (SVN_ERR_AUTHZ_ROOT_UNREADABLE, NULL, 1376 _("Not authorized to open root of edit operation")); 1377 1378 /* Collect information about the source and target nodes. */ 1379 s_fullpath = svn_fspath__join(b->fs_base, b->s_operand, pool); 1380 SVN_ERR(get_source_root(b, &s_root, s_rev)); 1381 SVN_ERR(fake_dirent(&s_entry, s_root, s_fullpath, pool)); 1382 SVN_ERR(fake_dirent(&t_entry, b->t_root, b->t_path, pool)); 1383 1384 /* If the operand is a locally added file or directory, it won't 1385 exist in the source, so accept that. */ 1386 info_is_set_path = (SVN_IS_VALID_REVNUM(info->rev) && !info->link_path); 1387 if (info_is_set_path && !s_entry) 1388 s_fullpath = NULL; 1389 1390 /* Check if the target path exists first. */ 1391 if (!*b->s_operand && !(t_entry)) 1392 return svn_error_createf(SVN_ERR_FS_PATH_SYNTAX, NULL, 1393 _("Target path '%s' does not exist"), 1394 b->t_path); 1395 1396 /* If the anchor is the operand, the source and target must be dirs. 1397 Check this before opening the root to avoid modifying the wc. */ 1398 else if (!*b->s_operand && (!s_entry || s_entry->kind != svn_node_dir 1399 || t_entry->kind != svn_node_dir)) 1400 return svn_error_create(SVN_ERR_FS_PATH_SYNTAX, NULL, 1401 _("Cannot replace a directory from within")); 1402 1403 SVN_ERR(b->editor->set_target_revision(b->edit_baton, b->t_rev, pool)); 1404 SVN_ERR(b->editor->open_root(b->edit_baton, s_rev, pool, &root_baton)); 1405 1406 /* If the anchor is the operand, diff the two directories; otherwise 1407 update the operand within the anchor directory. */ 1408 if (!*b->s_operand) 1409 SVN_ERR(delta_dirs(b, s_rev, s_fullpath, b->t_path, root_baton, 1410 "", info->start_empty, info->depth, b->requested_depth, 1411 pool)); 1412 else 1413 SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, b->t_path, 1414 t_entry, root_baton, b->s_operand, info, 1415 info->depth, b->requested_depth, pool)); 1416 1417 return svn_error_trace(b->editor->close_directory(root_baton, pool)); 1418} 1419 1420/* Initialize the baton fields for editor-driving, and drive the editor. */ 1421static svn_error_t * 1422finish_report(report_baton_t *b, apr_pool_t *pool) 1423{ 1424 path_info_t *info; 1425 apr_pool_t *subpool; 1426 svn_revnum_t s_rev; 1427 int i; 1428 1429 /* Save our pool to manage the lookahead and fs_root cache with. */ 1430 b->pool = pool; 1431 1432 /* Add the end marker. */ 1433 SVN_ERR(svn_spillbuf__reader_write(b->reader, "-", 1, pool)); 1434 1435 /* Read the first pathinfo from the report and verify that it is a top-level 1436 set_path entry. */ 1437 SVN_ERR(read_path_info(&info, b->reader, pool)); 1438 if (!info || strcmp(info->path, b->s_operand) != 0 1439 || info->link_path || !SVN_IS_VALID_REVNUM(info->rev)) 1440 return svn_error_create(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL, 1441 _("Invalid report for top level of working copy")); 1442 s_rev = info->rev; 1443 1444 /* Initialize the lookahead pathinfo. */ 1445 subpool = svn_pool_create(pool); 1446 SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool)); 1447 1448 if (b->lookahead && strcmp(b->lookahead->path, b->s_operand) == 0) 1449 { 1450 /* If the operand of the wc operation is switched or deleted, 1451 then info above is just a place-holder, and the only thing we 1452 have to do is pass the revision it contains to open_root. 1453 The next pathinfo actually describes the target. */ 1454 if (!*b->s_operand) 1455 return svn_error_create(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL, 1456 _("Two top-level reports with no target")); 1457 /* If the client issued a set-path followed by a delete-path, we need 1458 to respect the depth set by the initial set-path. */ 1459 if (! SVN_IS_VALID_REVNUM(b->lookahead->rev)) 1460 { 1461 b->lookahead->depth = info->depth; 1462 } 1463 info = b->lookahead; 1464 SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool)); 1465 } 1466 1467 /* Open the target root and initialize the source root cache. */ 1468 SVN_ERR(svn_fs_revision_root(&b->t_root, b->repos->fs, b->t_rev, pool)); 1469 for (i = 0; i < NUM_CACHED_SOURCE_ROOTS; i++) 1470 b->s_roots[i] = NULL; 1471 1472 { 1473 svn_error_t *err = svn_error_trace(drive(b, s_rev, info, pool)); 1474 1475 if (err == SVN_NO_ERROR) 1476 return svn_error_trace(b->editor->close_edit(b->edit_baton, pool)); 1477 1478 return svn_error_trace( 1479 svn_error_compose_create(err, 1480 b->editor->abort_edit(b->edit_baton, 1481 pool))); 1482 } 1483} 1484 1485/* --- COLLECTING THE REPORT INFORMATION --- */ 1486 1487/* Record a report operation into the spill buffer. Return an error 1488 if DEPTH is svn_depth_unknown. */ 1489static svn_error_t * 1490write_path_info(report_baton_t *b, const char *path, const char *lpath, 1491 svn_revnum_t rev, svn_depth_t depth, 1492 svn_boolean_t start_empty, 1493 const char *lock_token, apr_pool_t *pool) 1494{ 1495 const char *lrep, *rrep, *drep, *ltrep, *rep; 1496 1497 /* Munge the path to be anchor-relative, so that we can use edit paths 1498 as report paths. */ 1499 path = svn_relpath_join(b->s_operand, path, pool); 1500 1501 lrep = lpath ? apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s", 1502 strlen(lpath), lpath) : "-"; 1503 rrep = (SVN_IS_VALID_REVNUM(rev)) ? 1504 apr_psprintf(pool, "+%ld:", rev) : "-"; 1505 1506 if (depth == svn_depth_exclude) 1507 drep = "+X"; 1508 else if (depth == svn_depth_empty) 1509 drep = "+E"; 1510 else if (depth == svn_depth_files) 1511 drep = "+F"; 1512 else if (depth == svn_depth_immediates) 1513 drep = "+M"; 1514 else if (depth == svn_depth_infinity) 1515 drep = "-"; 1516 else 1517 return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL, 1518 _("Unsupported report depth '%s'"), 1519 svn_depth_to_word(depth)); 1520 1521 ltrep = lock_token ? apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s", 1522 strlen(lock_token), lock_token) : "-"; 1523 rep = apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s%s%s%s%c%s", 1524 strlen(path), path, lrep, rrep, drep, 1525 start_empty ? '+' : '-', ltrep); 1526 return svn_error_trace( 1527 svn_spillbuf__reader_write(b->reader, rep, strlen(rep), pool)); 1528} 1529 1530svn_error_t * 1531svn_repos_set_path3(void *baton, const char *path, svn_revnum_t rev, 1532 svn_depth_t depth, svn_boolean_t start_empty, 1533 const char *lock_token, apr_pool_t *pool) 1534{ 1535 return svn_error_trace( 1536 write_path_info(baton, path, NULL, rev, depth, start_empty, 1537 lock_token, pool)); 1538} 1539 1540svn_error_t * 1541svn_repos_link_path3(void *baton, const char *path, const char *link_path, 1542 svn_revnum_t rev, svn_depth_t depth, 1543 svn_boolean_t start_empty, 1544 const char *lock_token, apr_pool_t *pool) 1545{ 1546 if (depth == svn_depth_exclude) 1547 return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL, 1548 _("Depth 'exclude' not supported for link")); 1549 1550 return svn_error_trace( 1551 write_path_info(baton, path, link_path, rev, depth, 1552 start_empty, lock_token, pool)); 1553} 1554 1555svn_error_t * 1556svn_repos_delete_path(void *baton, const char *path, apr_pool_t *pool) 1557{ 1558 /* We pass svn_depth_infinity because deletion of a path always 1559 deletes everything underneath it. */ 1560 return svn_error_trace( 1561 write_path_info(baton, path, NULL, SVN_INVALID_REVNUM, 1562 svn_depth_infinity, FALSE, NULL, pool)); 1563} 1564 1565svn_error_t * 1566svn_repos_finish_report(void *baton, apr_pool_t *pool) 1567{ 1568 report_baton_t *b = baton; 1569 1570 return svn_error_trace(finish_report(b, pool)); 1571} 1572 1573svn_error_t * 1574svn_repos_abort_report(void *baton, apr_pool_t *pool) 1575{ 1576 return SVN_NO_ERROR; 1577} 1578 1579/* --- BEGINNING THE REPORT --- */ 1580 1581 1582svn_error_t * 1583svn_repos_begin_report3(void **report_baton, 1584 svn_revnum_t revnum, 1585 svn_repos_t *repos, 1586 const char *fs_base, 1587 const char *s_operand, 1588 const char *switch_path, 1589 svn_boolean_t text_deltas, 1590 svn_depth_t depth, 1591 svn_boolean_t ignore_ancestry, 1592 svn_boolean_t send_copyfrom_args, 1593 const svn_delta_editor_t *editor, 1594 void *edit_baton, 1595 svn_repos_authz_func_t authz_read_func, 1596 void *authz_read_baton, 1597 apr_size_t zero_copy_limit, 1598 apr_pool_t *pool) 1599{ 1600 report_baton_t *b; 1601 const char *uuid; 1602 1603 if (depth == svn_depth_exclude) 1604 return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL, 1605 _("Request depth 'exclude' not supported")); 1606 1607 SVN_ERR(svn_fs_get_uuid(repos->fs, &uuid, pool)); 1608 1609 /* Build a reporter baton. Copy strings in case the caller doesn't 1610 keep track of them. */ 1611 b = apr_palloc(pool, sizeof(*b)); 1612 b->repos = repos; 1613 b->fs_base = svn_fspath__canonicalize(fs_base, pool); 1614 b->s_operand = apr_pstrdup(pool, s_operand); 1615 b->t_rev = revnum; 1616 b->t_path = switch_path ? svn_fspath__canonicalize(switch_path, pool) 1617 : svn_fspath__join(b->fs_base, s_operand, pool); 1618 b->text_deltas = text_deltas; 1619 b->zero_copy_limit = zero_copy_limit; 1620 b->requested_depth = depth; 1621 b->ignore_ancestry = ignore_ancestry; 1622 b->send_copyfrom_args = send_copyfrom_args; 1623 b->is_switch = (switch_path != NULL); 1624 b->editor = editor; 1625 b->edit_baton = edit_baton; 1626 b->authz_read_func = authz_read_func; 1627 b->authz_read_baton = authz_read_baton; 1628 b->revision_infos = apr_hash_make(pool); 1629 b->pool = pool; 1630 b->reader = svn_spillbuf__reader_create(1000 /* blocksize */, 1631 1000000 /* maxsize */, 1632 pool); 1633 b->repos_uuid = svn_string_create(uuid, pool); 1634 1635 /* Hand reporter back to client. */ 1636 *report_baton = b; 1637 return SVN_NO_ERROR; 1638} 1639