1 /*
2 * deprecated.c: holding file for all deprecated APIs.
3 * "we can't lose 'em, but we can shun 'em!"
4 *
5 * ====================================================================
6 * Licensed to the Apache Software Foundation (ASF) under one
7 * or more contributor license agreements. See the NOTICE file
8 * distributed with this work for additional information
9 * regarding copyright ownership. The ASF licenses this file
10 * to you under the Apache License, Version 2.0 (the
11 * "License"); you may not use this file except in compliance
12 * with the License. You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing,
17 * software distributed under the License is distributed on an
18 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
19 * KIND, either express or implied. See the License for the
20 * specific language governing permissions and limitations
21 * under the License.
22 * ====================================================================
23 */
24
25 /* We define this here to remove any further warnings about the usage of
26 deprecated functions in this file. */
27 #define SVN_DEPRECATED
28
29 #include <apr_md5.h>
30
31 #include "svn_wc.h"
32 #include "svn_subst.h"
33 #include "svn_pools.h"
34 #include "svn_props.h"
35 #include "svn_hash.h"
36 #include "svn_time.h"
37 #include "svn_dirent_uri.h"
38 #include "svn_path.h"
39
40 #include "private/svn_subr_private.h"
41 #include "private/svn_wc_private.h"
42 #include "private/svn_io_private.h"
43
44 #include "wc.h"
45 #include "entries.h"
46 #include "lock.h"
47 #include "props.h"
48 #include "translate.h"
49 #include "workqueue.h"
50
51 #include "svn_private_config.h"
52
53 /* baton for traversal_info_update */
54 struct traversal_info_update_baton
55 {
56 struct svn_wc_traversal_info_t *traversal;
57 svn_wc__db_t *db;
58 };
59
60 /* Helper for updating svn_wc_traversal_info_t structures
61 * Implements svn_wc_external_update_t */
62 static svn_error_t *
traversal_info_update(void * baton,const char * local_abspath,const svn_string_t * old_val,const svn_string_t * new_val,svn_depth_t depth,apr_pool_t * scratch_pool)63 traversal_info_update(void *baton,
64 const char *local_abspath,
65 const svn_string_t *old_val,
66 const svn_string_t *new_val,
67 svn_depth_t depth,
68 apr_pool_t *scratch_pool)
69 {
70 const char *dup_path;
71 svn_wc_adm_access_t *adm_access;
72 struct traversal_info_update_baton *ub = baton;
73 apr_pool_t *dup_pool = ub->traversal->pool;
74 const char *dup_val = NULL;
75
76 /* We make the abspath relative by retrieving the access baton
77 for the specific directory */
78 adm_access = svn_wc__adm_retrieve_internal2(ub->db, local_abspath,
79 scratch_pool);
80
81 if (adm_access)
82 dup_path = apr_pstrdup(dup_pool, svn_wc_adm_access_path(adm_access));
83 else
84 dup_path = apr_pstrdup(dup_pool, local_abspath);
85
86 if (old_val)
87 {
88 dup_val = apr_pstrmemdup(dup_pool, old_val->data, old_val->len);
89
90 svn_hash_sets(ub->traversal->externals_old, dup_path, dup_val);
91 }
92
93 if (new_val)
94 {
95 /* In most cases the value is identical */
96 if (old_val != new_val)
97 dup_val = apr_pstrmemdup(dup_pool, new_val->data, new_val->len);
98
99 svn_hash_sets(ub->traversal->externals_new, dup_path, dup_val);
100 }
101
102 svn_hash_sets(ub->traversal->depths, dup_path, svn_depth_to_word(depth));
103
104 return SVN_NO_ERROR;
105 }
106
107 /* Helper for functions that used to gather traversal_info */
108 static svn_error_t *
gather_traversal_info(svn_wc_context_t * wc_ctx,const char * local_abspath,const char * path,svn_depth_t depth,struct svn_wc_traversal_info_t * traversal_info,svn_boolean_t gather_as_old,svn_boolean_t gather_as_new,apr_pool_t * scratch_pool)109 gather_traversal_info(svn_wc_context_t *wc_ctx,
110 const char *local_abspath,
111 const char *path,
112 svn_depth_t depth,
113 struct svn_wc_traversal_info_t *traversal_info,
114 svn_boolean_t gather_as_old,
115 svn_boolean_t gather_as_new,
116 apr_pool_t *scratch_pool)
117 {
118 apr_hash_t *externals;
119 apr_hash_t *ambient_depths;
120 apr_hash_index_t *hi;
121
122 SVN_ERR(svn_wc__externals_gather_definitions(&externals, &ambient_depths,
123 wc_ctx, local_abspath,
124 depth,
125 scratch_pool, scratch_pool));
126
127 for (hi = apr_hash_first(scratch_pool, externals);
128 hi;
129 hi = apr_hash_next(hi))
130 {
131 const char *node_abspath = apr_hash_this_key(hi);
132 const char *relpath;
133
134 relpath = svn_dirent_join(path,
135 svn_dirent_skip_ancestor(local_abspath,
136 node_abspath),
137 traversal_info->pool);
138
139 if (gather_as_old)
140 svn_hash_sets(traversal_info->externals_old, relpath,
141 apr_hash_this_val(hi));
142
143 if (gather_as_new)
144 svn_hash_sets(traversal_info->externals_new, relpath,
145 apr_hash_this_val(hi));
146
147 svn_hash_sets(traversal_info->depths, relpath,
148 svn_hash_gets(ambient_depths, node_abspath));
149 }
150
151 return SVN_NO_ERROR;
152 }
153
154
155 /*** From adm_crawler.c ***/
156
157 svn_error_t *
svn_wc_crawl_revisions4(const char * path,svn_wc_adm_access_t * adm_access,const svn_ra_reporter3_t * reporter,void * report_baton,svn_boolean_t restore_files,svn_depth_t depth,svn_boolean_t honor_depth_exclude,svn_boolean_t depth_compatibility_trick,svn_boolean_t use_commit_times,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)158 svn_wc_crawl_revisions4(const char *path,
159 svn_wc_adm_access_t *adm_access,
160 const svn_ra_reporter3_t *reporter,
161 void *report_baton,
162 svn_boolean_t restore_files,
163 svn_depth_t depth,
164 svn_boolean_t honor_depth_exclude,
165 svn_boolean_t depth_compatibility_trick,
166 svn_boolean_t use_commit_times,
167 svn_wc_notify_func2_t notify_func,
168 void *notify_baton,
169 svn_wc_traversal_info_t *traversal_info,
170 apr_pool_t *pool)
171 {
172 svn_wc_context_t *wc_ctx;
173 svn_wc__db_t *wc_db = svn_wc__adm_get_db(adm_access);
174 const char *local_abspath;
175
176 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
177 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
178
179 SVN_ERR(svn_wc_crawl_revisions5(wc_ctx,
180 local_abspath,
181 reporter,
182 report_baton,
183 restore_files,
184 depth,
185 honor_depth_exclude,
186 depth_compatibility_trick,
187 use_commit_times,
188 NULL /* cancel_func */,
189 NULL /* cancel_baton */,
190 notify_func,
191 notify_baton,
192 pool));
193
194 if (traversal_info)
195 SVN_ERR(gather_traversal_info(wc_ctx, local_abspath, path, depth,
196 traversal_info, TRUE, FALSE, pool));
197
198 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
199 }
200
201 /*** Compatibility wrapper: turns an svn_ra_reporter2_t into an
202 svn_ra_reporter3_t.
203
204 This code looks like it duplicates code in libsvn_ra/ra_loader.c,
205 but it does not. That code makes an new thing look like an old
206 thing; this code makes an old thing look like a new thing. ***/
207
208 struct wrap_3to2_report_baton {
209 const svn_ra_reporter2_t *reporter;
210 void *baton;
211 };
212
213 /* */
wrap_3to2_set_path(void * report_baton,const char * path,svn_revnum_t revision,svn_depth_t depth,svn_boolean_t start_empty,const char * lock_token,apr_pool_t * pool)214 static svn_error_t *wrap_3to2_set_path(void *report_baton,
215 const char *path,
216 svn_revnum_t revision,
217 svn_depth_t depth,
218 svn_boolean_t start_empty,
219 const char *lock_token,
220 apr_pool_t *pool)
221 {
222 struct wrap_3to2_report_baton *wrb = report_baton;
223
224 return wrb->reporter->set_path(wrb->baton, path, revision, start_empty,
225 lock_token, pool);
226 }
227
228 /* */
wrap_3to2_delete_path(void * report_baton,const char * path,apr_pool_t * pool)229 static svn_error_t *wrap_3to2_delete_path(void *report_baton,
230 const char *path,
231 apr_pool_t *pool)
232 {
233 struct wrap_3to2_report_baton *wrb = report_baton;
234
235 return wrb->reporter->delete_path(wrb->baton, path, pool);
236 }
237
238 /* */
wrap_3to2_link_path(void * report_baton,const char * path,const char * url,svn_revnum_t revision,svn_depth_t depth,svn_boolean_t start_empty,const char * lock_token,apr_pool_t * pool)239 static svn_error_t *wrap_3to2_link_path(void *report_baton,
240 const char *path,
241 const char *url,
242 svn_revnum_t revision,
243 svn_depth_t depth,
244 svn_boolean_t start_empty,
245 const char *lock_token,
246 apr_pool_t *pool)
247 {
248 struct wrap_3to2_report_baton *wrb = report_baton;
249
250 return wrb->reporter->link_path(wrb->baton, path, url, revision,
251 start_empty, lock_token, pool);
252 }
253
254 /* */
wrap_3to2_finish_report(void * report_baton,apr_pool_t * pool)255 static svn_error_t *wrap_3to2_finish_report(void *report_baton,
256 apr_pool_t *pool)
257 {
258 struct wrap_3to2_report_baton *wrb = report_baton;
259
260 return wrb->reporter->finish_report(wrb->baton, pool);
261 }
262
263 /* */
wrap_3to2_abort_report(void * report_baton,apr_pool_t * pool)264 static svn_error_t *wrap_3to2_abort_report(void *report_baton,
265 apr_pool_t *pool)
266 {
267 struct wrap_3to2_report_baton *wrb = report_baton;
268
269 return wrb->reporter->abort_report(wrb->baton, pool);
270 }
271
272 static const svn_ra_reporter3_t wrap_3to2_reporter = {
273 wrap_3to2_set_path,
274 wrap_3to2_delete_path,
275 wrap_3to2_link_path,
276 wrap_3to2_finish_report,
277 wrap_3to2_abort_report
278 };
279
280 svn_error_t *
svn_wc_crawl_revisions3(const char * path,svn_wc_adm_access_t * adm_access,const svn_ra_reporter3_t * reporter,void * report_baton,svn_boolean_t restore_files,svn_depth_t depth,svn_boolean_t depth_compatibility_trick,svn_boolean_t use_commit_times,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)281 svn_wc_crawl_revisions3(const char *path,
282 svn_wc_adm_access_t *adm_access,
283 const svn_ra_reporter3_t *reporter,
284 void *report_baton,
285 svn_boolean_t restore_files,
286 svn_depth_t depth,
287 svn_boolean_t depth_compatibility_trick,
288 svn_boolean_t use_commit_times,
289 svn_wc_notify_func2_t notify_func,
290 void *notify_baton,
291 svn_wc_traversal_info_t *traversal_info,
292 apr_pool_t *pool)
293 {
294 return svn_wc_crawl_revisions4(path,
295 adm_access,
296 reporter, report_baton,
297 restore_files,
298 depth,
299 FALSE,
300 depth_compatibility_trick,
301 use_commit_times,
302 notify_func,
303 notify_baton,
304 traversal_info,
305 pool);
306 }
307
308 svn_error_t *
svn_wc_crawl_revisions2(const char * path,svn_wc_adm_access_t * adm_access,const svn_ra_reporter2_t * reporter,void * report_baton,svn_boolean_t restore_files,svn_boolean_t recurse,svn_boolean_t use_commit_times,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)309 svn_wc_crawl_revisions2(const char *path,
310 svn_wc_adm_access_t *adm_access,
311 const svn_ra_reporter2_t *reporter,
312 void *report_baton,
313 svn_boolean_t restore_files,
314 svn_boolean_t recurse,
315 svn_boolean_t use_commit_times,
316 svn_wc_notify_func2_t notify_func,
317 void *notify_baton,
318 svn_wc_traversal_info_t *traversal_info,
319 apr_pool_t *pool)
320 {
321 struct wrap_3to2_report_baton wrb;
322 wrb.reporter = reporter;
323 wrb.baton = report_baton;
324
325 return svn_wc_crawl_revisions3(path,
326 adm_access,
327 &wrap_3to2_reporter, &wrb,
328 restore_files,
329 SVN_DEPTH_INFINITY_OR_FILES(recurse),
330 FALSE,
331 use_commit_times,
332 notify_func,
333 notify_baton,
334 traversal_info,
335 pool);
336 }
337
338
339 /* Baton for compat_call_notify_func below. */
340 struct compat_notify_baton_t {
341 /* Wrapped func/baton. */
342 svn_wc_notify_func_t func;
343 void *baton;
344 };
345
346
347 /* Implements svn_wc_notify_func2_t. Call BATON->func (BATON is of type
348 svn_wc__compat_notify_baton_t), passing BATON->baton and the appropriate
349 arguments from NOTIFY. */
350 static void
compat_call_notify_func(void * baton,const svn_wc_notify_t * n,apr_pool_t * pool)351 compat_call_notify_func(void *baton,
352 const svn_wc_notify_t *n,
353 apr_pool_t *pool)
354 {
355 struct compat_notify_baton_t *nb = baton;
356
357 if (nb->func)
358 (*nb->func)(nb->baton, n->path, n->action, n->kind, n->mime_type,
359 n->content_state, n->prop_state, n->revision);
360 }
361
362
363 /*** Compatibility wrapper: turns an svn_ra_reporter_t into an
364 svn_ra_reporter2_t.
365
366 This code looks like it duplicates code in libsvn_ra/ra_loader.c,
367 but it does not. That code makes an new thing look like an old
368 thing; this code makes an old thing look like a new thing. ***/
369
370 struct wrap_2to1_report_baton {
371 const svn_ra_reporter_t *reporter;
372 void *baton;
373 };
374
375 /* */
wrap_2to1_set_path(void * report_baton,const char * path,svn_revnum_t revision,svn_boolean_t start_empty,const char * lock_token,apr_pool_t * pool)376 static svn_error_t *wrap_2to1_set_path(void *report_baton,
377 const char *path,
378 svn_revnum_t revision,
379 svn_boolean_t start_empty,
380 const char *lock_token,
381 apr_pool_t *pool)
382 {
383 struct wrap_2to1_report_baton *wrb = report_baton;
384
385 return wrb->reporter->set_path(wrb->baton, path, revision, start_empty,
386 pool);
387 }
388
389 /* */
wrap_2to1_delete_path(void * report_baton,const char * path,apr_pool_t * pool)390 static svn_error_t *wrap_2to1_delete_path(void *report_baton,
391 const char *path,
392 apr_pool_t *pool)
393 {
394 struct wrap_2to1_report_baton *wrb = report_baton;
395
396 return wrb->reporter->delete_path(wrb->baton, path, pool);
397 }
398
399 /* */
wrap_2to1_link_path(void * report_baton,const char * path,const char * url,svn_revnum_t revision,svn_boolean_t start_empty,const char * lock_token,apr_pool_t * pool)400 static svn_error_t *wrap_2to1_link_path(void *report_baton,
401 const char *path,
402 const char *url,
403 svn_revnum_t revision,
404 svn_boolean_t start_empty,
405 const char *lock_token,
406 apr_pool_t *pool)
407 {
408 struct wrap_2to1_report_baton *wrb = report_baton;
409
410 return wrb->reporter->link_path(wrb->baton, path, url, revision,
411 start_empty, pool);
412 }
413
414 /* */
wrap_2to1_finish_report(void * report_baton,apr_pool_t * pool)415 static svn_error_t *wrap_2to1_finish_report(void *report_baton,
416 apr_pool_t *pool)
417 {
418 struct wrap_2to1_report_baton *wrb = report_baton;
419
420 return wrb->reporter->finish_report(wrb->baton, pool);
421 }
422
423 /* */
wrap_2to1_abort_report(void * report_baton,apr_pool_t * pool)424 static svn_error_t *wrap_2to1_abort_report(void *report_baton,
425 apr_pool_t *pool)
426 {
427 struct wrap_2to1_report_baton *wrb = report_baton;
428
429 return wrb->reporter->abort_report(wrb->baton, pool);
430 }
431
432 static const svn_ra_reporter2_t wrap_2to1_reporter = {
433 wrap_2to1_set_path,
434 wrap_2to1_delete_path,
435 wrap_2to1_link_path,
436 wrap_2to1_finish_report,
437 wrap_2to1_abort_report
438 };
439
440 svn_error_t *
svn_wc_crawl_revisions(const char * path,svn_wc_adm_access_t * adm_access,const svn_ra_reporter_t * reporter,void * report_baton,svn_boolean_t restore_files,svn_boolean_t recurse,svn_boolean_t use_commit_times,svn_wc_notify_func_t notify_func,void * notify_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)441 svn_wc_crawl_revisions(const char *path,
442 svn_wc_adm_access_t *adm_access,
443 const svn_ra_reporter_t *reporter,
444 void *report_baton,
445 svn_boolean_t restore_files,
446 svn_boolean_t recurse,
447 svn_boolean_t use_commit_times,
448 svn_wc_notify_func_t notify_func,
449 void *notify_baton,
450 svn_wc_traversal_info_t *traversal_info,
451 apr_pool_t *pool)
452 {
453 struct wrap_2to1_report_baton wrb;
454 struct compat_notify_baton_t nb;
455
456 wrb.reporter = reporter;
457 wrb.baton = report_baton;
458
459 nb.func = notify_func;
460 nb.baton = notify_baton;
461
462 return svn_wc_crawl_revisions2(path, adm_access, &wrap_2to1_reporter, &wrb,
463 restore_files, recurse, use_commit_times,
464 compat_call_notify_func, &nb,
465 traversal_info,
466 pool);
467 }
468
469 svn_error_t *
svn_wc_transmit_text_deltas2(const char ** tempfile,unsigned char digest[],const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t fulltext,const svn_delta_editor_t * editor,void * file_baton,apr_pool_t * pool)470 svn_wc_transmit_text_deltas2(const char **tempfile,
471 unsigned char digest[],
472 const char *path,
473 svn_wc_adm_access_t *adm_access,
474 svn_boolean_t fulltext,
475 const svn_delta_editor_t *editor,
476 void *file_baton,
477 apr_pool_t *pool)
478 {
479 const char *local_abspath;
480 svn_wc_context_t *wc_ctx;
481 const svn_checksum_t *new_text_base_md5_checksum;
482 svn_stream_t *tempstream;
483 svn_error_t *err;
484
485 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
486 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
487 svn_wc__adm_get_db(adm_access),
488 pool));
489 if (tempfile)
490 {
491 apr_file_t *f;
492
493 /* The temporary file can't be the same location as in 1.6 because the
494 * admin directory no longer exists. */
495 SVN_ERR(svn_io_open_unique_file3(&f, tempfile, NULL,
496 svn_io_file_del_none,
497 pool, pool));
498 tempstream = svn_stream__from_aprfile(f, FALSE, TRUE, pool);
499 }
500 else
501 {
502 tempstream = NULL;
503 }
504
505 err = svn_wc__internal_transmit_text_deltas(svn_stream_disown(tempstream, pool),
506 (digest
507 ? &new_text_base_md5_checksum
508 : NULL),
509 NULL, wc_ctx->db,
510 local_abspath, fulltext,
511 editor, file_baton,
512 pool, pool);
513 if (tempfile)
514 {
515 err = svn_error_compose_create(err, svn_stream_close(tempstream));
516
517 if (err)
518 {
519 err = svn_error_compose_create(
520 err, svn_io_remove_file2(*tempfile, TRUE, pool));
521 }
522 }
523
524 SVN_ERR(err);
525
526 if (digest)
527 memcpy(digest, new_text_base_md5_checksum->digest, APR_MD5_DIGESTSIZE);
528
529 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
530 }
531
532 svn_error_t *
svn_wc_transmit_text_deltas(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t fulltext,const svn_delta_editor_t * editor,void * file_baton,const char ** tempfile,apr_pool_t * pool)533 svn_wc_transmit_text_deltas(const char *path,
534 svn_wc_adm_access_t *adm_access,
535 svn_boolean_t fulltext,
536 const svn_delta_editor_t *editor,
537 void *file_baton,
538 const char **tempfile,
539 apr_pool_t *pool)
540 {
541 return svn_wc_transmit_text_deltas2(tempfile, NULL, path, adm_access,
542 fulltext, editor, file_baton, pool);
543 }
544
545 svn_error_t *
svn_wc_transmit_prop_deltas(const char * path,svn_wc_adm_access_t * adm_access,const svn_wc_entry_t * entry,const svn_delta_editor_t * editor,void * baton,const char ** tempfile,apr_pool_t * pool)546 svn_wc_transmit_prop_deltas(const char *path,
547 svn_wc_adm_access_t *adm_access,
548 const svn_wc_entry_t *entry,
549 const svn_delta_editor_t *editor,
550 void *baton,
551 const char **tempfile,
552 apr_pool_t *pool)
553 {
554 const char *local_abspath;
555 svn_wc_context_t *wc_ctx;
556
557 if (tempfile)
558 *tempfile = NULL;
559
560 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
561 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
562 svn_wc__adm_get_db(adm_access),
563 pool));
564
565 SVN_ERR(svn_wc_transmit_prop_deltas2(wc_ctx, local_abspath, editor, baton,
566 pool));
567
568 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
569 }
570
571 /*** From adm_files.c ***/
572 svn_error_t *
svn_wc_ensure_adm3(const char * path,const char * uuid,const char * url,const char * repos,svn_revnum_t revision,svn_depth_t depth,apr_pool_t * pool)573 svn_wc_ensure_adm3(const char *path,
574 const char *uuid,
575 const char *url,
576 const char *repos,
577 svn_revnum_t revision,
578 svn_depth_t depth,
579 apr_pool_t *pool)
580 {
581 const char *local_abspath;
582 svn_wc_context_t *wc_ctx;
583
584 if (uuid == NULL)
585 return svn_error_create(SVN_ERR_BAD_UUID, NULL, NULL);
586 if (repos == NULL)
587 return svn_error_create(SVN_ERR_BAD_URL, NULL, NULL);
588
589 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
590 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL /* config */, pool, pool));
591
592 SVN_ERR(svn_wc_ensure_adm4(wc_ctx, local_abspath, url, repos, uuid, revision,
593 depth, pool));
594
595 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
596 }
597
598 svn_error_t *
svn_wc_ensure_adm2(const char * path,const char * uuid,const char * url,const char * repos,svn_revnum_t revision,apr_pool_t * pool)599 svn_wc_ensure_adm2(const char *path,
600 const char *uuid,
601 const char *url,
602 const char *repos,
603 svn_revnum_t revision,
604 apr_pool_t *pool)
605 {
606 return svn_wc_ensure_adm3(path, uuid, url, repos, revision,
607 svn_depth_infinity, pool);
608 }
609
610
611 svn_error_t *
svn_wc_ensure_adm(const char * path,const char * uuid,const char * url,svn_revnum_t revision,apr_pool_t * pool)612 svn_wc_ensure_adm(const char *path,
613 const char *uuid,
614 const char *url,
615 svn_revnum_t revision,
616 apr_pool_t *pool)
617 {
618 return svn_wc_ensure_adm2(path, uuid, url, NULL, revision, pool);
619 }
620
621 svn_error_t *
svn_wc_create_tmp_file(apr_file_t ** fp,const char * path,svn_boolean_t delete_on_close,apr_pool_t * pool)622 svn_wc_create_tmp_file(apr_file_t **fp,
623 const char *path,
624 svn_boolean_t delete_on_close,
625 apr_pool_t *pool)
626 {
627 return svn_wc_create_tmp_file2(fp, NULL, path,
628 delete_on_close
629 ? svn_io_file_del_on_close
630 : svn_io_file_del_none,
631 pool);
632 }
633
634 svn_error_t *
svn_wc_create_tmp_file2(apr_file_t ** fp,const char ** new_name,const char * path,svn_io_file_del_t delete_when,apr_pool_t * pool)635 svn_wc_create_tmp_file2(apr_file_t **fp,
636 const char **new_name,
637 const char *path,
638 svn_io_file_del_t delete_when,
639 apr_pool_t *pool)
640 {
641 svn_wc_context_t *wc_ctx;
642 const char *local_abspath;
643 const char *temp_dir;
644 svn_error_t *err;
645
646 SVN_ERR_ASSERT(fp || new_name);
647
648 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL /* config */, pool, pool));
649
650 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
651 err = svn_wc__get_tmpdir(&temp_dir, wc_ctx, local_abspath, pool, pool);
652 err = svn_error_compose_create(err, svn_wc_context_destroy(wc_ctx));
653 if (err)
654 return svn_error_trace(err);
655
656 SVN_ERR(svn_io_open_unique_file3(fp, new_name, temp_dir,
657 delete_when, pool, pool));
658
659 return SVN_NO_ERROR;
660 }
661
662
663 /*** From adm_ops.c ***/
664 svn_error_t *
svn_wc_get_pristine_contents(svn_stream_t ** contents,const char * path,apr_pool_t * result_pool,apr_pool_t * scratch_pool)665 svn_wc_get_pristine_contents(svn_stream_t **contents,
666 const char *path,
667 apr_pool_t *result_pool,
668 apr_pool_t *scratch_pool)
669 {
670 svn_wc_context_t *wc_ctx;
671 const char *local_abspath;
672
673 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, scratch_pool, scratch_pool));
674 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
675
676 SVN_ERR(svn_wc_get_pristine_contents2(contents,
677 wc_ctx,
678 local_abspath,
679 result_pool,
680 scratch_pool));
681
682 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
683 }
684
685 svn_error_t *
svn_wc_queue_committed3(svn_wc_committed_queue_t * queue,svn_wc_context_t * wc_ctx,const char * local_abspath,svn_boolean_t recurse,const apr_array_header_t * wcprop_changes,svn_boolean_t remove_lock,svn_boolean_t remove_changelist,const svn_checksum_t * sha1_checksum,apr_pool_t * scratch_pool)686 svn_wc_queue_committed3(svn_wc_committed_queue_t *queue,
687 svn_wc_context_t *wc_ctx,
688 const char *local_abspath,
689 svn_boolean_t recurse,
690 const apr_array_header_t *wcprop_changes,
691 svn_boolean_t remove_lock,
692 svn_boolean_t remove_changelist,
693 const svn_checksum_t *sha1_checksum,
694 apr_pool_t *scratch_pool)
695 {
696 return svn_error_trace(
697 svn_wc_queue_committed4(queue, wc_ctx, local_abspath,
698 recurse, TRUE /* is_committed */,
699 wcprop_changes, remove_lock,
700 remove_changelist, sha1_checksum,
701 scratch_pool));
702 }
703
704 svn_error_t *
svn_wc_queue_committed2(svn_wc_committed_queue_t * queue,const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t recurse,const apr_array_header_t * wcprop_changes,svn_boolean_t remove_lock,svn_boolean_t remove_changelist,const svn_checksum_t * md5_checksum,apr_pool_t * scratch_pool)705 svn_wc_queue_committed2(svn_wc_committed_queue_t *queue,
706 const char *path,
707 svn_wc_adm_access_t *adm_access,
708 svn_boolean_t recurse,
709 const apr_array_header_t *wcprop_changes,
710 svn_boolean_t remove_lock,
711 svn_boolean_t remove_changelist,
712 const svn_checksum_t *md5_checksum,
713 apr_pool_t *scratch_pool)
714 {
715 svn_wc_context_t *wc_ctx;
716 const char *local_abspath;
717 const svn_checksum_t *sha1_checksum = NULL;
718
719 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
720 svn_wc__adm_get_db(adm_access),
721 scratch_pool));
722 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
723
724 if (md5_checksum != NULL)
725 {
726 svn_error_t *err;
727 err = svn_wc__db_pristine_get_sha1(&sha1_checksum, wc_ctx->db,
728 local_abspath, md5_checksum,
729 svn_wc__get_committed_queue_pool(queue),
730 scratch_pool);
731
732 /* Don't fail on SHA1 not found */
733 if (err && err->apr_err == SVN_ERR_WC_DB_ERROR)
734 {
735 svn_error_clear(err);
736 sha1_checksum = NULL;
737 }
738 else
739 SVN_ERR(err);
740 }
741
742 SVN_ERR(svn_wc_queue_committed3(queue, wc_ctx, local_abspath, recurse,
743 wcprop_changes,
744 remove_lock, remove_changelist,
745 sha1_checksum, scratch_pool));
746
747 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
748 }
749
750 svn_error_t *
svn_wc_queue_committed(svn_wc_committed_queue_t ** queue,const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t recurse,const apr_array_header_t * wcprop_changes,svn_boolean_t remove_lock,svn_boolean_t remove_changelist,const unsigned char * digest,apr_pool_t * pool)751 svn_wc_queue_committed(svn_wc_committed_queue_t **queue,
752 const char *path,
753 svn_wc_adm_access_t *adm_access,
754 svn_boolean_t recurse,
755 const apr_array_header_t *wcprop_changes,
756 svn_boolean_t remove_lock,
757 svn_boolean_t remove_changelist,
758 const unsigned char *digest,
759 apr_pool_t *pool)
760 {
761 const svn_checksum_t *md5_checksum;
762
763 if (digest)
764 md5_checksum = svn_checksum__from_digest_md5(
765 digest, svn_wc__get_committed_queue_pool(*queue));
766 else
767 md5_checksum = NULL;
768
769 return svn_wc_queue_committed2(*queue, path, adm_access, recurse,
770 wcprop_changes, remove_lock,
771 remove_changelist, md5_checksum, pool);
772 }
773
774 svn_error_t *
svn_wc_process_committed_queue(svn_wc_committed_queue_t * queue,svn_wc_adm_access_t * adm_access,svn_revnum_t new_revnum,const char * rev_date,const char * rev_author,apr_pool_t * pool)775 svn_wc_process_committed_queue(svn_wc_committed_queue_t *queue,
776 svn_wc_adm_access_t *adm_access,
777 svn_revnum_t new_revnum,
778 const char *rev_date,
779 const char *rev_author,
780 apr_pool_t *pool)
781 {
782 svn_wc_context_t *wc_ctx;
783
784 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
785 svn_wc__adm_get_db(adm_access),
786 pool));
787 SVN_ERR(svn_wc_process_committed_queue2(queue, wc_ctx, new_revnum,
788 rev_date, rev_author,
789 NULL, NULL, pool));
790 SVN_ERR(svn_wc_context_destroy(wc_ctx));
791
792 return SVN_NO_ERROR;
793 }
794
795 svn_error_t *
svn_wc_process_committed4(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t recurse,svn_revnum_t new_revnum,const char * rev_date,const char * rev_author,const apr_array_header_t * wcprop_changes,svn_boolean_t remove_lock,svn_boolean_t remove_changelist,const unsigned char * digest,apr_pool_t * pool)796 svn_wc_process_committed4(const char *path,
797 svn_wc_adm_access_t *adm_access,
798 svn_boolean_t recurse,
799 svn_revnum_t new_revnum,
800 const char *rev_date,
801 const char *rev_author,
802 const apr_array_header_t *wcprop_changes,
803 svn_boolean_t remove_lock,
804 svn_boolean_t remove_changelist,
805 const unsigned char *digest,
806 apr_pool_t *pool)
807 {
808 svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
809 const char *local_abspath;
810 const svn_checksum_t *md5_checksum;
811 const svn_checksum_t *sha1_checksum = NULL;
812 svn_wc_context_t *wc_ctx;
813 svn_wc_committed_queue_t *queue;
814
815 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
816 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
817
818 if (digest)
819 md5_checksum = svn_checksum__from_digest_md5(digest, pool);
820 else
821 md5_checksum = NULL;
822
823 if (md5_checksum != NULL)
824 {
825 svn_error_t *err;
826 err = svn_wc__db_pristine_get_sha1(&sha1_checksum, db,
827 local_abspath, md5_checksum,
828 pool, pool);
829
830 if (err && err->apr_err == SVN_ERR_WC_DB_ERROR)
831 {
832 svn_error_clear(err);
833 sha1_checksum = NULL;
834 }
835 else
836 SVN_ERR(err);
837 }
838
839 queue = svn_wc_committed_queue_create(pool);
840 SVN_ERR(svn_wc_queue_committed3(queue, wc_ctx, local_abspath, recurse,
841 wcprop_changes, remove_lock,
842 remove_changelist,
843 sha1_checksum /* or NULL if not modified
844 or directory */,
845 pool));
846
847 SVN_ERR(svn_wc_process_committed_queue2(queue, wc_ctx,
848 new_revnum, rev_date, rev_author,
849 NULL, NULL /* cancel */,
850 pool));
851
852 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
853 }
854
855
856 svn_error_t *
svn_wc_process_committed3(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t recurse,svn_revnum_t new_revnum,const char * rev_date,const char * rev_author,const apr_array_header_t * wcprop_changes,svn_boolean_t remove_lock,const unsigned char * digest,apr_pool_t * pool)857 svn_wc_process_committed3(const char *path,
858 svn_wc_adm_access_t *adm_access,
859 svn_boolean_t recurse,
860 svn_revnum_t new_revnum,
861 const char *rev_date,
862 const char *rev_author,
863 const apr_array_header_t *wcprop_changes,
864 svn_boolean_t remove_lock,
865 const unsigned char *digest,
866 apr_pool_t *pool)
867 {
868 return svn_wc_process_committed4(path, adm_access, recurse, new_revnum,
869 rev_date, rev_author, wcprop_changes,
870 remove_lock, FALSE, digest, pool);
871 }
872
873 svn_error_t *
svn_wc_process_committed2(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t recurse,svn_revnum_t new_revnum,const char * rev_date,const char * rev_author,const apr_array_header_t * wcprop_changes,svn_boolean_t remove_lock,apr_pool_t * pool)874 svn_wc_process_committed2(const char *path,
875 svn_wc_adm_access_t *adm_access,
876 svn_boolean_t recurse,
877 svn_revnum_t new_revnum,
878 const char *rev_date,
879 const char *rev_author,
880 const apr_array_header_t *wcprop_changes,
881 svn_boolean_t remove_lock,
882 apr_pool_t *pool)
883 {
884 return svn_wc_process_committed3(path, adm_access, recurse, new_revnum,
885 rev_date, rev_author, wcprop_changes,
886 remove_lock, NULL, pool);
887 }
888
889 svn_error_t *
svn_wc_process_committed(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t recurse,svn_revnum_t new_revnum,const char * rev_date,const char * rev_author,const apr_array_header_t * wcprop_changes,apr_pool_t * pool)890 svn_wc_process_committed(const char *path,
891 svn_wc_adm_access_t *adm_access,
892 svn_boolean_t recurse,
893 svn_revnum_t new_revnum,
894 const char *rev_date,
895 const char *rev_author,
896 const apr_array_header_t *wcprop_changes,
897 apr_pool_t *pool)
898 {
899 return svn_wc_process_committed2(path, adm_access, recurse, new_revnum,
900 rev_date, rev_author, wcprop_changes,
901 FALSE, pool);
902 }
903
904 svn_error_t *
svn_wc_maybe_set_repos_root(svn_wc_adm_access_t * adm_access,const char * path,const char * repos,apr_pool_t * pool)905 svn_wc_maybe_set_repos_root(svn_wc_adm_access_t *adm_access,
906 const char *path,
907 const char *repos,
908 apr_pool_t *pool)
909 {
910 return SVN_NO_ERROR;
911 }
912
913 svn_error_t *
svn_wc_delete3(const char * path,svn_wc_adm_access_t * adm_access,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_boolean_t keep_local,apr_pool_t * pool)914 svn_wc_delete3(const char *path,
915 svn_wc_adm_access_t *adm_access,
916 svn_cancel_func_t cancel_func,
917 void *cancel_baton,
918 svn_wc_notify_func2_t notify_func,
919 void *notify_baton,
920 svn_boolean_t keep_local,
921 apr_pool_t *pool)
922 {
923 svn_wc_context_t *wc_ctx;
924 svn_wc__db_t *wc_db = svn_wc__adm_get_db(adm_access);
925 svn_wc_adm_access_t *dir_access;
926 const char *local_abspath;
927
928 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
929 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
930
931 /* Open access batons for everything below path, because we used to open
932 these before. */
933 SVN_ERR(svn_wc_adm_probe_try3(&dir_access, adm_access, path,
934 TRUE, -1, cancel_func, cancel_baton, pool));
935
936 SVN_ERR(svn_wc_delete4(wc_ctx,
937 local_abspath,
938 keep_local,
939 TRUE,
940 cancel_func, cancel_baton,
941 notify_func, notify_baton,
942 pool));
943
944 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
945 }
946
947 svn_error_t *
svn_wc_delete2(const char * path,svn_wc_adm_access_t * adm_access,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)948 svn_wc_delete2(const char *path,
949 svn_wc_adm_access_t *adm_access,
950 svn_cancel_func_t cancel_func,
951 void *cancel_baton,
952 svn_wc_notify_func2_t notify_func,
953 void *notify_baton,
954 apr_pool_t *pool)
955 {
956 return svn_wc_delete3(path, adm_access, cancel_func, cancel_baton,
957 notify_func, notify_baton, FALSE, pool);
958 }
959
960 svn_error_t *
svn_wc_delete(const char * path,svn_wc_adm_access_t * adm_access,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func_t notify_func,void * notify_baton,apr_pool_t * pool)961 svn_wc_delete(const char *path,
962 svn_wc_adm_access_t *adm_access,
963 svn_cancel_func_t cancel_func,
964 void *cancel_baton,
965 svn_wc_notify_func_t notify_func,
966 void *notify_baton,
967 apr_pool_t *pool)
968 {
969 struct compat_notify_baton_t nb;
970
971 nb.func = notify_func;
972 nb.baton = notify_baton;
973
974 return svn_wc_delete2(path, adm_access, cancel_func, cancel_baton,
975 compat_call_notify_func, &nb, pool);
976 }
977
978 svn_error_t *
svn_wc_add_from_disk2(svn_wc_context_t * wc_ctx,const char * local_abspath,const apr_hash_t * props,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * scratch_pool)979 svn_wc_add_from_disk2(svn_wc_context_t *wc_ctx,
980 const char *local_abspath,
981 const apr_hash_t *props,
982 svn_wc_notify_func2_t notify_func,
983 void *notify_baton,
984 apr_pool_t *scratch_pool)
985 {
986 SVN_ERR(svn_wc_add_from_disk3(wc_ctx, local_abspath, props, FALSE,
987 notify_func, notify_baton, scratch_pool));
988 return SVN_NO_ERROR;
989 }
990
991 svn_error_t *
svn_wc_add_from_disk(svn_wc_context_t * wc_ctx,const char * local_abspath,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * scratch_pool)992 svn_wc_add_from_disk(svn_wc_context_t *wc_ctx,
993 const char *local_abspath,
994 svn_wc_notify_func2_t notify_func,
995 void *notify_baton,
996 apr_pool_t *scratch_pool)
997 {
998 SVN_ERR(svn_wc_add_from_disk2(wc_ctx, local_abspath, NULL,
999 notify_func, notify_baton, scratch_pool));
1000 return SVN_NO_ERROR;
1001 }
1002
1003 svn_error_t *
svn_wc_add3(const char * path,svn_wc_adm_access_t * parent_access,svn_depth_t depth,const char * copyfrom_url,svn_revnum_t copyfrom_rev,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)1004 svn_wc_add3(const char *path,
1005 svn_wc_adm_access_t *parent_access,
1006 svn_depth_t depth,
1007 const char *copyfrom_url,
1008 svn_revnum_t copyfrom_rev,
1009 svn_cancel_func_t cancel_func,
1010 void *cancel_baton,
1011 svn_wc_notify_func2_t notify_func,
1012 void *notify_baton,
1013 apr_pool_t *pool)
1014 {
1015 svn_wc_context_t *wc_ctx;
1016 svn_wc__db_t *wc_db = svn_wc__adm_get_db(parent_access);
1017 const char *local_abspath;
1018
1019 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
1020 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1021
1022 SVN_ERR(svn_wc_add4(wc_ctx, local_abspath,
1023 depth, copyfrom_url,
1024 copyfrom_rev,
1025 cancel_func, cancel_baton,
1026 notify_func, notify_baton, pool));
1027
1028 /* Make sure the caller gets the new access baton in the set. */
1029 if (svn_wc__adm_retrieve_internal2(wc_db, local_abspath, pool) == NULL)
1030 {
1031 svn_node_kind_t kind;
1032
1033 SVN_ERR(svn_wc__db_read_kind(&kind, wc_db, local_abspath,
1034 FALSE /* allow_missing */,
1035 TRUE /* show_deleted */,
1036 FALSE /* show_hidden */, pool));
1037 if (kind == svn_node_dir)
1038 {
1039 svn_wc_adm_access_t *adm_access;
1040
1041 /* Open the access baton in adm_access' pool to give it the same
1042 lifetime */
1043 SVN_ERR(svn_wc_adm_open3(&adm_access, parent_access, path, TRUE,
1044 copyfrom_url ? -1 : 0,
1045 cancel_func, cancel_baton,
1046 svn_wc_adm_access_pool(parent_access)));
1047 }
1048 }
1049
1050 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1051 }
1052
1053
1054 svn_error_t *
svn_wc_add2(const char * path,svn_wc_adm_access_t * parent_access,const char * copyfrom_url,svn_revnum_t copyfrom_rev,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)1055 svn_wc_add2(const char *path,
1056 svn_wc_adm_access_t *parent_access,
1057 const char *copyfrom_url,
1058 svn_revnum_t copyfrom_rev,
1059 svn_cancel_func_t cancel_func,
1060 void *cancel_baton,
1061 svn_wc_notify_func2_t notify_func,
1062 void *notify_baton,
1063 apr_pool_t *pool)
1064 {
1065 return svn_wc_add3(path, parent_access, svn_depth_infinity,
1066 copyfrom_url, copyfrom_rev,
1067 cancel_func, cancel_baton,
1068 notify_func, notify_baton, pool);
1069 }
1070
1071 svn_error_t *
svn_wc_add(const char * path,svn_wc_adm_access_t * parent_access,const char * copyfrom_url,svn_revnum_t copyfrom_rev,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func_t notify_func,void * notify_baton,apr_pool_t * pool)1072 svn_wc_add(const char *path,
1073 svn_wc_adm_access_t *parent_access,
1074 const char *copyfrom_url,
1075 svn_revnum_t copyfrom_rev,
1076 svn_cancel_func_t cancel_func,
1077 void *cancel_baton,
1078 svn_wc_notify_func_t notify_func,
1079 void *notify_baton,
1080 apr_pool_t *pool)
1081 {
1082 struct compat_notify_baton_t nb;
1083
1084 nb.func = notify_func;
1085 nb.baton = notify_baton;
1086
1087 return svn_wc_add2(path, parent_access, copyfrom_url, copyfrom_rev,
1088 cancel_func, cancel_baton,
1089 compat_call_notify_func, &nb, pool);
1090 }
1091
1092 /*** From revert.c ***/
1093 svn_error_t *
svn_wc_revert5(svn_wc_context_t * wc_ctx,const char * local_abspath,svn_depth_t depth,svn_boolean_t use_commit_times,const apr_array_header_t * changelist_filter,svn_boolean_t clear_changelists,svn_boolean_t metadata_only,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * scratch_pool)1094 svn_wc_revert5(svn_wc_context_t *wc_ctx,
1095 const char *local_abspath,
1096 svn_depth_t depth,
1097 svn_boolean_t use_commit_times,
1098 const apr_array_header_t *changelist_filter,
1099 svn_boolean_t clear_changelists,
1100 svn_boolean_t metadata_only,
1101 svn_cancel_func_t cancel_func,
1102 void *cancel_baton,
1103 svn_wc_notify_func2_t notify_func,
1104 void *notify_baton,
1105 apr_pool_t *scratch_pool)
1106 {
1107 SVN_ERR(svn_wc_revert6(wc_ctx, local_abspath,
1108 depth,
1109 use_commit_times,
1110 changelist_filter,
1111 clear_changelists,
1112 metadata_only,
1113 TRUE /*added_keep_local*/,
1114 cancel_func, cancel_baton,
1115 notify_func, notify_baton,
1116 scratch_pool));
1117 return SVN_NO_ERROR;
1118 }
1119
1120 svn_error_t *
svn_wc_revert4(svn_wc_context_t * wc_ctx,const char * local_abspath,svn_depth_t depth,svn_boolean_t use_commit_times,const apr_array_header_t * changelist_filter,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * scratch_pool)1121 svn_wc_revert4(svn_wc_context_t *wc_ctx,
1122 const char *local_abspath,
1123 svn_depth_t depth,
1124 svn_boolean_t use_commit_times,
1125 const apr_array_header_t *changelist_filter,
1126 svn_cancel_func_t cancel_func,
1127 void *cancel_baton,
1128 svn_wc_notify_func2_t notify_func,
1129 void *notify_baton,
1130 apr_pool_t *scratch_pool)
1131 {
1132 return svn_error_trace(svn_wc_revert5(wc_ctx, local_abspath,
1133 depth,
1134 use_commit_times,
1135 changelist_filter,
1136 FALSE /* clear_changelists */,
1137 FALSE /* metadata_only */,
1138 cancel_func, cancel_baton,
1139 notify_func, notify_baton,
1140 scratch_pool));
1141 }
1142
1143 svn_error_t *
svn_wc_revert3(const char * path,svn_wc_adm_access_t * parent_access,svn_depth_t depth,svn_boolean_t use_commit_times,const apr_array_header_t * changelist_filter,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)1144 svn_wc_revert3(const char *path,
1145 svn_wc_adm_access_t *parent_access,
1146 svn_depth_t depth,
1147 svn_boolean_t use_commit_times,
1148 const apr_array_header_t *changelist_filter,
1149 svn_cancel_func_t cancel_func,
1150 void *cancel_baton,
1151 svn_wc_notify_func2_t notify_func,
1152 void *notify_baton,
1153 apr_pool_t *pool)
1154 {
1155 svn_wc_context_t *wc_ctx;
1156 svn_wc__db_t *wc_db = svn_wc__adm_get_db(parent_access);
1157 const char *local_abspath;
1158
1159 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
1160 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1161
1162 SVN_ERR(svn_wc_revert4(wc_ctx,
1163 local_abspath,
1164 depth,
1165 use_commit_times,
1166 changelist_filter,
1167 cancel_func, cancel_baton,
1168 notify_func, notify_baton,
1169 pool));
1170
1171 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1172 }
1173
1174 svn_error_t *
svn_wc_revert2(const char * path,svn_wc_adm_access_t * parent_access,svn_boolean_t recursive,svn_boolean_t use_commit_times,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)1175 svn_wc_revert2(const char *path,
1176 svn_wc_adm_access_t *parent_access,
1177 svn_boolean_t recursive,
1178 svn_boolean_t use_commit_times,
1179 svn_cancel_func_t cancel_func,
1180 void *cancel_baton,
1181 svn_wc_notify_func2_t notify_func,
1182 void *notify_baton,
1183 apr_pool_t *pool)
1184 {
1185 return svn_wc_revert3(path, parent_access,
1186 SVN_DEPTH_INFINITY_OR_EMPTY(recursive),
1187 use_commit_times, NULL, cancel_func, cancel_baton,
1188 notify_func, notify_baton, pool);
1189 }
1190
1191 svn_error_t *
svn_wc_revert(const char * path,svn_wc_adm_access_t * parent_access,svn_boolean_t recursive,svn_boolean_t use_commit_times,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func_t notify_func,void * notify_baton,apr_pool_t * pool)1192 svn_wc_revert(const char *path,
1193 svn_wc_adm_access_t *parent_access,
1194 svn_boolean_t recursive,
1195 svn_boolean_t use_commit_times,
1196 svn_cancel_func_t cancel_func,
1197 void *cancel_baton,
1198 svn_wc_notify_func_t notify_func,
1199 void *notify_baton,
1200 apr_pool_t *pool)
1201 {
1202 struct compat_notify_baton_t nb;
1203
1204 nb.func = notify_func;
1205 nb.baton = notify_baton;
1206
1207 return svn_wc_revert2(path, parent_access, recursive, use_commit_times,
1208 cancel_func, cancel_baton,
1209 compat_call_notify_func, &nb, pool);
1210 }
1211
1212 svn_error_t *
svn_wc_remove_from_revision_control(svn_wc_adm_access_t * adm_access,const char * name,svn_boolean_t destroy_wf,svn_boolean_t instant_error,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)1213 svn_wc_remove_from_revision_control(svn_wc_adm_access_t *adm_access,
1214 const char *name,
1215 svn_boolean_t destroy_wf,
1216 svn_boolean_t instant_error,
1217 svn_cancel_func_t cancel_func,
1218 void *cancel_baton,
1219 apr_pool_t *pool)
1220 {
1221 svn_wc_context_t *wc_ctx;
1222 svn_wc__db_t *wc_db = svn_wc__adm_get_db(adm_access);
1223 const char *local_abspath = svn_dirent_join(
1224 svn_wc__adm_access_abspath(adm_access),
1225 name,
1226 pool);
1227
1228 /* name must be an entry in adm_access, fail if not */
1229 SVN_ERR_ASSERT(strcmp(svn_dirent_basename(name, NULL), name) == 0);
1230 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
1231
1232 SVN_ERR(svn_wc_remove_from_revision_control2(wc_ctx,
1233 local_abspath,
1234 destroy_wf,
1235 instant_error,
1236 cancel_func, cancel_baton,
1237 pool));
1238
1239 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1240 }
1241
1242 svn_error_t *
svn_wc_resolved_conflict4(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t resolve_text,svn_boolean_t resolve_props,svn_boolean_t resolve_tree,svn_depth_t depth,svn_wc_conflict_choice_t conflict_choice,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)1243 svn_wc_resolved_conflict4(const char *path,
1244 svn_wc_adm_access_t *adm_access,
1245 svn_boolean_t resolve_text,
1246 svn_boolean_t resolve_props,
1247 svn_boolean_t resolve_tree,
1248 svn_depth_t depth,
1249 svn_wc_conflict_choice_t conflict_choice,
1250 svn_wc_notify_func2_t notify_func,
1251 void *notify_baton,
1252 svn_cancel_func_t cancel_func,
1253 void *cancel_baton,
1254 apr_pool_t *pool)
1255 {
1256 svn_wc_context_t *wc_ctx;
1257 svn_wc__db_t *wc_db = svn_wc__adm_get_db(adm_access);
1258 const char *local_abspath;
1259
1260 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1261 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
1262
1263 SVN_ERR(svn_wc_resolved_conflict5(wc_ctx,
1264 local_abspath,
1265 depth,
1266 resolve_text,
1267 resolve_props ? "" : NULL,
1268 resolve_tree,
1269 conflict_choice,
1270 cancel_func,
1271 cancel_baton,
1272 notify_func,
1273 notify_baton,
1274 pool));
1275
1276 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1277
1278 }
1279
1280 svn_error_t *
svn_wc_resolved_conflict(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t resolve_text,svn_boolean_t resolve_props,svn_boolean_t recurse,svn_wc_notify_func_t notify_func,void * notify_baton,apr_pool_t * pool)1281 svn_wc_resolved_conflict(const char *path,
1282 svn_wc_adm_access_t *adm_access,
1283 svn_boolean_t resolve_text,
1284 svn_boolean_t resolve_props,
1285 svn_boolean_t recurse,
1286 svn_wc_notify_func_t notify_func,
1287 void *notify_baton,
1288 apr_pool_t *pool)
1289 {
1290 struct compat_notify_baton_t nb;
1291
1292 nb.func = notify_func;
1293 nb.baton = notify_baton;
1294
1295 return svn_wc_resolved_conflict2(path, adm_access,
1296 resolve_text, resolve_props, recurse,
1297 compat_call_notify_func, &nb,
1298 NULL, NULL, pool);
1299
1300 }
1301
1302 svn_error_t *
svn_wc_resolved_conflict2(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t resolve_text,svn_boolean_t resolve_props,svn_boolean_t recurse,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)1303 svn_wc_resolved_conflict2(const char *path,
1304 svn_wc_adm_access_t *adm_access,
1305 svn_boolean_t resolve_text,
1306 svn_boolean_t resolve_props,
1307 svn_boolean_t recurse,
1308 svn_wc_notify_func2_t notify_func,
1309 void *notify_baton,
1310 svn_cancel_func_t cancel_func,
1311 void *cancel_baton,
1312 apr_pool_t *pool)
1313 {
1314 return svn_wc_resolved_conflict3(path, adm_access, resolve_text,
1315 resolve_props,
1316 SVN_DEPTH_INFINITY_OR_EMPTY(recurse),
1317 svn_wc_conflict_choose_merged,
1318 notify_func, notify_baton, cancel_func,
1319 cancel_baton, pool);
1320 }
1321
1322 svn_error_t *
svn_wc_resolved_conflict3(const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t resolve_text,svn_boolean_t resolve_props,svn_depth_t depth,svn_wc_conflict_choice_t conflict_choice,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)1323 svn_wc_resolved_conflict3(const char *path,
1324 svn_wc_adm_access_t *adm_access,
1325 svn_boolean_t resolve_text,
1326 svn_boolean_t resolve_props,
1327 svn_depth_t depth,
1328 svn_wc_conflict_choice_t conflict_choice,
1329 svn_wc_notify_func2_t notify_func,
1330 void *notify_baton,
1331 svn_cancel_func_t cancel_func,
1332 void *cancel_baton,
1333 apr_pool_t *pool)
1334 {
1335 return svn_wc_resolved_conflict4(path, adm_access, resolve_text,
1336 resolve_props, FALSE, depth,
1337 svn_wc_conflict_choose_merged,
1338 notify_func, notify_baton, cancel_func,
1339 cancel_baton, pool);
1340 }
1341
1342 svn_error_t *
svn_wc_add_lock(const char * path,const svn_lock_t * lock,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)1343 svn_wc_add_lock(const char *path,
1344 const svn_lock_t *lock,
1345 svn_wc_adm_access_t *adm_access,
1346 apr_pool_t *pool)
1347 {
1348 const char *local_abspath;
1349 svn_wc_context_t *wc_ctx;
1350
1351 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1352 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
1353 svn_wc__adm_get_db(adm_access),
1354 pool));
1355
1356 SVN_ERR(svn_wc_add_lock2(wc_ctx, local_abspath, lock, pool));
1357
1358 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1359 }
1360
1361 svn_error_t *
svn_wc_remove_lock(const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)1362 svn_wc_remove_lock(const char *path,
1363 svn_wc_adm_access_t *adm_access,
1364 apr_pool_t *pool)
1365 {
1366 const char *local_abspath;
1367 svn_wc_context_t *wc_ctx;
1368
1369 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1370 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
1371 svn_wc__adm_get_db(adm_access),
1372 pool));
1373
1374 SVN_ERR(svn_wc_remove_lock2(wc_ctx, local_abspath, pool));
1375
1376 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1377
1378 }
1379
1380 svn_error_t *
svn_wc_get_ancestry(char ** url,svn_revnum_t * rev,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)1381 svn_wc_get_ancestry(char **url,
1382 svn_revnum_t *rev,
1383 const char *path,
1384 svn_wc_adm_access_t *adm_access,
1385 apr_pool_t *pool)
1386 {
1387 const char *local_abspath;
1388 const svn_wc_entry_t *entry;
1389
1390 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1391
1392 SVN_ERR(svn_wc__get_entry(&entry, svn_wc__adm_get_db(adm_access),
1393 local_abspath, FALSE,
1394 svn_node_unknown,
1395 pool, pool));
1396
1397 if (url)
1398 *url = apr_pstrdup(pool, entry->url);
1399
1400 if (rev)
1401 *rev = entry->revision;
1402
1403 return SVN_NO_ERROR;
1404 }
1405
1406 svn_error_t *
svn_wc_set_changelist(const char * path,const char * changelist,svn_wc_adm_access_t * adm_access,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)1407 svn_wc_set_changelist(const char *path,
1408 const char *changelist,
1409 svn_wc_adm_access_t *adm_access,
1410 svn_cancel_func_t cancel_func,
1411 void *cancel_baton,
1412 svn_wc_notify_func2_t notify_func,
1413 void *notify_baton,
1414 apr_pool_t *pool)
1415 {
1416 const char *local_abspath;
1417 svn_wc_context_t *wc_ctx;
1418
1419 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1420 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
1421 svn_wc__adm_get_db(adm_access),
1422 pool));
1423
1424 SVN_ERR(svn_wc_set_changelist2(wc_ctx, local_abspath, changelist,
1425 svn_depth_empty, NULL,
1426 cancel_func, cancel_baton, notify_func,
1427 notify_baton, pool));
1428
1429 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1430 }
1431
1432
1433 /*** From diff.c ***/
1434 /* Used to wrap svn_wc_diff_callbacks_t. */
1435 struct diff_callbacks_wrapper_baton {
1436 const svn_wc_diff_callbacks_t *callbacks;
1437 void *baton;
1438 };
1439
1440 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1441 static svn_error_t *
wrap_3to1_file_changed(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * contentstate,svn_wc_notify_state_t * propstate,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,svn_revnum_t rev1,svn_revnum_t rev2,const char * mimetype1,const char * mimetype2,const apr_array_header_t * propchanges,apr_hash_t * originalprops,void * diff_baton)1442 wrap_3to1_file_changed(svn_wc_adm_access_t *adm_access,
1443 svn_wc_notify_state_t *contentstate,
1444 svn_wc_notify_state_t *propstate,
1445 svn_boolean_t *tree_conflicted,
1446 const char *path,
1447 const char *tmpfile1,
1448 const char *tmpfile2,
1449 svn_revnum_t rev1,
1450 svn_revnum_t rev2,
1451 const char *mimetype1,
1452 const char *mimetype2,
1453 const apr_array_header_t *propchanges,
1454 apr_hash_t *originalprops,
1455 void *diff_baton)
1456 {
1457 struct diff_callbacks_wrapper_baton *b = diff_baton;
1458
1459 if (tree_conflicted)
1460 *tree_conflicted = FALSE;
1461
1462 if (tmpfile2 != NULL)
1463 SVN_ERR(b->callbacks->file_changed(adm_access, contentstate, path,
1464 tmpfile1, tmpfile2,
1465 rev1, rev2, mimetype1, mimetype2,
1466 b->baton));
1467 if (propchanges->nelts > 0)
1468 SVN_ERR(b->callbacks->props_changed(adm_access, propstate, path,
1469 propchanges, originalprops,
1470 b->baton));
1471
1472 return SVN_NO_ERROR;
1473 }
1474
1475 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1476 static svn_error_t *
wrap_3to1_file_added(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * contentstate,svn_wc_notify_state_t * propstate,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,svn_revnum_t rev1,svn_revnum_t rev2,const char * mimetype1,const char * mimetype2,const apr_array_header_t * propchanges,apr_hash_t * originalprops,void * diff_baton)1477 wrap_3to1_file_added(svn_wc_adm_access_t *adm_access,
1478 svn_wc_notify_state_t *contentstate,
1479 svn_wc_notify_state_t *propstate,
1480 svn_boolean_t *tree_conflicted,
1481 const char *path,
1482 const char *tmpfile1,
1483 const char *tmpfile2,
1484 svn_revnum_t rev1,
1485 svn_revnum_t rev2,
1486 const char *mimetype1,
1487 const char *mimetype2,
1488 const apr_array_header_t *propchanges,
1489 apr_hash_t *originalprops,
1490 void *diff_baton)
1491 {
1492 struct diff_callbacks_wrapper_baton *b = diff_baton;
1493
1494 if (tree_conflicted)
1495 *tree_conflicted = FALSE;
1496
1497 SVN_ERR(b->callbacks->file_added(adm_access, contentstate, path,
1498 tmpfile1, tmpfile2, rev1, rev2,
1499 mimetype1, mimetype2, b->baton));
1500 if (propchanges->nelts > 0)
1501 SVN_ERR(b->callbacks->props_changed(adm_access, propstate, path,
1502 propchanges, originalprops,
1503 b->baton));
1504
1505 return SVN_NO_ERROR;
1506 }
1507
1508 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1509 static svn_error_t *
wrap_3to1_file_deleted(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,const char * mimetype1,const char * mimetype2,apr_hash_t * originalprops,void * diff_baton)1510 wrap_3to1_file_deleted(svn_wc_adm_access_t *adm_access,
1511 svn_wc_notify_state_t *state,
1512 svn_boolean_t *tree_conflicted,
1513 const char *path,
1514 const char *tmpfile1,
1515 const char *tmpfile2,
1516 const char *mimetype1,
1517 const char *mimetype2,
1518 apr_hash_t *originalprops,
1519 void *diff_baton)
1520 {
1521 struct diff_callbacks_wrapper_baton *b = diff_baton;
1522
1523 if (tree_conflicted)
1524 *tree_conflicted = FALSE;
1525
1526 SVN_ERR_ASSERT(originalprops);
1527
1528 return b->callbacks->file_deleted(adm_access, state, path,
1529 tmpfile1, tmpfile2, mimetype1, mimetype2,
1530 b->baton);
1531 }
1532
1533 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1534 static svn_error_t *
wrap_3to1_dir_added(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,svn_revnum_t rev,void * diff_baton)1535 wrap_3to1_dir_added(svn_wc_adm_access_t *adm_access,
1536 svn_wc_notify_state_t *state,
1537 svn_boolean_t *tree_conflicted,
1538 const char *path,
1539 svn_revnum_t rev,
1540 void *diff_baton)
1541 {
1542 struct diff_callbacks_wrapper_baton *b = diff_baton;
1543
1544 if (tree_conflicted)
1545 *tree_conflicted = FALSE;
1546
1547 return b->callbacks->dir_added(adm_access, state, path, rev, b->baton);
1548 }
1549
1550 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1551 static svn_error_t *
wrap_3to1_dir_deleted(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,void * diff_baton)1552 wrap_3to1_dir_deleted(svn_wc_adm_access_t *adm_access,
1553 svn_wc_notify_state_t *state,
1554 svn_boolean_t *tree_conflicted,
1555 const char *path,
1556 void *diff_baton)
1557 {
1558 struct diff_callbacks_wrapper_baton *b = diff_baton;
1559
1560 if (tree_conflicted)
1561 *tree_conflicted = FALSE;
1562
1563 return b->callbacks->dir_deleted(adm_access, state, path, b->baton);
1564 }
1565
1566 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1567 static svn_error_t *
wrap_3to1_dir_props_changed(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,const apr_array_header_t * propchanges,apr_hash_t * originalprops,void * diff_baton)1568 wrap_3to1_dir_props_changed(svn_wc_adm_access_t *adm_access,
1569 svn_wc_notify_state_t *state,
1570 svn_boolean_t *tree_conflicted,
1571 const char *path,
1572 const apr_array_header_t *propchanges,
1573 apr_hash_t *originalprops,
1574 void *diff_baton)
1575 {
1576 struct diff_callbacks_wrapper_baton *b = diff_baton;
1577
1578 if (tree_conflicted)
1579 *tree_conflicted = FALSE;
1580
1581 return b->callbacks->props_changed(adm_access, state, path, propchanges,
1582 originalprops, b->baton);
1583 }
1584
1585 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t
1586 and svn_wc_diff_callbacks2_t. */
1587 static svn_error_t *
wrap_3to1or2_dir_opened(svn_wc_adm_access_t * adm_access,svn_boolean_t * tree_conflicted,const char * path,svn_revnum_t rev,void * diff_baton)1588 wrap_3to1or2_dir_opened(svn_wc_adm_access_t *adm_access,
1589 svn_boolean_t *tree_conflicted,
1590 const char *path,
1591 svn_revnum_t rev,
1592 void *diff_baton)
1593 {
1594 if (tree_conflicted)
1595 *tree_conflicted = FALSE;
1596 /* Do nothing. */
1597 return SVN_NO_ERROR;
1598 }
1599
1600 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t
1601 and svn_wc_diff_callbacks2_t. */
1602 static svn_error_t *
wrap_3to1or2_dir_closed(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * propstate,svn_wc_notify_state_t * contentstate,svn_boolean_t * tree_conflicted,const char * path,void * diff_baton)1603 wrap_3to1or2_dir_closed(svn_wc_adm_access_t *adm_access,
1604 svn_wc_notify_state_t *propstate,
1605 svn_wc_notify_state_t *contentstate,
1606 svn_boolean_t *tree_conflicted,
1607 const char *path,
1608 void *diff_baton)
1609 {
1610 if (contentstate)
1611 *contentstate = svn_wc_notify_state_unknown;
1612 if (propstate)
1613 *propstate = svn_wc_notify_state_unknown;
1614 if (tree_conflicted)
1615 *tree_conflicted = FALSE;
1616 /* Do nothing. */
1617 return SVN_NO_ERROR;
1618 }
1619
1620 /* Used to wrap svn_diff_callbacks_t as an svn_wc_diff_callbacks3_t. */
1621 static struct svn_wc_diff_callbacks3_t diff_callbacks_wrapper = {
1622 wrap_3to1_file_changed,
1623 wrap_3to1_file_added,
1624 wrap_3to1_file_deleted,
1625 wrap_3to1_dir_added,
1626 wrap_3to1_dir_deleted,
1627 wrap_3to1_dir_props_changed,
1628 wrap_3to1or2_dir_opened,
1629 wrap_3to1or2_dir_closed
1630 };
1631
1632
1633
1634 /* Used to wrap svn_wc_diff_callbacks2_t. */
1635 struct diff_callbacks2_wrapper_baton {
1636 const svn_wc_diff_callbacks2_t *callbacks2;
1637 void *baton;
1638 };
1639
1640 /* An svn_wc_diff_callbacks3_t function for wrapping
1641 * svn_wc_diff_callbacks2_t. */
1642 static svn_error_t *
wrap_3to2_file_changed(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * contentstate,svn_wc_notify_state_t * propstate,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,svn_revnum_t rev1,svn_revnum_t rev2,const char * mimetype1,const char * mimetype2,const apr_array_header_t * propchanges,apr_hash_t * originalprops,void * diff_baton)1643 wrap_3to2_file_changed(svn_wc_adm_access_t *adm_access,
1644 svn_wc_notify_state_t *contentstate,
1645 svn_wc_notify_state_t *propstate,
1646 svn_boolean_t *tree_conflicted,
1647 const char *path,
1648 const char *tmpfile1,
1649 const char *tmpfile2,
1650 svn_revnum_t rev1,
1651 svn_revnum_t rev2,
1652 const char *mimetype1,
1653 const char *mimetype2,
1654 const apr_array_header_t *propchanges,
1655 apr_hash_t *originalprops,
1656 void *diff_baton)
1657 {
1658 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1659
1660 if (tree_conflicted)
1661 *tree_conflicted = FALSE;
1662
1663 return b->callbacks2->file_changed(adm_access, contentstate, propstate,
1664 path, tmpfile1, tmpfile2,
1665 rev1, rev2, mimetype1, mimetype2,
1666 propchanges, originalprops, b->baton);
1667 }
1668
1669 /* An svn_wc_diff_callbacks3_t function for wrapping
1670 * svn_wc_diff_callbacks2_t. */
1671 static svn_error_t *
wrap_3to2_file_added(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * contentstate,svn_wc_notify_state_t * propstate,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,svn_revnum_t rev1,svn_revnum_t rev2,const char * mimetype1,const char * mimetype2,const apr_array_header_t * propchanges,apr_hash_t * originalprops,void * diff_baton)1672 wrap_3to2_file_added(svn_wc_adm_access_t *adm_access,
1673 svn_wc_notify_state_t *contentstate,
1674 svn_wc_notify_state_t *propstate,
1675 svn_boolean_t *tree_conflicted,
1676 const char *path,
1677 const char *tmpfile1,
1678 const char *tmpfile2,
1679 svn_revnum_t rev1,
1680 svn_revnum_t rev2,
1681 const char *mimetype1,
1682 const char *mimetype2,
1683 const apr_array_header_t *propchanges,
1684 apr_hash_t *originalprops,
1685 void *diff_baton)
1686 {
1687 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1688
1689 if (tree_conflicted)
1690 *tree_conflicted = FALSE;
1691
1692 return b->callbacks2->file_added(adm_access, contentstate, propstate, path,
1693 tmpfile1, tmpfile2, rev1, rev2,
1694 mimetype1, mimetype2, propchanges,
1695 originalprops, b->baton);
1696 }
1697
1698 /* An svn_wc_diff_callbacks3_t function for wrapping
1699 * svn_wc_diff_callbacks2_t. */
1700 static svn_error_t *
wrap_3to2_file_deleted(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,const char * mimetype1,const char * mimetype2,apr_hash_t * originalprops,void * diff_baton)1701 wrap_3to2_file_deleted(svn_wc_adm_access_t *adm_access,
1702 svn_wc_notify_state_t *state,
1703 svn_boolean_t *tree_conflicted,
1704 const char *path,
1705 const char *tmpfile1,
1706 const char *tmpfile2,
1707 const char *mimetype1,
1708 const char *mimetype2,
1709 apr_hash_t *originalprops,
1710 void *diff_baton)
1711 {
1712 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1713
1714 if (tree_conflicted)
1715 *tree_conflicted = FALSE;
1716
1717 return b->callbacks2->file_deleted(adm_access, state, path,
1718 tmpfile1, tmpfile2, mimetype1, mimetype2,
1719 originalprops, b->baton);
1720 }
1721
1722 /* An svn_wc_diff_callbacks3_t function for wrapping
1723 * svn_wc_diff_callbacks2_t. */
1724 static svn_error_t *
wrap_3to2_dir_added(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,svn_revnum_t rev,void * diff_baton)1725 wrap_3to2_dir_added(svn_wc_adm_access_t *adm_access,
1726 svn_wc_notify_state_t *state,
1727 svn_boolean_t *tree_conflicted,
1728 const char *path,
1729 svn_revnum_t rev,
1730 void *diff_baton)
1731 {
1732 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1733
1734 if (tree_conflicted)
1735 *tree_conflicted = FALSE;
1736
1737 return b->callbacks2->dir_added(adm_access, state, path, rev, b->baton);
1738 }
1739
1740 /* An svn_wc_diff_callbacks3_t function for wrapping
1741 * svn_wc_diff_callbacks2_t. */
1742 static svn_error_t *
wrap_3to2_dir_deleted(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,void * diff_baton)1743 wrap_3to2_dir_deleted(svn_wc_adm_access_t *adm_access,
1744 svn_wc_notify_state_t *state,
1745 svn_boolean_t *tree_conflicted,
1746 const char *path,
1747 void *diff_baton)
1748 {
1749 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1750
1751 if (tree_conflicted)
1752 *tree_conflicted = FALSE;
1753
1754 return b->callbacks2->dir_deleted(adm_access, state, path, b->baton);
1755 }
1756
1757 /* An svn_wc_diff_callbacks3_t function for wrapping
1758 * svn_wc_diff_callbacks2_t. */
1759 static svn_error_t *
wrap_3to2_dir_props_changed(svn_wc_adm_access_t * adm_access,svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,const apr_array_header_t * propchanges,apr_hash_t * originalprops,void * diff_baton)1760 wrap_3to2_dir_props_changed(svn_wc_adm_access_t *adm_access,
1761 svn_wc_notify_state_t *state,
1762 svn_boolean_t *tree_conflicted,
1763 const char *path,
1764 const apr_array_header_t *propchanges,
1765 apr_hash_t *originalprops,
1766 void *diff_baton)
1767 {
1768 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1769
1770 if (tree_conflicted)
1771 *tree_conflicted = FALSE;
1772
1773 return b->callbacks2->dir_props_changed(adm_access, state, path, propchanges,
1774 originalprops, b->baton);
1775 }
1776
1777 /* Used to wrap svn_diff_callbacks2_t as an svn_wc_diff_callbacks3_t. */
1778 static struct svn_wc_diff_callbacks3_t diff_callbacks2_wrapper = {
1779 wrap_3to2_file_changed,
1780 wrap_3to2_file_added,
1781 wrap_3to2_file_deleted,
1782 wrap_3to2_dir_added,
1783 wrap_3to2_dir_deleted,
1784 wrap_3to2_dir_props_changed,
1785 wrap_3to1or2_dir_opened,
1786 wrap_3to1or2_dir_closed
1787 };
1788
1789
1790
1791 /* Used to wrap svn_wc_diff_callbacks3_t. */
1792 struct diff_callbacks3_wrapper_baton {
1793 const svn_wc_diff_callbacks3_t *callbacks3;
1794 svn_wc__db_t *db;
1795 void *baton;
1796 const char *anchor;
1797 const char *anchor_abspath;
1798 };
1799
1800 static svn_error_t *
wrap_4to3_file_opened(svn_boolean_t * tree_conflicted,svn_boolean_t * skip,const char * path,svn_revnum_t rev,void * diff_baton,apr_pool_t * scratch_pool)1801 wrap_4to3_file_opened(svn_boolean_t *tree_conflicted,
1802 svn_boolean_t *skip,
1803 const char *path,
1804 svn_revnum_t rev,
1805 void *diff_baton,
1806 apr_pool_t *scratch_pool)
1807 {
1808 return SVN_NO_ERROR;
1809 }
1810
1811 /* An svn_wc_diff_callbacks4_t function for wrapping
1812 * svn_wc_diff_callbacks3_t. */
1813 static svn_error_t *
wrap_4to3_file_changed(svn_wc_notify_state_t * contentstate,svn_wc_notify_state_t * propstate,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,svn_revnum_t rev1,svn_revnum_t rev2,const char * mimetype1,const char * mimetype2,const apr_array_header_t * propchanges,apr_hash_t * originalprops,void * diff_baton,apr_pool_t * scratch_pool)1814 wrap_4to3_file_changed(svn_wc_notify_state_t *contentstate,
1815 svn_wc_notify_state_t *propstate,
1816 svn_boolean_t *tree_conflicted,
1817 const char *path,
1818 const char *tmpfile1,
1819 const char *tmpfile2,
1820 svn_revnum_t rev1,
1821 svn_revnum_t rev2,
1822 const char *mimetype1,
1823 const char *mimetype2,
1824 const apr_array_header_t *propchanges,
1825 apr_hash_t *originalprops,
1826 void *diff_baton,
1827 apr_pool_t *scratch_pool)
1828 {
1829 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1830 svn_wc_adm_access_t *adm_access;
1831 const char *dir = svn_relpath_dirname(path, scratch_pool);
1832
1833 adm_access = svn_wc__adm_retrieve_internal2(
1834 b->db,
1835 svn_dirent_join(b->anchor_abspath, dir, scratch_pool),
1836 scratch_pool);
1837
1838 return b->callbacks3->file_changed(adm_access, contentstate, propstate,
1839 tree_conflicted,
1840 svn_dirent_join(b->anchor, path,
1841 scratch_pool),
1842 tmpfile1, tmpfile2,
1843 rev1, rev2, mimetype1, mimetype2,
1844 propchanges, originalprops, b->baton);
1845 }
1846
1847 /* An svn_wc_diff_callbacks4_t function for wrapping
1848 * svn_wc_diff_callbacks3_t. */
1849 static svn_error_t *
wrap_4to3_file_added(svn_wc_notify_state_t * contentstate,svn_wc_notify_state_t * propstate,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,svn_revnum_t rev1,svn_revnum_t rev2,const char * mimetype1,const char * mimetype2,const char * copyfrom_path,svn_revnum_t copyfrom_revision,const apr_array_header_t * propchanges,apr_hash_t * originalprops,void * diff_baton,apr_pool_t * scratch_pool)1850 wrap_4to3_file_added(svn_wc_notify_state_t *contentstate,
1851 svn_wc_notify_state_t *propstate,
1852 svn_boolean_t *tree_conflicted,
1853 const char *path,
1854 const char *tmpfile1,
1855 const char *tmpfile2,
1856 svn_revnum_t rev1,
1857 svn_revnum_t rev2,
1858 const char *mimetype1,
1859 const char *mimetype2,
1860 const char *copyfrom_path,
1861 svn_revnum_t copyfrom_revision,
1862 const apr_array_header_t *propchanges,
1863 apr_hash_t *originalprops,
1864 void *diff_baton,
1865 apr_pool_t *scratch_pool)
1866 {
1867 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1868 svn_wc_adm_access_t *adm_access;
1869 const char *dir = svn_relpath_dirname(path, scratch_pool);
1870
1871 adm_access = svn_wc__adm_retrieve_internal2(
1872 b->db,
1873 svn_dirent_join(b->anchor_abspath, dir, scratch_pool),
1874 scratch_pool);
1875
1876 return b->callbacks3->file_added(adm_access, contentstate, propstate,
1877 tree_conflicted,
1878 svn_dirent_join(b->anchor, path,
1879 scratch_pool),
1880 tmpfile1, tmpfile2,
1881 rev1, rev2, mimetype1, mimetype2,
1882 propchanges, originalprops, b->baton);
1883 }
1884
1885 /* An svn_wc_diff_callbacks4_t function for wrapping
1886 * svn_wc_diff_callbacks3_t. */
1887 static svn_error_t *
wrap_4to3_file_deleted(svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,const char * tmpfile1,const char * tmpfile2,const char * mimetype1,const char * mimetype2,apr_hash_t * originalprops,void * diff_baton,apr_pool_t * scratch_pool)1888 wrap_4to3_file_deleted(svn_wc_notify_state_t *state,
1889 svn_boolean_t *tree_conflicted,
1890 const char *path,
1891 const char *tmpfile1,
1892 const char *tmpfile2,
1893 const char *mimetype1,
1894 const char *mimetype2,
1895 apr_hash_t *originalprops,
1896 void *diff_baton,
1897 apr_pool_t *scratch_pool)
1898 {
1899 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1900 svn_wc_adm_access_t *adm_access;
1901 const char *dir = svn_relpath_dirname(path, scratch_pool);
1902
1903 adm_access = svn_wc__adm_retrieve_internal2(
1904 b->db,
1905 svn_dirent_join(b->anchor_abspath, dir, scratch_pool),
1906 scratch_pool);
1907
1908 return b->callbacks3->file_deleted(adm_access, state, tree_conflicted,
1909 svn_dirent_join(b->anchor, path,
1910 scratch_pool),
1911 tmpfile1, tmpfile2,
1912 mimetype1, mimetype2, originalprops,
1913 b->baton);
1914 }
1915
1916 /* An svn_wc_diff_callbacks4_t function for wrapping
1917 * svn_wc_diff_callbacks3_t. */
1918 static svn_error_t *
wrap_4to3_dir_added(svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,svn_boolean_t * skip,svn_boolean_t * skip_children,const char * path,svn_revnum_t rev,const char * copyfrom_path,svn_revnum_t copyfrom_revision,void * diff_baton,apr_pool_t * scratch_pool)1919 wrap_4to3_dir_added(svn_wc_notify_state_t *state,
1920 svn_boolean_t *tree_conflicted,
1921 svn_boolean_t *skip,
1922 svn_boolean_t *skip_children,
1923 const char *path,
1924 svn_revnum_t rev,
1925 const char *copyfrom_path,
1926 svn_revnum_t copyfrom_revision,
1927 void *diff_baton,
1928 apr_pool_t *scratch_pool)
1929 {
1930 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1931 svn_wc_adm_access_t *adm_access;
1932
1933 adm_access = svn_wc__adm_retrieve_internal2(
1934 b->db,
1935 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
1936 scratch_pool);
1937
1938 return b->callbacks3->dir_added(adm_access, state, tree_conflicted,
1939 svn_dirent_join(b->anchor, path,
1940 scratch_pool),
1941 rev, b->baton);
1942 }
1943
1944 /* An svn_wc_diff_callbacks4_t function for wrapping
1945 * svn_wc_diff_callbacks3_t. */
1946 static svn_error_t *
wrap_4to3_dir_deleted(svn_wc_notify_state_t * state,svn_boolean_t * tree_conflicted,const char * path,void * diff_baton,apr_pool_t * scratch_pool)1947 wrap_4to3_dir_deleted(svn_wc_notify_state_t *state,
1948 svn_boolean_t *tree_conflicted,
1949 const char *path,
1950 void *diff_baton,
1951 apr_pool_t *scratch_pool)
1952 {
1953 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1954 svn_wc_adm_access_t *adm_access;
1955
1956 adm_access = svn_wc__adm_retrieve_internal2(
1957 b->db,
1958 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
1959 scratch_pool);
1960
1961 return b->callbacks3->dir_deleted(adm_access, state, tree_conflicted,
1962 svn_dirent_join(b->anchor, path,
1963 scratch_pool),
1964 b->baton);
1965 }
1966
1967 /* An svn_wc_diff_callbacks4_t function for wrapping
1968 * svn_wc_diff_callbacks3_t. */
1969 static svn_error_t *
wrap_4to3_dir_props_changed(svn_wc_notify_state_t * propstate,svn_boolean_t * tree_conflicted,const char * path,svn_boolean_t dir_was_added,const apr_array_header_t * propchanges,apr_hash_t * original_props,void * diff_baton,apr_pool_t * scratch_pool)1970 wrap_4to3_dir_props_changed(svn_wc_notify_state_t *propstate,
1971 svn_boolean_t *tree_conflicted,
1972 const char *path,
1973 svn_boolean_t dir_was_added,
1974 const apr_array_header_t *propchanges,
1975 apr_hash_t *original_props,
1976 void *diff_baton,
1977 apr_pool_t *scratch_pool)
1978 {
1979 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1980 svn_wc_adm_access_t *adm_access;
1981
1982 adm_access = svn_wc__adm_retrieve_internal2(
1983 b->db,
1984 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
1985 scratch_pool);
1986
1987 return b->callbacks3->dir_props_changed(adm_access, propstate,
1988 tree_conflicted,
1989 svn_dirent_join(b->anchor, path,
1990 scratch_pool),
1991 propchanges, original_props,
1992 b->baton);
1993 }
1994
1995 /* An svn_wc_diff_callbacks4_t function for wrapping
1996 * svn_wc_diff_callbacks3_t. */
1997 static svn_error_t *
wrap_4to3_dir_opened(svn_boolean_t * tree_conflicted,svn_boolean_t * skip,svn_boolean_t * skip_children,const char * path,svn_revnum_t rev,void * diff_baton,apr_pool_t * scratch_pool)1998 wrap_4to3_dir_opened(svn_boolean_t *tree_conflicted,
1999 svn_boolean_t *skip,
2000 svn_boolean_t *skip_children,
2001 const char *path,
2002 svn_revnum_t rev,
2003 void *diff_baton,
2004 apr_pool_t *scratch_pool)
2005 {
2006 struct diff_callbacks3_wrapper_baton *b = diff_baton;
2007 svn_wc_adm_access_t *adm_access;
2008
2009 adm_access = svn_wc__adm_retrieve_internal2(
2010 b->db,
2011 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
2012 scratch_pool);
2013 if (skip_children)
2014 *skip_children = FALSE;
2015
2016 return b->callbacks3->dir_opened(adm_access, tree_conflicted,
2017 svn_dirent_join(b->anchor, path,
2018 scratch_pool),
2019 rev, b->baton);
2020 }
2021
2022 /* An svn_wc_diff_callbacks4_t function for wrapping
2023 * svn_wc_diff_callbacks3_t. */
2024 static svn_error_t *
wrap_4to3_dir_closed(svn_wc_notify_state_t * contentstate,svn_wc_notify_state_t * propstate,svn_boolean_t * tree_conflicted,const char * path,svn_boolean_t dir_was_added,void * diff_baton,apr_pool_t * scratch_pool)2025 wrap_4to3_dir_closed(svn_wc_notify_state_t *contentstate,
2026 svn_wc_notify_state_t *propstate,
2027 svn_boolean_t *tree_conflicted,
2028 const char *path,
2029 svn_boolean_t dir_was_added,
2030 void *diff_baton,
2031 apr_pool_t *scratch_pool)
2032 {
2033 struct diff_callbacks3_wrapper_baton *b = diff_baton;
2034 svn_wc_adm_access_t *adm_access;
2035
2036 adm_access = svn_wc__adm_retrieve_internal2(
2037 b->db,
2038 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
2039 scratch_pool);
2040
2041 return b->callbacks3->dir_closed(adm_access, contentstate, propstate,
2042 tree_conflicted,
2043 svn_dirent_join(b->anchor, path,
2044 scratch_pool),
2045 b->baton);
2046 }
2047
2048
2049 /* Used to wrap svn_diff_callbacks3_t as an svn_wc_diff_callbacks4_t. */
2050 static struct svn_wc_diff_callbacks4_t diff_callbacks3_wrapper = {
2051 wrap_4to3_file_opened,
2052 wrap_4to3_file_changed,
2053 wrap_4to3_file_added,
2054 wrap_4to3_file_deleted,
2055 wrap_4to3_dir_deleted,
2056 wrap_4to3_dir_opened,
2057 wrap_4to3_dir_added,
2058 wrap_4to3_dir_props_changed,
2059 wrap_4to3_dir_closed
2060 };
2061
2062
2063 svn_error_t *
svn_wc_get_diff_editor6(const svn_delta_editor_t ** editor,void ** edit_baton,svn_wc_context_t * wc_ctx,const char * anchor_abspath,const char * target,svn_depth_t depth,svn_boolean_t ignore_ancestry,svn_boolean_t show_copies_as_adds,svn_boolean_t use_git_diff_format,svn_boolean_t use_text_base,svn_boolean_t reverse_order,svn_boolean_t server_performs_filtering,const apr_array_header_t * changelist_filter,const svn_wc_diff_callbacks4_t * callbacks,void * callback_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * result_pool,apr_pool_t * scratch_pool)2064 svn_wc_get_diff_editor6(const svn_delta_editor_t **editor,
2065 void **edit_baton,
2066 svn_wc_context_t *wc_ctx,
2067 const char *anchor_abspath,
2068 const char *target,
2069 svn_depth_t depth,
2070 svn_boolean_t ignore_ancestry,
2071 svn_boolean_t show_copies_as_adds,
2072 svn_boolean_t use_git_diff_format,
2073 svn_boolean_t use_text_base,
2074 svn_boolean_t reverse_order,
2075 svn_boolean_t server_performs_filtering,
2076 const apr_array_header_t *changelist_filter,
2077 const svn_wc_diff_callbacks4_t *callbacks,
2078 void *callback_baton,
2079 svn_cancel_func_t cancel_func,
2080 void *cancel_baton,
2081 apr_pool_t *result_pool,
2082 apr_pool_t *scratch_pool)
2083 {
2084 const svn_diff_tree_processor_t *diff_processor;
2085
2086 /* --git implies --show-copies-as-adds */
2087 if (use_git_diff_format)
2088 show_copies_as_adds = TRUE;
2089
2090 /* --show-copies-as-adds implies --notice-ancestry */
2091 if (show_copies_as_adds)
2092 ignore_ancestry = FALSE;
2093
2094 SVN_ERR(svn_wc__wrap_diff_callbacks(&diff_processor,
2095 callbacks, callback_baton, TRUE,
2096 result_pool, scratch_pool));
2097
2098 if (reverse_order)
2099 diff_processor = svn_diff__tree_processor_reverse_create(diff_processor, result_pool);
2100
2101 if (! show_copies_as_adds)
2102 diff_processor = svn_diff__tree_processor_copy_as_changed_create(
2103 diff_processor, result_pool);
2104
2105 return svn_error_trace(
2106 svn_wc__get_diff_editor(editor, edit_baton,
2107 wc_ctx,
2108 anchor_abspath, target,
2109 depth,
2110 ignore_ancestry, use_text_base,
2111 reverse_order, server_performs_filtering,
2112 changelist_filter,
2113 diff_processor,
2114 cancel_func, cancel_baton,
2115 result_pool, scratch_pool));
2116 }
2117
2118
2119 svn_error_t *
svn_wc_get_diff_editor5(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks3_t * callbacks,void * callback_baton,svn_depth_t depth,svn_boolean_t ignore_ancestry,svn_boolean_t use_text_base,svn_boolean_t reverse_order,svn_cancel_func_t cancel_func,void * cancel_baton,const apr_array_header_t * changelist_filter,const svn_delta_editor_t ** editor,void ** edit_baton,apr_pool_t * pool)2120 svn_wc_get_diff_editor5(svn_wc_adm_access_t *anchor,
2121 const char *target,
2122 const svn_wc_diff_callbacks3_t *callbacks,
2123 void *callback_baton,
2124 svn_depth_t depth,
2125 svn_boolean_t ignore_ancestry,
2126 svn_boolean_t use_text_base,
2127 svn_boolean_t reverse_order,
2128 svn_cancel_func_t cancel_func,
2129 void *cancel_baton,
2130 const apr_array_header_t *changelist_filter,
2131 const svn_delta_editor_t **editor,
2132 void **edit_baton,
2133 apr_pool_t *pool)
2134 {
2135 struct diff_callbacks3_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2136 svn_wc_context_t *wc_ctx;
2137 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
2138
2139 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
2140
2141 b->callbacks3 = callbacks;
2142 b->baton = callback_baton;
2143 b->db = db;
2144 b->anchor = svn_wc_adm_access_path(anchor);
2145 b->anchor_abspath = svn_wc__adm_access_abspath(anchor);
2146
2147 SVN_ERR(svn_wc_get_diff_editor6(editor,
2148 edit_baton,
2149 wc_ctx,
2150 b->anchor_abspath,
2151 target,
2152 depth,
2153 ignore_ancestry,
2154 FALSE,
2155 FALSE,
2156 use_text_base,
2157 reverse_order,
2158 FALSE,
2159 changelist_filter,
2160 &diff_callbacks3_wrapper,
2161 b,
2162 cancel_func,
2163 cancel_baton,
2164 pool,
2165 pool));
2166
2167 /* Can't destroy wc_ctx. It is used by the diff editor */
2168
2169 return SVN_NO_ERROR;
2170 }
2171
2172 svn_error_t *
svn_wc_get_diff_editor4(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks2_t * callbacks,void * callback_baton,svn_depth_t depth,svn_boolean_t ignore_ancestry,svn_boolean_t use_text_base,svn_boolean_t reverse_order,svn_cancel_func_t cancel_func,void * cancel_baton,const apr_array_header_t * changelist_filter,const svn_delta_editor_t ** editor,void ** edit_baton,apr_pool_t * pool)2173 svn_wc_get_diff_editor4(svn_wc_adm_access_t *anchor,
2174 const char *target,
2175 const svn_wc_diff_callbacks2_t *callbacks,
2176 void *callback_baton,
2177 svn_depth_t depth,
2178 svn_boolean_t ignore_ancestry,
2179 svn_boolean_t use_text_base,
2180 svn_boolean_t reverse_order,
2181 svn_cancel_func_t cancel_func,
2182 void *cancel_baton,
2183 const apr_array_header_t *changelist_filter,
2184 const svn_delta_editor_t **editor,
2185 void **edit_baton,
2186 apr_pool_t *pool)
2187 {
2188 struct diff_callbacks2_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2189 b->callbacks2 = callbacks;
2190 b->baton = callback_baton;
2191 return svn_wc_get_diff_editor5(anchor,
2192 target,
2193 &diff_callbacks2_wrapper,
2194 b,
2195 depth,
2196 ignore_ancestry,
2197 use_text_base,
2198 reverse_order,
2199 cancel_func,
2200 cancel_baton,
2201 changelist_filter,
2202 editor,
2203 edit_baton,
2204 pool);
2205 }
2206
2207 svn_error_t *
svn_wc_get_diff_editor3(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks2_t * callbacks,void * callback_baton,svn_boolean_t recurse,svn_boolean_t ignore_ancestry,svn_boolean_t use_text_base,svn_boolean_t reverse_order,svn_cancel_func_t cancel_func,void * cancel_baton,const svn_delta_editor_t ** editor,void ** edit_baton,apr_pool_t * pool)2208 svn_wc_get_diff_editor3(svn_wc_adm_access_t *anchor,
2209 const char *target,
2210 const svn_wc_diff_callbacks2_t *callbacks,
2211 void *callback_baton,
2212 svn_boolean_t recurse,
2213 svn_boolean_t ignore_ancestry,
2214 svn_boolean_t use_text_base,
2215 svn_boolean_t reverse_order,
2216 svn_cancel_func_t cancel_func,
2217 void *cancel_baton,
2218 const svn_delta_editor_t **editor,
2219 void **edit_baton,
2220 apr_pool_t *pool)
2221 {
2222 return svn_wc_get_diff_editor4(anchor,
2223 target,
2224 callbacks,
2225 callback_baton,
2226 SVN_DEPTH_INFINITY_OR_FILES(recurse),
2227 ignore_ancestry,
2228 use_text_base,
2229 reverse_order,
2230 cancel_func,
2231 cancel_baton,
2232 NULL,
2233 editor,
2234 edit_baton,
2235 pool);
2236 }
2237
2238 svn_error_t *
svn_wc_get_diff_editor2(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks_t * callbacks,void * callback_baton,svn_boolean_t recurse,svn_boolean_t ignore_ancestry,svn_boolean_t use_text_base,svn_boolean_t reverse_order,svn_cancel_func_t cancel_func,void * cancel_baton,const svn_delta_editor_t ** editor,void ** edit_baton,apr_pool_t * pool)2239 svn_wc_get_diff_editor2(svn_wc_adm_access_t *anchor,
2240 const char *target,
2241 const svn_wc_diff_callbacks_t *callbacks,
2242 void *callback_baton,
2243 svn_boolean_t recurse,
2244 svn_boolean_t ignore_ancestry,
2245 svn_boolean_t use_text_base,
2246 svn_boolean_t reverse_order,
2247 svn_cancel_func_t cancel_func,
2248 void *cancel_baton,
2249 const svn_delta_editor_t **editor,
2250 void **edit_baton,
2251 apr_pool_t *pool)
2252 {
2253 struct diff_callbacks_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2254 b->callbacks = callbacks;
2255 b->baton = callback_baton;
2256 return svn_wc_get_diff_editor5(anchor, target, &diff_callbacks_wrapper, b,
2257 SVN_DEPTH_INFINITY_OR_FILES(recurse),
2258 ignore_ancestry, use_text_base,
2259 reverse_order, cancel_func, cancel_baton,
2260 NULL, editor, edit_baton, pool);
2261 }
2262
2263 svn_error_t *
svn_wc_get_diff_editor(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks_t * callbacks,void * callback_baton,svn_boolean_t recurse,svn_boolean_t use_text_base,svn_boolean_t reverse_order,svn_cancel_func_t cancel_func,void * cancel_baton,const svn_delta_editor_t ** editor,void ** edit_baton,apr_pool_t * pool)2264 svn_wc_get_diff_editor(svn_wc_adm_access_t *anchor,
2265 const char *target,
2266 const svn_wc_diff_callbacks_t *callbacks,
2267 void *callback_baton,
2268 svn_boolean_t recurse,
2269 svn_boolean_t use_text_base,
2270 svn_boolean_t reverse_order,
2271 svn_cancel_func_t cancel_func,
2272 void *cancel_baton,
2273 const svn_delta_editor_t **editor,
2274 void **edit_baton,
2275 apr_pool_t *pool)
2276 {
2277 return svn_wc_get_diff_editor2(anchor, target, callbacks, callback_baton,
2278 recurse, FALSE, use_text_base, reverse_order,
2279 cancel_func, cancel_baton,
2280 editor, edit_baton, pool);
2281 }
2282
2283 svn_error_t *
svn_wc_diff5(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks3_t * callbacks,void * callback_baton,svn_depth_t depth,svn_boolean_t ignore_ancestry,const apr_array_header_t * changelist_filter,apr_pool_t * pool)2284 svn_wc_diff5(svn_wc_adm_access_t *anchor,
2285 const char *target,
2286 const svn_wc_diff_callbacks3_t *callbacks,
2287 void *callback_baton,
2288 svn_depth_t depth,
2289 svn_boolean_t ignore_ancestry,
2290 const apr_array_header_t *changelist_filter,
2291 apr_pool_t *pool)
2292 {
2293 struct diff_callbacks3_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2294 svn_wc_context_t *wc_ctx;
2295 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
2296
2297 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
2298
2299 b->callbacks3 = callbacks;
2300 b->baton = callback_baton;
2301 b->anchor = svn_wc_adm_access_path(anchor);
2302 b->anchor_abspath = svn_wc__adm_access_abspath(anchor);
2303
2304 SVN_ERR(svn_wc_diff6(wc_ctx,
2305 svn_dirent_join(b->anchor_abspath, target, pool),
2306 &diff_callbacks3_wrapper,
2307 b,
2308 depth,
2309 ignore_ancestry,
2310 FALSE,
2311 FALSE,
2312 changelist_filter,
2313 NULL, NULL,
2314 pool));
2315
2316 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
2317 }
2318
2319 svn_error_t *
svn_wc_diff4(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks2_t * callbacks,void * callback_baton,svn_depth_t depth,svn_boolean_t ignore_ancestry,const apr_array_header_t * changelist_filter,apr_pool_t * pool)2320 svn_wc_diff4(svn_wc_adm_access_t *anchor,
2321 const char *target,
2322 const svn_wc_diff_callbacks2_t *callbacks,
2323 void *callback_baton,
2324 svn_depth_t depth,
2325 svn_boolean_t ignore_ancestry,
2326 const apr_array_header_t *changelist_filter,
2327 apr_pool_t *pool)
2328 {
2329 struct diff_callbacks2_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2330 b->callbacks2 = callbacks;
2331 b->baton = callback_baton;
2332
2333 return svn_wc_diff5(anchor, target, &diff_callbacks2_wrapper, b,
2334 depth, ignore_ancestry, changelist_filter, pool);
2335 }
2336
2337 svn_error_t *
svn_wc_diff3(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks2_t * callbacks,void * callback_baton,svn_boolean_t recurse,svn_boolean_t ignore_ancestry,apr_pool_t * pool)2338 svn_wc_diff3(svn_wc_adm_access_t *anchor,
2339 const char *target,
2340 const svn_wc_diff_callbacks2_t *callbacks,
2341 void *callback_baton,
2342 svn_boolean_t recurse,
2343 svn_boolean_t ignore_ancestry,
2344 apr_pool_t *pool)
2345 {
2346 return svn_wc_diff4(anchor, target, callbacks, callback_baton,
2347 SVN_DEPTH_INFINITY_OR_FILES(recurse), ignore_ancestry,
2348 NULL, pool);
2349 }
2350
2351 svn_error_t *
svn_wc_diff2(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks_t * callbacks,void * callback_baton,svn_boolean_t recurse,svn_boolean_t ignore_ancestry,apr_pool_t * pool)2352 svn_wc_diff2(svn_wc_adm_access_t *anchor,
2353 const char *target,
2354 const svn_wc_diff_callbacks_t *callbacks,
2355 void *callback_baton,
2356 svn_boolean_t recurse,
2357 svn_boolean_t ignore_ancestry,
2358 apr_pool_t *pool)
2359 {
2360 struct diff_callbacks_wrapper_baton *b = apr_pcalloc(pool, sizeof(*b));
2361 b->callbacks = callbacks;
2362 b->baton = callback_baton;
2363 return svn_wc_diff5(anchor, target, &diff_callbacks_wrapper, b,
2364 SVN_DEPTH_INFINITY_OR_FILES(recurse), ignore_ancestry,
2365 NULL, pool);
2366 }
2367
2368 svn_error_t *
svn_wc_diff(svn_wc_adm_access_t * anchor,const char * target,const svn_wc_diff_callbacks_t * callbacks,void * callback_baton,svn_boolean_t recurse,apr_pool_t * pool)2369 svn_wc_diff(svn_wc_adm_access_t *anchor,
2370 const char *target,
2371 const svn_wc_diff_callbacks_t *callbacks,
2372 void *callback_baton,
2373 svn_boolean_t recurse,
2374 apr_pool_t *pool)
2375 {
2376 return svn_wc_diff2(anchor, target, callbacks, callback_baton,
2377 recurse, FALSE, pool);
2378 }
2379
2380 /*** From entries.c ***/
2381 svn_error_t *
svn_wc_walk_entries2(const char * path,svn_wc_adm_access_t * adm_access,const svn_wc_entry_callbacks_t * walk_callbacks,void * walk_baton,svn_boolean_t show_hidden,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)2382 svn_wc_walk_entries2(const char *path,
2383 svn_wc_adm_access_t *adm_access,
2384 const svn_wc_entry_callbacks_t *walk_callbacks,
2385 void *walk_baton,
2386 svn_boolean_t show_hidden,
2387 svn_cancel_func_t cancel_func,
2388 void *cancel_baton,
2389 apr_pool_t *pool)
2390 {
2391 svn_wc_entry_callbacks2_t walk_cb2 = { 0 };
2392 walk_cb2.found_entry = walk_callbacks->found_entry;
2393 walk_cb2.handle_error = svn_wc__walker_default_error_handler;
2394 return svn_wc_walk_entries3(path, adm_access,
2395 &walk_cb2, walk_baton, svn_depth_infinity,
2396 show_hidden, cancel_func, cancel_baton, pool);
2397 }
2398
2399 svn_error_t *
svn_wc_walk_entries(const char * path,svn_wc_adm_access_t * adm_access,const svn_wc_entry_callbacks_t * walk_callbacks,void * walk_baton,svn_boolean_t show_hidden,apr_pool_t * pool)2400 svn_wc_walk_entries(const char *path,
2401 svn_wc_adm_access_t *adm_access,
2402 const svn_wc_entry_callbacks_t *walk_callbacks,
2403 void *walk_baton,
2404 svn_boolean_t show_hidden,
2405 apr_pool_t *pool)
2406 {
2407 return svn_wc_walk_entries2(path, adm_access, walk_callbacks,
2408 walk_baton, show_hidden, NULL, NULL,
2409 pool);
2410 }
2411
2412 svn_error_t *
svn_wc_mark_missing_deleted(const char * path,svn_wc_adm_access_t * parent,apr_pool_t * pool)2413 svn_wc_mark_missing_deleted(const char *path,
2414 svn_wc_adm_access_t *parent,
2415 apr_pool_t *pool)
2416 {
2417 /* With a single DB a node will never be missing */
2418 return svn_error_createf(SVN_ERR_WC_PATH_FOUND, NULL,
2419 _("Unexpectedly found '%s': "
2420 "path is marked 'missing'"),
2421 svn_dirent_local_style(path, pool));
2422 }
2423
2424
2425 /*** From props.c ***/
2426 svn_error_t *
svn_wc_parse_externals_description2(apr_array_header_t ** externals_p,const char * parent_directory,const char * desc,apr_pool_t * pool)2427 svn_wc_parse_externals_description2(apr_array_header_t **externals_p,
2428 const char *parent_directory,
2429 const char *desc,
2430 apr_pool_t *pool)
2431 {
2432 apr_array_header_t *list;
2433 apr_pool_t *subpool = svn_pool_create(pool);
2434
2435 SVN_ERR(svn_wc_parse_externals_description3(externals_p ? &list : NULL,
2436 parent_directory, desc,
2437 TRUE, subpool));
2438
2439 if (externals_p)
2440 {
2441 int i;
2442
2443 *externals_p = apr_array_make(pool, list->nelts,
2444 sizeof(svn_wc_external_item_t *));
2445 for (i = 0; i < list->nelts; i++)
2446 {
2447 svn_wc_external_item2_t *item2 = APR_ARRAY_IDX(list, i,
2448 svn_wc_external_item2_t *);
2449 svn_wc_external_item_t *item = apr_palloc(pool, sizeof (*item));
2450
2451 if (item2->target_dir)
2452 item->target_dir = apr_pstrdup(pool, item2->target_dir);
2453 if (item2->url)
2454 item->url = apr_pstrdup(pool, item2->url);
2455 item->revision = item2->revision;
2456
2457 APR_ARRAY_PUSH(*externals_p, svn_wc_external_item_t *) = item;
2458 }
2459 }
2460
2461 svn_pool_destroy(subpool);
2462
2463 return SVN_NO_ERROR;
2464 }
2465
2466
2467 svn_error_t *
svn_wc_parse_externals_description(apr_hash_t ** externals_p,const char * parent_directory,const char * desc,apr_pool_t * pool)2468 svn_wc_parse_externals_description(apr_hash_t **externals_p,
2469 const char *parent_directory,
2470 const char *desc,
2471 apr_pool_t *pool)
2472 {
2473 apr_array_header_t *list;
2474
2475 SVN_ERR(svn_wc_parse_externals_description2(externals_p ? &list : NULL,
2476 parent_directory, desc, pool));
2477
2478 /* Store all of the items into the hash if that was requested. */
2479 if (externals_p)
2480 {
2481 int i;
2482
2483 *externals_p = apr_hash_make(pool);
2484 for (i = 0; i < list->nelts; i++)
2485 {
2486 svn_wc_external_item_t *item;
2487 item = APR_ARRAY_IDX(list, i, svn_wc_external_item_t *);
2488
2489 svn_hash_sets(*externals_p, item->target_dir, item);
2490 }
2491 }
2492 return SVN_NO_ERROR;
2493 }
2494
2495 svn_error_t *
svn_wc_prop_set3(const char * name,const svn_string_t * value,const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t skip_checks,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)2496 svn_wc_prop_set3(const char *name,
2497 const svn_string_t *value,
2498 const char *path,
2499 svn_wc_adm_access_t *adm_access,
2500 svn_boolean_t skip_checks,
2501 svn_wc_notify_func2_t notify_func,
2502 void *notify_baton,
2503 apr_pool_t *pool)
2504 {
2505 svn_wc_context_t *wc_ctx;
2506 const char *local_abspath;
2507 svn_error_t *err;
2508
2509 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2510 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2511 svn_wc__adm_get_db(adm_access),
2512 pool));
2513
2514 err = svn_wc_prop_set4(wc_ctx, local_abspath,
2515 name, value,
2516 svn_depth_empty,
2517 skip_checks, NULL /* changelist_filter */,
2518 NULL, NULL /* cancellation */,
2519 notify_func, notify_baton,
2520 pool);
2521
2522 if (err && err->apr_err == SVN_ERR_WC_INVALID_SCHEDULE)
2523 svn_error_clear(err);
2524 else
2525 SVN_ERR(err);
2526
2527 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
2528 }
2529
2530 svn_error_t *
svn_wc_prop_set2(const char * name,const svn_string_t * value,const char * path,svn_wc_adm_access_t * adm_access,svn_boolean_t skip_checks,apr_pool_t * pool)2531 svn_wc_prop_set2(const char *name,
2532 const svn_string_t *value,
2533 const char *path,
2534 svn_wc_adm_access_t *adm_access,
2535 svn_boolean_t skip_checks,
2536 apr_pool_t *pool)
2537 {
2538 return svn_wc_prop_set3(name, value, path, adm_access, skip_checks,
2539 NULL, NULL, pool);
2540 }
2541
2542 svn_error_t *
svn_wc_prop_set(const char * name,const svn_string_t * value,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)2543 svn_wc_prop_set(const char *name,
2544 const svn_string_t *value,
2545 const char *path,
2546 svn_wc_adm_access_t *adm_access,
2547 apr_pool_t *pool)
2548 {
2549 return svn_wc_prop_set2(name, value, path, adm_access, FALSE, pool);
2550 }
2551
2552 svn_error_t *
svn_wc_prop_list(apr_hash_t ** props,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)2553 svn_wc_prop_list(apr_hash_t **props,
2554 const char *path,
2555 svn_wc_adm_access_t *adm_access,
2556 apr_pool_t *pool)
2557 {
2558 svn_wc_context_t *wc_ctx;
2559 const char *local_abspath;
2560 svn_error_t *err;
2561
2562 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2563 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2564 svn_wc__adm_get_db(adm_access), pool));
2565
2566 err = svn_wc_prop_list2(props, wc_ctx, local_abspath, pool, pool);
2567 if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
2568 {
2569 *props = apr_hash_make(pool);
2570 svn_error_clear(err);
2571 err = NULL;
2572 }
2573
2574 return svn_error_compose_create(err, svn_wc_context_destroy(wc_ctx));
2575 }
2576
2577 svn_error_t *
svn_wc_prop_get(const svn_string_t ** value,const char * name,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)2578 svn_wc_prop_get(const svn_string_t **value,
2579 const char *name,
2580 const char *path,
2581 svn_wc_adm_access_t *adm_access,
2582 apr_pool_t *pool)
2583 {
2584
2585 svn_wc_context_t *wc_ctx;
2586 const char *local_abspath;
2587 svn_error_t *err;
2588
2589 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2590 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2591 svn_wc__adm_get_db(adm_access), pool));
2592
2593 err = svn_wc_prop_get2(value, wc_ctx, local_abspath, name, pool, pool);
2594
2595 if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
2596 {
2597 *value = NULL;
2598 svn_error_clear(err);
2599 err = NULL;
2600 }
2601
2602 return svn_error_compose_create(err, svn_wc_context_destroy(wc_ctx));
2603 }
2604
2605 /* baton for conflict_func_1to2_wrapper */
2606 struct conflict_func_1to2_baton
2607 {
2608 svn_wc_conflict_resolver_func_t inner_func;
2609 void *inner_baton;
2610 };
2611
2612
2613 /* Implements svn_wc_conflict_resolver_func2_t */
2614 static svn_error_t *
conflict_func_1to2_wrapper(svn_wc_conflict_result_t ** result,const svn_wc_conflict_description2_t * conflict,void * baton,apr_pool_t * result_pool,apr_pool_t * scratch_pool)2615 conflict_func_1to2_wrapper(svn_wc_conflict_result_t **result,
2616 const svn_wc_conflict_description2_t *conflict,
2617 void *baton,
2618 apr_pool_t *result_pool,
2619 apr_pool_t *scratch_pool)
2620 {
2621 struct conflict_func_1to2_baton *btn = baton;
2622 svn_wc_conflict_description_t *cd = svn_wc__cd2_to_cd(conflict,
2623 scratch_pool);
2624
2625 return svn_error_trace(btn->inner_func(result, cd, btn->inner_baton,
2626 result_pool));
2627 }
2628
2629 svn_error_t *
svn_wc_merge_props2(svn_wc_notify_state_t * state,const char * path,svn_wc_adm_access_t * adm_access,apr_hash_t * baseprops,const apr_array_header_t * propchanges,svn_boolean_t base_merge,svn_boolean_t dry_run,svn_wc_conflict_resolver_func_t conflict_func,void * conflict_baton,apr_pool_t * scratch_pool)2630 svn_wc_merge_props2(svn_wc_notify_state_t *state,
2631 const char *path,
2632 svn_wc_adm_access_t *adm_access,
2633 apr_hash_t *baseprops,
2634 const apr_array_header_t *propchanges,
2635 svn_boolean_t base_merge,
2636 svn_boolean_t dry_run,
2637 svn_wc_conflict_resolver_func_t conflict_func,
2638 void *conflict_baton,
2639 apr_pool_t *scratch_pool)
2640 {
2641 const char *local_abspath;
2642 svn_error_t *err;
2643 svn_wc_context_t *wc_ctx;
2644 struct conflict_func_1to2_baton conflict_wrapper;
2645
2646 if (base_merge && !dry_run)
2647 return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
2648 U_("base_merge=TRUE is no longer supported; "
2649 "see notes/api-errata/1.7/wc006.txt"));
2650
2651 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
2652
2653 conflict_wrapper.inner_func = conflict_func;
2654 conflict_wrapper.inner_baton = conflict_baton;
2655
2656 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
2657 svn_wc__adm_get_db(adm_access),
2658 scratch_pool));
2659
2660 err = svn_wc_merge_props3(state,
2661 wc_ctx,
2662 local_abspath,
2663 NULL /* left_version */,
2664 NULL /* right_version */,
2665 baseprops,
2666 propchanges,
2667 dry_run,
2668 conflict_func ? conflict_func_1to2_wrapper
2669 : NULL,
2670 &conflict_wrapper,
2671 NULL, NULL,
2672 scratch_pool);
2673
2674 if (err)
2675 switch(err->apr_err)
2676 {
2677 case SVN_ERR_WC_PATH_NOT_FOUND:
2678 case SVN_ERR_WC_PATH_UNEXPECTED_STATUS:
2679 err->apr_err = SVN_ERR_UNVERSIONED_RESOURCE;
2680 break;
2681 }
2682 return svn_error_trace(
2683 svn_error_compose_create(err,
2684 svn_wc_context_destroy(wc_ctx)));
2685 }
2686
2687 svn_error_t *
svn_wc_merge_props(svn_wc_notify_state_t * state,const char * path,svn_wc_adm_access_t * adm_access,apr_hash_t * baseprops,const apr_array_header_t * propchanges,svn_boolean_t base_merge,svn_boolean_t dry_run,apr_pool_t * pool)2688 svn_wc_merge_props(svn_wc_notify_state_t *state,
2689 const char *path,
2690 svn_wc_adm_access_t *adm_access,
2691 apr_hash_t *baseprops,
2692 const apr_array_header_t *propchanges,
2693 svn_boolean_t base_merge,
2694 svn_boolean_t dry_run,
2695 apr_pool_t *pool)
2696 {
2697 return svn_wc_merge_props2(state, path, adm_access, baseprops, propchanges,
2698 base_merge, dry_run, NULL, NULL, pool);
2699 }
2700
2701
2702 svn_error_t *
svn_wc_merge_prop_diffs(svn_wc_notify_state_t * state,const char * path,svn_wc_adm_access_t * adm_access,const apr_array_header_t * propchanges,svn_boolean_t base_merge,svn_boolean_t dry_run,apr_pool_t * pool)2703 svn_wc_merge_prop_diffs(svn_wc_notify_state_t *state,
2704 const char *path,
2705 svn_wc_adm_access_t *adm_access,
2706 const apr_array_header_t *propchanges,
2707 svn_boolean_t base_merge,
2708 svn_boolean_t dry_run,
2709 apr_pool_t *pool)
2710 {
2711 /* NOTE: Here, we use implementation knowledge. The public
2712 svn_wc_merge_props2 doesn't allow NULL as baseprops argument, but we know
2713 that it works. */
2714 return svn_wc_merge_props2(state, path, adm_access, NULL, propchanges,
2715 base_merge, dry_run, NULL, NULL, pool);
2716 }
2717
2718 svn_error_t *
svn_wc_get_prop_diffs(apr_array_header_t ** propchanges,apr_hash_t ** original_props,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)2719 svn_wc_get_prop_diffs(apr_array_header_t **propchanges,
2720 apr_hash_t **original_props,
2721 const char *path,
2722 svn_wc_adm_access_t *adm_access,
2723 apr_pool_t *pool)
2724 {
2725 svn_wc_context_t *wc_ctx;
2726 const char *local_abspath;
2727
2728 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2729 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2730 svn_wc__adm_get_db(adm_access), pool));
2731
2732 SVN_ERR(svn_wc_get_prop_diffs2(propchanges, original_props, wc_ctx,
2733 local_abspath, pool, pool));
2734
2735 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
2736 }
2737
2738
2739 svn_error_t *
svn_wc_props_modified_p(svn_boolean_t * modified_p,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)2740 svn_wc_props_modified_p(svn_boolean_t *modified_p,
2741 const char *path,
2742 svn_wc_adm_access_t *adm_access,
2743 apr_pool_t *pool)
2744 {
2745 svn_wc_context_t *wc_ctx;
2746 const char *local_abspath;
2747 svn_error_t *err;
2748
2749 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2750 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2751 svn_wc__adm_get_db(adm_access), pool));
2752
2753 err = svn_wc_props_modified_p2(modified_p,
2754 wc_ctx,
2755 local_abspath,
2756 pool);
2757
2758 if (err)
2759 {
2760 if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
2761 return svn_error_trace(err);
2762
2763 svn_error_clear(err);
2764 *modified_p = FALSE;
2765 }
2766
2767 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
2768 }
2769
2770
2771 svn_error_t *
svn_wc__status2_from_3(svn_wc_status2_t ** status,const svn_wc_status3_t * old_status,svn_wc_context_t * wc_ctx,const char * local_abspath,apr_pool_t * result_pool,apr_pool_t * scratch_pool)2772 svn_wc__status2_from_3(svn_wc_status2_t **status,
2773 const svn_wc_status3_t *old_status,
2774 svn_wc_context_t *wc_ctx,
2775 const char *local_abspath,
2776 apr_pool_t *result_pool,
2777 apr_pool_t *scratch_pool)
2778 {
2779 const svn_wc_entry_t *entry = NULL;
2780
2781 if (old_status == NULL)
2782 {
2783 *status = NULL;
2784 return SVN_NO_ERROR;
2785 }
2786
2787 *status = apr_pcalloc(result_pool, sizeof(**status));
2788
2789 if (old_status->versioned)
2790 {
2791 svn_error_t *err;
2792 err= svn_wc__get_entry(&entry, wc_ctx->db, local_abspath, FALSE,
2793 svn_node_unknown, result_pool, scratch_pool);
2794
2795 if (err && err->apr_err == SVN_ERR_NODE_UNEXPECTED_KIND)
2796 svn_error_clear(err);
2797 else
2798 SVN_ERR(err);
2799 }
2800
2801 (*status)->entry = entry;
2802 (*status)->copied = old_status->copied;
2803 (*status)->repos_lock = svn_lock_dup(old_status->repos_lock, result_pool);
2804
2805 if (old_status->repos_relpath)
2806 (*status)->url = svn_path_url_add_component2(old_status->repos_root_url,
2807 old_status->repos_relpath,
2808 result_pool);
2809 (*status)->ood_last_cmt_rev = old_status->ood_changed_rev;
2810 (*status)->ood_last_cmt_date = old_status->ood_changed_date;
2811 (*status)->ood_kind = old_status->ood_kind;
2812 (*status)->ood_last_cmt_author = old_status->ood_changed_author;
2813
2814 if (old_status->conflicted)
2815 {
2816 const svn_wc_conflict_description2_t *tree_conflict2;
2817 SVN_ERR(svn_wc__get_tree_conflict(&tree_conflict2, wc_ctx, local_abspath,
2818 scratch_pool, scratch_pool));
2819 (*status)->tree_conflict = svn_wc__cd2_to_cd(tree_conflict2, result_pool);
2820 }
2821
2822 (*status)->switched = old_status->switched;
2823
2824 (*status)->text_status = old_status->node_status;
2825 (*status)->prop_status = old_status->prop_status;
2826
2827 (*status)->repos_text_status = old_status->repos_node_status;
2828 (*status)->repos_prop_status = old_status->repos_prop_status;
2829
2830 /* Some values might be inherited from properties */
2831 if (old_status->node_status == svn_wc_status_modified
2832 || old_status->node_status == svn_wc_status_conflicted)
2833 (*status)->text_status = old_status->text_status;
2834
2835 /* (Currently a no-op, but just make sure it is ok) */
2836 if (old_status->repos_node_status == svn_wc_status_modified
2837 || old_status->repos_node_status == svn_wc_status_conflicted)
2838 (*status)->repos_text_status = old_status->repos_text_status;
2839
2840 if (old_status->node_status == svn_wc_status_added)
2841 (*status)->prop_status = svn_wc_status_none; /* No separate info */
2842
2843 /* Find pristine_text_status value */
2844 switch (old_status->text_status)
2845 {
2846 case svn_wc_status_none:
2847 case svn_wc_status_normal:
2848 case svn_wc_status_modified:
2849 (*status)->pristine_text_status = old_status->text_status;
2850 break;
2851 case svn_wc_status_conflicted:
2852 default:
2853 /* ### Fetch compare data, or fall back to the documented
2854 not retrieved behavior? */
2855 (*status)->pristine_text_status = svn_wc_status_none;
2856 break;
2857 }
2858
2859 /* Find pristine_prop_status value */
2860 switch (old_status->prop_status)
2861 {
2862 case svn_wc_status_none:
2863 case svn_wc_status_normal:
2864 case svn_wc_status_modified:
2865 if (old_status->node_status != svn_wc_status_added
2866 && old_status->node_status != svn_wc_status_deleted
2867 && old_status->node_status != svn_wc_status_replaced)
2868 {
2869 (*status)->pristine_prop_status = old_status->prop_status;
2870 }
2871 else
2872 (*status)->pristine_prop_status = svn_wc_status_none;
2873 break;
2874 case svn_wc_status_conflicted:
2875 default:
2876 /* ### Fetch compare data, or fall back to the documented
2877 not retrieved behavior? */
2878 (*status)->pristine_prop_status = svn_wc_status_none;
2879 break;
2880 }
2881
2882 if (old_status->versioned
2883 && old_status->conflicted
2884 && old_status->node_status != svn_wc_status_obstructed
2885 && (old_status->kind == svn_node_file
2886 || old_status->node_status != svn_wc_status_missing))
2887 {
2888 svn_boolean_t text_conflict_p, prop_conflict_p;
2889
2890 /* The entry says there was a conflict, but the user might have
2891 marked it as resolved by deleting the artifact files, so check
2892 for that. */
2893 SVN_ERR(svn_wc__internal_conflicted_p(&text_conflict_p,
2894 &prop_conflict_p,
2895 NULL,
2896 wc_ctx->db, local_abspath,
2897 scratch_pool));
2898
2899 if (text_conflict_p)
2900 (*status)->text_status = svn_wc_status_conflicted;
2901
2902 if (prop_conflict_p)
2903 (*status)->prop_status = svn_wc_status_conflicted;
2904 }
2905
2906 return SVN_NO_ERROR;
2907 }
2908
2909
2910
2911 /*** From status.c ***/
2912
2913 struct status4_wrapper_baton
2914 {
2915 svn_wc_status_func3_t old_func;
2916 void *old_baton;
2917 const char *anchor_abspath;
2918 const char *anchor_relpath;
2919 svn_wc_context_t *wc_ctx;
2920 };
2921
2922 /* */
2923 static svn_error_t *
status4_wrapper_func(void * baton,const char * local_abspath,const svn_wc_status3_t * status,apr_pool_t * scratch_pool)2924 status4_wrapper_func(void *baton,
2925 const char *local_abspath,
2926 const svn_wc_status3_t *status,
2927 apr_pool_t *scratch_pool)
2928 {
2929 struct status4_wrapper_baton *swb = baton;
2930 svn_wc_status2_t *dup;
2931 const char *path = local_abspath;
2932
2933 SVN_ERR(svn_wc__status2_from_3(&dup, status, swb->wc_ctx, local_abspath,
2934 scratch_pool, scratch_pool));
2935
2936 if (swb->anchor_abspath != NULL)
2937 {
2938 path = svn_dirent_join(
2939 swb->anchor_relpath,
2940 svn_dirent_skip_ancestor(swb->anchor_abspath, local_abspath),
2941 scratch_pool);
2942 }
2943
2944 return (*swb->old_func)(swb->old_baton, path, dup, scratch_pool);
2945 }
2946
2947
2948 svn_error_t *
svn_wc_get_status_editor5(const svn_delta_editor_t ** editor,void ** edit_baton,void ** set_locks_baton,svn_revnum_t * edit_revision,svn_wc_context_t * wc_ctx,const char * anchor_abspath,const char * target_basename,svn_depth_t depth,svn_boolean_t get_all,svn_boolean_t no_ignore,svn_boolean_t depth_as_sticky,svn_boolean_t server_performs_filtering,const apr_array_header_t * ignore_patterns,svn_wc_status_func4_t status_func,void * status_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * result_pool,apr_pool_t * scratch_pool)2949 svn_wc_get_status_editor5(const svn_delta_editor_t **editor,
2950 void **edit_baton,
2951 void **set_locks_baton,
2952 svn_revnum_t *edit_revision,
2953 svn_wc_context_t *wc_ctx,
2954 const char *anchor_abspath,
2955 const char *target_basename,
2956 svn_depth_t depth,
2957 svn_boolean_t get_all,
2958 svn_boolean_t no_ignore,
2959 svn_boolean_t depth_as_sticky,
2960 svn_boolean_t server_performs_filtering,
2961 const apr_array_header_t *ignore_patterns,
2962 svn_wc_status_func4_t status_func,
2963 void *status_baton,
2964 svn_cancel_func_t cancel_func,
2965 void *cancel_baton,
2966 apr_pool_t *result_pool,
2967 apr_pool_t *scratch_pool)
2968 {
2969 return svn_error_trace(
2970 svn_wc__get_status_editor(editor, edit_baton,
2971 set_locks_baton,
2972 edit_revision,
2973 wc_ctx,
2974 anchor_abspath,
2975 target_basename,
2976 depth, get_all,
2977 TRUE, /* check_working_copy */
2978 no_ignore, depth_as_sticky,
2979 server_performs_filtering,
2980 ignore_patterns,
2981 status_func, status_baton,
2982 cancel_func, cancel_baton,
2983 result_pool,
2984 scratch_pool));
2985 }
2986
2987
2988 svn_error_t *
svn_wc_get_status_editor4(const svn_delta_editor_t ** editor,void ** edit_baton,void ** set_locks_baton,svn_revnum_t * edit_revision,svn_wc_adm_access_t * anchor,const char * target,svn_depth_t depth,svn_boolean_t get_all,svn_boolean_t no_ignore,const apr_array_header_t * ignore_patterns,svn_wc_status_func3_t status_func,void * status_baton,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)2989 svn_wc_get_status_editor4(const svn_delta_editor_t **editor,
2990 void **edit_baton,
2991 void **set_locks_baton,
2992 svn_revnum_t *edit_revision,
2993 svn_wc_adm_access_t *anchor,
2994 const char *target,
2995 svn_depth_t depth,
2996 svn_boolean_t get_all,
2997 svn_boolean_t no_ignore,
2998 const apr_array_header_t *ignore_patterns,
2999 svn_wc_status_func3_t status_func,
3000 void *status_baton,
3001 svn_cancel_func_t cancel_func,
3002 void *cancel_baton,
3003 svn_wc_traversal_info_t *traversal_info,
3004 apr_pool_t *pool)
3005 {
3006 struct status4_wrapper_baton *swb = apr_palloc(pool, sizeof(*swb));
3007 svn_wc__db_t *wc_db;
3008 svn_wc_context_t *wc_ctx;
3009 const char *anchor_abspath;
3010
3011 swb->old_func = status_func;
3012 swb->old_baton = status_baton;
3013
3014 wc_db = svn_wc__adm_get_db(anchor);
3015
3016 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3017 wc_db, pool));
3018
3019 swb->wc_ctx = wc_ctx;
3020
3021 anchor_abspath = svn_wc__adm_access_abspath(anchor);
3022
3023 if (!svn_dirent_is_absolute(svn_wc_adm_access_path(anchor)))
3024 {
3025 swb->anchor_abspath = anchor_abspath;
3026 swb->anchor_relpath = svn_wc_adm_access_path(anchor);
3027 }
3028 else
3029 {
3030 swb->anchor_abspath = NULL;
3031 swb->anchor_relpath = NULL;
3032 }
3033
3034 /* Before subversion 1.7 status always handled depth as sticky. 1.7 made
3035 the output of svn status by default match the result of what would be
3036 updated by a similar svn update. (Following the documentation) */
3037
3038 SVN_ERR(svn_wc_get_status_editor5(editor, edit_baton, set_locks_baton,
3039 edit_revision, wc_ctx, anchor_abspath,
3040 target, depth, get_all,
3041 no_ignore,
3042 (depth != svn_depth_unknown) /*as_sticky*/,
3043 FALSE /* server_performs_filtering */,
3044 ignore_patterns,
3045 status4_wrapper_func, swb,
3046 cancel_func, cancel_baton,
3047 pool, pool));
3048
3049 if (traversal_info)
3050 {
3051 const char *local_path = svn_wc_adm_access_path(anchor);
3052 const char *local_abspath = anchor_abspath;
3053 if (*target)
3054 {
3055 local_path = svn_dirent_join(local_path, target, pool);
3056 local_abspath = svn_dirent_join(local_abspath, target, pool);
3057 }
3058
3059 SVN_ERR(gather_traversal_info(wc_ctx, local_abspath, local_path, depth,
3060 traversal_info, TRUE, TRUE,
3061 pool));
3062 }
3063
3064 /* We can't destroy wc_ctx here, because the editor needs it while it's
3065 driven. */
3066 return SVN_NO_ERROR;
3067 }
3068
3069 struct status_editor3_compat_baton
3070 {
3071 svn_wc_status_func2_t old_func;
3072 void *old_baton;
3073 };
3074
3075 /* */
3076 static svn_error_t *
status_editor3_compat_func(void * baton,const char * path,svn_wc_status2_t * status,apr_pool_t * pool)3077 status_editor3_compat_func(void *baton,
3078 const char *path,
3079 svn_wc_status2_t *status,
3080 apr_pool_t *pool)
3081 {
3082 struct status_editor3_compat_baton *secb = baton;
3083
3084 secb->old_func(secb->old_baton, path, status);
3085 return SVN_NO_ERROR;
3086 }
3087
3088 svn_error_t *
svn_wc_get_status_editor3(const svn_delta_editor_t ** editor,void ** edit_baton,void ** set_locks_baton,svn_revnum_t * edit_revision,svn_wc_adm_access_t * anchor,const char * target,svn_depth_t depth,svn_boolean_t get_all,svn_boolean_t no_ignore,const apr_array_header_t * ignore_patterns,svn_wc_status_func2_t status_func,void * status_baton,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3089 svn_wc_get_status_editor3(const svn_delta_editor_t **editor,
3090 void **edit_baton,
3091 void **set_locks_baton,
3092 svn_revnum_t *edit_revision,
3093 svn_wc_adm_access_t *anchor,
3094 const char *target,
3095 svn_depth_t depth,
3096 svn_boolean_t get_all,
3097 svn_boolean_t no_ignore,
3098 const apr_array_header_t *ignore_patterns,
3099 svn_wc_status_func2_t status_func,
3100 void *status_baton,
3101 svn_cancel_func_t cancel_func,
3102 void *cancel_baton,
3103 svn_wc_traversal_info_t *traversal_info,
3104 apr_pool_t *pool)
3105 {
3106 /* This baton must live beyond this function. Alloc on heap. */
3107 struct status_editor3_compat_baton *secb = apr_palloc(pool, sizeof(*secb));
3108
3109 secb->old_func = status_func;
3110 secb->old_baton = status_baton;
3111
3112 return svn_wc_get_status_editor4(editor, edit_baton, set_locks_baton,
3113 edit_revision, anchor, target, depth,
3114 get_all, no_ignore, ignore_patterns,
3115 status_editor3_compat_func, secb,
3116 cancel_func, cancel_baton, traversal_info,
3117 pool);
3118 }
3119
3120 svn_error_t *
svn_wc_get_status_editor2(const svn_delta_editor_t ** editor,void ** edit_baton,void ** set_locks_baton,svn_revnum_t * edit_revision,svn_wc_adm_access_t * anchor,const char * target,apr_hash_t * config,svn_boolean_t recurse,svn_boolean_t get_all,svn_boolean_t no_ignore,svn_wc_status_func2_t status_func,void * status_baton,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3121 svn_wc_get_status_editor2(const svn_delta_editor_t **editor,
3122 void **edit_baton,
3123 void **set_locks_baton,
3124 svn_revnum_t *edit_revision,
3125 svn_wc_adm_access_t *anchor,
3126 const char *target,
3127 apr_hash_t *config,
3128 svn_boolean_t recurse,
3129 svn_boolean_t get_all,
3130 svn_boolean_t no_ignore,
3131 svn_wc_status_func2_t status_func,
3132 void *status_baton,
3133 svn_cancel_func_t cancel_func,
3134 void *cancel_baton,
3135 svn_wc_traversal_info_t *traversal_info,
3136 apr_pool_t *pool)
3137 {
3138 apr_array_header_t *ignores;
3139
3140 SVN_ERR(svn_wc_get_default_ignores(&ignores, config, pool));
3141 return svn_wc_get_status_editor3(editor,
3142 edit_baton,
3143 set_locks_baton,
3144 edit_revision,
3145 anchor,
3146 target,
3147 SVN_DEPTH_INFINITY_OR_IMMEDIATES(recurse),
3148 get_all,
3149 no_ignore,
3150 ignores,
3151 status_func,
3152 status_baton,
3153 cancel_func,
3154 cancel_baton,
3155 traversal_info,
3156 pool);
3157 }
3158
3159
3160 /* Helpers for deprecated svn_wc_status_editor(), of type
3161 svn_wc_status_func2_t. */
3162 struct old_status_func_cb_baton
3163 {
3164 svn_wc_status_func_t original_func;
3165 void *original_baton;
3166 };
3167
3168 /* */
old_status_func_cb(void * baton,const char * path,svn_wc_status2_t * status)3169 static void old_status_func_cb(void *baton,
3170 const char *path,
3171 svn_wc_status2_t *status)
3172 {
3173 struct old_status_func_cb_baton *b = baton;
3174 svn_wc_status_t *stat = (svn_wc_status_t *) status;
3175
3176 b->original_func(b->original_baton, path, stat);
3177 }
3178
3179 svn_error_t *
svn_wc_get_status_editor(const svn_delta_editor_t ** editor,void ** edit_baton,svn_revnum_t * edit_revision,svn_wc_adm_access_t * anchor,const char * target,apr_hash_t * config,svn_boolean_t recurse,svn_boolean_t get_all,svn_boolean_t no_ignore,svn_wc_status_func_t status_func,void * status_baton,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3180 svn_wc_get_status_editor(const svn_delta_editor_t **editor,
3181 void **edit_baton,
3182 svn_revnum_t *edit_revision,
3183 svn_wc_adm_access_t *anchor,
3184 const char *target,
3185 apr_hash_t *config,
3186 svn_boolean_t recurse,
3187 svn_boolean_t get_all,
3188 svn_boolean_t no_ignore,
3189 svn_wc_status_func_t status_func,
3190 void *status_baton,
3191 svn_cancel_func_t cancel_func,
3192 void *cancel_baton,
3193 svn_wc_traversal_info_t *traversal_info,
3194 apr_pool_t *pool)
3195 {
3196 struct old_status_func_cb_baton *b = apr_pcalloc(pool, sizeof(*b));
3197 apr_array_header_t *ignores;
3198 b->original_func = status_func;
3199 b->original_baton = status_baton;
3200 SVN_ERR(svn_wc_get_default_ignores(&ignores, config, pool));
3201 return svn_wc_get_status_editor3(editor, edit_baton, NULL, edit_revision,
3202 anchor, target,
3203 SVN_DEPTH_INFINITY_OR_IMMEDIATES(recurse),
3204 get_all, no_ignore, ignores,
3205 old_status_func_cb, b,
3206 cancel_func, cancel_baton,
3207 traversal_info, pool);
3208 }
3209
3210 svn_error_t *
svn_wc_status(svn_wc_status_t ** status,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)3211 svn_wc_status(svn_wc_status_t **status,
3212 const char *path,
3213 svn_wc_adm_access_t *adm_access,
3214 apr_pool_t *pool)
3215 {
3216 svn_wc_status2_t *stat2;
3217
3218 SVN_ERR(svn_wc_status2(&stat2, path, adm_access, pool));
3219 *status = (svn_wc_status_t *) stat2;
3220 return SVN_NO_ERROR;
3221 }
3222
3223
3224 static svn_wc_conflict_description_t *
conflict_description_dup(const svn_wc_conflict_description_t * conflict,apr_pool_t * pool)3225 conflict_description_dup(const svn_wc_conflict_description_t *conflict,
3226 apr_pool_t *pool)
3227 {
3228 svn_wc_conflict_description_t *new_conflict;
3229
3230 new_conflict = apr_pcalloc(pool, sizeof(*new_conflict));
3231
3232 /* Shallow copy all members. */
3233 *new_conflict = *conflict;
3234
3235 if (conflict->path)
3236 new_conflict->path = apr_pstrdup(pool, conflict->path);
3237 if (conflict->property_name)
3238 new_conflict->property_name = apr_pstrdup(pool, conflict->property_name);
3239 if (conflict->mime_type)
3240 new_conflict->mime_type = apr_pstrdup(pool, conflict->mime_type);
3241 /* NOTE: We cannot make a deep copy of adm_access. */
3242 if (conflict->base_file)
3243 new_conflict->base_file = apr_pstrdup(pool, conflict->base_file);
3244 if (conflict->their_file)
3245 new_conflict->their_file = apr_pstrdup(pool, conflict->their_file);
3246 if (conflict->my_file)
3247 new_conflict->my_file = apr_pstrdup(pool, conflict->my_file);
3248 if (conflict->merged_file)
3249 new_conflict->merged_file = apr_pstrdup(pool, conflict->merged_file);
3250 if (conflict->src_left_version)
3251 new_conflict->src_left_version =
3252 svn_wc_conflict_version_dup(conflict->src_left_version, pool);
3253 if (conflict->src_right_version)
3254 new_conflict->src_right_version =
3255 svn_wc_conflict_version_dup(conflict->src_right_version, pool);
3256
3257 return new_conflict;
3258 }
3259
3260
3261 svn_wc_status2_t *
svn_wc_dup_status2(const svn_wc_status2_t * orig_stat,apr_pool_t * pool)3262 svn_wc_dup_status2(const svn_wc_status2_t *orig_stat,
3263 apr_pool_t *pool)
3264 {
3265 svn_wc_status2_t *new_stat = apr_palloc(pool, sizeof(*new_stat));
3266
3267 /* Shallow copy all members. */
3268 *new_stat = *orig_stat;
3269
3270 /* Now go back and dup the deep items into this pool. */
3271 if (orig_stat->entry)
3272 new_stat->entry = svn_wc_entry_dup(orig_stat->entry, pool);
3273
3274 if (orig_stat->repos_lock)
3275 new_stat->repos_lock = svn_lock_dup(orig_stat->repos_lock, pool);
3276
3277 if (orig_stat->url)
3278 new_stat->url = apr_pstrdup(pool, orig_stat->url);
3279
3280 if (orig_stat->ood_last_cmt_author)
3281 new_stat->ood_last_cmt_author
3282 = apr_pstrdup(pool, orig_stat->ood_last_cmt_author);
3283
3284 if (orig_stat->tree_conflict)
3285 new_stat->tree_conflict
3286 = conflict_description_dup(orig_stat->tree_conflict, pool);
3287
3288 /* Return the new hotness. */
3289 return new_stat;
3290 }
3291
3292 svn_wc_status_t *
svn_wc_dup_status(const svn_wc_status_t * orig_stat,apr_pool_t * pool)3293 svn_wc_dup_status(const svn_wc_status_t *orig_stat,
3294 apr_pool_t *pool)
3295 {
3296 svn_wc_status_t *new_stat = apr_palloc(pool, sizeof(*new_stat));
3297
3298 /* Shallow copy all members. */
3299 *new_stat = *orig_stat;
3300
3301 /* Now go back and dup the deep item into this pool. */
3302 if (orig_stat->entry)
3303 new_stat->entry = svn_wc_entry_dup(orig_stat->entry, pool);
3304
3305 /* Return the new hotness. */
3306 return new_stat;
3307 }
3308
3309 svn_error_t *
svn_wc_get_ignores(apr_array_header_t ** patterns,apr_hash_t * config,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)3310 svn_wc_get_ignores(apr_array_header_t **patterns,
3311 apr_hash_t *config,
3312 svn_wc_adm_access_t *adm_access,
3313 apr_pool_t *pool)
3314 {
3315 svn_wc_context_t *wc_ctx;
3316 const char *local_abspath;
3317
3318 SVN_ERR(svn_dirent_get_absolute(&local_abspath,
3319 svn_wc_adm_access_path(adm_access), pool));
3320
3321 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3322 svn_wc__adm_get_db(adm_access),
3323 pool));
3324
3325 SVN_ERR(svn_wc_get_ignores2(patterns, wc_ctx, local_abspath, config, pool,
3326 pool));
3327
3328 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3329 }
3330
3331 svn_error_t *
svn_wc_status2(svn_wc_status2_t ** status,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)3332 svn_wc_status2(svn_wc_status2_t **status,
3333 const char *path,
3334 svn_wc_adm_access_t *adm_access,
3335 apr_pool_t *pool)
3336 {
3337 const char *local_abspath;
3338 svn_wc_context_t *wc_ctx;
3339 svn_wc_status3_t *stat3;
3340
3341 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
3342 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3343 svn_wc__adm_get_db(adm_access),
3344 pool));
3345
3346 SVN_ERR(svn_wc_status3(&stat3, wc_ctx, local_abspath, pool, pool));
3347 SVN_ERR(svn_wc__status2_from_3(status, stat3, wc_ctx, local_abspath,
3348 pool, pool));
3349
3350 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3351 }
3352
3353
3354 /*** From update_editor.c ***/
3355
3356 svn_error_t *
svn_wc_add_repos_file3(const char * dst_path,svn_wc_adm_access_t * adm_access,svn_stream_t * new_base_contents,svn_stream_t * new_contents,apr_hash_t * new_base_props,apr_hash_t * new_props,const char * copyfrom_url,svn_revnum_t copyfrom_rev,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)3357 svn_wc_add_repos_file3(const char *dst_path,
3358 svn_wc_adm_access_t *adm_access,
3359 svn_stream_t *new_base_contents,
3360 svn_stream_t *new_contents,
3361 apr_hash_t *new_base_props,
3362 apr_hash_t *new_props,
3363 const char *copyfrom_url,
3364 svn_revnum_t copyfrom_rev,
3365 svn_cancel_func_t cancel_func,
3366 void *cancel_baton,
3367 svn_wc_notify_func2_t notify_func,
3368 void *notify_baton,
3369 apr_pool_t *pool)
3370 {
3371 const char *local_abspath;
3372 svn_wc_context_t *wc_ctx;
3373
3374 SVN_ERR(svn_dirent_get_absolute(&local_abspath, dst_path, pool));
3375 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3376 svn_wc__adm_get_db(adm_access),
3377 pool));
3378
3379 SVN_ERR(svn_wc_add_repos_file4(wc_ctx,
3380 local_abspath,
3381 new_base_contents,
3382 new_contents,
3383 new_base_props,
3384 new_props,
3385 copyfrom_url,
3386 copyfrom_rev,
3387 cancel_func, cancel_baton,
3388 pool));
3389
3390 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3391 }
3392
3393 svn_error_t *
svn_wc_add_repos_file2(const char * dst_path,svn_wc_adm_access_t * adm_access,const char * new_text_base_path,const char * new_text_path,apr_hash_t * new_base_props,apr_hash_t * new_props,const char * copyfrom_url,svn_revnum_t copyfrom_rev,apr_pool_t * pool)3394 svn_wc_add_repos_file2(const char *dst_path,
3395 svn_wc_adm_access_t *adm_access,
3396 const char *new_text_base_path,
3397 const char *new_text_path,
3398 apr_hash_t *new_base_props,
3399 apr_hash_t *new_props,
3400 const char *copyfrom_url,
3401 svn_revnum_t copyfrom_rev,
3402 apr_pool_t *pool)
3403 {
3404 svn_stream_t *new_base_contents;
3405 svn_stream_t *new_contents = NULL;
3406
3407 SVN_ERR(svn_stream_open_readonly(&new_base_contents, new_text_base_path,
3408 pool, pool));
3409
3410 if (new_text_path)
3411 {
3412 /* NOTE: the specified path may *not* be under version control.
3413 It is most likely sitting in .svn/tmp/. Thus, we cannot use the
3414 typical WC functions to access "special", "keywords" or "EOL"
3415 information. We need to look at the properties given to us. */
3416
3417 /* If the new file is special, then we can simply open the given
3418 contents since it is already in normal form. */
3419 if (svn_hash_gets(new_props, SVN_PROP_SPECIAL) != NULL)
3420 {
3421 SVN_ERR(svn_stream_open_readonly(&new_contents, new_text_path,
3422 pool, pool));
3423 }
3424 else
3425 {
3426 /* The new text contents need to be detrans'd into normal form. */
3427 svn_subst_eol_style_t eol_style;
3428 const char *eol_str;
3429 apr_hash_t *keywords = NULL;
3430 svn_string_t *list;
3431
3432 list = svn_hash_gets(new_props, SVN_PROP_KEYWORDS);
3433 if (list != NULL)
3434 {
3435 /* Since we are detranslating, all of the keyword values
3436 can be "". */
3437 SVN_ERR(svn_subst_build_keywords2(&keywords,
3438 list->data,
3439 "", "", 0, "",
3440 pool));
3441 if (apr_hash_count(keywords) == 0)
3442 keywords = NULL;
3443 }
3444
3445 svn_subst_eol_style_from_value(&eol_style, &eol_str,
3446 svn_hash_gets(new_props,
3447 SVN_PROP_EOL_STYLE));
3448
3449 if (svn_subst_translation_required(eol_style, eol_str, keywords,
3450 FALSE, FALSE))
3451 {
3452 SVN_ERR(svn_subst_stream_detranslated(&new_contents,
3453 new_text_path,
3454 eol_style, eol_str,
3455 FALSE,
3456 keywords,
3457 FALSE,
3458 pool));
3459 }
3460 else
3461 {
3462 SVN_ERR(svn_stream_open_readonly(&new_contents, new_text_path,
3463 pool, pool));
3464 }
3465 }
3466 }
3467
3468 SVN_ERR(svn_wc_add_repos_file3(dst_path, adm_access,
3469 new_base_contents, new_contents,
3470 new_base_props, new_props,
3471 copyfrom_url, copyfrom_rev,
3472 NULL, NULL, NULL, NULL,
3473 pool));
3474
3475 /* The API contract states that the text files will be removed upon
3476 successful completion. add_repos_file3() does not remove the files
3477 since it only has streams on them. Toss 'em now. */
3478 svn_error_clear(svn_io_remove_file(new_text_base_path, pool));
3479 if (new_text_path)
3480 svn_error_clear(svn_io_remove_file(new_text_path, pool));
3481
3482 return SVN_NO_ERROR;
3483 }
3484
3485
3486 svn_error_t *
svn_wc_add_repos_file(const char * dst_path,svn_wc_adm_access_t * adm_access,const char * new_text_path,apr_hash_t * new_props,const char * copyfrom_url,svn_revnum_t copyfrom_rev,apr_pool_t * pool)3487 svn_wc_add_repos_file(const char *dst_path,
3488 svn_wc_adm_access_t *adm_access,
3489 const char *new_text_path,
3490 apr_hash_t *new_props,
3491 const char *copyfrom_url,
3492 svn_revnum_t copyfrom_rev,
3493 apr_pool_t *pool)
3494 {
3495 return svn_wc_add_repos_file2(dst_path, adm_access,
3496 new_text_path, NULL,
3497 new_props, NULL,
3498 copyfrom_url, copyfrom_rev,
3499 pool);
3500 }
3501
3502 svn_error_t *
svn_wc_get_actual_target(const char * path,const char ** anchor,const char ** target,apr_pool_t * pool)3503 svn_wc_get_actual_target(const char *path,
3504 const char **anchor,
3505 const char **target,
3506 apr_pool_t *pool)
3507 {
3508 svn_wc_context_t *wc_ctx;
3509
3510 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
3511 SVN_ERR(svn_wc_get_actual_target2(anchor, target, wc_ctx, path, pool, pool));
3512
3513 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3514 }
3515
3516 /* This function has no internal variant as its behavior on switched
3517 non-directories is not what you would expect. But this happens to
3518 be the legacy behavior of this function. */
3519 svn_error_t *
svn_wc_is_wc_root2(svn_boolean_t * wc_root,svn_wc_context_t * wc_ctx,const char * local_abspath,apr_pool_t * scratch_pool)3520 svn_wc_is_wc_root2(svn_boolean_t *wc_root,
3521 svn_wc_context_t *wc_ctx,
3522 const char *local_abspath,
3523 apr_pool_t *scratch_pool)
3524 {
3525 svn_boolean_t is_root;
3526 svn_boolean_t is_switched;
3527 svn_node_kind_t kind;
3528 svn_error_t *err;
3529 SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
3530
3531 err = svn_wc__db_is_switched(&is_root, &is_switched, &kind,
3532 wc_ctx->db, local_abspath, scratch_pool);
3533
3534 if (err)
3535 {
3536 if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND &&
3537 err->apr_err != SVN_ERR_WC_NOT_WORKING_COPY)
3538 return svn_error_trace(err);
3539
3540 return svn_error_create(SVN_ERR_ENTRY_NOT_FOUND, err, err->message);
3541 }
3542
3543 *wc_root = is_root || (kind == svn_node_dir && is_switched);
3544
3545 return SVN_NO_ERROR;
3546 }
3547
3548 svn_error_t *
svn_wc_is_wc_root(svn_boolean_t * wc_root,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)3549 svn_wc_is_wc_root(svn_boolean_t *wc_root,
3550 const char *path,
3551 svn_wc_adm_access_t *adm_access,
3552 apr_pool_t *pool)
3553 {
3554 svn_wc_context_t *wc_ctx;
3555 const char *local_abspath;
3556 svn_error_t *err;
3557
3558 /* Subversion <= 1.6 said that '.' or a drive root is a WC root. */
3559 if (svn_path_is_empty(path) || svn_dirent_is_root(path, strlen(path)))
3560 {
3561 *wc_root = TRUE;
3562 return SVN_NO_ERROR;
3563 }
3564
3565 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
3566 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3567 svn_wc__adm_get_db(adm_access),
3568 pool));
3569
3570 err = svn_wc_is_wc_root2(wc_root, wc_ctx, local_abspath, pool);
3571
3572 if (err
3573 && (err->apr_err == SVN_ERR_WC_NOT_WORKING_COPY
3574 || err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND))
3575 {
3576 /* Subversion <= 1.6 said that an unversioned path is a WC root. */
3577 svn_error_clear(err);
3578 *wc_root = TRUE;
3579 }
3580 else
3581 SVN_ERR(err);
3582
3583 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3584 }
3585
3586
3587 svn_error_t *
svn_wc_get_update_editor4(const svn_delta_editor_t ** editor,void ** edit_baton,svn_revnum_t * target_revision,svn_wc_context_t * wc_ctx,const char * anchor_abspath,const char * target_basename,svn_boolean_t use_commit_times,svn_depth_t depth,svn_boolean_t depth_is_sticky,svn_boolean_t allow_unver_obstructions,svn_boolean_t adds_as_modification,svn_boolean_t server_performs_filtering,svn_boolean_t clean_checkout,const char * diff3_cmd,const apr_array_header_t * preserved_exts,svn_wc_dirents_func_t fetch_dirents_func,void * fetch_dirents_baton,svn_wc_conflict_resolver_func2_t conflict_func,void * conflict_baton,svn_wc_external_update_t external_func,void * external_baton,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * result_pool,apr_pool_t * scratch_pool)3588 svn_wc_get_update_editor4(const svn_delta_editor_t **editor,
3589 void **edit_baton,
3590 svn_revnum_t *target_revision,
3591 svn_wc_context_t *wc_ctx,
3592 const char *anchor_abspath,
3593 const char *target_basename,
3594 svn_boolean_t use_commit_times,
3595 svn_depth_t depth,
3596 svn_boolean_t depth_is_sticky,
3597 svn_boolean_t allow_unver_obstructions,
3598 svn_boolean_t adds_as_modification,
3599 svn_boolean_t server_performs_filtering,
3600 svn_boolean_t clean_checkout,
3601 const char *diff3_cmd,
3602 const apr_array_header_t *preserved_exts,
3603 svn_wc_dirents_func_t fetch_dirents_func,
3604 void *fetch_dirents_baton,
3605 svn_wc_conflict_resolver_func2_t conflict_func,
3606 void *conflict_baton,
3607 svn_wc_external_update_t external_func,
3608 void *external_baton,
3609 svn_cancel_func_t cancel_func,
3610 void *cancel_baton,
3611 svn_wc_notify_func2_t notify_func,
3612 void *notify_baton,
3613 apr_pool_t *result_pool,
3614 apr_pool_t *scratch_pool)
3615 {
3616 return svn_error_trace(
3617 svn_wc__get_update_editor(editor, edit_baton,
3618 target_revision,
3619 wc_ctx,
3620 anchor_abspath,
3621 target_basename, NULL,
3622 use_commit_times,
3623 depth, depth_is_sticky,
3624 allow_unver_obstructions,
3625 adds_as_modification,
3626 server_performs_filtering,
3627 clean_checkout,
3628 diff3_cmd,
3629 preserved_exts,
3630 fetch_dirents_func, fetch_dirents_baton,
3631 conflict_func, conflict_baton,
3632 external_func, external_baton,
3633 cancel_func, cancel_baton,
3634 notify_func, notify_baton,
3635 result_pool, scratch_pool));
3636 }
3637
3638
3639 svn_error_t *
svn_wc_get_update_editor3(svn_revnum_t * target_revision,svn_wc_adm_access_t * anchor,const char * target,svn_boolean_t use_commit_times,svn_depth_t depth,svn_boolean_t depth_is_sticky,svn_boolean_t allow_unver_obstructions,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_conflict_resolver_func_t conflict_func,void * conflict_baton,svn_wc_get_file_t fetch_func,void * fetch_baton,const char * diff3_cmd,const apr_array_header_t * preserved_exts,const svn_delta_editor_t ** editor,void ** edit_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3640 svn_wc_get_update_editor3(svn_revnum_t *target_revision,
3641 svn_wc_adm_access_t *anchor,
3642 const char *target,
3643 svn_boolean_t use_commit_times,
3644 svn_depth_t depth,
3645 svn_boolean_t depth_is_sticky,
3646 svn_boolean_t allow_unver_obstructions,
3647 svn_wc_notify_func2_t notify_func,
3648 void *notify_baton,
3649 svn_cancel_func_t cancel_func,
3650 void *cancel_baton,
3651 svn_wc_conflict_resolver_func_t conflict_func,
3652 void *conflict_baton,
3653 svn_wc_get_file_t fetch_func,
3654 void *fetch_baton,
3655 const char *diff3_cmd,
3656 const apr_array_header_t *preserved_exts,
3657 const svn_delta_editor_t **editor,
3658 void **edit_baton,
3659 svn_wc_traversal_info_t *traversal_info,
3660 apr_pool_t *pool)
3661 {
3662 svn_wc_context_t *wc_ctx;
3663 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
3664 svn_wc_external_update_t external_func = NULL;
3665 struct traversal_info_update_baton *eb = NULL;
3666 struct conflict_func_1to2_baton *cfw = NULL;
3667
3668 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
3669
3670 if (traversal_info)
3671 {
3672 eb = apr_palloc(pool, sizeof(*eb));
3673 eb->db = db;
3674 eb->traversal = traversal_info;
3675 external_func = traversal_info_update;
3676 }
3677
3678 if (conflict_func)
3679 {
3680 cfw = apr_pcalloc(pool, sizeof(*cfw));
3681 cfw->inner_func = conflict_func;
3682 cfw->inner_baton = conflict_baton;
3683 }
3684
3685 if (diff3_cmd)
3686 SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
3687
3688 SVN_ERR(svn_wc_get_update_editor4(editor, edit_baton,
3689 target_revision,
3690 wc_ctx,
3691 svn_wc__adm_access_abspath(anchor),
3692 target,
3693 use_commit_times,
3694 depth, depth_is_sticky,
3695 allow_unver_obstructions,
3696 TRUE /* adds_as_modification */,
3697 FALSE /* server_performs_filtering */,
3698 FALSE /* clean_checkout */,
3699 diff3_cmd,
3700 preserved_exts,
3701 NULL, NULL, /* fetch_dirents_func, baton */
3702 conflict_func ? conflict_func_1to2_wrapper
3703 : NULL,
3704 cfw,
3705 external_func, eb,
3706 cancel_func, cancel_baton,
3707 notify_func, notify_baton,
3708 pool, pool));
3709
3710 /* We can't destroy wc_ctx here, because the editor needs it while it's
3711 driven. */
3712 return SVN_NO_ERROR;
3713 }
3714
3715 svn_error_t *
svn_wc_get_update_editor2(svn_revnum_t * target_revision,svn_wc_adm_access_t * anchor,const char * target,svn_boolean_t use_commit_times,svn_boolean_t recurse,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,const char * diff3_cmd,const svn_delta_editor_t ** editor,void ** edit_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3716 svn_wc_get_update_editor2(svn_revnum_t *target_revision,
3717 svn_wc_adm_access_t *anchor,
3718 const char *target,
3719 svn_boolean_t use_commit_times,
3720 svn_boolean_t recurse,
3721 svn_wc_notify_func2_t notify_func,
3722 void *notify_baton,
3723 svn_cancel_func_t cancel_func,
3724 void *cancel_baton,
3725 const char *diff3_cmd,
3726 const svn_delta_editor_t **editor,
3727 void **edit_baton,
3728 svn_wc_traversal_info_t *traversal_info,
3729 apr_pool_t *pool)
3730 {
3731 return svn_wc_get_update_editor3(target_revision, anchor, target,
3732 use_commit_times,
3733 SVN_DEPTH_INFINITY_OR_FILES(recurse), FALSE,
3734 FALSE, notify_func, notify_baton,
3735 cancel_func, cancel_baton, NULL, NULL,
3736 NULL, NULL,
3737 diff3_cmd, NULL, editor, edit_baton,
3738 traversal_info, pool);
3739 }
3740
3741 svn_error_t *
svn_wc_get_update_editor(svn_revnum_t * target_revision,svn_wc_adm_access_t * anchor,const char * target,svn_boolean_t use_commit_times,svn_boolean_t recurse,svn_wc_notify_func_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,const char * diff3_cmd,const svn_delta_editor_t ** editor,void ** edit_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3742 svn_wc_get_update_editor(svn_revnum_t *target_revision,
3743 svn_wc_adm_access_t *anchor,
3744 const char *target,
3745 svn_boolean_t use_commit_times,
3746 svn_boolean_t recurse,
3747 svn_wc_notify_func_t notify_func,
3748 void *notify_baton,
3749 svn_cancel_func_t cancel_func,
3750 void *cancel_baton,
3751 const char *diff3_cmd,
3752 const svn_delta_editor_t **editor,
3753 void **edit_baton,
3754 svn_wc_traversal_info_t *traversal_info,
3755 apr_pool_t *pool)
3756 {
3757 /* This baton must live beyond this function. Alloc on heap. */
3758 struct compat_notify_baton_t *nb = apr_palloc(pool, sizeof(*nb));
3759
3760 nb->func = notify_func;
3761 nb->baton = notify_baton;
3762
3763 return svn_wc_get_update_editor3(target_revision, anchor, target,
3764 use_commit_times,
3765 SVN_DEPTH_INFINITY_OR_FILES(recurse), FALSE,
3766 FALSE, compat_call_notify_func, nb,
3767 cancel_func, cancel_baton, NULL, NULL,
3768 NULL, NULL,
3769 diff3_cmd, NULL, editor, edit_baton,
3770 traversal_info, pool);
3771 }
3772
3773
3774 svn_error_t *
svn_wc_get_switch_editor4(const svn_delta_editor_t ** editor,void ** edit_baton,svn_revnum_t * target_revision,svn_wc_context_t * wc_ctx,const char * anchor_abspath,const char * target_basename,const char * switch_url,svn_boolean_t use_commit_times,svn_depth_t depth,svn_boolean_t depth_is_sticky,svn_boolean_t allow_unver_obstructions,svn_boolean_t server_performs_filtering,const char * diff3_cmd,const apr_array_header_t * preserved_exts,svn_wc_dirents_func_t fetch_dirents_func,void * fetch_dirents_baton,svn_wc_conflict_resolver_func2_t conflict_func,void * conflict_baton,svn_wc_external_update_t external_func,void * external_baton,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * result_pool,apr_pool_t * scratch_pool)3775 svn_wc_get_switch_editor4(const svn_delta_editor_t **editor,
3776 void **edit_baton,
3777 svn_revnum_t *target_revision,
3778 svn_wc_context_t *wc_ctx,
3779 const char *anchor_abspath,
3780 const char *target_basename,
3781 const char *switch_url,
3782 svn_boolean_t use_commit_times,
3783 svn_depth_t depth,
3784 svn_boolean_t depth_is_sticky,
3785 svn_boolean_t allow_unver_obstructions,
3786 svn_boolean_t server_performs_filtering,
3787 const char *diff3_cmd,
3788 const apr_array_header_t *preserved_exts,
3789 svn_wc_dirents_func_t fetch_dirents_func,
3790 void *fetch_dirents_baton,
3791 svn_wc_conflict_resolver_func2_t conflict_func,
3792 void *conflict_baton,
3793 svn_wc_external_update_t external_func,
3794 void *external_baton,
3795 svn_cancel_func_t cancel_func,
3796 void *cancel_baton,
3797 svn_wc_notify_func2_t notify_func,
3798 void *notify_baton,
3799 apr_pool_t *result_pool,
3800 apr_pool_t *scratch_pool)
3801 {
3802 return svn_error_trace(
3803 svn_wc__get_switch_editor(editor, edit_baton,
3804 target_revision,
3805 wc_ctx,
3806 anchor_abspath, target_basename,
3807 switch_url, NULL,
3808 use_commit_times,
3809 depth, depth_is_sticky,
3810 allow_unver_obstructions,
3811 server_performs_filtering,
3812 diff3_cmd,
3813 preserved_exts,
3814 fetch_dirents_func, fetch_dirents_baton,
3815 conflict_func, conflict_baton,
3816 external_func, external_baton,
3817 cancel_func, cancel_baton,
3818 notify_func, notify_baton,
3819 result_pool, scratch_pool));
3820 }
3821
3822
3823 svn_error_t *
svn_wc_get_switch_editor3(svn_revnum_t * target_revision,svn_wc_adm_access_t * anchor,const char * target,const char * switch_url,svn_boolean_t use_commit_times,svn_depth_t depth,svn_boolean_t depth_is_sticky,svn_boolean_t allow_unver_obstructions,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_conflict_resolver_func_t conflict_func,void * conflict_baton,const char * diff3_cmd,const apr_array_header_t * preserved_exts,const svn_delta_editor_t ** editor,void ** edit_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3824 svn_wc_get_switch_editor3(svn_revnum_t *target_revision,
3825 svn_wc_adm_access_t *anchor,
3826 const char *target,
3827 const char *switch_url,
3828 svn_boolean_t use_commit_times,
3829 svn_depth_t depth,
3830 svn_boolean_t depth_is_sticky,
3831 svn_boolean_t allow_unver_obstructions,
3832 svn_wc_notify_func2_t notify_func,
3833 void *notify_baton,
3834 svn_cancel_func_t cancel_func,
3835 void *cancel_baton,
3836 svn_wc_conflict_resolver_func_t conflict_func,
3837 void *conflict_baton,
3838 const char *diff3_cmd,
3839 const apr_array_header_t *preserved_exts,
3840 const svn_delta_editor_t **editor,
3841 void **edit_baton,
3842 svn_wc_traversal_info_t *traversal_info,
3843 apr_pool_t *pool)
3844 {
3845 svn_wc_context_t *wc_ctx;
3846 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
3847 svn_wc_external_update_t external_func = NULL;
3848 struct traversal_info_update_baton *eb = NULL;
3849 struct conflict_func_1to2_baton *cfw = NULL;
3850
3851 SVN_ERR_ASSERT(switch_url && svn_uri_is_canonical(switch_url, pool));
3852
3853 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
3854
3855 if (traversal_info)
3856 {
3857 eb = apr_palloc(pool, sizeof(*eb));
3858 eb->db = db;
3859 eb->traversal = traversal_info;
3860 external_func = traversal_info_update;
3861 }
3862
3863 if (conflict_func)
3864 {
3865 cfw = apr_pcalloc(pool, sizeof(*cfw));
3866 cfw->inner_func = conflict_func;
3867 cfw->inner_baton = conflict_baton;
3868 }
3869
3870 if (diff3_cmd)
3871 SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
3872
3873 SVN_ERR(svn_wc_get_switch_editor4(editor, edit_baton,
3874 target_revision,
3875 wc_ctx,
3876 svn_wc__adm_access_abspath(anchor),
3877 target, switch_url,
3878 use_commit_times,
3879 depth, depth_is_sticky,
3880 allow_unver_obstructions,
3881 FALSE /* server_performs_filtering */,
3882 diff3_cmd,
3883 preserved_exts,
3884 NULL, NULL, /* fetch_dirents_func, baton */
3885 conflict_func ? conflict_func_1to2_wrapper
3886 : NULL,
3887 cfw,
3888 external_func, eb,
3889 cancel_func, cancel_baton,
3890 notify_func, notify_baton,
3891 pool, pool));
3892
3893 /* We can't destroy wc_ctx here, because the editor needs it while it's
3894 driven. */
3895 return SVN_NO_ERROR;
3896 }
3897
3898 svn_error_t *
svn_wc_get_switch_editor2(svn_revnum_t * target_revision,svn_wc_adm_access_t * anchor,const char * target,const char * switch_url,svn_boolean_t use_commit_times,svn_boolean_t recurse,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,const char * diff3_cmd,const svn_delta_editor_t ** editor,void ** edit_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3899 svn_wc_get_switch_editor2(svn_revnum_t *target_revision,
3900 svn_wc_adm_access_t *anchor,
3901 const char *target,
3902 const char *switch_url,
3903 svn_boolean_t use_commit_times,
3904 svn_boolean_t recurse,
3905 svn_wc_notify_func2_t notify_func,
3906 void *notify_baton,
3907 svn_cancel_func_t cancel_func,
3908 void *cancel_baton,
3909 const char *diff3_cmd,
3910 const svn_delta_editor_t **editor,
3911 void **edit_baton,
3912 svn_wc_traversal_info_t *traversal_info,
3913 apr_pool_t *pool)
3914 {
3915 SVN_ERR_ASSERT(switch_url);
3916
3917 return svn_wc_get_switch_editor3(target_revision, anchor, target,
3918 switch_url, use_commit_times,
3919 SVN_DEPTH_INFINITY_OR_FILES(recurse), FALSE,
3920 FALSE, notify_func, notify_baton,
3921 cancel_func, cancel_baton,
3922 NULL, NULL, diff3_cmd,
3923 NULL, editor, edit_baton, traversal_info,
3924 pool);
3925 }
3926
3927 svn_error_t *
svn_wc_get_switch_editor(svn_revnum_t * target_revision,svn_wc_adm_access_t * anchor,const char * target,const char * switch_url,svn_boolean_t use_commit_times,svn_boolean_t recurse,svn_wc_notify_func_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,const char * diff3_cmd,const svn_delta_editor_t ** editor,void ** edit_baton,svn_wc_traversal_info_t * traversal_info,apr_pool_t * pool)3928 svn_wc_get_switch_editor(svn_revnum_t *target_revision,
3929 svn_wc_adm_access_t *anchor,
3930 const char *target,
3931 const char *switch_url,
3932 svn_boolean_t use_commit_times,
3933 svn_boolean_t recurse,
3934 svn_wc_notify_func_t notify_func,
3935 void *notify_baton,
3936 svn_cancel_func_t cancel_func,
3937 void *cancel_baton,
3938 const char *diff3_cmd,
3939 const svn_delta_editor_t **editor,
3940 void **edit_baton,
3941 svn_wc_traversal_info_t *traversal_info,
3942 apr_pool_t *pool)
3943 {
3944 /* This baton must live beyond this function. Alloc on heap. */
3945 struct compat_notify_baton_t *nb = apr_palloc(pool, sizeof(*nb));
3946
3947 nb->func = notify_func;
3948 nb->baton = notify_baton;
3949
3950 return svn_wc_get_switch_editor3(target_revision, anchor, target,
3951 switch_url, use_commit_times,
3952 SVN_DEPTH_INFINITY_OR_FILES(recurse), FALSE,
3953 FALSE, compat_call_notify_func, nb,
3954 cancel_func, cancel_baton,
3955 NULL, NULL, diff3_cmd,
3956 NULL, editor, edit_baton, traversal_info,
3957 pool);
3958 }
3959
3960
3961 svn_error_t *
svn_wc_external_item_create(const svn_wc_external_item2_t ** item,apr_pool_t * pool)3962 svn_wc_external_item_create(const svn_wc_external_item2_t **item,
3963 apr_pool_t *pool)
3964 {
3965 *item = apr_pcalloc(pool, sizeof(svn_wc_external_item2_t));
3966 return SVN_NO_ERROR;
3967 }
3968
3969 svn_wc_external_item_t *
svn_wc_external_item_dup(const svn_wc_external_item_t * item,apr_pool_t * pool)3970 svn_wc_external_item_dup(const svn_wc_external_item_t *item,
3971 apr_pool_t *pool)
3972 {
3973 svn_wc_external_item_t *new_item = apr_palloc(pool, sizeof(*new_item));
3974
3975 *new_item = *item;
3976
3977 if (new_item->target_dir)
3978 new_item->target_dir = apr_pstrdup(pool, new_item->target_dir);
3979
3980 if (new_item->url)
3981 new_item->url = apr_pstrdup(pool, new_item->url);
3982
3983 return new_item;
3984 }
3985
3986
3987 svn_wc_traversal_info_t *
svn_wc_init_traversal_info(apr_pool_t * pool)3988 svn_wc_init_traversal_info(apr_pool_t *pool)
3989 {
3990 svn_wc_traversal_info_t *ti = apr_palloc(pool, sizeof(*ti));
3991
3992 ti->pool = pool;
3993 ti->externals_old = apr_hash_make(pool);
3994 ti->externals_new = apr_hash_make(pool);
3995 ti->depths = apr_hash_make(pool);
3996
3997 return ti;
3998 }
3999
4000
4001 void
svn_wc_edited_externals(apr_hash_t ** externals_old,apr_hash_t ** externals_new,svn_wc_traversal_info_t * traversal_info)4002 svn_wc_edited_externals(apr_hash_t **externals_old,
4003 apr_hash_t **externals_new,
4004 svn_wc_traversal_info_t *traversal_info)
4005 {
4006 *externals_old = traversal_info->externals_old;
4007 *externals_new = traversal_info->externals_new;
4008 }
4009
4010
4011 void
svn_wc_traversed_depths(apr_hash_t ** depths,svn_wc_traversal_info_t * traversal_info)4012 svn_wc_traversed_depths(apr_hash_t **depths,
4013 svn_wc_traversal_info_t *traversal_info)
4014 {
4015 *depths = traversal_info->depths;
4016 }
4017
4018
4019 /*** From lock.c ***/
4020
4021 /* To preserve API compatibility with Subversion 1.0.0 */
4022 svn_error_t *
svn_wc_adm_open(svn_wc_adm_access_t ** adm_access,svn_wc_adm_access_t * associated,const char * path,svn_boolean_t write_lock,svn_boolean_t tree_lock,apr_pool_t * pool)4023 svn_wc_adm_open(svn_wc_adm_access_t **adm_access,
4024 svn_wc_adm_access_t *associated,
4025 const char *path,
4026 svn_boolean_t write_lock,
4027 svn_boolean_t tree_lock,
4028 apr_pool_t *pool)
4029 {
4030 return svn_wc_adm_open3(adm_access, associated, path, write_lock,
4031 (tree_lock ? -1 : 0), NULL, NULL, pool);
4032 }
4033
4034 svn_error_t *
svn_wc_adm_open2(svn_wc_adm_access_t ** adm_access,svn_wc_adm_access_t * associated,const char * path,svn_boolean_t write_lock,int levels_to_lock,apr_pool_t * pool)4035 svn_wc_adm_open2(svn_wc_adm_access_t **adm_access,
4036 svn_wc_adm_access_t *associated,
4037 const char *path,
4038 svn_boolean_t write_lock,
4039 int levels_to_lock,
4040 apr_pool_t *pool)
4041 {
4042 return svn_wc_adm_open3(adm_access, associated, path, write_lock,
4043 levels_to_lock, NULL, NULL, pool);
4044 }
4045
4046 svn_error_t *
svn_wc_adm_probe_open(svn_wc_adm_access_t ** adm_access,svn_wc_adm_access_t * associated,const char * path,svn_boolean_t write_lock,svn_boolean_t tree_lock,apr_pool_t * pool)4047 svn_wc_adm_probe_open(svn_wc_adm_access_t **adm_access,
4048 svn_wc_adm_access_t *associated,
4049 const char *path,
4050 svn_boolean_t write_lock,
4051 svn_boolean_t tree_lock,
4052 apr_pool_t *pool)
4053 {
4054 return svn_wc_adm_probe_open3(adm_access, associated, path,
4055 write_lock, (tree_lock ? -1 : 0),
4056 NULL, NULL, pool);
4057 }
4058
4059
4060 svn_error_t *
svn_wc_adm_probe_open2(svn_wc_adm_access_t ** adm_access,svn_wc_adm_access_t * associated,const char * path,svn_boolean_t write_lock,int levels_to_lock,apr_pool_t * pool)4061 svn_wc_adm_probe_open2(svn_wc_adm_access_t **adm_access,
4062 svn_wc_adm_access_t *associated,
4063 const char *path,
4064 svn_boolean_t write_lock,
4065 int levels_to_lock,
4066 apr_pool_t *pool)
4067 {
4068 return svn_wc_adm_probe_open3(adm_access, associated, path, write_lock,
4069 levels_to_lock, NULL, NULL, pool);
4070 }
4071
4072 svn_error_t *
svn_wc_adm_probe_try2(svn_wc_adm_access_t ** adm_access,svn_wc_adm_access_t * associated,const char * path,svn_boolean_t write_lock,int levels_to_lock,apr_pool_t * pool)4073 svn_wc_adm_probe_try2(svn_wc_adm_access_t **adm_access,
4074 svn_wc_adm_access_t *associated,
4075 const char *path,
4076 svn_boolean_t write_lock,
4077 int levels_to_lock,
4078 apr_pool_t *pool)
4079 {
4080 return svn_wc_adm_probe_try3(adm_access, associated, path, write_lock,
4081 levels_to_lock, NULL, NULL, pool);
4082 }
4083
4084 svn_error_t *
svn_wc_adm_probe_try(svn_wc_adm_access_t ** adm_access,svn_wc_adm_access_t * associated,const char * path,svn_boolean_t write_lock,svn_boolean_t tree_lock,apr_pool_t * pool)4085 svn_wc_adm_probe_try(svn_wc_adm_access_t **adm_access,
4086 svn_wc_adm_access_t *associated,
4087 const char *path,
4088 svn_boolean_t write_lock,
4089 svn_boolean_t tree_lock,
4090 apr_pool_t *pool)
4091 {
4092 return svn_wc_adm_probe_try3(adm_access, associated, path, write_lock,
4093 (tree_lock ? -1 : 0), NULL, NULL, pool);
4094 }
4095
4096 svn_error_t *
svn_wc_adm_close(svn_wc_adm_access_t * adm_access)4097 svn_wc_adm_close(svn_wc_adm_access_t *adm_access)
4098 {
4099 /* This is the only pool we have access to. */
4100 apr_pool_t *scratch_pool = svn_wc_adm_access_pool(adm_access);
4101
4102 return svn_wc_adm_close2(adm_access, scratch_pool);
4103 }
4104
4105 svn_error_t *
svn_wc_locked(svn_boolean_t * locked,const char * path,apr_pool_t * pool)4106 svn_wc_locked(svn_boolean_t *locked,
4107 const char *path,
4108 apr_pool_t *pool)
4109 {
4110 svn_wc_context_t *wc_ctx;
4111 const char *local_abspath;
4112
4113 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4114 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
4115
4116 SVN_ERR(svn_wc_locked2(NULL, locked, wc_ctx, local_abspath, pool));
4117
4118 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4119 }
4120
4121 svn_error_t *
svn_wc_check_wc(const char * path,int * wc_format,apr_pool_t * pool)4122 svn_wc_check_wc(const char *path,
4123 int *wc_format,
4124 apr_pool_t *pool)
4125 {
4126 svn_wc_context_t *wc_ctx;
4127 const char *local_abspath;
4128
4129 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4130 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
4131
4132 SVN_ERR(svn_wc_check_wc2(wc_format, wc_ctx, local_abspath, pool));
4133
4134 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4135 }
4136
4137
4138 /*** From translate.c ***/
4139
4140 svn_error_t *
svn_wc_translated_file(const char ** xlated_p,const char * vfile,svn_wc_adm_access_t * adm_access,svn_boolean_t force_repair,apr_pool_t * pool)4141 svn_wc_translated_file(const char **xlated_p,
4142 const char *vfile,
4143 svn_wc_adm_access_t *adm_access,
4144 svn_boolean_t force_repair,
4145 apr_pool_t *pool)
4146 {
4147 return svn_wc_translated_file2(xlated_p, vfile, vfile, adm_access,
4148 SVN_WC_TRANSLATE_TO_NF
4149 | (force_repair ?
4150 SVN_WC_TRANSLATE_FORCE_EOL_REPAIR : 0),
4151 pool);
4152 }
4153
4154 svn_error_t *
svn_wc_translated_stream(svn_stream_t ** stream,const char * path,const char * versioned_file,svn_wc_adm_access_t * adm_access,apr_uint32_t flags,apr_pool_t * pool)4155 svn_wc_translated_stream(svn_stream_t **stream,
4156 const char *path,
4157 const char *versioned_file,
4158 svn_wc_adm_access_t *adm_access,
4159 apr_uint32_t flags,
4160 apr_pool_t *pool)
4161 {
4162 const char *local_abspath;
4163 const char *versioned_abspath;
4164
4165 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4166 SVN_ERR(svn_dirent_get_absolute(&versioned_abspath, versioned_file, pool));
4167
4168 return svn_error_trace(
4169 svn_wc__internal_translated_stream(stream, svn_wc__adm_get_db(adm_access),
4170 local_abspath, versioned_abspath, flags,
4171 pool, pool));
4172 }
4173
4174 svn_error_t *
svn_wc_translated_file2(const char ** xlated_path,const char * src,const char * versioned_file,svn_wc_adm_access_t * adm_access,apr_uint32_t flags,apr_pool_t * pool)4175 svn_wc_translated_file2(const char **xlated_path,
4176 const char *src,
4177 const char *versioned_file,
4178 svn_wc_adm_access_t *adm_access,
4179 apr_uint32_t flags,
4180 apr_pool_t *pool)
4181 {
4182 const char *versioned_abspath;
4183 const char *root;
4184 const char *tmp_root;
4185 const char *src_abspath;
4186
4187 SVN_ERR(svn_dirent_get_absolute(&versioned_abspath, versioned_file, pool));
4188 SVN_ERR(svn_dirent_get_absolute(&src_abspath, src, pool));
4189
4190 SVN_ERR(svn_wc__internal_translated_file(xlated_path, src_abspath,
4191 svn_wc__adm_get_db(adm_access),
4192 versioned_abspath,
4193 flags, NULL, NULL, pool, pool));
4194
4195 if (strcmp(*xlated_path, src_abspath) == 0)
4196 *xlated_path = src;
4197 else if (! svn_dirent_is_absolute(versioned_file))
4198 {
4199 SVN_ERR(svn_io_temp_dir(&tmp_root, pool));
4200 if (! svn_dirent_is_child(tmp_root, *xlated_path, pool))
4201 {
4202 SVN_ERR(svn_dirent_get_absolute(&root, "", pool));
4203
4204 if (svn_dirent_is_child(root, *xlated_path, pool))
4205 *xlated_path = svn_dirent_is_child(root, *xlated_path, pool);
4206 }
4207 }
4208
4209 return SVN_NO_ERROR;
4210 }
4211
4212 /*** From relocate.c ***/
4213 svn_error_t *
svn_wc_relocate3(const char * path,svn_wc_adm_access_t * adm_access,const char * from,const char * to,svn_boolean_t recurse,svn_wc_relocation_validator3_t validator,void * validator_baton,apr_pool_t * pool)4214 svn_wc_relocate3(const char *path,
4215 svn_wc_adm_access_t *adm_access,
4216 const char *from,
4217 const char *to,
4218 svn_boolean_t recurse,
4219 svn_wc_relocation_validator3_t validator,
4220 void *validator_baton,
4221 apr_pool_t *pool)
4222 {
4223 const char *local_abspath;
4224 svn_wc_context_t *wc_ctx;
4225
4226 if (! recurse)
4227 SVN_ERR(svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
4228 _("Non-recursive relocation not supported")));
4229
4230 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4231 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
4232 svn_wc__adm_get_db(adm_access),
4233 pool));
4234
4235 SVN_ERR(svn_wc_relocate4(wc_ctx, local_abspath, from, to,
4236 validator, validator_baton, pool));
4237
4238 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4239 }
4240
4241 /* Compatibility baton and wrapper. */
4242 struct compat2_baton {
4243 svn_wc_relocation_validator2_t validator;
4244 void *baton;
4245 };
4246
4247 /* Compatibility baton and wrapper. */
4248 struct compat_baton {
4249 svn_wc_relocation_validator_t validator;
4250 void *baton;
4251 };
4252
4253 /* This implements svn_wc_relocate_validator3_t. */
4254 static svn_error_t *
compat2_validator(void * baton,const char * uuid,const char * url,const char * root_url,apr_pool_t * pool)4255 compat2_validator(void *baton,
4256 const char *uuid,
4257 const char *url,
4258 const char *root_url,
4259 apr_pool_t *pool)
4260 {
4261 struct compat2_baton *cb = baton;
4262 /* The old callback type doesn't set root_url. */
4263 return cb->validator(cb->baton, uuid,
4264 (root_url ? root_url : url), (root_url != NULL),
4265 pool);
4266 }
4267
4268 /* This implements svn_wc_relocate_validator3_t. */
4269 static svn_error_t *
compat_validator(void * baton,const char * uuid,const char * url,const char * root_url,apr_pool_t * pool)4270 compat_validator(void *baton,
4271 const char *uuid,
4272 const char *url,
4273 const char *root_url,
4274 apr_pool_t *pool)
4275 {
4276 struct compat_baton *cb = baton;
4277 /* The old callback type doesn't allow uuid to be NULL. */
4278 if (uuid)
4279 return cb->validator(cb->baton, uuid, url);
4280 return SVN_NO_ERROR;
4281 }
4282
4283 svn_error_t *
svn_wc_relocate2(const char * path,svn_wc_adm_access_t * adm_access,const char * from,const char * to,svn_boolean_t recurse,svn_wc_relocation_validator2_t validator,void * validator_baton,apr_pool_t * pool)4284 svn_wc_relocate2(const char *path,
4285 svn_wc_adm_access_t *adm_access,
4286 const char *from,
4287 const char *to,
4288 svn_boolean_t recurse,
4289 svn_wc_relocation_validator2_t validator,
4290 void *validator_baton,
4291 apr_pool_t *pool)
4292 {
4293 struct compat2_baton cb;
4294
4295 cb.validator = validator;
4296 cb.baton = validator_baton;
4297
4298 return svn_wc_relocate3(path, adm_access, from, to, recurse,
4299 compat2_validator, &cb, pool);
4300 }
4301
4302 svn_error_t *
svn_wc_relocate(const char * path,svn_wc_adm_access_t * adm_access,const char * from,const char * to,svn_boolean_t recurse,svn_wc_relocation_validator_t validator,void * validator_baton,apr_pool_t * pool)4303 svn_wc_relocate(const char *path,
4304 svn_wc_adm_access_t *adm_access,
4305 const char *from,
4306 const char *to,
4307 svn_boolean_t recurse,
4308 svn_wc_relocation_validator_t validator,
4309 void *validator_baton,
4310 apr_pool_t *pool)
4311 {
4312 struct compat_baton cb;
4313
4314 cb.validator = validator;
4315 cb.baton = validator_baton;
4316
4317 return svn_wc_relocate3(path, adm_access, from, to, recurse,
4318 compat_validator, &cb, pool);
4319 }
4320
4321
4322 /*** From log.c / cleanup.c ***/
4323
4324 svn_error_t *
svn_wc_cleanup3(svn_wc_context_t * wc_ctx,const char * local_abspath,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * scratch_pool)4325 svn_wc_cleanup3(svn_wc_context_t *wc_ctx,
4326 const char *local_abspath,
4327 svn_cancel_func_t cancel_func,
4328 void *cancel_baton,
4329 apr_pool_t *scratch_pool)
4330 {
4331 return svn_error_trace(
4332 svn_wc_cleanup4(wc_ctx,
4333 local_abspath,
4334 TRUE /* break_locks */,
4335 TRUE /* fix_recorded_timestamps */,
4336 TRUE /* clear_dav_cache */,
4337 TRUE /* clean_pristines */,
4338 cancel_func, cancel_baton,
4339 NULL, NULL /* notify */,
4340 scratch_pool));
4341 }
4342
4343 svn_error_t *
svn_wc_cleanup2(const char * path,const char * diff3_cmd,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)4344 svn_wc_cleanup2(const char *path,
4345 const char *diff3_cmd,
4346 svn_cancel_func_t cancel_func,
4347 void *cancel_baton,
4348 apr_pool_t *pool)
4349 {
4350 svn_wc_context_t *wc_ctx;
4351 const char *local_abspath;
4352
4353 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4354 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
4355
4356 SVN_ERR(svn_wc_cleanup3(wc_ctx, local_abspath, cancel_func,
4357 cancel_baton, pool));
4358
4359 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4360 }
4361
4362 svn_error_t *
svn_wc_cleanup(const char * path,svn_wc_adm_access_t * optional_adm_access,const char * diff3_cmd,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)4363 svn_wc_cleanup(const char *path,
4364 svn_wc_adm_access_t *optional_adm_access,
4365 const char *diff3_cmd,
4366 svn_cancel_func_t cancel_func,
4367 void *cancel_baton,
4368 apr_pool_t *pool)
4369 {
4370 return svn_wc_cleanup2(path, diff3_cmd, cancel_func, cancel_baton, pool);
4371 }
4372
4373 /*** From questions.c ***/
4374
4375 svn_error_t *
svn_wc_has_binary_prop(svn_boolean_t * has_binary_prop,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)4376 svn_wc_has_binary_prop(svn_boolean_t *has_binary_prop,
4377 const char *path,
4378 svn_wc_adm_access_t *adm_access,
4379 apr_pool_t *pool)
4380 {
4381 svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
4382 const char *local_abspath;
4383 const svn_string_t *value;
4384
4385 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4386
4387 SVN_ERR(svn_wc__internal_propget(&value, db, local_abspath,
4388 SVN_PROP_MIME_TYPE,
4389 pool, pool));
4390
4391 if (value && (svn_mime_type_is_binary(value->data)))
4392 *has_binary_prop = TRUE;
4393 else
4394 *has_binary_prop = FALSE;
4395
4396 return SVN_NO_ERROR;
4397 }
4398
4399 svn_error_t *
svn_wc_conflicted_p2(svn_boolean_t * text_conflicted_p,svn_boolean_t * prop_conflicted_p,svn_boolean_t * tree_conflicted_p,const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)4400 svn_wc_conflicted_p2(svn_boolean_t *text_conflicted_p,
4401 svn_boolean_t *prop_conflicted_p,
4402 svn_boolean_t *tree_conflicted_p,
4403 const char *path,
4404 svn_wc_adm_access_t *adm_access,
4405 apr_pool_t *pool)
4406 {
4407 const char *local_abspath;
4408 svn_wc_context_t *wc_ctx;
4409 svn_error_t *err;
4410
4411 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4412 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
4413 svn_wc__adm_get_db(adm_access),
4414 pool));
4415
4416 err = svn_wc_conflicted_p3(text_conflicted_p, prop_conflicted_p,
4417 tree_conflicted_p, wc_ctx, local_abspath, pool);
4418
4419 if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
4420 {
4421 svn_error_clear(err);
4422
4423 if (text_conflicted_p)
4424 *text_conflicted_p = FALSE;
4425 if (prop_conflicted_p)
4426 *prop_conflicted_p = FALSE;
4427 if (tree_conflicted_p)
4428 *tree_conflicted_p = FALSE;
4429 }
4430 else if (err)
4431 return err;
4432
4433 return SVN_NO_ERROR;
4434 }
4435
4436 svn_error_t *
svn_wc_conflicted_p(svn_boolean_t * text_conflicted_p,svn_boolean_t * prop_conflicted_p,const char * dir_path,const svn_wc_entry_t * entry,apr_pool_t * pool)4437 svn_wc_conflicted_p(svn_boolean_t *text_conflicted_p,
4438 svn_boolean_t *prop_conflicted_p,
4439 const char *dir_path,
4440 const svn_wc_entry_t *entry,
4441 apr_pool_t *pool)
4442 {
4443 svn_node_kind_t kind;
4444 const char *path;
4445
4446 *text_conflicted_p = FALSE;
4447 *prop_conflicted_p = FALSE;
4448
4449 if (entry->conflict_old)
4450 {
4451 path = svn_dirent_join(dir_path, entry->conflict_old, pool);
4452 SVN_ERR(svn_io_check_path(path, &kind, pool));
4453 *text_conflicted_p = (kind == svn_node_file);
4454 }
4455
4456 if ((! *text_conflicted_p) && (entry->conflict_new))
4457 {
4458 path = svn_dirent_join(dir_path, entry->conflict_new, pool);
4459 SVN_ERR(svn_io_check_path(path, &kind, pool));
4460 *text_conflicted_p = (kind == svn_node_file);
4461 }
4462
4463 if ((! *text_conflicted_p) && (entry->conflict_wrk))
4464 {
4465 path = svn_dirent_join(dir_path, entry->conflict_wrk, pool);
4466 SVN_ERR(svn_io_check_path(path, &kind, pool));
4467 *text_conflicted_p = (kind == svn_node_file);
4468 }
4469
4470 if (entry->prejfile)
4471 {
4472 path = svn_dirent_join(dir_path, entry->prejfile, pool);
4473 SVN_ERR(svn_io_check_path(path, &kind, pool));
4474 *prop_conflicted_p = (kind == svn_node_file);
4475 }
4476
4477 return SVN_NO_ERROR;
4478 }
4479
4480 svn_error_t *
svn_wc_text_modified_p(svn_boolean_t * modified_p,const char * filename,svn_boolean_t force_comparison,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)4481 svn_wc_text_modified_p(svn_boolean_t *modified_p,
4482 const char *filename,
4483 svn_boolean_t force_comparison,
4484 svn_wc_adm_access_t *adm_access,
4485 apr_pool_t *pool)
4486 {
4487 svn_wc_context_t *wc_ctx;
4488 svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
4489 const char *local_abspath;
4490
4491 SVN_ERR(svn_dirent_get_absolute(&local_abspath, filename, pool));
4492 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
4493
4494 SVN_ERR(svn_wc_text_modified_p2(modified_p, wc_ctx, local_abspath,
4495 force_comparison, pool));
4496
4497 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4498 }
4499
4500
4501 /*** From copy.c ***/
4502 svn_error_t *
svn_wc_copy2(const char * src,svn_wc_adm_access_t * dst_parent,const char * dst_basename,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * pool)4503 svn_wc_copy2(const char *src,
4504 svn_wc_adm_access_t *dst_parent,
4505 const char *dst_basename,
4506 svn_cancel_func_t cancel_func,
4507 void *cancel_baton,
4508 svn_wc_notify_func2_t notify_func,
4509 void *notify_baton,
4510 apr_pool_t *pool)
4511 {
4512 svn_wc_context_t *wc_ctx;
4513 svn_wc__db_t *wc_db = svn_wc__adm_get_db(dst_parent);
4514 const char *src_abspath;
4515 const char *dst_abspath;
4516
4517 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
4518 SVN_ERR(svn_dirent_get_absolute(&src_abspath, src, pool));
4519
4520 dst_abspath = svn_dirent_join(svn_wc__adm_access_abspath(dst_parent),
4521 dst_basename, pool);
4522
4523 SVN_ERR(svn_wc_copy3(wc_ctx,
4524 src_abspath,
4525 dst_abspath,
4526 FALSE /* metadata_only */,
4527 cancel_func, cancel_baton,
4528 notify_func, notify_baton,
4529 pool));
4530
4531 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4532 }
4533
4534 svn_error_t *
svn_wc_copy(const char * src_path,svn_wc_adm_access_t * dst_parent,const char * dst_basename,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func_t notify_func,void * notify_baton,apr_pool_t * pool)4535 svn_wc_copy(const char *src_path,
4536 svn_wc_adm_access_t *dst_parent,
4537 const char *dst_basename,
4538 svn_cancel_func_t cancel_func,
4539 void *cancel_baton,
4540 svn_wc_notify_func_t notify_func,
4541 void *notify_baton,
4542 apr_pool_t *pool)
4543 {
4544 struct compat_notify_baton_t nb;
4545
4546 nb.func = notify_func;
4547 nb.baton = notify_baton;
4548
4549 return svn_wc_copy2(src_path, dst_parent, dst_basename, cancel_func,
4550 cancel_baton, compat_call_notify_func,
4551 &nb, pool);
4552 }
4553
4554
4555 /*** From merge.c ***/
4556
4557 svn_error_t *
svn_wc_merge4(enum svn_wc_merge_outcome_t * merge_outcome,svn_wc_context_t * wc_ctx,const char * left_abspath,const char * right_abspath,const char * target_abspath,const char * left_label,const char * right_label,const char * target_label,const svn_wc_conflict_version_t * left_version,const svn_wc_conflict_version_t * right_version,svn_boolean_t dry_run,const char * diff3_cmd,const apr_array_header_t * merge_options,const apr_array_header_t * prop_diff,svn_wc_conflict_resolver_func2_t conflict_func,void * conflict_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * scratch_pool)4558 svn_wc_merge4(enum svn_wc_merge_outcome_t *merge_outcome,
4559 svn_wc_context_t *wc_ctx,
4560 const char *left_abspath,
4561 const char *right_abspath,
4562 const char *target_abspath,
4563 const char *left_label,
4564 const char *right_label,
4565 const char *target_label,
4566 const svn_wc_conflict_version_t *left_version,
4567 const svn_wc_conflict_version_t *right_version,
4568 svn_boolean_t dry_run,
4569 const char *diff3_cmd,
4570 const apr_array_header_t *merge_options,
4571 const apr_array_header_t *prop_diff,
4572 svn_wc_conflict_resolver_func2_t conflict_func,
4573 void *conflict_baton,
4574 svn_cancel_func_t cancel_func,
4575 void *cancel_baton,
4576 apr_pool_t *scratch_pool)
4577 {
4578 return svn_error_trace(
4579 svn_wc_merge5(merge_outcome,
4580 NULL /* merge_props_outcome */,
4581 wc_ctx,
4582 left_abspath,
4583 right_abspath,
4584 target_abspath,
4585 left_label,
4586 right_label,
4587 target_label,
4588 left_version,
4589 right_version,
4590 dry_run,
4591 diff3_cmd,
4592 merge_options,
4593 NULL /* original_props */,
4594 prop_diff,
4595 conflict_func, conflict_baton,
4596 cancel_func, cancel_baton,
4597 scratch_pool));
4598 }
4599
4600 svn_error_t *
svn_wc_merge3(enum svn_wc_merge_outcome_t * merge_outcome,const char * left,const char * right,const char * merge_target,svn_wc_adm_access_t * adm_access,const char * left_label,const char * right_label,const char * target_label,svn_boolean_t dry_run,const char * diff3_cmd,const apr_array_header_t * merge_options,const apr_array_header_t * prop_diff,svn_wc_conflict_resolver_func_t conflict_func,void * conflict_baton,apr_pool_t * pool)4601 svn_wc_merge3(enum svn_wc_merge_outcome_t *merge_outcome,
4602 const char *left,
4603 const char *right,
4604 const char *merge_target,
4605 svn_wc_adm_access_t *adm_access,
4606 const char *left_label,
4607 const char *right_label,
4608 const char *target_label,
4609 svn_boolean_t dry_run,
4610 const char *diff3_cmd,
4611 const apr_array_header_t *merge_options,
4612 const apr_array_header_t *prop_diff,
4613 svn_wc_conflict_resolver_func_t conflict_func,
4614 void *conflict_baton,
4615 apr_pool_t *pool)
4616 {
4617 svn_wc_context_t *wc_ctx;
4618 svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
4619 const char *left_abspath, *right_abspath, *target_abspath;
4620 struct conflict_func_1to2_baton cfw;
4621
4622 SVN_ERR(svn_dirent_get_absolute(&left_abspath, left, pool));
4623 SVN_ERR(svn_dirent_get_absolute(&right_abspath, right, pool));
4624 SVN_ERR(svn_dirent_get_absolute(&target_abspath, merge_target, pool));
4625
4626 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */, db, pool));
4627
4628 cfw.inner_func = conflict_func;
4629 cfw.inner_baton = conflict_baton;
4630
4631 if (diff3_cmd)
4632 SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
4633
4634 SVN_ERR(svn_wc_merge4(merge_outcome,
4635 wc_ctx,
4636 left_abspath,
4637 right_abspath,
4638 target_abspath,
4639 left_label,
4640 right_label,
4641 target_label,
4642 NULL,
4643 NULL,
4644 dry_run,
4645 diff3_cmd,
4646 merge_options,
4647 prop_diff,
4648 conflict_func ? conflict_func_1to2_wrapper : NULL,
4649 &cfw,
4650 NULL, NULL,
4651 pool));
4652
4653 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4654 }
4655
4656 svn_error_t *
svn_wc_merge2(enum svn_wc_merge_outcome_t * merge_outcome,const char * left,const char * right,const char * merge_target,svn_wc_adm_access_t * adm_access,const char * left_label,const char * right_label,const char * target_label,svn_boolean_t dry_run,const char * diff3_cmd,const apr_array_header_t * merge_options,apr_pool_t * pool)4657 svn_wc_merge2(enum svn_wc_merge_outcome_t *merge_outcome,
4658 const char *left,
4659 const char *right,
4660 const char *merge_target,
4661 svn_wc_adm_access_t *adm_access,
4662 const char *left_label,
4663 const char *right_label,
4664 const char *target_label,
4665 svn_boolean_t dry_run,
4666 const char *diff3_cmd,
4667 const apr_array_header_t *merge_options,
4668 apr_pool_t *pool)
4669 {
4670 return svn_wc_merge3(merge_outcome,
4671 left, right, merge_target, adm_access,
4672 left_label, right_label, target_label,
4673 dry_run, diff3_cmd, merge_options, NULL,
4674 NULL, NULL, pool);
4675 }
4676
4677 svn_error_t *
svn_wc_merge(const char * left,const char * right,const char * merge_target,svn_wc_adm_access_t * adm_access,const char * left_label,const char * right_label,const char * target_label,svn_boolean_t dry_run,enum svn_wc_merge_outcome_t * merge_outcome,const char * diff3_cmd,apr_pool_t * pool)4678 svn_wc_merge(const char *left,
4679 const char *right,
4680 const char *merge_target,
4681 svn_wc_adm_access_t *adm_access,
4682 const char *left_label,
4683 const char *right_label,
4684 const char *target_label,
4685 svn_boolean_t dry_run,
4686 enum svn_wc_merge_outcome_t *merge_outcome,
4687 const char *diff3_cmd,
4688 apr_pool_t *pool)
4689 {
4690 return svn_wc_merge3(merge_outcome,
4691 left, right, merge_target, adm_access,
4692 left_label, right_label, target_label,
4693 dry_run, diff3_cmd, NULL, NULL, NULL,
4694 NULL, pool);
4695 }
4696
4697
4698 /*** From util.c ***/
4699
4700 svn_wc_conflict_version_t *
svn_wc_conflict_version_create(const char * repos_url,const char * path_in_repos,svn_revnum_t peg_rev,svn_node_kind_t node_kind,apr_pool_t * pool)4701 svn_wc_conflict_version_create(const char *repos_url,
4702 const char *path_in_repos,
4703 svn_revnum_t peg_rev,
4704 svn_node_kind_t node_kind,
4705 apr_pool_t *pool)
4706 {
4707 return svn_wc_conflict_version_create2(repos_url, NULL, path_in_repos,
4708 peg_rev, node_kind, pool);
4709 }
4710
4711 svn_wc_conflict_description_t *
svn_wc_conflict_description_create_text(const char * path,svn_wc_adm_access_t * adm_access,apr_pool_t * pool)4712 svn_wc_conflict_description_create_text(const char *path,
4713 svn_wc_adm_access_t *adm_access,
4714 apr_pool_t *pool)
4715 {
4716 svn_wc_conflict_description_t *conflict;
4717
4718 conflict = apr_pcalloc(pool, sizeof(*conflict));
4719 conflict->path = path;
4720 conflict->node_kind = svn_node_file;
4721 conflict->kind = svn_wc_conflict_kind_text;
4722 conflict->access = adm_access;
4723 conflict->action = svn_wc_conflict_action_edit;
4724 conflict->reason = svn_wc_conflict_reason_edited;
4725 return conflict;
4726 }
4727
4728 svn_wc_conflict_description_t *
svn_wc_conflict_description_create_prop(const char * path,svn_wc_adm_access_t * adm_access,svn_node_kind_t node_kind,const char * property_name,apr_pool_t * pool)4729 svn_wc_conflict_description_create_prop(const char *path,
4730 svn_wc_adm_access_t *adm_access,
4731 svn_node_kind_t node_kind,
4732 const char *property_name,
4733 apr_pool_t *pool)
4734 {
4735 svn_wc_conflict_description_t *conflict;
4736
4737 conflict = apr_pcalloc(pool, sizeof(*conflict));
4738 conflict->path = path;
4739 conflict->node_kind = node_kind;
4740 conflict->kind = svn_wc_conflict_kind_property;
4741 conflict->access = adm_access;
4742 conflict->property_name = property_name;
4743 return conflict;
4744 }
4745
4746 svn_wc_conflict_description_t *
svn_wc_conflict_description_create_tree(const char * path,svn_wc_adm_access_t * adm_access,svn_node_kind_t node_kind,svn_wc_operation_t operation,svn_wc_conflict_version_t * src_left_version,svn_wc_conflict_version_t * src_right_version,apr_pool_t * pool)4747 svn_wc_conflict_description_create_tree(
4748 const char *path,
4749 svn_wc_adm_access_t *adm_access,
4750 svn_node_kind_t node_kind,
4751 svn_wc_operation_t operation,
4752 svn_wc_conflict_version_t *src_left_version,
4753 svn_wc_conflict_version_t *src_right_version,
4754 apr_pool_t *pool)
4755 {
4756 svn_wc_conflict_description_t *conflict;
4757
4758 conflict = apr_pcalloc(pool, sizeof(*conflict));
4759 conflict->path = path;
4760 conflict->node_kind = node_kind;
4761 conflict->kind = svn_wc_conflict_kind_tree;
4762 conflict->access = adm_access;
4763 conflict->operation = operation;
4764 conflict->src_left_version = src_left_version;
4765 conflict->src_right_version = src_right_version;
4766 return conflict;
4767 }
4768
4769
4770 /*** From revision_status.c ***/
4771
4772 svn_error_t *
svn_wc_revision_status(svn_wc_revision_status_t ** result_p,const char * wc_path,const char * trail_url,svn_boolean_t committed,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)4773 svn_wc_revision_status(svn_wc_revision_status_t **result_p,
4774 const char *wc_path,
4775 const char *trail_url,
4776 svn_boolean_t committed,
4777 svn_cancel_func_t cancel_func,
4778 void *cancel_baton,
4779 apr_pool_t *pool)
4780 {
4781 svn_wc_context_t *wc_ctx;
4782 const char *local_abspath;
4783
4784 SVN_ERR(svn_dirent_get_absolute(&local_abspath, wc_path, pool));
4785 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL /* config */, pool, pool));
4786
4787 SVN_ERR(svn_wc_revision_status2(result_p, wc_ctx, local_abspath, trail_url,
4788 committed, cancel_func, cancel_baton, pool,
4789 pool));
4790
4791 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4792 }
4793
4794 /*** From crop.c ***/
4795 svn_error_t *
svn_wc_crop_tree(svn_wc_adm_access_t * anchor,const char * target,svn_depth_t depth,svn_wc_notify_func2_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)4796 svn_wc_crop_tree(svn_wc_adm_access_t *anchor,
4797 const char *target,
4798 svn_depth_t depth,
4799 svn_wc_notify_func2_t notify_func,
4800 void *notify_baton,
4801 svn_cancel_func_t cancel_func,
4802 void *cancel_baton,
4803 apr_pool_t *pool)
4804 {
4805 svn_wc_context_t *wc_ctx;
4806 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
4807 const char *local_abspath;
4808
4809 local_abspath = svn_dirent_join(svn_wc__adm_access_abspath(anchor),
4810 target, pool);
4811
4812 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
4813
4814 if (depth == svn_depth_exclude)
4815 {
4816 SVN_ERR(svn_wc_exclude(wc_ctx,
4817 local_abspath,
4818 cancel_func, cancel_baton,
4819 notify_func, notify_baton,
4820 pool));
4821 }
4822 else
4823 {
4824 SVN_ERR(svn_wc_crop_tree2(wc_ctx,
4825 local_abspath,
4826 depth,
4827 cancel_func, cancel_baton,
4828 notify_func, notify_baton,
4829 pool));
4830 }
4831
4832 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4833 }
4834
4835 svn_error_t *
svn_wc_move(svn_wc_context_t * wc_ctx,const char * src_abspath,const char * dst_abspath,svn_boolean_t metadata_only,svn_cancel_func_t cancel_func,void * cancel_baton,svn_wc_notify_func2_t notify_func,void * notify_baton,apr_pool_t * scratch_pool)4836 svn_wc_move(svn_wc_context_t *wc_ctx,
4837 const char *src_abspath,
4838 const char *dst_abspath,
4839 svn_boolean_t metadata_only,
4840 svn_cancel_func_t cancel_func,
4841 void *cancel_baton,
4842 svn_wc_notify_func2_t notify_func,
4843 void *notify_baton,
4844 apr_pool_t *scratch_pool)
4845 {
4846 return svn_error_trace(svn_wc__move2(wc_ctx, src_abspath, dst_abspath,
4847 metadata_only,
4848 TRUE, /* allow_mixed_revisions */
4849 cancel_func, cancel_baton,
4850 notify_func, notify_baton,
4851 scratch_pool));
4852 }
4853
4854 svn_error_t *
svn_wc_read_kind(svn_node_kind_t * kind,svn_wc_context_t * wc_ctx,const char * abspath,svn_boolean_t show_hidden,apr_pool_t * scratch_pool)4855 svn_wc_read_kind(svn_node_kind_t *kind,
4856 svn_wc_context_t *wc_ctx,
4857 const char *abspath,
4858 svn_boolean_t show_hidden,
4859 apr_pool_t *scratch_pool)
4860 {
4861 return svn_error_trace(
4862 svn_wc_read_kind2(kind,
4863 wc_ctx, abspath,
4864 TRUE /* show_deleted */,
4865 show_hidden,
4866 scratch_pool));
4867 }
4868
4869 svn_wc_conflict_description2_t *
svn_wc__conflict_description2_dup(const svn_wc_conflict_description2_t * conflict,apr_pool_t * pool)4870 svn_wc__conflict_description2_dup(const svn_wc_conflict_description2_t *conflict,
4871 apr_pool_t *pool)
4872 {
4873 return svn_wc_conflict_description2_dup(conflict, pool);
4874 }
4875