2 * log.c: return log messages
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 #define APR_WANT_STRFUNC
27 #include <apr_strings.h>
28 #include <apr_pools.h>
30 #include "svn_pools.h"
31 #include "svn_client.h"
32 #include "svn_compat.h"
33 #include "svn_error.h"
34 #include "svn_dirent_uri.h"
37 #include "svn_sorts.h"
38 #include "svn_props.h"
42 #include "svn_private_config.h"
43 #include "private/svn_wc_private.h"
47 /*** Getting misc. information ***/
49 /* The baton for use with copyfrom_info_receiver(). */
50 typedef struct copyfrom_info_t
52 svn_boolean_t is_first;
58 /* A location segment callback for obtaining the copy source of
59 a node at a path and storing it in *BATON (a struct copyfrom_info_t *).
60 Implements svn_location_segment_receiver_t. */
62 copyfrom_info_receiver(svn_location_segment_t *segment,
66 copyfrom_info_t *copyfrom_info = baton;
68 /* If we've already identified the copy source, there's nothing more
70 ### FIXME: We *should* be able to send */
71 if (copyfrom_info->path)
74 /* If this is the first segment, it's not of interest to us. Otherwise
75 (so long as this segment doesn't represent a history gap), it holds
76 our path's previous location (from which it was last copied). */
77 if (copyfrom_info->is_first)
79 copyfrom_info->is_first = FALSE;
81 else if (segment->path)
83 /* The end of the second non-gap segment is the location copied from. */
84 copyfrom_info->path = apr_pstrdup(copyfrom_info->pool, segment->path);
85 copyfrom_info->rev = segment->range_end;
87 /* ### FIXME: We *should* be able to return SVN_ERR_CEASE_INVOCATION
88 ### here so we don't get called anymore. */
95 svn_client__get_copy_source(const char **original_repos_relpath,
96 svn_revnum_t *original_revision,
97 const char *path_or_url,
98 const svn_opt_revision_t *revision,
99 svn_ra_session_t *ra_session,
100 svn_client_ctx_t *ctx,
101 apr_pool_t *result_pool,
102 apr_pool_t *scratch_pool)
105 copyfrom_info_t copyfrom_info = { 0 };
106 apr_pool_t *sesspool = svn_pool_create(scratch_pool);
107 svn_client__pathrev_t *at_loc;
108 const char *old_session_url = NULL;
110 copyfrom_info.is_first = TRUE;
111 copyfrom_info.path = NULL;
112 copyfrom_info.rev = SVN_INVALID_REVNUM;
113 copyfrom_info.pool = result_pool;
117 SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &at_loc,
125 if (svn_path_is_url(path_or_url))
129 SVN_ERR(svn_client_url_from_path2(&url, path_or_url, ctx, sesspool,
133 return svn_error_createf(SVN_ERR_ENTRY_MISSING_URL, NULL,
134 _("'%s' has no URL"), path_or_url);
137 SVN_ERR(svn_client__ensure_ra_session_url(&old_session_url, ra_session,
140 err = svn_client__resolve_rev_and_url(&at_loc, ra_session, path_or_url,
141 revision, revision, ctx,
144 /* On error reparent back (and return), otherwise reparent to new
146 SVN_ERR(svn_error_compose_create(
148 svn_ra_reparent(ra_session, err ? old_session_url
149 : at_loc->url, sesspool)));
152 /* Find the copy source. Walk the location segments to find the revision
153 at which this node was created (copied or added). */
155 err = svn_ra_get_location_segments(ra_session, "", at_loc->rev, at_loc->rev,
157 copyfrom_info_receiver, ©from_info,
161 err = svn_error_compose_create(
163 svn_ra_reparent(ra_session, old_session_url, sesspool));
165 svn_pool_destroy(sesspool);
169 if (err->apr_err == SVN_ERR_FS_NOT_FOUND ||
170 err->apr_err == SVN_ERR_RA_DAV_REQUEST_FAILED)
172 /* A locally-added but uncommitted versioned resource won't
173 exist in the repository. */
174 svn_error_clear(err);
177 *original_repos_relpath = NULL;
178 *original_revision = SVN_INVALID_REVNUM;
180 return svn_error_trace(err);
183 *original_repos_relpath = copyfrom_info.path;
184 *original_revision = copyfrom_info.rev;
189 /* compatibility with pre-1.5 servers, which send only author/date/log
190 *revprops in log entries */
191 typedef struct pre_15_receiver_baton_t
193 svn_client_ctx_t *ctx;
194 /* ra session for retrieving revprops from old servers */
195 svn_ra_session_t *ra_session;
196 /* caller's list of requested revprops, receiver, and baton */
197 const char *ra_session_url;
198 apr_pool_t *ra_session_pool;
199 const apr_array_header_t *revprops;
200 svn_log_entry_receiver_t receiver;
202 } pre_15_receiver_baton_t;
205 pre_15_receiver(void *baton, svn_log_entry_t *log_entry, apr_pool_t *pool)
207 pre_15_receiver_baton_t *rb = baton;
209 if (log_entry->revision == SVN_INVALID_REVNUM)
210 return rb->receiver(rb->baton, log_entry, pool);
212 /* If only some revprops are requested, get them one at a time on the
213 second ra connection. If all are requested, get them all with
214 svn_ra_rev_proplist. This avoids getting unrequested revprops (which
215 may be arbitrarily large), but means one round-trip per requested
216 revprop. epg isn't entirely sure which should be optimized for. */
220 svn_boolean_t want_author, want_date, want_log;
221 want_author = want_date = want_log = FALSE;
222 for (i = 0; i < rb->revprops->nelts; i++)
224 const char *name = APR_ARRAY_IDX(rb->revprops, i, const char *);
227 /* If a standard revprop is requested, we know it is already in
228 log_entry->revprops if available. */
229 if (strcmp(name, SVN_PROP_REVISION_AUTHOR) == 0)
234 if (strcmp(name, SVN_PROP_REVISION_DATE) == 0)
239 if (strcmp(name, SVN_PROP_REVISION_LOG) == 0)
245 if (rb->ra_session == NULL)
246 SVN_ERR(svn_client_open_ra_session2(&rb->ra_session,
247 rb->ra_session_url, NULL,
248 rb->ctx, rb->ra_session_pool,
251 SVN_ERR(svn_ra_rev_prop(rb->ra_session, log_entry->revision,
252 name, &value, pool));
253 if (log_entry->revprops == NULL)
254 log_entry->revprops = apr_hash_make(pool);
255 svn_hash_sets(log_entry->revprops, name, value);
257 if (log_entry->revprops)
259 /* Pre-1.5 servers send the standard revprops unconditionally;
260 clear those the caller doesn't want. */
262 svn_hash_sets(log_entry->revprops, SVN_PROP_REVISION_AUTHOR, NULL);
264 svn_hash_sets(log_entry->revprops, SVN_PROP_REVISION_DATE, NULL);
266 svn_hash_sets(log_entry->revprops, SVN_PROP_REVISION_LOG, NULL);
271 if (rb->ra_session == NULL)
272 SVN_ERR(svn_client_open_ra_session2(&rb->ra_session,
273 rb->ra_session_url, NULL,
274 rb->ctx, rb->ra_session_pool,
277 SVN_ERR(svn_ra_rev_proplist(rb->ra_session, log_entry->revision,
278 &log_entry->revprops, pool));
281 return rb->receiver(rb->baton, log_entry, pool);
285 typedef struct limit_receiver_baton_t
288 svn_log_entry_receiver_t receiver;
290 } limit_receiver_baton_t;
293 limit_receiver(void *baton, svn_log_entry_t *log_entry, apr_pool_t *pool)
295 limit_receiver_baton_t *rb = baton;
299 return rb->receiver(rb->baton, log_entry, pool);
302 /* Resolve the URLs or WC path in TARGETS as per the svn_client_log5 API.
304 The limitations on TARGETS specified by svn_client_log5 are enforced here.
305 So TARGETS can only contain a single WC path or a URL and zero or more
306 relative paths -- anything else will raise an error.
308 PEG_REVISION, TARGETS, and CTX are as per svn_client_log5.
310 If TARGETS contains a single WC path then set *RA_TARGET to the absolute
311 path of that single path if PEG_REVISION is dependent on the working copy
312 (e.g. PREV). Otherwise set *RA_TARGET to the corresponding URL for the
313 single WC path. Set *RELATIVE_TARGETS to an array with a single
316 If TARGETS contains only a single URL, then set *RA_TARGET to a copy of
317 that URL and *RELATIVE_TARGETS to an array with a single element "".
319 If TARGETS contains a single URL and one or more relative paths, then
320 set *RA_TARGET to a copy of that URL and *RELATIVE_TARGETS to a copy of
321 each relative path after the URL.
323 If *PEG_REVISION is svn_opt_revision_unspecified, then *PEG_REVISION is
324 set to svn_opt_revision_head for URLs or svn_opt_revision_working for a
327 *RA_TARGET and *RELATIVE_TARGETS are allocated in RESULT_POOL. */
329 resolve_log_targets(apr_array_header_t **relative_targets,
330 const char **ra_target,
331 svn_opt_revision_t *peg_revision,
332 const apr_array_header_t *targets,
333 svn_client_ctx_t *ctx,
334 apr_pool_t *result_pool,
335 apr_pool_t *scratch_pool)
338 svn_boolean_t url_targets;
340 /* Per svn_client_log5, TARGETS contains either a URL followed by zero or
341 more relative paths, or one working copy path. */
342 const char *url_or_path = APR_ARRAY_IDX(targets, 0, const char *);
344 /* svn_client_log5 requires at least one target. */
345 if (targets->nelts == 0)
346 return svn_error_create(SVN_ERR_ILLEGAL_TARGET, NULL,
347 _("No valid target found"));
349 /* Initialize the output array. At a minimum, we need room for one
350 (possibly empty) relpath. Otherwise, we have to hold a relpath
351 for every item in TARGETS except the first. */
352 *relative_targets = apr_array_make(result_pool,
353 MAX(1, targets->nelts - 1),
354 sizeof(const char *));
356 if (svn_path_is_url(url_or_path))
358 /* An unspecified PEG_REVISION for a URL path defaults
359 to svn_opt_revision_head. */
360 if (peg_revision->kind == svn_opt_revision_unspecified)
361 peg_revision->kind = svn_opt_revision_head;
363 /* The logic here is this: If we get passed one argument, we assume
364 it is the full URL to a file/dir we want log info for. If we get
365 a URL plus some paths, then we assume that the URL is the base,
366 and that the paths passed are relative to it. */
367 if (targets->nelts > 1)
369 /* We have some paths, let's use them. Start after the URL. */
370 for (i = 1; i < targets->nelts; i++)
374 target = APR_ARRAY_IDX(targets, i, const char *);
376 if (svn_path_is_url(target) || svn_dirent_is_absolute(target))
377 return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
378 _("'%s' is not a relative path"),
381 APR_ARRAY_PUSH(*relative_targets, const char *) =
382 apr_pstrdup(result_pool, target);
387 /* If we have a single URL, then the session will be rooted at
388 it, so just send an empty string for the paths we are
390 APR_ARRAY_PUSH(*relative_targets, const char *) = "";
393 /* Remember that our targets are URLs. */
396 else /* WC path target. */
399 const char *target_abspath;
402 if (targets->nelts > 1)
403 return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
404 _("When specifying working copy paths, only "
405 "one target may be given"));
407 /* An unspecified PEG_REVISION for a working copy path defaults
408 to svn_opt_revision_working. */
409 if (peg_revision->kind == svn_opt_revision_unspecified)
410 peg_revision->kind = svn_opt_revision_working;
412 /* Get URLs for each target */
413 target = APR_ARRAY_IDX(targets, 0, const char *);
415 SVN_ERR(svn_dirent_get_absolute(&target_abspath, target, scratch_pool));
416 SVN_ERR(svn_wc__node_get_url(&url_or_path, ctx->wc_ctx, target_abspath,
417 scratch_pool, scratch_pool));
418 APR_ARRAY_PUSH(*relative_targets, const char *) = "";
421 /* If this is a revision type that requires access to the working copy,
422 * we use our initial target path to figure out where to root the RA
423 * session, otherwise we use our URL. */
424 if (SVN_CLIENT__REVKIND_NEEDS_WC(peg_revision->kind))
427 return svn_error_create(SVN_ERR_CLIENT_BAD_REVISION, NULL,
428 _("PREV, BASE, or COMMITTED revision "
429 "keywords are invalid for URL"));
432 SVN_ERR(svn_dirent_get_absolute(
433 ra_target, APR_ARRAY_IDX(targets, 0, const char *), result_pool));
437 *ra_target = apr_pstrdup(result_pool, url_or_path);
443 /* Keep track of oldest and youngest opt revs found.
445 If REV is younger than *YOUNGEST_REV, or *YOUNGEST_REV is
446 svn_opt_revision_unspecified, then set *YOUNGEST_REV equal to REV.
448 If REV is older than *OLDEST_REV, or *OLDEST_REV is
449 svn_opt_revision_unspecified, then set *OLDEST_REV equal to REV. */
451 find_youngest_and_oldest_revs(svn_revnum_t *youngest_rev,
452 svn_revnum_t *oldest_rev,
455 /* Is REV younger than YOUNGEST_REV? */
456 if (! SVN_IS_VALID_REVNUM(*youngest_rev)
457 || rev > *youngest_rev)
460 if (! SVN_IS_VALID_REVNUM(*oldest_rev)
461 || rev < *oldest_rev)
465 typedef struct rev_range_t
467 svn_revnum_t range_start;
468 svn_revnum_t range_end;
471 /* Convert array of svn_opt_revision_t ranges to an array of svn_revnum_t
474 Given a log target URL_OR_ABSPATH@PEG_REV and an array of
475 svn_opt_revision_range_t's OPT_REV_RANGES, resolve the opt revs in
476 OPT_REV_RANGES to svn_revnum_t's and return these in *REVISION_RANGES, an
477 array of rev_range_t *.
479 Set *YOUNGEST_REV and *OLDEST_REV to the youngest and oldest revisions
480 found in *REVISION_RANGES.
482 If the repository needs to be contacted to resolve svn_opt_revision_date or
483 svn_opt_revision_head revisions, then the session used to do this is
484 RA_SESSION; it must be an open session to any URL in the right repository.
487 convert_opt_rev_array_to_rev_range_array(
488 apr_array_header_t **revision_ranges,
489 svn_revnum_t *youngest_rev,
490 svn_revnum_t *oldest_rev,
491 svn_ra_session_t *ra_session,
492 const char *url_or_abspath,
493 const apr_array_header_t *opt_rev_ranges,
494 const svn_opt_revision_t *peg_rev,
495 svn_client_ctx_t *ctx,
496 apr_pool_t *result_pool,
497 apr_pool_t *scratch_pool)
500 svn_revnum_t head_rev = SVN_INVALID_REVNUM;
502 /* Initialize the input/output parameters. */
503 *youngest_rev = *oldest_rev = SVN_INVALID_REVNUM;
505 /* Convert OPT_REV_RANGES to an array of rev_range_t and find the youngest
506 and oldest revision range that spans all of OPT_REV_RANGES. */
507 *revision_ranges = apr_array_make(result_pool, opt_rev_ranges->nelts,
508 sizeof(rev_range_t *));
510 for (i = 0; i < opt_rev_ranges->nelts; i++)
512 svn_opt_revision_range_t *range;
513 rev_range_t *rev_range;
514 svn_boolean_t start_same_as_end = FALSE;
516 range = APR_ARRAY_IDX(opt_rev_ranges, i, svn_opt_revision_range_t *);
518 /* Right now RANGE can be any valid pair of svn_opt_revision_t's. We
519 will now convert all RANGEs in place to the corresponding
520 svn_opt_revision_number kind. */
521 if ((range->start.kind != svn_opt_revision_unspecified)
522 && (range->end.kind == svn_opt_revision_unspecified))
524 /* If the user specified exactly one revision, then start rev is
525 * set but end is not. We show the log message for just that
526 * revision by making end equal to start.
528 * Note that if the user requested a single dated revision, then
529 * this will cause the same date to be resolved twice. The
530 * extra code complexity to get around this slight inefficiency
531 * doesn't seem worth it, however. */
532 range->end = range->start;
534 else if (range->start.kind == svn_opt_revision_unspecified)
536 /* Default to any specified peg revision. Otherwise, if the
537 * first target is a URL, then we default to HEAD:0. Lastly,
538 * the default is BASE:0 since WC@HEAD may not exist. */
539 if (peg_rev->kind == svn_opt_revision_unspecified)
541 if (svn_path_is_url(url_or_abspath))
542 range->start.kind = svn_opt_revision_head;
544 range->start.kind = svn_opt_revision_base;
547 range->start = *peg_rev;
549 if (range->end.kind == svn_opt_revision_unspecified)
551 range->end.kind = svn_opt_revision_number;
552 range->end.value.number = 0;
556 if ((range->start.kind == svn_opt_revision_unspecified)
557 || (range->end.kind == svn_opt_revision_unspecified))
559 return svn_error_create
560 (SVN_ERR_CLIENT_BAD_REVISION, NULL,
561 _("Missing required revision specification"));
564 /* Does RANGE describe a single svn_opt_revision_t? */
565 if (range->start.kind == range->end.kind)
567 if (range->start.kind == svn_opt_revision_number)
569 if (range->start.value.number == range->end.value.number)
570 start_same_as_end = TRUE;
572 else if (range->start.kind == svn_opt_revision_date)
574 if (range->start.value.date == range->end.value.date)
575 start_same_as_end = TRUE;
579 start_same_as_end = TRUE;
583 rev_range = apr_palloc(result_pool, sizeof(*rev_range));
584 SVN_ERR(svn_client__get_revision_number(
585 &rev_range->range_start, &head_rev,
586 ctx->wc_ctx, url_or_abspath, ra_session,
587 &range->start, scratch_pool));
588 if (start_same_as_end)
589 rev_range->range_end = rev_range->range_start;
591 SVN_ERR(svn_client__get_revision_number(
592 &rev_range->range_end, &head_rev,
593 ctx->wc_ctx, url_or_abspath, ra_session,
594 &range->end, scratch_pool));
596 /* Possibly update the oldest and youngest revisions requested. */
597 find_youngest_and_oldest_revs(youngest_rev,
599 rev_range->range_start);
600 find_youngest_and_oldest_revs(youngest_rev,
602 rev_range->range_end);
603 APR_ARRAY_PUSH(*revision_ranges, rev_range_t *) = rev_range;
610 compare_rev_to_segment(const void *key_p,
611 const void *element_p)
614 * (svn_revnum_t *)key_p;
615 const svn_location_segment_t *segment =
616 *((const svn_location_segment_t * const *) element_p);
618 if (rev < segment->range_start)
620 else if (rev > segment->range_end)
626 /* Run svn_ra_get_log2 for PATHS, one or more paths relative to RA_SESSION's
627 common parent, for each revision in REVISION_RANGES, an array of
630 RA_SESSION is an open session pointing to ACTUAL_LOC.
632 LOG_SEGMENTS is an array of svn_location_segment_t * items representing the
633 history of PATHS from the oldest to youngest revisions found in
636 The TARGETS, LIMIT, DISCOVER_CHANGED_PATHS, STRICT_NODE_HISTORY,
637 INCLUDE_MERGED_REVISIONS, REVPROPS, REAL_RECEIVER, and REAL_RECEIVER_BATON
638 parameters are all as per the svn_client_log5 API. */
640 run_ra_get_log(apr_array_header_t *revision_ranges,
641 apr_array_header_t *paths,
642 apr_array_header_t *log_segments,
643 svn_client__pathrev_t *actual_loc,
644 svn_ra_session_t *ra_session,
645 /* The following are as per svn_client_log5. */
646 const apr_array_header_t *targets,
648 svn_boolean_t discover_changed_paths,
649 svn_boolean_t strict_node_history,
650 svn_boolean_t include_merged_revisions,
651 const apr_array_header_t *revprops,
652 svn_log_entry_receiver_t real_receiver,
653 void *real_receiver_baton,
654 svn_client_ctx_t *ctx,
655 apr_pool_t *scratch_pool)
658 pre_15_receiver_baton_t rb = {0};
659 apr_pool_t *iterpool;
660 svn_boolean_t has_log_revprops;
662 SVN_ERR(svn_ra_has_capability(ra_session, &has_log_revprops,
663 SVN_RA_CAPABILITY_LOG_REVPROPS,
666 if (!has_log_revprops)
668 /* See above pre-1.5 notes. */
671 /* Create ra session on first use */
672 rb.ra_session_pool = scratch_pool;
673 rb.ra_session_url = actual_loc->url;
676 /* It's a bit complex to correctly handle the special revision words
677 * such as "BASE", "COMMITTED", and "PREV". For example, if the
680 * $ svn log -rCOMMITTED foo.txt bar.c
682 * which committed rev should be used? The younger of the two? The
683 * first one? Should we just error?
685 * None of the above, I think. Rather, the committed rev of each
686 * target in turn should be used. This is what most users would
687 * expect, and is the most useful interpretation. Of course, this
688 * goes for the other dynamic (i.e., local) revision words too.
690 * Note that the code to do this is a bit more complex than a simple
691 * loop, because the user might run
693 * $ svn log -rCOMMITTED:42 foo.txt bar.c
695 * in which case we want to avoid recomputing the static revision on
698 * ### FIXME: However, we can't yet handle multiple wc targets anyway.
700 * We used to iterate over each target in turn, getting the logs for
701 * the named range. This led to revisions being printed in strange
702 * order or being printed more than once. This is issue 1550.
704 * In r851673, jpieper blocked multiple wc targets in svn/log-cmd.c,
705 * meaning this block not only doesn't work right in that case, but isn't
706 * even testable that way (svn has no unit test suite; we can only test
707 * via the svn command). So, that check is now moved into this function
710 * kfogel ponders future enhancements in r844260:
711 * I think that's okay behavior, since the sense of the command is
712 * that one wants a particular range of logs for *this* file, then
713 * another range for *that* file, and so on. But we should
714 * probably put some sort of separator header between the log
715 * groups. Of course, libsvn_client can't just print stuff out --
716 * it has to take a callback from the client to do that. So we
717 * need to define that callback interface, then have the command
718 * line client pass one down here.
720 * epg wonders if the repository could send a unified stream of log
721 * entries if the paths and revisions were passed down.
723 iterpool = svn_pool_create(scratch_pool);
724 for (i = 0; i < revision_ranges->nelts; i++)
726 const char *old_session_url;
727 const char *path = APR_ARRAY_IDX(targets, 0, const char *);
728 const char *local_abspath_or_url;
730 limit_receiver_baton_t lb;
731 svn_log_entry_receiver_t passed_receiver;
732 void *passed_receiver_baton;
733 const apr_array_header_t *passed_receiver_revprops;
734 svn_location_segment_t **matching_segment;
735 svn_revnum_t younger_rev;
737 svn_pool_clear(iterpool);
739 if (!svn_path_is_url(path))
740 SVN_ERR(svn_dirent_get_absolute(&local_abspath_or_url, path,
743 local_abspath_or_url = path;
745 range = APR_ARRAY_IDX(revision_ranges, i, rev_range_t *);
747 /* Issue #4355: Account for renames spanning requested
749 younger_rev = MAX(range->range_start, range->range_end);
750 matching_segment = bsearch(&younger_rev, log_segments->elts,
751 log_segments->nelts, log_segments->elt_size,
752 compare_rev_to_segment);
753 /* LOG_SEGMENTS is supposed to represent the history of PATHS from
754 the oldest to youngest revs in REVISION_RANGES. This function's
755 current sole caller svn_client_log5 *should* be providing
756 LOG_SEGMENTS that span the oldest to youngest revs in
757 REVISION_RANGES, even if one or more of the svn_location_segment_t's
758 returned have NULL path members indicating a gap in the history. So
759 MATCHING_SEGMENT should never be NULL, but clearly sometimes it is,
760 see http://svn.haxx.se/dev/archive-2013-06/0522.shtml
761 So to be safe we handle that case. */
762 if (matching_segment == NULL)
765 /* A segment with a NULL path means there is gap in the history.
766 We'll just proceed and let svn_ra_get_log2 fail with a useful
768 if ((*matching_segment)->path != NULL)
770 /* ...but if there is history, then we must account for issue
771 #4355 and make sure our RA session is pointing at the correct
773 const char *segment_url = svn_path_url_add_component2(
774 actual_loc->repos_root_url, (*matching_segment)->path,
776 SVN_ERR(svn_client__ensure_ra_session_url(&old_session_url,
782 if (has_log_revprops)
784 passed_receiver = real_receiver;
785 passed_receiver_baton = real_receiver_baton;
786 passed_receiver_revprops = revprops;
790 rb.revprops = revprops;
791 rb.receiver = real_receiver;
792 rb.baton = real_receiver_baton;
794 passed_receiver = pre_15_receiver;
795 passed_receiver_baton = &rb;
796 passed_receiver_revprops = svn_compat_log_revprops_in(iterpool);
799 if (limit && revision_ranges->nelts > 1)
802 lb.receiver = passed_receiver;
803 lb.baton = passed_receiver_baton;
805 passed_receiver = limit_receiver;
806 passed_receiver_baton = &lb;
809 SVN_ERR(svn_ra_get_log2(ra_session,
814 discover_changed_paths,
816 include_merged_revisions,
817 passed_receiver_revprops,
819 passed_receiver_baton,
822 if (limit && revision_ranges->nelts > 1)
831 svn_pool_destroy(iterpool);
836 /*** Public Interface. ***/
839 svn_client_log5(const apr_array_header_t *targets,
840 const svn_opt_revision_t *peg_revision,
841 const apr_array_header_t *opt_rev_ranges,
843 svn_boolean_t discover_changed_paths,
844 svn_boolean_t strict_node_history,
845 svn_boolean_t include_merged_revisions,
846 const apr_array_header_t *revprops,
847 svn_log_entry_receiver_t real_receiver,
848 void *real_receiver_baton,
849 svn_client_ctx_t *ctx,
852 svn_ra_session_t *ra_session;
853 const char *old_session_url;
854 const char *ra_target;
855 const char *path_or_url;
856 svn_opt_revision_t youngest_opt_rev;
857 svn_revnum_t youngest_rev;
858 svn_revnum_t oldest_rev;
859 svn_opt_revision_t peg_rev;
860 svn_client__pathrev_t *ra_session_loc;
861 svn_client__pathrev_t *actual_loc;
862 apr_array_header_t *log_segments;
863 apr_array_header_t *revision_ranges;
864 apr_array_header_t *relative_targets;
866 if (opt_rev_ranges->nelts == 0)
868 return svn_error_create
869 (SVN_ERR_CLIENT_BAD_REVISION, NULL,
870 _("Missing required revision specification"));
873 /* Make a copy of PEG_REVISION, we may need to change it to a
875 peg_rev = *peg_revision;
877 SVN_ERR(resolve_log_targets(&relative_targets, &ra_target, &peg_rev,
878 targets, ctx, pool, pool));
880 SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &ra_session_loc,
881 ra_target, NULL, &peg_rev, &peg_rev,
884 /* Convert OPT_REV_RANGES to an array of rev_range_t and find the youngest
885 and oldest revision range that spans all of OPT_REV_RANGES. */
886 SVN_ERR(convert_opt_rev_array_to_rev_range_array(&revision_ranges,
891 opt_rev_ranges, &peg_rev,
894 /* For some peg revisions we must resolve revision and url via a local path
895 so use the original RA_TARGET. For others, use the potentially corrected
896 (redirected) ra session URL. */
897 if (peg_rev.kind == svn_opt_revision_previous ||
898 peg_rev.kind == svn_opt_revision_base ||
899 peg_rev.kind == svn_opt_revision_committed ||
900 peg_rev.kind == svn_opt_revision_working)
901 path_or_url = ra_target;
903 path_or_url = ra_session_loc->url;
905 /* Make ACTUAL_LOC and RA_SESSION point to the youngest operative rev. */
906 youngest_opt_rev.kind = svn_opt_revision_number;
907 youngest_opt_rev.value.number = youngest_rev;
908 SVN_ERR(svn_client__resolve_rev_and_url(&actual_loc, ra_session,
909 path_or_url, &peg_rev,
910 &youngest_opt_rev, ctx, pool));
911 SVN_ERR(svn_client__ensure_ra_session_url(&old_session_url, ra_session,
912 actual_loc->url, pool));
914 /* Save us an RA layer round trip if we are on the repository root and
915 know the result in advance, or if we don't need multiple ranges.
916 All the revision data has already been validated.
918 if (strcmp(actual_loc->url, actual_loc->repos_root_url) == 0
919 || opt_rev_ranges->nelts <= 1)
921 svn_location_segment_t *segment = apr_pcalloc(pool, sizeof(*segment));
922 log_segments = apr_array_make(pool, 1, sizeof(segment));
924 segment->range_start = oldest_rev;
925 segment->range_end = actual_loc->rev;
926 segment->path = svn_uri_skip_ancestor(actual_loc->repos_root_url,
927 actual_loc->url, pool);
928 APR_ARRAY_PUSH(log_segments, svn_location_segment_t *) = segment;
932 /* Get the svn_location_segment_t's representing the requested log
934 SVN_ERR(svn_client__repos_location_segments(&log_segments, ra_session,
936 actual_loc->rev, /* peg */
937 actual_loc->rev, /* start */
938 oldest_rev, /* end */
943 SVN_ERR(run_ra_get_log(revision_ranges, relative_targets, log_segments,
944 actual_loc, ra_session, targets, limit,
945 discover_changed_paths, strict_node_history,
946 include_merged_revisions, revprops,
947 real_receiver, real_receiver_baton, ctx, pool));