1 /*
2 * deprecated.c: holding file for all deprecated APIs.
3 * "we can't lose 'em, but we can shun 'em!"
4 *
5 * ====================================================================
6 * Licensed to the Apache Software Foundation (ASF) under one
7 * or more contributor license agreements. See the NOTICE file
8 * distributed with this work for additional information
9 * regarding copyright ownership. The ASF licenses this file
10 * to you under the Apache License, Version 2.0 (the
11 * "License"); you may not use this file except in compliance
12 * with the License. You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing,
17 * software distributed under the License is distributed on an
18 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
19 * KIND, either express or implied. See the License for the
20 * specific language governing permissions and limitations
21 * under the License.
22 * ====================================================================
23 */
24
25 /* We define this here to remove any further warnings about the usage of
26 deprecated functions in this file. */
27 #define SVN_DEPRECATED
28
29 #include "svn_repos.h"
30 #include "svn_compat.h"
31 #include "svn_hash.h"
32 #include "svn_props.h"
33
34 #include "svn_private_config.h"
35
36 #include "repos.h"
37
38
39
40
41 /*** From commit.c ***/
42
43 svn_error_t *
svn_repos_get_commit_editor4(const svn_delta_editor_t ** editor,void ** edit_baton,svn_repos_t * repos,svn_fs_txn_t * txn,const char * repos_url,const char * base_path,const char * user,const char * log_msg,svn_commit_callback2_t commit_callback,void * commit_baton,svn_repos_authz_callback_t authz_callback,void * authz_baton,apr_pool_t * pool)44 svn_repos_get_commit_editor4(const svn_delta_editor_t **editor,
45 void **edit_baton,
46 svn_repos_t *repos,
47 svn_fs_txn_t *txn,
48 const char *repos_url,
49 const char *base_path,
50 const char *user,
51 const char *log_msg,
52 svn_commit_callback2_t commit_callback,
53 void *commit_baton,
54 svn_repos_authz_callback_t authz_callback,
55 void *authz_baton,
56 apr_pool_t *pool)
57 {
58 apr_hash_t *revprop_table = apr_hash_make(pool);
59 if (user)
60 svn_hash_sets(revprop_table, SVN_PROP_REVISION_AUTHOR,
61 svn_string_create(user, pool));
62 if (log_msg)
63 svn_hash_sets(revprop_table, SVN_PROP_REVISION_LOG,
64 svn_string_create(log_msg, pool));
65 return svn_repos_get_commit_editor5(editor, edit_baton, repos, txn,
66 repos_url, base_path, revprop_table,
67 commit_callback, commit_baton,
68 authz_callback, authz_baton, pool);
69 }
70
71
72 svn_error_t *
svn_repos_get_commit_editor3(const svn_delta_editor_t ** editor,void ** edit_baton,svn_repos_t * repos,svn_fs_txn_t * txn,const char * repos_url,const char * base_path,const char * user,const char * log_msg,svn_commit_callback_t callback,void * callback_baton,svn_repos_authz_callback_t authz_callback,void * authz_baton,apr_pool_t * pool)73 svn_repos_get_commit_editor3(const svn_delta_editor_t **editor,
74 void **edit_baton,
75 svn_repos_t *repos,
76 svn_fs_txn_t *txn,
77 const char *repos_url,
78 const char *base_path,
79 const char *user,
80 const char *log_msg,
81 svn_commit_callback_t callback,
82 void *callback_baton,
83 svn_repos_authz_callback_t authz_callback,
84 void *authz_baton,
85 apr_pool_t *pool)
86 {
87 svn_commit_callback2_t callback2;
88 void *callback2_baton;
89
90 svn_compat_wrap_commit_callback(&callback2, &callback2_baton,
91 callback, callback_baton,
92 pool);
93
94 return svn_repos_get_commit_editor4(editor, edit_baton, repos, txn,
95 repos_url, base_path, user,
96 log_msg, callback2,
97 callback2_baton, authz_callback,
98 authz_baton, pool);
99 }
100
101
102 svn_error_t *
svn_repos_get_commit_editor2(const svn_delta_editor_t ** editor,void ** edit_baton,svn_repos_t * repos,svn_fs_txn_t * txn,const char * repos_url,const char * base_path,const char * user,const char * log_msg,svn_commit_callback_t callback,void * callback_baton,apr_pool_t * pool)103 svn_repos_get_commit_editor2(const svn_delta_editor_t **editor,
104 void **edit_baton,
105 svn_repos_t *repos,
106 svn_fs_txn_t *txn,
107 const char *repos_url,
108 const char *base_path,
109 const char *user,
110 const char *log_msg,
111 svn_commit_callback_t callback,
112 void *callback_baton,
113 apr_pool_t *pool)
114 {
115 return svn_repos_get_commit_editor3(editor, edit_baton, repos, txn,
116 repos_url, base_path, user,
117 log_msg, callback, callback_baton,
118 NULL, NULL, pool);
119 }
120
121
122 svn_error_t *
svn_repos_get_commit_editor(const svn_delta_editor_t ** editor,void ** edit_baton,svn_repos_t * repos,const char * repos_url,const char * base_path,const char * user,const char * log_msg,svn_commit_callback_t callback,void * callback_baton,apr_pool_t * pool)123 svn_repos_get_commit_editor(const svn_delta_editor_t **editor,
124 void **edit_baton,
125 svn_repos_t *repos,
126 const char *repos_url,
127 const char *base_path,
128 const char *user,
129 const char *log_msg,
130 svn_commit_callback_t callback,
131 void *callback_baton,
132 apr_pool_t *pool)
133 {
134 return svn_repos_get_commit_editor2(editor, edit_baton, repos, NULL,
135 repos_url, base_path, user,
136 log_msg, callback,
137 callback_baton, pool);
138 }
139
140 svn_error_t *
svn_repos_open2(svn_repos_t ** repos_p,const char * path,apr_hash_t * fs_config,apr_pool_t * pool)141 svn_repos_open2(svn_repos_t **repos_p,
142 const char *path,
143 apr_hash_t *fs_config,
144 apr_pool_t *pool)
145 {
146 return svn_repos_open3(repos_p, path, fs_config, pool, pool);
147 }
148
149 svn_error_t *
svn_repos_open(svn_repos_t ** repos_p,const char * path,apr_pool_t * pool)150 svn_repos_open(svn_repos_t **repos_p,
151 const char *path,
152 apr_pool_t *pool)
153 {
154 return svn_repos_open2(repos_p, path, NULL, pool);
155 }
156
157
158 /*** From repos.c ***/
159 struct recover_baton
160 {
161 svn_error_t *(*start_callback)(void *baton);
162 void *start_callback_baton;
163 };
164
165 static void
recovery_started(void * baton,const svn_repos_notify_t * notify,apr_pool_t * scratch_pool)166 recovery_started(void *baton,
167 const svn_repos_notify_t *notify,
168 apr_pool_t *scratch_pool)
169 {
170 struct recover_baton *rb = baton;
171
172 if (notify->action == svn_repos_notify_mutex_acquired
173 && rb->start_callback != NULL)
174 svn_error_clear(rb->start_callback(rb->start_callback_baton));
175 }
176
177 svn_error_t *
svn_repos_recover3(const char * path,svn_boolean_t nonblocking,svn_error_t * (* start_callback)(void * baton),void * start_callback_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)178 svn_repos_recover3(const char *path,
179 svn_boolean_t nonblocking,
180 svn_error_t *(*start_callback)(void *baton),
181 void *start_callback_baton,
182 svn_cancel_func_t cancel_func, void *cancel_baton,
183 apr_pool_t *pool)
184 {
185 struct recover_baton rb;
186
187 rb.start_callback = start_callback;
188 rb.start_callback_baton = start_callback_baton;
189
190 return svn_repos_recover4(path, nonblocking, recovery_started, &rb,
191 cancel_func, cancel_baton, pool);
192 }
193
194 svn_error_t *
svn_repos_recover2(const char * path,svn_boolean_t nonblocking,svn_error_t * (* start_callback)(void * baton),void * start_callback_baton,apr_pool_t * pool)195 svn_repos_recover2(const char *path,
196 svn_boolean_t nonblocking,
197 svn_error_t *(*start_callback)(void *baton),
198 void *start_callback_baton,
199 apr_pool_t *pool)
200 {
201 return svn_repos_recover3(path, nonblocking,
202 start_callback, start_callback_baton,
203 NULL, NULL,
204 pool);
205 }
206
207 svn_error_t *
svn_repos_recover(const char * path,apr_pool_t * pool)208 svn_repos_recover(const char *path,
209 apr_pool_t *pool)
210 {
211 return svn_repos_recover2(path, FALSE, NULL, NULL, pool);
212 }
213
214 svn_error_t *
svn_repos_upgrade(const char * path,svn_boolean_t nonblocking,svn_error_t * (* start_callback)(void * baton),void * start_callback_baton,apr_pool_t * pool)215 svn_repos_upgrade(const char *path,
216 svn_boolean_t nonblocking,
217 svn_error_t *(*start_callback)(void *baton),
218 void *start_callback_baton,
219 apr_pool_t *pool)
220 {
221 struct recover_baton rb;
222
223 rb.start_callback = start_callback;
224 rb.start_callback_baton = start_callback_baton;
225
226 return svn_repos_upgrade2(path, nonblocking, recovery_started, &rb, pool);
227 }
228
229 svn_error_t *
svn_repos_hotcopy2(const char * src_path,const char * dst_path,svn_boolean_t clean_logs,svn_boolean_t incremental,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)230 svn_repos_hotcopy2(const char *src_path,
231 const char *dst_path,
232 svn_boolean_t clean_logs,
233 svn_boolean_t incremental,
234 svn_cancel_func_t cancel_func,
235 void *cancel_baton,
236 apr_pool_t *pool)
237 {
238 return svn_error_trace(svn_repos_hotcopy3(src_path, dst_path, clean_logs,
239 incremental, NULL, NULL,
240 cancel_func, cancel_baton, pool));
241 }
242
243 svn_error_t *
svn_repos_hotcopy(const char * src_path,const char * dst_path,svn_boolean_t clean_logs,apr_pool_t * pool)244 svn_repos_hotcopy(const char *src_path,
245 const char *dst_path,
246 svn_boolean_t clean_logs,
247 apr_pool_t *pool)
248 {
249 return svn_error_trace(svn_repos_hotcopy2(src_path, dst_path, clean_logs,
250 FALSE, NULL, NULL, pool));
251 }
252
253 /*** From reporter.c ***/
254 svn_error_t *
svn_repos_begin_report(void ** report_baton,svn_revnum_t revnum,const char * username,svn_repos_t * repos,const char * fs_base,const char * s_operand,const char * switch_path,svn_boolean_t text_deltas,svn_boolean_t recurse,svn_boolean_t ignore_ancestry,const svn_delta_editor_t * editor,void * edit_baton,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,apr_pool_t * pool)255 svn_repos_begin_report(void **report_baton,
256 svn_revnum_t revnum,
257 const char *username,
258 svn_repos_t *repos,
259 const char *fs_base,
260 const char *s_operand,
261 const char *switch_path,
262 svn_boolean_t text_deltas,
263 svn_boolean_t recurse,
264 svn_boolean_t ignore_ancestry,
265 const svn_delta_editor_t *editor,
266 void *edit_baton,
267 svn_repos_authz_func_t authz_read_func,
268 void *authz_read_baton,
269 apr_pool_t *pool)
270 {
271 return svn_repos_begin_report2(report_baton,
272 revnum,
273 repos,
274 fs_base,
275 s_operand,
276 switch_path,
277 text_deltas,
278 SVN_DEPTH_INFINITY_OR_FILES(recurse),
279 ignore_ancestry,
280 FALSE, /* don't send copyfrom args */
281 editor,
282 edit_baton,
283 authz_read_func,
284 authz_read_baton,
285 pool);
286 }
287
288 svn_error_t *
svn_repos_begin_report2(void ** report_baton,svn_revnum_t revnum,svn_repos_t * repos,const char * fs_base,const char * target,const char * tgt_path,svn_boolean_t text_deltas,svn_depth_t depth,svn_boolean_t ignore_ancestry,svn_boolean_t send_copyfrom_args,const svn_delta_editor_t * editor,void * edit_baton,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,apr_pool_t * pool)289 svn_repos_begin_report2(void **report_baton,
290 svn_revnum_t revnum,
291 svn_repos_t *repos,
292 const char *fs_base,
293 const char *target,
294 const char *tgt_path,
295 svn_boolean_t text_deltas,
296 svn_depth_t depth,
297 svn_boolean_t ignore_ancestry,
298 svn_boolean_t send_copyfrom_args,
299 const svn_delta_editor_t *editor,
300 void *edit_baton,
301 svn_repos_authz_func_t authz_read_func,
302 void *authz_read_baton,
303 apr_pool_t *pool)
304 {
305 return svn_repos_begin_report3(report_baton,
306 revnum,
307 repos,
308 fs_base,
309 target,
310 tgt_path,
311 text_deltas,
312 depth,
313 ignore_ancestry,
314 send_copyfrom_args,
315 editor,
316 edit_baton,
317 authz_read_func,
318 authz_read_baton,
319 0, /* disable zero-copy code path */
320 pool);
321 }
322
323 svn_error_t *
svn_repos_set_path2(void * baton,const char * path,svn_revnum_t rev,svn_boolean_t start_empty,const char * lock_token,apr_pool_t * pool)324 svn_repos_set_path2(void *baton, const char *path, svn_revnum_t rev,
325 svn_boolean_t start_empty, const char *lock_token,
326 apr_pool_t *pool)
327 {
328 return svn_repos_set_path3(baton, path, rev, svn_depth_infinity,
329 start_empty, lock_token, pool);
330 }
331
332 svn_error_t *
svn_repos_set_path(void * baton,const char * path,svn_revnum_t rev,svn_boolean_t start_empty,apr_pool_t * pool)333 svn_repos_set_path(void *baton, const char *path, svn_revnum_t rev,
334 svn_boolean_t start_empty, apr_pool_t *pool)
335 {
336 return svn_repos_set_path2(baton, path, rev, start_empty, NULL, pool);
337 }
338
339 svn_error_t *
svn_repos_link_path2(void * baton,const char * path,const char * link_path,svn_revnum_t rev,svn_boolean_t start_empty,const char * lock_token,apr_pool_t * pool)340 svn_repos_link_path2(void *baton, const char *path, const char *link_path,
341 svn_revnum_t rev, svn_boolean_t start_empty,
342 const char *lock_token, apr_pool_t *pool)
343 {
344 return svn_repos_link_path3(baton, path, link_path, rev, svn_depth_infinity,
345 start_empty, lock_token, pool);
346 }
347
348 svn_error_t *
svn_repos_link_path(void * baton,const char * path,const char * link_path,svn_revnum_t rev,svn_boolean_t start_empty,apr_pool_t * pool)349 svn_repos_link_path(void *baton, const char *path, const char *link_path,
350 svn_revnum_t rev, svn_boolean_t start_empty,
351 apr_pool_t *pool)
352 {
353 return svn_repos_link_path2(baton, path, link_path, rev, start_empty,
354 NULL, pool);
355 }
356
357 /*** From dir-delta.c ***/
358 svn_error_t *
svn_repos_dir_delta(svn_fs_root_t * src_root,const char * src_parent_dir,const char * src_entry,svn_fs_root_t * tgt_root,const char * tgt_fullpath,const svn_delta_editor_t * editor,void * edit_baton,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,svn_boolean_t text_deltas,svn_boolean_t recurse,svn_boolean_t entry_props,svn_boolean_t ignore_ancestry,apr_pool_t * pool)359 svn_repos_dir_delta(svn_fs_root_t *src_root,
360 const char *src_parent_dir,
361 const char *src_entry,
362 svn_fs_root_t *tgt_root,
363 const char *tgt_fullpath,
364 const svn_delta_editor_t *editor,
365 void *edit_baton,
366 svn_repos_authz_func_t authz_read_func,
367 void *authz_read_baton,
368 svn_boolean_t text_deltas,
369 svn_boolean_t recurse,
370 svn_boolean_t entry_props,
371 svn_boolean_t ignore_ancestry,
372 apr_pool_t *pool)
373 {
374 return svn_repos_dir_delta2(src_root,
375 src_parent_dir,
376 src_entry,
377 tgt_root,
378 tgt_fullpath,
379 editor,
380 edit_baton,
381 authz_read_func,
382 authz_read_baton,
383 text_deltas,
384 SVN_DEPTH_INFINITY_OR_FILES(recurse),
385 entry_props,
386 ignore_ancestry,
387 pool);
388 }
389
390 /*** From replay.c ***/
391 svn_error_t *
svn_repos_replay(svn_fs_root_t * root,const svn_delta_editor_t * editor,void * edit_baton,apr_pool_t * pool)392 svn_repos_replay(svn_fs_root_t *root,
393 const svn_delta_editor_t *editor,
394 void *edit_baton,
395 apr_pool_t *pool)
396 {
397 return svn_repos_replay2(root,
398 "" /* the whole tree */,
399 SVN_INVALID_REVNUM, /* no low water mark */
400 FALSE /* no text deltas */,
401 editor, edit_baton,
402 NULL /* no authz func */,
403 NULL /* no authz baton */,
404 pool);
405 }
406
407 /*** From fs-wrap.c ***/
408 svn_error_t *
svn_repos_fs_change_rev_prop3(svn_repos_t * repos,svn_revnum_t rev,const char * author,const char * name,const svn_string_t * new_value,svn_boolean_t use_pre_revprop_change_hook,svn_boolean_t use_post_revprop_change_hook,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,apr_pool_t * pool)409 svn_repos_fs_change_rev_prop3(svn_repos_t *repos,
410 svn_revnum_t rev,
411 const char *author,
412 const char *name,
413 const svn_string_t *new_value,
414 svn_boolean_t use_pre_revprop_change_hook,
415 svn_boolean_t use_post_revprop_change_hook,
416 svn_repos_authz_func_t authz_read_func,
417 void *authz_read_baton,
418 apr_pool_t *pool)
419 {
420 return svn_repos_fs_change_rev_prop4(repos, rev, author, name, NULL,
421 new_value,
422 use_pre_revprop_change_hook,
423 use_post_revprop_change_hook,
424 authz_read_func,
425 authz_read_baton, pool);
426 }
427
428 svn_error_t *
svn_repos_fs_change_rev_prop2(svn_repos_t * repos,svn_revnum_t rev,const char * author,const char * name,const svn_string_t * new_value,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,apr_pool_t * pool)429 svn_repos_fs_change_rev_prop2(svn_repos_t *repos,
430 svn_revnum_t rev,
431 const char *author,
432 const char *name,
433 const svn_string_t *new_value,
434 svn_repos_authz_func_t authz_read_func,
435 void *authz_read_baton,
436 apr_pool_t *pool)
437 {
438 return svn_repos_fs_change_rev_prop3(repos, rev, author, name, new_value,
439 TRUE, TRUE, authz_read_func,
440 authz_read_baton, pool);
441 }
442
443
444
445 svn_error_t *
svn_repos_fs_change_rev_prop(svn_repos_t * repos,svn_revnum_t rev,const char * author,const char * name,const svn_string_t * new_value,apr_pool_t * pool)446 svn_repos_fs_change_rev_prop(svn_repos_t *repos,
447 svn_revnum_t rev,
448 const char *author,
449 const char *name,
450 const svn_string_t *new_value,
451 apr_pool_t *pool)
452 {
453 return svn_repos_fs_change_rev_prop2(repos, rev, author, name, new_value,
454 NULL, NULL, pool);
455 }
456
457 struct pack_notify_wrapper_baton
458 {
459 svn_fs_pack_notify_t notify_func;
460 void *notify_baton;
461 };
462
463 static void
pack_notify_wrapper_func(void * baton,const svn_repos_notify_t * notify,apr_pool_t * scratch_pool)464 pack_notify_wrapper_func(void *baton,
465 const svn_repos_notify_t *notify,
466 apr_pool_t *scratch_pool)
467 {
468 struct pack_notify_wrapper_baton *pnwb = baton;
469
470 svn_error_clear(pnwb->notify_func(pnwb->notify_baton, notify->shard,
471 notify->action - 3, scratch_pool));
472 }
473
474 svn_error_t *
svn_repos_fs_pack(svn_repos_t * repos,svn_fs_pack_notify_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)475 svn_repos_fs_pack(svn_repos_t *repos,
476 svn_fs_pack_notify_t notify_func,
477 void *notify_baton,
478 svn_cancel_func_t cancel_func,
479 void *cancel_baton,
480 apr_pool_t *pool)
481 {
482 struct pack_notify_wrapper_baton pnwb;
483
484 pnwb.notify_func = notify_func;
485 pnwb.notify_baton = notify_baton;
486
487 return svn_repos_fs_pack2(repos, pack_notify_wrapper_func, &pnwb,
488 cancel_func, cancel_baton, pool);
489 }
490
491
492 svn_error_t *
svn_repos_fs_get_locks(apr_hash_t ** locks,svn_repos_t * repos,const char * path,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,apr_pool_t * pool)493 svn_repos_fs_get_locks(apr_hash_t **locks,
494 svn_repos_t *repos,
495 const char *path,
496 svn_repos_authz_func_t authz_read_func,
497 void *authz_read_baton,
498 apr_pool_t *pool)
499 {
500 return svn_error_trace(svn_repos_fs_get_locks2(locks, repos, path,
501 svn_depth_infinity,
502 authz_read_func,
503 authz_read_baton, pool));
504 }
505
506
507 /*** From logs.c ***/
508 svn_error_t *
svn_repos_get_logs3(svn_repos_t * repos,const apr_array_header_t * paths,svn_revnum_t start,svn_revnum_t end,int limit,svn_boolean_t discover_changed_paths,svn_boolean_t strict_node_history,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,svn_log_message_receiver_t receiver,void * receiver_baton,apr_pool_t * pool)509 svn_repos_get_logs3(svn_repos_t *repos,
510 const apr_array_header_t *paths,
511 svn_revnum_t start,
512 svn_revnum_t end,
513 int limit,
514 svn_boolean_t discover_changed_paths,
515 svn_boolean_t strict_node_history,
516 svn_repos_authz_func_t authz_read_func,
517 void *authz_read_baton,
518 svn_log_message_receiver_t receiver,
519 void *receiver_baton,
520 apr_pool_t *pool)
521 {
522 svn_log_entry_receiver_t receiver2;
523 void *receiver2_baton;
524
525 svn_compat_wrap_log_receiver(&receiver2, &receiver2_baton,
526 receiver, receiver_baton,
527 pool);
528
529 return svn_repos_get_logs4(repos, paths, start, end, limit,
530 discover_changed_paths, strict_node_history,
531 FALSE, svn_compat_log_revprops_in(pool),
532 authz_read_func, authz_read_baton,
533 receiver2, receiver2_baton,
534 pool);
535 }
536
537 svn_error_t *
svn_repos_get_logs2(svn_repos_t * repos,const apr_array_header_t * paths,svn_revnum_t start,svn_revnum_t end,svn_boolean_t discover_changed_paths,svn_boolean_t strict_node_history,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,svn_log_message_receiver_t receiver,void * receiver_baton,apr_pool_t * pool)538 svn_repos_get_logs2(svn_repos_t *repos,
539 const apr_array_header_t *paths,
540 svn_revnum_t start,
541 svn_revnum_t end,
542 svn_boolean_t discover_changed_paths,
543 svn_boolean_t strict_node_history,
544 svn_repos_authz_func_t authz_read_func,
545 void *authz_read_baton,
546 svn_log_message_receiver_t receiver,
547 void *receiver_baton,
548 apr_pool_t *pool)
549 {
550 return svn_repos_get_logs3(repos, paths, start, end, 0,
551 discover_changed_paths, strict_node_history,
552 authz_read_func, authz_read_baton, receiver,
553 receiver_baton, pool);
554 }
555
556
557 svn_error_t *
svn_repos_get_logs(svn_repos_t * repos,const apr_array_header_t * paths,svn_revnum_t start,svn_revnum_t end,svn_boolean_t discover_changed_paths,svn_boolean_t strict_node_history,svn_log_message_receiver_t receiver,void * receiver_baton,apr_pool_t * pool)558 svn_repos_get_logs(svn_repos_t *repos,
559 const apr_array_header_t *paths,
560 svn_revnum_t start,
561 svn_revnum_t end,
562 svn_boolean_t discover_changed_paths,
563 svn_boolean_t strict_node_history,
564 svn_log_message_receiver_t receiver,
565 void *receiver_baton,
566 apr_pool_t *pool)
567 {
568 return svn_repos_get_logs3(repos, paths, start, end, 0,
569 discover_changed_paths, strict_node_history,
570 NULL, NULL, /* no authz stuff */
571 receiver, receiver_baton, pool);
572 }
573
574 /*** From rev_hunt.c ***/
575 svn_error_t *
svn_repos_history(svn_fs_t * fs,const char * path,svn_repos_history_func_t history_func,void * history_baton,svn_revnum_t start,svn_revnum_t end,svn_boolean_t cross_copies,apr_pool_t * pool)576 svn_repos_history(svn_fs_t *fs,
577 const char *path,
578 svn_repos_history_func_t history_func,
579 void *history_baton,
580 svn_revnum_t start,
581 svn_revnum_t end,
582 svn_boolean_t cross_copies,
583 apr_pool_t *pool)
584 {
585 return svn_repos_history2(fs, path, history_func, history_baton,
586 NULL, NULL,
587 start, end, cross_copies, pool);
588 }
589
590 svn_error_t *
svn_repos_get_file_revs(svn_repos_t * repos,const char * path,svn_revnum_t start,svn_revnum_t end,svn_repos_authz_func_t authz_read_func,void * authz_read_baton,svn_repos_file_rev_handler_t handler,void * handler_baton,apr_pool_t * pool)591 svn_repos_get_file_revs(svn_repos_t *repos,
592 const char *path,
593 svn_revnum_t start,
594 svn_revnum_t end,
595 svn_repos_authz_func_t authz_read_func,
596 void *authz_read_baton,
597 svn_repos_file_rev_handler_t handler,
598 void *handler_baton,
599 apr_pool_t *pool)
600 {
601 svn_file_rev_handler_t handler2;
602 void *handler2_baton;
603
604 svn_compat_wrap_file_rev_handler(&handler2, &handler2_baton, handler,
605 handler_baton, pool);
606
607 return svn_repos_get_file_revs2(repos, path, start, end, FALSE,
608 authz_read_func, authz_read_baton,
609 handler2, handler2_baton, pool);
610 }
611
612 /*** From dump.c ***/
613 svn_error_t *
svn_repos_dump_fs(svn_repos_t * repos,svn_stream_t * stream,svn_stream_t * feedback_stream,svn_revnum_t start_rev,svn_revnum_t end_rev,svn_boolean_t incremental,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)614 svn_repos_dump_fs(svn_repos_t *repos,
615 svn_stream_t *stream,
616 svn_stream_t *feedback_stream,
617 svn_revnum_t start_rev,
618 svn_revnum_t end_rev,
619 svn_boolean_t incremental,
620 svn_cancel_func_t cancel_func,
621 void *cancel_baton,
622 apr_pool_t *pool)
623 {
624 return svn_repos_dump_fs2(repos, stream, feedback_stream, start_rev,
625 end_rev, incremental, FALSE, cancel_func,
626 cancel_baton, pool);
627 }
628
629 /* Implementation of svn_repos_notify_func_t to wrap the output to a
630 response stream for svn_repos_dump_fs2() and svn_repos_verify_fs() */
631 static void
repos_notify_handler(void * baton,const svn_repos_notify_t * notify,apr_pool_t * scratch_pool)632 repos_notify_handler(void *baton,
633 const svn_repos_notify_t *notify,
634 apr_pool_t *scratch_pool)
635 {
636 svn_stream_t *feedback_stream = baton;
637 apr_size_t len;
638
639 switch (notify->action)
640 {
641 case svn_repos_notify_warning:
642 svn_error_clear(svn_stream_puts(feedback_stream, notify->warning_str));
643 return;
644
645 case svn_repos_notify_dump_rev_end:
646 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
647 _("* Dumped revision %ld.\n"),
648 notify->revision));
649 return;
650
651 case svn_repos_notify_verify_rev_end:
652 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
653 _("* Verified revision %ld.\n"),
654 notify->revision));
655 return;
656
657 case svn_repos_notify_load_txn_committed:
658 if (notify->old_revision == SVN_INVALID_REVNUM)
659 {
660 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
661 _("\n------- Committed revision %ld >>>\n\n"),
662 notify->new_revision));
663 }
664 else
665 {
666 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
667 _("\n------- Committed new rev %ld"
668 " (loaded from original rev %ld"
669 ") >>>\n\n"), notify->new_revision,
670 notify->old_revision));
671 }
672 return;
673
674 case svn_repos_notify_load_node_start:
675 {
676 switch (notify->node_action)
677 {
678 case svn_node_action_change:
679 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
680 _(" * editing path : %s ..."),
681 notify->path));
682 break;
683
684 case svn_node_action_delete:
685 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
686 _(" * deleting path : %s ..."),
687 notify->path));
688 break;
689
690 case svn_node_action_add:
691 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
692 _(" * adding path : %s ..."),
693 notify->path));
694 break;
695
696 case svn_node_action_replace:
697 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
698 _(" * replacing path : %s ..."),
699 notify->path));
700 break;
701
702 }
703 }
704 return;
705
706 case svn_repos_notify_load_node_done:
707 len = 7;
708 svn_error_clear(svn_stream_write(feedback_stream, _(" done.\n"), &len));
709 return;
710
711 case svn_repos_notify_load_copied_node:
712 len = 9;
713 svn_error_clear(svn_stream_write(feedback_stream, "COPIED...", &len));
714 return;
715
716 case svn_repos_notify_load_txn_start:
717 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
718 _("<<< Started new transaction, based on "
719 "original revision %ld\n"),
720 notify->old_revision));
721 return;
722
723 case svn_repos_notify_load_normalized_mergeinfo:
724 svn_error_clear(svn_stream_printf(feedback_stream, scratch_pool,
725 _(" removing '\\r' from %s ..."),
726 SVN_PROP_MERGEINFO));
727 return;
728
729 default:
730 return;
731 }
732 }
733
734
735 svn_error_t *
svn_repos_dump_fs2(svn_repos_t * repos,svn_stream_t * stream,svn_stream_t * feedback_stream,svn_revnum_t start_rev,svn_revnum_t end_rev,svn_boolean_t incremental,svn_boolean_t use_deltas,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)736 svn_repos_dump_fs2(svn_repos_t *repos,
737 svn_stream_t *stream,
738 svn_stream_t *feedback_stream,
739 svn_revnum_t start_rev,
740 svn_revnum_t end_rev,
741 svn_boolean_t incremental,
742 svn_boolean_t use_deltas,
743 svn_cancel_func_t cancel_func,
744 void *cancel_baton,
745 apr_pool_t *pool)
746 {
747 return svn_error_trace(svn_repos_dump_fs3(repos,
748 stream,
749 start_rev,
750 end_rev,
751 incremental,
752 use_deltas,
753 feedback_stream
754 ? repos_notify_handler
755 : NULL,
756 feedback_stream,
757 cancel_func,
758 cancel_baton,
759 pool));
760 }
761
762 svn_error_t *
svn_repos_verify_fs2(svn_repos_t * repos,svn_revnum_t start_rev,svn_revnum_t end_rev,svn_repos_notify_func_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)763 svn_repos_verify_fs2(svn_repos_t *repos,
764 svn_revnum_t start_rev,
765 svn_revnum_t end_rev,
766 svn_repos_notify_func_t notify_func,
767 void *notify_baton,
768 svn_cancel_func_t cancel_func,
769 void *cancel_baton,
770 apr_pool_t *pool)
771 {
772 return svn_error_trace(svn_repos_verify_fs3(repos,
773 start_rev,
774 end_rev,
775 FALSE,
776 FALSE,
777 notify_func,
778 notify_baton,
779 NULL, NULL,
780 cancel_func,
781 cancel_baton,
782 pool));
783 }
784
785 svn_error_t *
svn_repos_verify_fs(svn_repos_t * repos,svn_stream_t * feedback_stream,svn_revnum_t start_rev,svn_revnum_t end_rev,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)786 svn_repos_verify_fs(svn_repos_t *repos,
787 svn_stream_t *feedback_stream,
788 svn_revnum_t start_rev,
789 svn_revnum_t end_rev,
790 svn_cancel_func_t cancel_func,
791 void *cancel_baton,
792 apr_pool_t *pool)
793 {
794 return svn_error_trace(svn_repos_verify_fs2(repos,
795 start_rev,
796 end_rev,
797 feedback_stream
798 ? repos_notify_handler
799 : NULL,
800 feedback_stream,
801 cancel_func,
802 cancel_baton,
803 pool));
804 }
805
806 /*** From load.c ***/
807
808 svn_error_t *
svn_repos_load_fs4(svn_repos_t * repos,svn_stream_t * dumpstream,svn_revnum_t start_rev,svn_revnum_t end_rev,enum svn_repos_load_uuid uuid_action,const char * parent_dir,svn_boolean_t use_pre_commit_hook,svn_boolean_t use_post_commit_hook,svn_boolean_t validate_props,svn_repos_notify_func_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)809 svn_repos_load_fs4(svn_repos_t *repos,
810 svn_stream_t *dumpstream,
811 svn_revnum_t start_rev,
812 svn_revnum_t end_rev,
813 enum svn_repos_load_uuid uuid_action,
814 const char *parent_dir,
815 svn_boolean_t use_pre_commit_hook,
816 svn_boolean_t use_post_commit_hook,
817 svn_boolean_t validate_props,
818 svn_repos_notify_func_t notify_func,
819 void *notify_baton,
820 svn_cancel_func_t cancel_func,
821 void *cancel_baton,
822 apr_pool_t *pool)
823 {
824 return svn_repos_load_fs5(repos, dumpstream, start_rev, end_rev,
825 uuid_action, parent_dir,
826 use_post_commit_hook, use_post_commit_hook,
827 validate_props, FALSE,
828 notify_func, notify_baton,
829 cancel_func, cancel_baton, pool);
830 }
831
832 svn_error_t *
svn_repos_load_fs3(svn_repos_t * repos,svn_stream_t * dumpstream,enum svn_repos_load_uuid uuid_action,const char * parent_dir,svn_boolean_t use_pre_commit_hook,svn_boolean_t use_post_commit_hook,svn_boolean_t validate_props,svn_repos_notify_func_t notify_func,void * notify_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)833 svn_repos_load_fs3(svn_repos_t *repos,
834 svn_stream_t *dumpstream,
835 enum svn_repos_load_uuid uuid_action,
836 const char *parent_dir,
837 svn_boolean_t use_pre_commit_hook,
838 svn_boolean_t use_post_commit_hook,
839 svn_boolean_t validate_props,
840 svn_repos_notify_func_t notify_func,
841 void *notify_baton,
842 svn_cancel_func_t cancel_func,
843 void *cancel_baton,
844 apr_pool_t *pool)
845 {
846 return svn_repos_load_fs4(repos, dumpstream,
847 SVN_INVALID_REVNUM, SVN_INVALID_REVNUM,
848 uuid_action, parent_dir,
849 use_pre_commit_hook, use_post_commit_hook,
850 validate_props, notify_func, notify_baton,
851 cancel_func, cancel_baton, pool);
852 }
853
854 svn_error_t *
svn_repos_load_fs2(svn_repos_t * repos,svn_stream_t * dumpstream,svn_stream_t * feedback_stream,enum svn_repos_load_uuid uuid_action,const char * parent_dir,svn_boolean_t use_pre_commit_hook,svn_boolean_t use_post_commit_hook,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)855 svn_repos_load_fs2(svn_repos_t *repos,
856 svn_stream_t *dumpstream,
857 svn_stream_t *feedback_stream,
858 enum svn_repos_load_uuid uuid_action,
859 const char *parent_dir,
860 svn_boolean_t use_pre_commit_hook,
861 svn_boolean_t use_post_commit_hook,
862 svn_cancel_func_t cancel_func,
863 void *cancel_baton,
864 apr_pool_t *pool)
865 {
866 return svn_repos_load_fs3(repos, dumpstream, uuid_action, parent_dir,
867 use_pre_commit_hook, use_post_commit_hook, FALSE,
868 feedback_stream ? repos_notify_handler : NULL,
869 feedback_stream, cancel_func, cancel_baton, pool);
870 }
871
872
873 static svn_repos_parser_fns_t *
fns_from_fns2(const svn_repos_parse_fns2_t * fns2,apr_pool_t * pool)874 fns_from_fns2(const svn_repos_parse_fns2_t *fns2,
875 apr_pool_t *pool)
876 {
877 svn_repos_parser_fns_t *fns;
878
879 fns = apr_palloc(pool, sizeof(*fns));
880 fns->new_revision_record = fns2->new_revision_record;
881 fns->uuid_record = fns2->uuid_record;
882 fns->new_node_record = fns2->new_node_record;
883 fns->set_revision_property = fns2->set_revision_property;
884 fns->set_node_property = fns2->set_node_property;
885 fns->remove_node_props = fns2->remove_node_props;
886 fns->set_fulltext = fns2->set_fulltext;
887 fns->close_node = fns2->close_node;
888 fns->close_revision = fns2->close_revision;
889 return fns;
890 }
891
892 static svn_repos_parser_fns2_t *
fns2_from_fns3(const svn_repos_parse_fns3_t * fns3,apr_pool_t * pool)893 fns2_from_fns3(const svn_repos_parse_fns3_t *fns3,
894 apr_pool_t *pool)
895 {
896 svn_repos_parser_fns2_t *fns2;
897
898 fns2 = apr_palloc(pool, sizeof(*fns2));
899 fns2->new_revision_record = fns3->new_revision_record;
900 fns2->uuid_record = fns3->uuid_record;
901 fns2->new_node_record = fns3->new_node_record;
902 fns2->set_revision_property = fns3->set_revision_property;
903 fns2->set_node_property = fns3->set_node_property;
904 fns2->remove_node_props = fns3->remove_node_props;
905 fns2->set_fulltext = fns3->set_fulltext;
906 fns2->close_node = fns3->close_node;
907 fns2->close_revision = fns3->close_revision;
908 fns2->delete_node_property = fns3->delete_node_property;
909 fns2->apply_textdelta = fns3->apply_textdelta;
910 return fns2;
911 }
912
913 static svn_repos_parse_fns2_t *
fns2_from_fns(const svn_repos_parser_fns_t * fns,apr_pool_t * pool)914 fns2_from_fns(const svn_repos_parser_fns_t *fns,
915 apr_pool_t *pool)
916 {
917 svn_repos_parse_fns2_t *fns2;
918
919 fns2 = apr_palloc(pool, sizeof(*fns2));
920 fns2->new_revision_record = fns->new_revision_record;
921 fns2->uuid_record = fns->uuid_record;
922 fns2->new_node_record = fns->new_node_record;
923 fns2->set_revision_property = fns->set_revision_property;
924 fns2->set_node_property = fns->set_node_property;
925 fns2->remove_node_props = fns->remove_node_props;
926 fns2->set_fulltext = fns->set_fulltext;
927 fns2->close_node = fns->close_node;
928 fns2->close_revision = fns->close_revision;
929 fns2->delete_node_property = NULL;
930 fns2->apply_textdelta = NULL;
931 return fns2;
932 }
933
934 static svn_repos_parse_fns3_t *
fns3_from_fns2(const svn_repos_parser_fns2_t * fns2,apr_pool_t * pool)935 fns3_from_fns2(const svn_repos_parser_fns2_t *fns2,
936 apr_pool_t *pool)
937 {
938 svn_repos_parse_fns3_t *fns3;
939
940 fns3 = apr_palloc(pool, sizeof(*fns3));
941 fns3->magic_header_record = NULL;
942 fns3->uuid_record = fns2->uuid_record;
943 fns3->new_revision_record = fns2->new_revision_record;
944 fns3->new_node_record = fns2->new_node_record;
945 fns3->set_revision_property = fns2->set_revision_property;
946 fns3->set_node_property = fns2->set_node_property;
947 fns3->remove_node_props = fns2->remove_node_props;
948 fns3->set_fulltext = fns2->set_fulltext;
949 fns3->close_node = fns2->close_node;
950 fns3->close_revision = fns2->close_revision;
951 fns3->delete_node_property = fns2->delete_node_property;
952 fns3->apply_textdelta = fns2->apply_textdelta;
953 return fns3;
954 }
955
956 svn_error_t *
svn_repos_parse_dumpstream2(svn_stream_t * stream,const svn_repos_parser_fns2_t * parse_fns,void * parse_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)957 svn_repos_parse_dumpstream2(svn_stream_t *stream,
958 const svn_repos_parser_fns2_t *parse_fns,
959 void *parse_baton,
960 svn_cancel_func_t cancel_func,
961 void *cancel_baton,
962 apr_pool_t *pool)
963 {
964 svn_repos_parse_fns3_t *fns3 = fns3_from_fns2(parse_fns, pool);
965
966 return svn_repos_parse_dumpstream3(stream, fns3, parse_baton, FALSE,
967 cancel_func, cancel_baton, pool);
968 }
969
970 svn_error_t *
svn_repos_parse_dumpstream(svn_stream_t * stream,const svn_repos_parser_fns_t * parse_fns,void * parse_baton,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)971 svn_repos_parse_dumpstream(svn_stream_t *stream,
972 const svn_repos_parser_fns_t *parse_fns,
973 void *parse_baton,
974 svn_cancel_func_t cancel_func,
975 void *cancel_baton,
976 apr_pool_t *pool)
977 {
978 svn_repos_parse_fns2_t *fns2 = fns2_from_fns(parse_fns, pool);
979
980 return svn_repos_parse_dumpstream2(stream, fns2, parse_baton,
981 cancel_func, cancel_baton, pool);
982 }
983
984 svn_error_t *
svn_repos_load_fs(svn_repos_t * repos,svn_stream_t * dumpstream,svn_stream_t * feedback_stream,enum svn_repos_load_uuid uuid_action,const char * parent_dir,svn_cancel_func_t cancel_func,void * cancel_baton,apr_pool_t * pool)985 svn_repos_load_fs(svn_repos_t *repos,
986 svn_stream_t *dumpstream,
987 svn_stream_t *feedback_stream,
988 enum svn_repos_load_uuid uuid_action,
989 const char *parent_dir,
990 svn_cancel_func_t cancel_func,
991 void *cancel_baton,
992 apr_pool_t *pool)
993 {
994 return svn_repos_load_fs2(repos, dumpstream, feedback_stream,
995 uuid_action, parent_dir, FALSE, FALSE,
996 cancel_func, cancel_baton, pool);
997 }
998
999 svn_error_t *
svn_repos_get_fs_build_parser4(const svn_repos_parse_fns3_t ** callbacks,void ** parse_baton,svn_repos_t * repos,svn_revnum_t start_rev,svn_revnum_t end_rev,svn_boolean_t use_history,svn_boolean_t validate_props,enum svn_repos_load_uuid uuid_action,const char * parent_dir,svn_repos_notify_func_t notify_func,void * notify_baton,apr_pool_t * pool)1000 svn_repos_get_fs_build_parser4(const svn_repos_parse_fns3_t **callbacks,
1001 void **parse_baton,
1002 svn_repos_t *repos,
1003 svn_revnum_t start_rev,
1004 svn_revnum_t end_rev,
1005 svn_boolean_t use_history,
1006 svn_boolean_t validate_props,
1007 enum svn_repos_load_uuid uuid_action,
1008 const char *parent_dir,
1009 svn_repos_notify_func_t notify_func,
1010 void *notify_baton,
1011 apr_pool_t *pool)
1012 {
1013 SVN_ERR(svn_repos_get_fs_build_parser5(callbacks, parse_baton,
1014 repos,
1015 start_rev, end_rev,
1016 use_history,
1017 validate_props,
1018 uuid_action,
1019 parent_dir,
1020 FALSE, FALSE, /*hooks */
1021 FALSE /*ignore_dates*/,
1022 notify_func,
1023 notify_baton,
1024 pool));
1025 return SVN_NO_ERROR;
1026 }
1027
1028 svn_error_t *
svn_repos_get_fs_build_parser3(const svn_repos_parse_fns2_t ** callbacks,void ** parse_baton,svn_repos_t * repos,svn_boolean_t use_history,svn_boolean_t validate_props,enum svn_repos_load_uuid uuid_action,const char * parent_dir,svn_repos_notify_func_t notify_func,void * notify_baton,apr_pool_t * pool)1029 svn_repos_get_fs_build_parser3(const svn_repos_parse_fns2_t **callbacks,
1030 void **parse_baton,
1031 svn_repos_t *repos,
1032 svn_boolean_t use_history,
1033 svn_boolean_t validate_props,
1034 enum svn_repos_load_uuid uuid_action,
1035 const char *parent_dir,
1036 svn_repos_notify_func_t notify_func,
1037 void *notify_baton,
1038 apr_pool_t *pool)
1039 {
1040 const svn_repos_parse_fns3_t *fns3;
1041
1042 SVN_ERR(svn_repos_get_fs_build_parser4(&fns3, parse_baton, repos,
1043 SVN_INVALID_REVNUM,
1044 SVN_INVALID_REVNUM,
1045 use_history, validate_props,
1046 uuid_action, parent_dir,
1047 notify_func, notify_baton, pool));
1048
1049 *callbacks = fns2_from_fns3(fns3, pool);
1050 return SVN_NO_ERROR;
1051 }
1052
1053 svn_error_t *
svn_repos_get_fs_build_parser2(const svn_repos_parse_fns2_t ** parser,void ** parse_baton,svn_repos_t * repos,svn_boolean_t use_history,enum svn_repos_load_uuid uuid_action,svn_stream_t * outstream,const char * parent_dir,apr_pool_t * pool)1054 svn_repos_get_fs_build_parser2(const svn_repos_parse_fns2_t **parser,
1055 void **parse_baton,
1056 svn_repos_t *repos,
1057 svn_boolean_t use_history,
1058 enum svn_repos_load_uuid uuid_action,
1059 svn_stream_t *outstream,
1060 const char *parent_dir,
1061 apr_pool_t *pool)
1062 {
1063 return svn_repos_get_fs_build_parser3(parser, parse_baton, repos, use_history,
1064 FALSE, uuid_action, parent_dir,
1065 outstream ? repos_notify_handler : NULL,
1066 outstream, pool);
1067 }
1068
1069 svn_error_t *
svn_repos_get_fs_build_parser(const svn_repos_parser_fns_t ** parser_callbacks,void ** parse_baton,svn_repos_t * repos,svn_boolean_t use_history,enum svn_repos_load_uuid uuid_action,svn_stream_t * outstream,const char * parent_dir,apr_pool_t * pool)1070 svn_repos_get_fs_build_parser(const svn_repos_parser_fns_t **parser_callbacks,
1071 void **parse_baton,
1072 svn_repos_t *repos,
1073 svn_boolean_t use_history,
1074 enum svn_repos_load_uuid uuid_action,
1075 svn_stream_t *outstream,
1076 const char *parent_dir,
1077 apr_pool_t *pool)
1078 {
1079 const svn_repos_parse_fns2_t *fns2;
1080
1081 SVN_ERR(svn_repos_get_fs_build_parser2(&fns2, parse_baton, repos,
1082 use_history, uuid_action, outstream,
1083 parent_dir, pool));
1084
1085 *parser_callbacks = fns_from_fns2(fns2, pool);
1086 return SVN_NO_ERROR;
1087 }
1088
1089
1090 svn_error_t *
svn_repos_fs_begin_txn_for_update(svn_fs_txn_t ** txn_p,svn_repos_t * repos,svn_revnum_t rev,const char * author,apr_pool_t * pool)1091 svn_repos_fs_begin_txn_for_update(svn_fs_txn_t **txn_p,
1092 svn_repos_t *repos,
1093 svn_revnum_t rev,
1094 const char *author,
1095 apr_pool_t *pool)
1096 {
1097 /* ### someday, we might run a read-hook here. */
1098
1099 /* Begin the transaction. */
1100 SVN_ERR(svn_fs_begin_txn2(txn_p, repos->fs, rev, 0, pool));
1101
1102 /* We pass the author to the filesystem by adding it as a property
1103 on the txn. */
1104
1105 /* User (author). */
1106 if (author)
1107 {
1108 svn_string_t val;
1109 val.data = author;
1110 val.len = strlen(author);
1111 SVN_ERR(svn_fs_change_txn_prop(*txn_p, SVN_PROP_REVISION_AUTHOR,
1112 &val, pool));
1113 }
1114
1115 return SVN_NO_ERROR;
1116 }
1117
1118 /*** From authz.c ***/
1119
1120 svn_error_t *
svn_repos_authz_read(svn_authz_t ** authz_p,const char * file,svn_boolean_t must_exist,apr_pool_t * pool)1121 svn_repos_authz_read(svn_authz_t **authz_p, const char *file,
1122 svn_boolean_t must_exist, apr_pool_t *pool)
1123 {
1124 return svn_repos__authz_read(authz_p, file, NULL, must_exist,
1125 FALSE, pool);
1126 }
1127