2 * reporter.c : `reporter' vtable routines for updates.
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
13 * http://www.apache.org/licenses/LICENSE-2.0
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
21 * ====================================================================
24 #include "svn_dirent_uri.h"
27 #include "svn_types.h"
28 #include "svn_error.h"
29 #include "svn_error_codes.h"
31 #include "svn_repos.h"
32 #include "svn_pools.h"
33 #include "svn_props.h"
35 #include "svn_private_config.h"
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"
42 #define NUM_CACHED_SOURCE_ROOTS 4
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.
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):
54 +/- '-' marks the end of the report
56 <length>:<bytes> Length-counted path string
57 +/- '+' indicates the presence of link_path
59 <length>:<bytes> Length-counted link_path string
60 +/- '+' indicates presence of revnum
62 <revnum>: Revnum of set_path or link_path
63 +/- '+' indicates depth other than svn_depth_infinity
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.
70 <length>:<bytes> Length-counted lock_token string
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". */
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
81 typedef struct path_info_t
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 */
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
96 typedef struct revision_info_t
98 svn_revnum_t rev; /* revision number */
99 svn_string_t* date; /* revision timestamp */
100 svn_string_t* author; /* name of the revisions' author */
103 /* A structure used by the routines within the `reporter' vtable,
104 driven by the client as it describes its working copy revisions. */
105 typedef struct report_baton_t
107 /* Parameters remembered from svn_repos_begin_report3 */
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. */
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;
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;
128 svn_repos_authz_func_t authz_read_func;
129 void *authz_read_baton;
131 /* The spill-buffer holding the report. */
132 svn_spillbuf_reader_t *reader;
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];
140 /* Cache for revision properties. This is used to eliminate redundant
142 apr_hash_t *revision_infos;
144 /* This will not change. So, fetch it once and reuse it. */
145 svn_string_t *repos_uuid;
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. */
153 typedef svn_error_t *proplist_change_fn_t(report_baton_t *b, void *object,
155 const svn_string_t *value,
158 static 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,
166 /* --- READING PREVIOUSLY STORED REPORT INFORMATION --- */
169 read_number(apr_uint64_t *num, svn_spillbuf_reader_t *reader, apr_pool_t *pool)
176 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
179 *num = *num * 10 + (c - '0');
185 read_string(const char **str, svn_spillbuf_reader_t *reader, apr_pool_t *pool)
192 SVN_ERR(read_number(&len, reader, pool));
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)
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,
205 _("Invalid length (%%%s) when "
206 "about to read a string"),
211 size = (apr_size_t)len;
212 buf = apr_palloc(pool, size+1);
215 SVN_ERR(svn_spillbuf__reader_read(&amt, reader, buf, size, pool));
216 SVN_ERR_ASSERT(amt == size);
224 read_rev(svn_revnum_t *rev, svn_spillbuf_reader_t *reader, apr_pool_t *pool)
229 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
232 SVN_ERR(read_number(&num, reader, pool));
233 *rev = (svn_revnum_t) num;
236 *rev = SVN_INVALID_REVNUM;
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. */
244 read_depth(svn_depth_t *depth, svn_spillbuf_reader_t *reader, const char *path,
249 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
253 *depth = svn_depth_exclude;
256 *depth = svn_depth_empty;
259 *depth = svn_depth_files;
262 *depth = svn_depth_immediates;
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. */
269 return svn_error_createf(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL,
270 _("Invalid depth (%c) for path '%s'"), c, path);
276 /* Read a report operation *PI out of READER. Set *PI to NULL if we
277 have reached the end of the report. */
279 read_path_info(path_info_t **pi,
280 svn_spillbuf_reader_t *reader,
285 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
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));
296 SVN_ERR(read_string(&(*pi)->link_path, reader, pool));
298 (*pi)->link_path = NULL;
299 SVN_ERR(read_rev(&(*pi)->rev, reader, pool));
300 SVN_ERR(svn_spillbuf__reader_getc(&c, reader, pool));
302 SVN_ERR(read_depth(&((*pi)->depth), reader, (*pi)->path, pool));
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));
309 SVN_ERR(read_string(&(*pi)->lock_token, reader, pool));
311 (*pi)->lock_token = NULL;
316 /* Return true if PI's path is a child of PREFIX (which has length PLEN). */
318 relevant(path_info_t *pi, const char *prefix, apr_size_t plen)
320 return (pi && strncmp(pi->path, prefix, plen) == 0 &&
321 (!*prefix || pi->path[plen] == '/'));
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
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. */
341 fetch_path_info(report_baton_t *b, const char **entry, path_info_t **info,
342 const char *prefix, apr_pool_t *pool)
344 apr_size_t plen = strlen(prefix);
345 const char *relpath, *sep;
348 if (!relevant(b->lookahead, prefix, plen))
350 /* No more entries relevant to prefix. */
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, '/');
361 /* Return the immediate child part; do not advance. */
362 *entry = apr_pstrmemdup(pool, relpath, sep - relpath);
367 /* This is an immediate child; return it and advance. */
369 *info = b->lookahead;
370 subpool = svn_pool_create(b->pool);
371 SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool));
377 /* Skip all path info entries relevant to *PREFIX. Call this when the
378 editor drive skips a directory. */
380 skip_path_info(report_baton_t *b, const char *prefix)
382 apr_size_t plen = strlen(prefix);
385 while (relevant(b->lookahead, prefix, plen))
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));
394 /* Return true if there is at least one path info entry relevant to *PREFIX. */
396 any_path_info(report_baton_t *b, const char *prefix)
398 return relevant(b->lookahead, prefix, strlen(prefix));
401 /* --- DRIVING THE EDITOR ONCE THE REPORT IS FINISHED --- */
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
415 get_source_root(report_baton_t *b, svn_fs_root_t **s_root, svn_revnum_t rev)
418 svn_fs_root_t *root, *prev = NULL;
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++)
424 root = b->s_roots[i];
425 b->s_roots[i] = prev;
426 if (root && svn_fs_revision_root_revision(root) == rev)
431 /* If we didn't find it, throw out the oldest root and open a new one. */
432 if (i == NUM_CACHED_SOURCE_ROOTS)
435 svn_fs_close_root(prev);
436 SVN_ERR(svn_fs_revision_root(&root, b->repos->fs, rev, b->pool));
439 /* Assign the desired root to the first cache slot and hand it back. */
440 b->s_roots[0] = root;
445 /* Call the directory property-setting function of B->editor to set
446 the property NAME to VALUE on DIR_BATON. */
448 change_dir_prop(report_baton_t *b, void *dir_baton, const char *name,
449 const svn_string_t *value, apr_pool_t *pool)
451 return svn_error_trace(b->editor->change_dir_prop(dir_baton, name, value,
455 /* Call the file property-setting function of B->editor to set the
456 property NAME to VALUE on FILE_BATON. */
458 change_file_prop(report_baton_t *b, void *file_baton, const char *name,
459 const svn_string_t *value, apr_pool_t *pool)
461 return svn_error_trace(b->editor->change_file_prop(file_baton, name, value,
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. */
469 get_revision_info(report_baton_t *b,
471 revision_info_t** revision_info,
472 apr_pool_t *scratch_pool)
475 svn_string_t *cdate, *author;
476 revision_info_t* info;
478 /* Try to find the info in the report's cache */
479 info = apr_hash_get(b->revision_infos, &rev, sizeof(rev));
482 /* Info is not available, yet.
484 SVN_ERR(svn_fs_revision_proplist(&r_props,
489 /* Extract the committed-date. */
490 cdate = svn_hash_gets(r_props, SVN_PROP_REVISION_DATE);
492 /* Extract the last-author. */
493 author = svn_hash_gets(r_props, SVN_PROP_REVISION_AUTHOR);
495 /* Create a result object */
496 info = apr_palloc(b->pool, sizeof(*info));
498 info->date = svn_string_dup(cdate, b->pool);
499 info->author = svn_string_dup(author, b->pool);
502 apr_hash_set(b->revision_infos, &info->rev, sizeof(info->rev), info);
505 *revision_info = info;
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
516 delta_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)
521 svn_fs_root_t *s_root;
522 apr_hash_t *s_props = NULL, *t_props;
523 apr_array_header_t *prop_diffs;
526 revision_info_t *revision_info;
527 svn_boolean_t changed;
528 const svn_prop_t *pc;
530 apr_hash_index_t *hi;
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))
536 /* convert committed-rev to string */
537 char buf[SVN_INT64_BUFFER_SIZE];
540 cr_str.len = svn__i64toa(buf, crev);
542 /* Transmit the committed-rev. */
543 SVN_ERR(change_fn(b, object,
544 SVN_PROP_ENTRY_COMMITTED_REV, &cr_str, pool));
546 SVN_ERR(get_revision_info(b, crev, &revision_info, pool));
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));
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));
558 /* Transmit the UUID. */
559 SVN_ERR(change_fn(b, object, SVN_PROP_ENTRY_UUID,
560 b->repos_uuid, pool));
563 /* Update lock properties. */
566 SVN_ERR(svn_fs_get_lock(&lock, b->repos->fs, t_path, pool));
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,
576 SVN_ERR(get_source_root(b, &s_root, s_rev));
578 /* Is this deltification worth our time? */
579 SVN_ERR(svn_fs_props_different(&changed, b->t_root, t_path, s_root,
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));
588 /* Get the target path's properties */
589 SVN_ERR(svn_fs_node_proplist(&t_props, b->t_root, t_path, pool));
591 if (s_props && apr_hash_count(s_props))
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++)
597 pc = &APR_ARRAY_IDX(prop_diffs, i, svn_prop_t);
598 SVN_ERR(change_fn(b, object, pc->name, pc->value, pool));
601 else if (apr_hash_count(t_props))
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))
606 const char *key = apr_hash_this_key(hi);
607 svn_string_t *val = apr_hash_this_val(hi);
609 SVN_ERR(change_fn(b, object, key, val, pool));
616 /* Baton type to be passed into send_zero_copy_delta.
618 typedef struct zero_copy_baton_t
620 /* don't process data larger than this limit */
621 apr_size_t zero_copy_limit;
623 /* window handler and baton to send the data to */
624 svn_txdelta_window_handler_t dhandler;
627 /* return value: will be set to TRUE, if the data was processed. */
628 svn_boolean_t zero_copy_succeeded;
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.
638 send_zero_copy_delta(const unsigned char *contents,
643 zero_copy_baton_t *zero_copy_baton = baton;
645 /* if the item is too large, the caller must revert to traditional
647 if (len > zero_copy_baton->zero_copy_limit)
649 zero_copy_baton->zero_copy_succeeded = FALSE;
653 SVN_ERR(svn_txdelta_send_contents(contents, len,
654 zero_copy_baton->dhandler,
655 zero_copy_baton->dbaton, pool));
658 zero_copy_baton->zero_copy_succeeded = TRUE;
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
668 delta_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,
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;
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));
686 SVN_ERR(get_source_root(b, &s_root, s_rev));
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));
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);
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));
707 if (dhandler != svn_delta_noop_window_handler)
711 /* if we send deltas against empty streams, we may use our
713 if (b->zero_copy_limit > 0 && s_path == NULL)
715 zero_copy_baton_t baton;
716 svn_boolean_t called = FALSE;
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,
724 send_zero_copy_delta,
727 /* data has been available and small enough,
728 i.e. been processed? */
729 if (called && baton.zero_copy_succeeded)
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));
738 SVN_ERR(dhandler(NULL, dbaton));
744 /* Determine if the user is authorized to view B->t_root/PATH. */
746 check_auth(report_baton_t *b, svn_boolean_t *allowed, const char *path,
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));
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. */
760 fake_dirent(const svn_fs_dirent_t **entry, svn_fs_root_t *root,
761 const char *path, apr_pool_t *pool)
763 svn_node_kind_t kind;
764 svn_fs_dirent_t *ent;
766 SVN_ERR(svn_fs_check_path(&kind, root, path, pool));
767 if (kind == svn_node_none)
771 ent = apr_palloc(pool, sizeof(**entry));
772 /* ### All callers should be updated to pass just one of these
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));
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. */
789 is_depth_upgrade(svn_depth_t wc_depth,
790 svn_depth_t requested_depth,
791 svn_node_kind_t kind)
793 if (requested_depth == svn_depth_unknown
794 || requested_depth <= wc_depth
795 || wc_depth == svn_depth_immediates)
798 if (kind == svn_node_file
799 && wc_depth == svn_depth_files)
802 if (kind == svn_node_dir
803 && wc_depth == svn_depth_empty
804 && requested_depth == svn_depth_files)
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. */
819 add_file_smartly(report_baton_t *b,
823 void **new_file_baton,
824 const char **copyfrom_path,
825 svn_revnum_t *copyfrom_rev,
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;
833 /* Pre-emptively assume no copyfrom args exist. */
834 *copyfrom_path = NULL;
835 *copyfrom_rev = SVN_INVALID_REVNUM;
837 if (b->send_copyfrom_args)
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 '/'
844 o_path = apr_pstrcat(pool, "/", o_path, SVN_VA_NULL);
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)
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)
855 SVN_ERR(svn_fs_copied_from(copyfrom_rev, copyfrom_path,
856 closest_copy_root, closest_copy_path,
858 if (b->authz_read_func)
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,
869 *copyfrom_path = NULL;
870 *copyfrom_rev = SVN_INVALID_REVNUM;
877 return svn_error_trace(b->editor->add_file(path, parent_baton,
878 *copyfrom_path, *copyfrom_rev,
879 pool, new_file_baton));
883 /* Emit a series of editing operations to transform a source entry to
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
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.
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.)
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
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. */
913 update_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)
919 svn_fs_root_t *s_root;
920 svn_boolean_t allowed, related;
922 svn_checksum_t *checksum;
923 const char *hex_digest;
925 /* For non-switch operations, follow link_path in the target. */
926 if (info && info->link_path && !b->is_switch)
928 t_path = info->link_path;
929 SVN_ERR(fake_dirent(&t_entry, b->t_root, t_path, pool));
932 if (info && !SVN_IS_VALID_REVNUM(info->rev))
934 /* Delete this entry in the source. */
938 else if (info && s_path)
940 /* Follow the rev and possibly path in this entry. */
941 s_path = (info->link_path) ? info->link_path : s_path;
943 SVN_ERR(get_source_root(b, &s_root, s_rev));
944 SVN_ERR(fake_dirent(&s_entry, s_root, s_path, pool));
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);
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. */
959 if (s_entry && t_entry && s_entry->kind == t_entry->kind)
961 int distance = svn_fs_compare_ids(s_entry->id, t_entry->id);
962 if (distance == 0 && !any_path_info(b, e_path)
963 && (requested_depth <= wc_depth || t_entry->kind == svn_node_file))
968 if (!info->start_empty)
972 if (!info->lock_token)
975 SVN_ERR(svn_fs_get_lock(&lock, b->repos->fs, t_path, pool));
976 if (lock && (strcmp(lock->token, info->lock_token) == 0))
981 related = (distance != -1 || b->ignore_ancestry);
984 /* If there's a source and it's not related to the target, nuke it. */
985 if (s_entry && !related)
987 svn_revnum_t deleted_rev;
989 SVN_ERR(svn_repos_deleted_rev(svn_fs_root_fs(b->t_root), t_path,
990 s_rev, b->t_rev, &deleted_rev,
993 if (!SVN_IS_VALID_REVNUM(deleted_rev))
995 /* Two possibilities: either the thing doesn't exist in S_REV; or
996 it wasn't deleted between S_REV and B->T_REV. In the first case,
997 I think we should leave DELETED_REV as SVN_INVALID_REVNUM, but
998 in the second, it should be set to B->T_REV-1 for the call to
999 delete_entry() below. */
1000 svn_node_kind_t kind;
1002 SVN_ERR(svn_fs_check_path(&kind, b->t_root, t_path, pool));
1003 if (kind != svn_node_none)
1004 deleted_rev = b->t_rev - 1;
1007 SVN_ERR(b->editor->delete_entry(e_path, deleted_rev, dir_baton,
1012 /* If there's no target, we have nothing more to do. */
1014 return svn_error_trace(skip_path_info(b, e_path));
1016 /* Check if the user is authorized to find out about the target. */
1017 SVN_ERR(check_auth(b, &allowed, t_path, pool));
1020 if (t_entry->kind == svn_node_dir)
1021 SVN_ERR(b->editor->absent_directory(e_path, dir_baton, pool));
1023 SVN_ERR(b->editor->absent_file(e_path, dir_baton, pool));
1024 return svn_error_trace(skip_path_info(b, e_path));
1027 if (t_entry->kind == svn_node_dir)
1030 SVN_ERR(b->editor->open_directory(e_path, dir_baton, s_rev, pool,
1033 SVN_ERR(b->editor->add_directory(e_path, dir_baton, NULL,
1034 SVN_INVALID_REVNUM, pool,
1037 SVN_ERR(delta_dirs(b, s_rev, s_path, t_path, new_baton, e_path,
1038 info ? info->start_empty : FALSE,
1039 wc_depth, requested_depth, pool));
1040 return svn_error_trace(b->editor->close_directory(new_baton, pool));
1046 SVN_ERR(b->editor->open_file(e_path, dir_baton, s_rev, pool,
1048 SVN_ERR(delta_files(b, new_baton, s_rev, s_path, t_path,
1049 info ? info->lock_token : NULL, pool));
1053 svn_revnum_t copyfrom_rev = SVN_INVALID_REVNUM;
1054 const char *copyfrom_path = NULL;
1055 SVN_ERR(add_file_smartly(b, e_path, dir_baton, t_path, &new_baton,
1056 ©from_path, ©from_rev, pool));
1057 if (! copyfrom_path)
1058 /* Send txdelta between empty file (s_path@s_rev doesn't
1059 exist) and added file (t_path@t_root). */
1060 SVN_ERR(delta_files(b, new_baton, s_rev, s_path, t_path,
1061 info ? info->lock_token : NULL, pool));
1063 /* Send txdelta between copied file (copyfrom_path@copyfrom_rev)
1064 and added file (tpath@t_root). */
1065 SVN_ERR(delta_files(b, new_baton, copyfrom_rev, copyfrom_path,
1066 t_path, info ? info->lock_token : NULL, pool));
1069 SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5, b->t_root,
1070 t_path, TRUE, pool));
1071 hex_digest = svn_checksum_to_cstring(checksum, pool);
1072 return svn_error_trace(b->editor->close_file(new_baton, hex_digest,
1077 /* A helper macro for when we have to recurse into subdirectories. */
1078 #define DEPTH_BELOW_HERE(depth) ((depth) == svn_depth_immediates) ? \
1079 svn_depth_empty : (depth)
1081 /* Emit edits within directory DIR_BATON (with corresponding path
1082 E_PATH) with the changes from the directory S_REV/S_PATH to the
1083 directory B->t_rev/T_PATH. S_PATH may be NULL if the entry does
1084 not exist in the source.
1086 WC_DEPTH is this path's depth as reported by set_path/link_path.
1087 REQUESTED_DEPTH is derived from the depth set by
1088 svn_repos_begin_report().
1090 When iterating over this directory's entries, the following tables
1091 describe what happens for all possible combinations
1092 of WC_DEPTH/REQUESTED_DEPTH (rows represent WC_DEPTH, columns
1093 represent REQUESTED_DEPTH):
1096 X: ignore this entry (it's either below the requested depth, or
1097 if the requested depth is svn_depth_unknown, below the working
1099 o: handle this entry normally
1100 U: handle the entry as if it were a newly added repository path
1101 (the client is upgrading to a deeper wc and doesn't currently
1102 have this entry, but it should be there after the upgrade, so we
1103 need to send the whole thing, not just deltas)
1106 ______________________________________________________________
1107 | req. depth| unknown | empty | files | immediates | infinity |
1108 |wc. depth | | | | | |
1109 |___________|_________|_______|_______|____________|__________|
1110 |empty | X | X | U | U | U |
1111 |___________|_________|_______|_______|____________|__________|
1112 |files | o | X | o | o | o |
1113 |___________|_________|_______|_______|____________|__________|
1114 |immediates | o | X | o | o | o |
1115 |___________|_________|_______|_______|____________|__________|
1116 |infinity | o | X | o | o | o |
1117 |___________|_________|_______|_______|____________|__________|
1120 ______________________________________________________________
1121 | req. depth| unknown | empty | files | immediates | infinity |
1122 |wc. depth | | | | | |
1123 |___________|_________|_______|_______|____________|__________|
1124 |empty | X | X | X | U | U |
1125 |___________|_________|_______|_______|____________|__________|
1126 |files | X | X | X | U | U |
1127 |___________|_________|_______|_______|____________|__________|
1128 |immediates | o | X | X | o | o |
1129 |___________|_________|_______|_______|____________|__________|
1130 |infinity | o | X | X | o | o |
1131 |___________|_________|_______|_______|____________|__________|
1133 These rules are enforced by the is_depth_upgrade() function and by
1134 various other checks below.
1136 static svn_error_t *
1137 delta_dirs(report_baton_t *b, svn_revnum_t s_rev, const char *s_path,
1138 const char *t_path, void *dir_baton, const char *e_path,
1139 svn_boolean_t start_empty, svn_depth_t wc_depth,
1140 svn_depth_t requested_depth, apr_pool_t *pool)
1142 apr_hash_t *s_entries = NULL, *t_entries;
1143 apr_hash_index_t *hi;
1144 apr_pool_t *subpool = svn_pool_create(pool);
1145 apr_array_header_t *t_ordered_entries = NULL;
1148 /* Compare the property lists. If we're starting empty, pass a NULL
1149 source path so that we add all the properties.
1151 When we support directory locks, we must pass the lock token here. */
1152 SVN_ERR(delta_proplists(b, s_rev, start_empty ? NULL : s_path, t_path,
1153 NULL, change_dir_prop, dir_baton, subpool));
1154 svn_pool_clear(subpool);
1156 if (requested_depth > svn_depth_empty
1157 || requested_depth == svn_depth_unknown)
1159 apr_pool_t *iterpool;
1161 /* Get the list of entries in each of source and target. */
1162 if (s_path && !start_empty)
1164 svn_fs_root_t *s_root;
1166 SVN_ERR(get_source_root(b, &s_root, s_rev));
1167 SVN_ERR(svn_fs_dir_entries(&s_entries, s_root, s_path, subpool));
1169 SVN_ERR(svn_fs_dir_entries(&t_entries, b->t_root, t_path, subpool));
1171 /* Iterate over the report information for this directory. */
1172 iterpool = svn_pool_create(subpool);
1177 const char *name, *s_fullpath, *t_fullpath, *e_fullpath;
1178 const svn_fs_dirent_t *s_entry, *t_entry;
1180 svn_pool_clear(iterpool);
1181 SVN_ERR(fetch_path_info(b, &name, &info, e_path, iterpool));
1185 /* Invalid revnum means we should delete, unless this is
1186 just an excluded subpath. */
1188 && !SVN_IS_VALID_REVNUM(info->rev)
1189 && info->depth != svn_depth_exclude)
1191 /* We want to perform deletes before non-replacement adds,
1192 for graceful handling of case-only renames on
1193 case-insensitive client filesystems. So, if the report
1194 item is a delete, remove the entry from the source hash,
1195 but don't update the entry yet. */
1197 svn_hash_sets(s_entries, name, NULL);
1199 svn_pool_destroy(info->pool);
1203 e_fullpath = svn_relpath_join(e_path, name, iterpool);
1204 t_fullpath = svn_fspath__join(t_path, name, iterpool);
1205 t_entry = svn_hash_gets(t_entries, name);
1206 s_fullpath = s_path ? svn_fspath__join(s_path, name, iterpool) : NULL;
1207 s_entry = s_entries ? svn_hash_gets(s_entries, name) : NULL;
1209 /* The only special cases where we don't process the entry are
1211 - When requested_depth is files but the reported path is
1212 a directory. This is technically a client error, but we
1213 handle it anyway, by skipping the entry.
1215 - When the reported depth is svn_depth_exclude.
1217 if (! ((requested_depth == svn_depth_files
1218 && ((t_entry && t_entry->kind == svn_node_dir)
1219 || (s_entry && s_entry->kind == svn_node_dir)))
1220 || (info && info->depth == svn_depth_exclude)))
1221 SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, t_fullpath,
1222 t_entry, dir_baton, e_fullpath, info,
1224 : DEPTH_BELOW_HERE(wc_depth),
1225 DEPTH_BELOW_HERE(requested_depth), iterpool));
1227 /* Don't revisit this name in the target or source entries. */
1228 svn_hash_sets(t_entries, name, NULL);
1230 /* Keep the entry for later process if it is reported as
1231 excluded and got deleted in repos. */
1232 && (! info || info->depth != svn_depth_exclude || t_entry))
1233 svn_hash_sets(s_entries, name, NULL);
1235 /* pathinfo entries live in their own subpools due to lookahead,
1236 so we need to clear each one out as we finish with it. */
1238 svn_pool_destroy(info->pool);
1241 /* Remove any deleted entries. Do this before processing the
1242 target, for graceful handling of case-only renames. */
1245 for (hi = apr_hash_first(subpool, s_entries);
1247 hi = apr_hash_next(hi))
1249 const svn_fs_dirent_t *s_entry = apr_hash_this_val(hi);
1251 svn_pool_clear(iterpool);
1253 if (svn_hash_gets(t_entries, s_entry->name) == NULL)
1255 const char *e_fullpath;
1256 svn_revnum_t deleted_rev;
1258 if (s_entry->kind == svn_node_file
1259 && wc_depth < svn_depth_files)
1262 if (s_entry->kind == svn_node_dir
1263 && (wc_depth < svn_depth_immediates
1264 || requested_depth == svn_depth_files))
1267 /* There is no corresponding target entry, so delete. */
1268 e_fullpath = svn_relpath_join(e_path, s_entry->name, iterpool);
1269 SVN_ERR(svn_repos_deleted_rev(svn_fs_root_fs(b->t_root),
1270 svn_fspath__join(t_path,
1274 &deleted_rev, iterpool));
1276 SVN_ERR(b->editor->delete_entry(e_fullpath,
1278 dir_baton, iterpool));
1283 /* Loop over the dirents in the target. */
1284 SVN_ERR(svn_fs_dir_optimal_order(&t_ordered_entries, b->t_root,
1285 t_entries, subpool, iterpool));
1286 for (i = 0; i < t_ordered_entries->nelts; ++i)
1288 const svn_fs_dirent_t *t_entry
1289 = APR_ARRAY_IDX(t_ordered_entries, i, svn_fs_dirent_t *);
1290 const svn_fs_dirent_t *s_entry;
1291 const char *s_fullpath, *t_fullpath, *e_fullpath;
1293 svn_pool_clear(iterpool);
1295 if (is_depth_upgrade(wc_depth, requested_depth, t_entry->kind))
1297 /* We're making the working copy deeper, pretend the source
1304 if (t_entry->kind == svn_node_file
1305 && requested_depth == svn_depth_unknown
1306 && wc_depth < svn_depth_files)
1309 if (t_entry->kind == svn_node_dir
1310 && (wc_depth < svn_depth_immediates
1311 || requested_depth == svn_depth_files))
1314 /* Look for an entry with the same name in the source dirents. */
1315 s_entry = s_entries ?
1316 svn_hash_gets(s_entries, t_entry->name) : NULL;
1317 s_fullpath = s_entry ?
1318 svn_fspath__join(s_path, t_entry->name, iterpool) : NULL;
1321 /* Compose the report, editor, and target paths for this entry. */
1322 e_fullpath = svn_relpath_join(e_path, t_entry->name, iterpool);
1323 t_fullpath = svn_fspath__join(t_path, t_entry->name, iterpool);
1325 SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, t_fullpath,
1326 t_entry, dir_baton, e_fullpath, NULL,
1327 DEPTH_BELOW_HERE(wc_depth),
1328 DEPTH_BELOW_HERE(requested_depth),
1332 /* iterpool is destroyed by destroying its parent (subpool) below */
1335 svn_pool_destroy(subpool);
1337 return SVN_NO_ERROR;
1340 static svn_error_t *
1341 drive(report_baton_t *b, svn_revnum_t s_rev, path_info_t *info,
1344 const char *t_anchor, *s_fullpath;
1345 svn_boolean_t allowed, info_is_set_path;
1346 svn_fs_root_t *s_root;
1347 const svn_fs_dirent_t *s_entry, *t_entry;
1350 /* Compute the target path corresponding to the working copy anchor,
1351 and check its authorization. */
1352 t_anchor = *b->s_operand ? svn_fspath__dirname(b->t_path, pool) : b->t_path;
1353 SVN_ERR(check_auth(b, &allowed, t_anchor, pool));
1355 return svn_error_create
1356 (SVN_ERR_AUTHZ_ROOT_UNREADABLE, NULL,
1357 _("Not authorized to open root of edit operation"));
1359 /* Collect information about the source and target nodes. */
1360 s_fullpath = svn_fspath__join(b->fs_base, b->s_operand, pool);
1361 SVN_ERR(get_source_root(b, &s_root, s_rev));
1362 SVN_ERR(fake_dirent(&s_entry, s_root, s_fullpath, pool));
1363 SVN_ERR(fake_dirent(&t_entry, b->t_root, b->t_path, pool));
1365 /* If the operand is a locally added file or directory, it won't
1366 exist in the source, so accept that. */
1367 info_is_set_path = (SVN_IS_VALID_REVNUM(info->rev) && !info->link_path);
1368 if (info_is_set_path && !s_entry)
1371 /* Check if the target path exists first. */
1372 if (!*b->s_operand && !(t_entry))
1373 return svn_error_createf(SVN_ERR_FS_PATH_SYNTAX, NULL,
1374 _("Target path '%s' does not exist"),
1377 /* If the anchor is the operand, the source and target must be dirs.
1378 Check this before opening the root to avoid modifying the wc. */
1379 else if (!*b->s_operand && (!s_entry || s_entry->kind != svn_node_dir
1380 || t_entry->kind != svn_node_dir))
1381 return svn_error_create(SVN_ERR_FS_PATH_SYNTAX, NULL,
1382 _("Cannot replace a directory from within"));
1384 SVN_ERR(b->editor->set_target_revision(b->edit_baton, b->t_rev, pool));
1385 SVN_ERR(b->editor->open_root(b->edit_baton, s_rev, pool, &root_baton));
1387 /* If the anchor is the operand, diff the two directories; otherwise
1388 update the operand within the anchor directory. */
1390 SVN_ERR(delta_dirs(b, s_rev, s_fullpath, b->t_path, root_baton,
1391 "", info->start_empty, info->depth, b->requested_depth,
1394 SVN_ERR(update_entry(b, s_rev, s_fullpath, s_entry, b->t_path,
1395 t_entry, root_baton, b->s_operand, info,
1396 info->depth, b->requested_depth, pool));
1398 return svn_error_trace(b->editor->close_directory(root_baton, pool));
1401 /* Initialize the baton fields for editor-driving, and drive the editor. */
1402 static svn_error_t *
1403 finish_report(report_baton_t *b, apr_pool_t *pool)
1406 apr_pool_t *subpool;
1410 /* Save our pool to manage the lookahead and fs_root cache with. */
1413 /* Add the end marker. */
1414 SVN_ERR(svn_spillbuf__reader_write(b->reader, "-", 1, pool));
1416 /* Read the first pathinfo from the report and verify that it is a top-level
1418 SVN_ERR(read_path_info(&info, b->reader, pool));
1419 if (!info || strcmp(info->path, b->s_operand) != 0
1420 || info->link_path || !SVN_IS_VALID_REVNUM(info->rev))
1421 return svn_error_create(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL,
1422 _("Invalid report for top level of working copy"));
1425 /* Initialize the lookahead pathinfo. */
1426 subpool = svn_pool_create(pool);
1427 SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool));
1429 if (b->lookahead && strcmp(b->lookahead->path, b->s_operand) == 0)
1431 /* If the operand of the wc operation is switched or deleted,
1432 then info above is just a place-holder, and the only thing we
1433 have to do is pass the revision it contains to open_root.
1434 The next pathinfo actually describes the target. */
1436 return svn_error_create(SVN_ERR_REPOS_BAD_REVISION_REPORT, NULL,
1437 _("Two top-level reports with no target"));
1438 /* If the client issued a set-path followed by a delete-path, we need
1439 to respect the depth set by the initial set-path. */
1440 if (! SVN_IS_VALID_REVNUM(b->lookahead->rev))
1442 b->lookahead->depth = info->depth;
1444 info = b->lookahead;
1445 SVN_ERR(read_path_info(&b->lookahead, b->reader, subpool));
1448 /* Open the target root and initialize the source root cache. */
1449 SVN_ERR(svn_fs_revision_root(&b->t_root, b->repos->fs, b->t_rev, pool));
1450 for (i = 0; i < NUM_CACHED_SOURCE_ROOTS; i++)
1451 b->s_roots[i] = NULL;
1454 svn_error_t *err = svn_error_trace(drive(b, s_rev, info, pool));
1456 if (err == SVN_NO_ERROR)
1457 return svn_error_trace(b->editor->close_edit(b->edit_baton, pool));
1459 return svn_error_trace(
1460 svn_error_compose_create(err,
1461 b->editor->abort_edit(b->edit_baton,
1466 /* --- COLLECTING THE REPORT INFORMATION --- */
1468 /* Record a report operation into the spill buffer. Return an error
1469 if DEPTH is svn_depth_unknown. */
1470 static svn_error_t *
1471 write_path_info(report_baton_t *b, const char *path, const char *lpath,
1472 svn_revnum_t rev, svn_depth_t depth,
1473 svn_boolean_t start_empty,
1474 const char *lock_token, apr_pool_t *pool)
1476 const char *lrep, *rrep, *drep, *ltrep, *rep;
1478 /* Munge the path to be anchor-relative, so that we can use edit paths
1480 path = svn_relpath_join(b->s_operand, path, pool);
1482 lrep = lpath ? apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s",
1483 strlen(lpath), lpath) : "-";
1484 rrep = (SVN_IS_VALID_REVNUM(rev)) ?
1485 apr_psprintf(pool, "+%ld:", rev) : "-";
1487 if (depth == svn_depth_exclude)
1489 else if (depth == svn_depth_empty)
1491 else if (depth == svn_depth_files)
1493 else if (depth == svn_depth_immediates)
1495 else if (depth == svn_depth_infinity)
1498 return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
1499 _("Unsupported report depth '%s'"),
1500 svn_depth_to_word(depth));
1502 ltrep = lock_token ? apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s",
1503 strlen(lock_token), lock_token) : "-";
1504 rep = apr_psprintf(pool, "+%" APR_SIZE_T_FMT ":%s%s%s%s%c%s",
1505 strlen(path), path, lrep, rrep, drep,
1506 start_empty ? '+' : '-', ltrep);
1507 return svn_error_trace(
1508 svn_spillbuf__reader_write(b->reader, rep, strlen(rep), pool));
1512 svn_repos_set_path3(void *baton, const char *path, svn_revnum_t rev,
1513 svn_depth_t depth, svn_boolean_t start_empty,
1514 const char *lock_token, apr_pool_t *pool)
1516 return svn_error_trace(
1517 write_path_info(baton, path, NULL, rev, depth, start_empty,
1522 svn_repos_link_path3(void *baton, const char *path, const char *link_path,
1523 svn_revnum_t rev, svn_depth_t depth,
1524 svn_boolean_t start_empty,
1525 const char *lock_token, apr_pool_t *pool)
1527 if (depth == svn_depth_exclude)
1528 return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL,
1529 _("Depth 'exclude' not supported for link"));
1531 return svn_error_trace(
1532 write_path_info(baton, path, link_path, rev, depth,
1533 start_empty, lock_token, pool));
1537 svn_repos_delete_path(void *baton, const char *path, apr_pool_t *pool)
1539 /* We pass svn_depth_infinity because deletion of a path always
1540 deletes everything underneath it. */
1541 return svn_error_trace(
1542 write_path_info(baton, path, NULL, SVN_INVALID_REVNUM,
1543 svn_depth_infinity, FALSE, NULL, pool));
1547 svn_repos_finish_report(void *baton, apr_pool_t *pool)
1549 report_baton_t *b = baton;
1551 return svn_error_trace(finish_report(b, pool));
1555 svn_repos_abort_report(void *baton, apr_pool_t *pool)
1557 return SVN_NO_ERROR;
1560 /* --- BEGINNING THE REPORT --- */
1564 svn_repos_begin_report3(void **report_baton,
1565 svn_revnum_t revnum,
1567 const char *fs_base,
1568 const char *s_operand,
1569 const char *switch_path,
1570 svn_boolean_t text_deltas,
1572 svn_boolean_t ignore_ancestry,
1573 svn_boolean_t send_copyfrom_args,
1574 const svn_delta_editor_t *editor,
1576 svn_repos_authz_func_t authz_read_func,
1577 void *authz_read_baton,
1578 apr_size_t zero_copy_limit,
1584 if (depth == svn_depth_exclude)
1585 return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL,
1586 _("Request depth 'exclude' not supported"));
1588 SVN_ERR(svn_fs_get_uuid(repos->fs, &uuid, pool));
1590 /* Build a reporter baton. Copy strings in case the caller doesn't
1591 keep track of them. */
1592 b = apr_palloc(pool, sizeof(*b));
1594 b->fs_base = svn_fspath__canonicalize(fs_base, pool);
1595 b->s_operand = apr_pstrdup(pool, s_operand);
1597 b->t_path = switch_path ? svn_fspath__canonicalize(switch_path, pool)
1598 : svn_fspath__join(b->fs_base, s_operand, pool);
1599 b->text_deltas = text_deltas;
1600 b->zero_copy_limit = zero_copy_limit;
1601 b->requested_depth = depth;
1602 b->ignore_ancestry = ignore_ancestry;
1603 b->send_copyfrom_args = send_copyfrom_args;
1604 b->is_switch = (switch_path != NULL);
1606 b->edit_baton = edit_baton;
1607 b->authz_read_func = authz_read_func;
1608 b->authz_read_baton = authz_read_baton;
1609 b->revision_infos = apr_hash_make(pool);
1611 b->reader = svn_spillbuf__reader_create(1000 /* blocksize */,
1612 1000000 /* maxsize */,
1614 b->repos_uuid = svn_string_create(uuid, pool);
1616 /* Hand reporter back to client. */
1618 return SVN_NO_ERROR;