?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
In the command-line client, forbid
[svn.git] / subversion / libsvn_repos / repos.c
blob20abe9e59b9f492e4710d631d148bcea4ed30c2c
1 /* repos.c : repository creation; shared and exclusive repository locking
2 *
3 * ====================================================================
4 * Copyright (c) 2000-2007 CollabNet. All rights reserved.
5 *
6 * This software is licensed as described in the file COPYING, which
7 * you should have received as part of this distribution. The terms
8 * are also available at http://subversion.tigris.org/license-1.html.
9 * If newer versions of this license are posted there, you may use a
10 * newer version instead, at your option.
11 *
12 * This software consists of voluntary contributions made by many
13 * individuals. For exact contribution history, see the revision
14 * history and logs, available at http://subversion.tigris.org/.
15 * ====================================================================
16 */
17
18 #include <assert.h>
19
20 #include <apr_pools.h>
21 #include <apr_file_io.h>
22
23 #include "svn_pools.h"
24 #include "svn_error.h"
25 #include "svn_path.h"
26 #include "svn_utf.h"
27 #include "svn_time.h"
28 #include "svn_fs.h"
29 #include "svn_ra.h" /* for SVN_RA_CAPABILITY_* */
30 #include "svn_repos.h"
31 #include "svn_private_config.h" /* for SVN_TEMPLATE_ROOT_DIR */
32
33 #include "repos.h"
34
35 /* Used to terminate lines in large multi-line string literals. */
36 #define NL APR_EOL_STR
37
38 \f
39 /* Path accessor functions. */
40
41
42 const char *
43 svn_repos_path(svn_repos_t *repos, apr_pool_t *pool)
44 {
45 return apr_pstrdup(pool, repos->path);
46 }
47
48
49 const char *
50 svn_repos_db_env(svn_repos_t *repos, apr_pool_t *pool)
51 {
52 return apr_pstrdup(pool, repos->db_path);
53 }
54
55
56 const char *
57 svn_repos_conf_dir(svn_repos_t *repos, apr_pool_t *pool)
58 {
59 return apr_pstrdup(pool, repos->conf_path);
60 }
61
62
63 const char *
64 svn_repos_svnserve_conf(svn_repos_t *repos, apr_pool_t *pool)
65 {
66 return svn_path_join(repos->conf_path, SVN_REPOS__CONF_SVNSERVE_CONF, pool);
67 }
68
69
70 const char *
71 svn_repos_lock_dir(svn_repos_t *repos, apr_pool_t *pool)
72 {
73 return apr_pstrdup(pool, repos->lock_path);
74 }
75
76
77 const char *
78 svn_repos_db_lockfile(svn_repos_t *repos, apr_pool_t *pool)
79 {
80 return svn_path_join(repos->lock_path, SVN_REPOS__DB_LOCKFILE, pool);
81 }
82
83
84 const char *
85 svn_repos_db_logs_lockfile(svn_repos_t *repos, apr_pool_t *pool)
86 {
87 return svn_path_join(repos->lock_path, SVN_REPOS__DB_LOGS_LOCKFILE, pool);
88 }
89
90 const char *
91 svn_repos_hook_dir(svn_repos_t *repos, apr_pool_t *pool)
92 {
93 return apr_pstrdup(pool, repos->hook_path);
94 }
95
96
97 const char *
98 svn_repos_start_commit_hook(svn_repos_t *repos, apr_pool_t *pool)
99 {
100 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_START_COMMIT, pool);
101 }
102
103
104 const char *
105 svn_repos_pre_commit_hook(svn_repos_t *repos, apr_pool_t *pool)
106 {
107 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_PRE_COMMIT, pool);
108 }
109
110
111 const char *
112 svn_repos_pre_lock_hook(svn_repos_t *repos, apr_pool_t *pool)
113 {
114 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_PRE_LOCK, pool);
115 }
116
117
118 const char *
119 svn_repos_pre_unlock_hook(svn_repos_t *repos, apr_pool_t *pool)
120 {
121 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_PRE_UNLOCK, pool);
122 }
123
124 const char *
125 svn_repos_post_lock_hook(svn_repos_t *repos, apr_pool_t *pool)
126 {
127 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_POST_LOCK, pool);
128 }
129
130
131 const char *
132 svn_repos_post_unlock_hook(svn_repos_t *repos, apr_pool_t *pool)
133 {
134 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_POST_UNLOCK, pool);
135 }
136
137
138 const char *
139 svn_repos_post_commit_hook(svn_repos_t *repos, apr_pool_t *pool)
140 {
141 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_POST_COMMIT, pool);
142 }
143
144
145 const char *
146 svn_repos_pre_revprop_change_hook(svn_repos_t *repos, apr_pool_t *pool)
147 {
148 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_PRE_REVPROP_CHANGE,
149 pool);
150 }
151
152
153 const char *
154 svn_repos_post_revprop_change_hook(svn_repos_t *repos, apr_pool_t *pool)
155 {
156 return svn_path_join(repos->hook_path, SVN_REPOS__HOOK_POST_REVPROP_CHANGE,
157 pool);
158 }
159
160
161 static svn_error_t *
162 create_repos_dir(const char *path, apr_pool_t *pool)
163 {
164 svn_error_t *err;
165
166 err = svn_io_dir_make(path, APR_OS_DEFAULT, pool);
167 if (err && (APR_STATUS_IS_EEXIST(err->apr_err)))
168 {
169 svn_boolean_t is_empty;
170
171 svn_error_clear(err);
172
173 SVN_ERR(svn_io_dir_empty(&is_empty, path, pool));
174
175 if (is_empty)
176 err = NULL;
177 else
178 err = svn_error_createf(SVN_ERR_DIR_NOT_EMPTY, 0,
179 _("'%s' exists and is non-empty"),
180 svn_path_local_style(path, pool));
181 }
182
183 return err;
184 }
185
186 static const char * bdb_lock_file_contents =
187 "DB lock file, representing locks on the versioned filesystem." NL
188 "" NL
189 "All accessors -- both readers and writers -- of the repository's" NL
190 "Berkeley DB environment take out shared locks on this file, and" NL
191 "each accessor removes its lock when done. If and when the DB" NL
192 "recovery procedure is run, the recovery code takes out an" NL
193 "exclusive lock on this file, so we can be sure no one else is" NL
194 "using the DB during the recovery." NL
195 "" NL
196 "You should never have to edit or remove this file." NL;
197
198 static const char * bdb_logs_lock_file_contents =
199 "DB logs lock file, representing locks on the versioned filesystem logs." NL
200 "" NL
201 "All log manipulators of the repository's Berkeley DB environment" NL
202 "take out exclusive locks on this file to ensure that only one" NL
203 "accessor manipulates the logs at a time." NL
204 "" NL
205 "You should never have to edit or remove this file." NL;
206
207 static const char * pre12_compat_unneeded_file_contents =
208 "This file is not used by Subversion 1.3.x or later." NL
209 "However, its existence is required for compatibility with" NL
210 "Subversion 1.2.x or earlier." NL;
211
212 /* Create the DB logs lockfile. */
213 static svn_error_t *
214 create_db_logs_lock(svn_repos_t *repos, apr_pool_t *pool) {
215 const char *contents;
216 const char *lockfile_path;
217
218 lockfile_path = svn_repos_db_logs_lockfile(repos, pool);
219 if (strcmp(repos->fs_type, SVN_FS_TYPE_BDB) == 0)
220 contents = bdb_logs_lock_file_contents;
221 else
222 contents = pre12_compat_unneeded_file_contents;
223
224 SVN_ERR_W(svn_io_file_create(lockfile_path, contents, pool),
225 _("Creating db logs lock file"));
226
227 return SVN_NO_ERROR;
228 }
229
230 /* Create the DB lockfile. */
231 static svn_error_t *
232 create_db_lock(svn_repos_t *repos, apr_pool_t *pool) {
233 const char *contents;
234 const char *lockfile_path;
235
236 lockfile_path = svn_repos_db_lockfile(repos, pool);
237 if (strcmp(repos->fs_type, SVN_FS_TYPE_BDB) == 0)
238 contents = bdb_lock_file_contents;
239 else
240 contents = pre12_compat_unneeded_file_contents;
241
242 SVN_ERR_W(svn_io_file_create(lockfile_path, contents, pool),
243 _("Creating db lock file"));
244
245 return SVN_NO_ERROR;
246 }
247
248 static svn_error_t *
249 create_locks(svn_repos_t *repos, apr_pool_t *pool)
250 {
251 /* Create the locks directory. */
252 SVN_ERR_W(create_repos_dir(repos->lock_path, pool),
253 _("Creating lock dir"));
254
255 SVN_ERR(create_db_lock(repos, pool));
256 SVN_ERR(create_db_logs_lock(repos, pool));
257
258 return SVN_NO_ERROR;
259 }
260
261
262 #define HOOKS_ENVIRONMENT_TEXT \
263 "# The hook program typically does not inherit the environment of" NL \
264 "# its parent process. For example, a common problem is for the" NL \
265 "# PATH environment variable to not be set to its usual value, so" NL \
266 "# that subprograms fail to launch unless invoked via absolute path." NL \
267 "# If you're having unexpected problems with a hook program, the" NL \
268 "# culprit may be unusual (or missing) environment variables." NL
269
270 #define PREWRITTEN_HOOKS_TEXT \
271 "# For more examples and pre-written hooks, see those in" NL \
272 "# the Subversion repository at" NL \
273 "# http://svn.collab.net/repos/svn/trunk/tools/hook-scripts/ and" NL \
274 "# http://svn.collab.net/repos/svn/trunk/contrib/hook-scripts/" NL
275
276
277 static svn_error_t *
278 create_hooks(svn_repos_t *repos, apr_pool_t *pool)
279 {
280 const char *this_path, *contents;
281
282 /* Create the hook directory. */
283 SVN_ERR_W(create_repos_dir(repos->hook_path, pool),
284 _("Creating hook directory"));
285
286 /*** Write a default template for each standard hook file. */
287
288 /* Start-commit hook. */
289 {
290 this_path = apr_psprintf(pool, "%s%s",
291 svn_repos_start_commit_hook(repos, pool),
292 SVN_REPOS__HOOK_DESC_EXT);
293
294 #define SCRIPT_NAME SVN_REPOS__HOOK_START_COMMIT
295
296 contents =
297 "#!/bin/sh" NL
298 "" NL
299 "# START-COMMIT HOOK" NL
300 "#" NL
301 "# The start-commit hook is invoked before a Subversion txn is created" NL
302 "# in the process of doing a commit. Subversion runs this hook" NL
303 "# by invoking a program (script, executable, binary, etc.) named" NL
304 "# '"SCRIPT_NAME"' (for which this file is a template)" NL
305 "# with the following ordered arguments:" NL
306 "#" NL
307 "# [1] REPOS-PATH (the path to this repository)" NL
308 "# [2] USER (the authenticated user attempting to commit)" NL
309 "# [3] CAPABILITIES (a colon-separated list of capabilities reported" NL
310 "# by the client; see note below)" NL
311 "#" NL
312 "# Note: The CAPABILITIES parameter is new in Subversion 1.5, and 1.5" NL
313 "# clients will typically report at least the \"" \
314 SVN_RA_CAPABILITY_MERGEINFO "\" capability." NL
315 "# If there are other capabilities, then the list is colon-separated," NL
316 "# e.g.: \"" SVN_RA_CAPABILITY_MERGEINFO ":some-other-capability\" " \
317 "(the order is undefined)." NL
318 "#" NL
319 "# The list is self-reported by the client. Therefore, you should not" NL
320 "# make security assumptions based on the capabilities list, nor should" NL
321 "# you assume that clients reliably report every capability they have." NL
322 "#" NL
323 "# The working directory for this hook program's invocation is undefined," NL
324 "# so the program should set one explicitly if it cares." NL
325 "#" NL
326 "# If the hook program exits with success, the commit continues; but" NL
327 "# if it exits with failure (non-zero), the commit is stopped before" NL
328 "# a Subversion txn is created, and STDERR is returned to the client." NL
329 "#" NL
330 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
331 "# invoke other programs to do the real work, though it may do the" NL
332 "# work itself too." NL
333 "#" NL
334 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
335 "# invoke it (typically the user httpd runs as), and that user must" NL
336 "# have filesystem-level permission to access the repository." NL
337 "#" NL
338 "# On a Windows system, you should name the hook program" NL
339 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
340 "# but the basic idea is the same." NL
341 "# " NL
342 HOOKS_ENVIRONMENT_TEXT
343 "# " NL
344 "# Here is an example hook script, for a Unix /bin/sh interpreter." NL
345 PREWRITTEN_HOOKS_TEXT
346 "" NL
347 "" NL
348 "REPOS=\"$1\"" NL
349 "USER=\"$2\"" NL
350 "" NL
351 "commit-allower.pl --repository \"$REPOS\" --user \"$USER\" || exit 1" NL
352 "special-auth-check.py --user \"$USER\" --auth-level 3 || exit 1" NL
353 "" NL
354 "# All checks passed, so allow the commit." NL
355 "exit 0" NL;
356
357 #undef SCRIPT_NAME
358
359 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
360 _("Creating start-commit hook"));
361 } /* end start-commit hook */
362
363 /* Pre-commit hook. */
364 {
365 this_path = apr_psprintf(pool, "%s%s",
366 svn_repos_pre_commit_hook(repos, pool),
367 SVN_REPOS__HOOK_DESC_EXT);
368
369 #define SCRIPT_NAME SVN_REPOS__HOOK_PRE_COMMIT
370
371 contents =
372 "#!/bin/sh" NL
373 "" NL
374 "# PRE-COMMIT HOOK" NL
375 "#" NL
376 "# The pre-commit hook is invoked before a Subversion txn is" NL
377 "# committed. Subversion runs this hook by invoking a program" NL
378 "# (script, executable, binary, etc.) named '"SCRIPT_NAME"' (for which" NL
379 "# this file is a template), with the following ordered arguments:" NL
380 "#" NL
381 "# [1] REPOS-PATH (the path to this repository)" NL
382 "# [2] TXN-NAME (the name of the txn about to be committed)" NL
383 "#" NL
384 "# The default working directory for the invocation is undefined, so" NL
385 "# the program should set one explicitly if it cares." NL
386 "#" NL
387 "# If the hook program exits with success, the txn is committed; but" NL
388 "# if it exits with failure (non-zero), the txn is aborted, no commit" NL
389 "# takes place, and STDERR is returned to the client. The hook" NL
390 "# program can use the 'svnlook' utility to help it examine the txn." NL
391 "#" NL
392 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
393 "# invoke other programs to do the real work, though it may do the" NL
394 "# work itself too." NL
395 "#" NL
396 "# *** NOTE: THE HOOK PROGRAM MUST NOT MODIFY THE TXN, EXCEPT ***" NL
397 "# *** FOR REVISION PROPERTIES (like svn:log or svn:author). ***" NL
398 "#" NL
399 "# This is why we recommend using the read-only 'svnlook' utility." NL
400 "# In the future, Subversion may enforce the rule that pre-commit" NL
401 "# hooks should not modify the versioned data in txns, or else come" NL
402 "# up with a mechanism to make it safe to do so (by informing the" NL
403 "# committing client of the changes). However, right now neither" NL
404 "# mechanism is implemented, so hook writers just have to be careful." NL
405 "#" NL
406 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
407 "# invoke it (typically the user httpd runs as), and that user must" NL
408 "# have filesystem-level permission to access the repository." NL
409 "#" NL
410 "# On a Windows system, you should name the hook program" NL
411 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
412 "# but the basic idea is the same." NL
413 "#" NL
414 HOOKS_ENVIRONMENT_TEXT
415 "# " NL
416 "# Here is an example hook script, for a Unix /bin/sh interpreter." NL
417 PREWRITTEN_HOOKS_TEXT
418 "" NL
419 "" NL
420 "REPOS=\"$1\"" NL
421 "TXN=\"$2\"" NL
422 "" NL
423 "# Make sure that the log message contains some text." NL
424 "SVNLOOK=" SVN_BINDIR "/svnlook" NL
425 "$SVNLOOK log -t \"$TXN\" \"$REPOS\" | \\" NL
426 " grep \"[a-zA-Z0-9]\" > /dev/null || exit 1" NL
427 "" NL
428 "# Check that the author of this commit has the rights to perform" NL
429 "# the commit on the files and directories being modified." NL
430 "commit-access-control.pl \"$REPOS\" \"$TXN\" commit-access-control.cfg || exit 1"
431 NL
432 "" NL
433 "# All checks passed, so allow the commit." NL
434 "exit 0" NL;
435
436 #undef SCRIPT_NAME
437
438 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
439 _("Creating pre-commit hook"));
440 } /* end pre-commit hook */
441
442
443 /* Pre-revprop-change hook. */
444 {
445 this_path = apr_psprintf(pool, "%s%s",
446 svn_repos_pre_revprop_change_hook(repos, pool),
447 SVN_REPOS__HOOK_DESC_EXT);
448
449 #define SCRIPT_NAME SVN_REPOS__HOOK_PRE_REVPROP_CHANGE
450
451 contents =
452 "#!/bin/sh" NL
453 "" NL
454 "# PRE-REVPROP-CHANGE HOOK" NL
455 "#" NL
456 "# The pre-revprop-change hook is invoked before a revision property" NL
457 "# is added, modified or deleted. Subversion runs this hook by invoking" NL
458 "# a program (script, executable, binary, etc.) named '"SCRIPT_NAME"'" NL
459 "# (for which this file is a template), with the following ordered" NL
460 "# arguments:" NL
461 "#" NL
462 "# [1] REPOS-PATH (the path to this repository)" NL
463 "# [2] REVISION (the revision being tweaked)" NL
464 "# [3] USER (the username of the person tweaking the property)" NL
465 "# [4] PROPNAME (the property being set on the revision)" NL
466 "# [5] ACTION (the property is being 'A'dded, 'M'odified, or 'D'eleted)"
467 NL
468 "#" NL
469 "# [STDIN] PROPVAL ** the new property value is passed via STDIN." NL
470 "#" NL
471 "# If the hook program exits with success, the propchange happens; but" NL
472 "# if it exits with failure (non-zero), the propchange doesn't happen." NL
473 "# The hook program can use the 'svnlook' utility to examine the " NL
474 "# existing value of the revision property." NL
475 "#" NL
476 "# WARNING: unlike other hooks, this hook MUST exist for revision" NL
477 "# properties to be changed. If the hook does not exist, Subversion " NL
478 "# will behave as if the hook were present, but failed. The reason" NL
479 "# for this is that revision properties are UNVERSIONED, meaning that" NL
480 "# a successful propchange is destructive; the old value is gone" NL
481 "# forever. We recommend the hook back up the old value somewhere." NL
482 "#" NL
483 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
484 "# invoke other programs to do the real work, though it may do the" NL
485 "# work itself too." NL
486 "#" NL
487 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
488 "# invoke it (typically the user httpd runs as), and that user must" NL
489 "# have filesystem-level permission to access the repository." NL
490 "#" NL
491 "# On a Windows system, you should name the hook program" NL
492 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
493 "# but the basic idea is the same." NL
494 "#" NL
495 HOOKS_ENVIRONMENT_TEXT
496 "# " NL
497 "# Here is an example hook script, for a Unix /bin/sh interpreter." NL
498 PREWRITTEN_HOOKS_TEXT
499 "" NL
500 "" NL
501 "REPOS=\"$1\"" NL
502 "REV=\"$2\"" NL
503 "USER=\"$3\"" NL
504 "PROPNAME=\"$4\"" NL
505 "ACTION=\"$5\"" NL
506 "" NL
507 "if [ \"$ACTION\" = \"M\" -a \"$PROPNAME\" = \"svn:log\" ]; then exit 0; fi" NL
508 "" NL
509 "echo \"Changing revision properties other than svn:log is prohibited\" >&2" NL
510 "exit 1" NL;
511
512 #undef SCRIPT_NAME
513
514 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
515 _("Creating pre-revprop-change hook"));
516 } /* end pre-revprop-change hook */
517
518
519 /* Pre-lock hook. */
520 {
521 this_path = apr_psprintf(pool, "%s%s",
522 svn_repos_pre_lock_hook(repos, pool),
523 SVN_REPOS__HOOK_DESC_EXT);
524
525 #define SCRIPT_NAME SVN_REPOS__HOOK_PRE_LOCK
526
527 contents =
528 "#!/bin/sh" NL
529 "" NL
530 "# PRE-LOCK HOOK" NL
531 "#" NL
532 "# The pre-lock hook is invoked before an exclusive lock is" NL
533 "# created. Subversion runs this hook by invoking a program " NL
534 "# (script, executable, binary, etc.) named '"SCRIPT_NAME"' (for which" NL
535 "# this file is a template), with the following ordered arguments:" NL
536 "#" NL
537 "# [1] REPOS-PATH (the path to this repository)" NL
538 "# [2] PATH (the path in the repository about to be locked)" NL
539 "# [3] USER (the user creating the lock)" NL
540 "#" NL
541 "# The default working directory for the invocation is undefined, so" NL
542 "# the program should set one explicitly if it cares." NL
543 "#" NL
544 "# If the hook program exits with success, the lock is created; but" NL
545 "# if it exits with failure (non-zero), the lock action is aborted" NL
546 "# and STDERR is returned to the client." NL
547 "" NL
548 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
549 "# invoke other programs to do the real work, though it may do the" NL
550 "# work itself too." NL
551 "#" NL
552 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
553 "# invoke it (typically the user httpd runs as), and that user must" NL
554 "# have filesystem-level permission to access the repository." NL
555 "#" NL
556 "# On a Windows system, you should name the hook program" NL
557 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
558 "# but the basic idea is the same." NL
559 "#" NL
560 "# Here is an example hook script, for a Unix /bin/sh interpreter:" NL
561 "" NL
562 "REPOS=\"$1\"" NL
563 "PATH=\"$2\"" NL
564 "USER=\"$3\"" NL
565 "" NL
566 "# If a lock exists and is owned by a different person, don't allow it" NL
567 "# to be stolen (e.g., with 'svn lock --force ...')." NL
568 "" NL
569 "# (Maybe this script could send email to the lock owner?)" NL
570 "SVNLOOK=" SVN_BINDIR "/svnlook" NL
571 "GREP=/bin/grep" NL
572 "SED=/bin/sed" NL
573 "" NL
574 "LOCK_OWNER=`$SVNLOOK lock \"$REPOS\" \"$PATH\" | \\" NL
575 " $GREP '^Owner: ' | $SED 's/Owner: //'`" NL
576 "" NL
577 "# If we get no result from svnlook, there's no lock, allow the lock to" NL
578 "# happen:" NL
579 "if [ \"$LOCK_OWNER\" = \"\" ]; then" NL
580 " exit 0" NL
581 "fi" NL
582 "" NL
583 "# If the person locking matches the lock's owner, allow the lock to" NL
584 "# happen:" NL
585 "if [ \"$LOCK_OWNER\" = \"$USER\" ]; then" NL
586 " exit 0" NL
587 "fi" NL
588 "" NL
589 "# Otherwise, we've got an owner mismatch, so return failure:" NL
590 "echo \"Error: $PATH already locked by ${LOCK_OWNER}.\" 1>&2" NL
591 "exit 1" NL;
592
593 #undef SCRIPT_NAME
594
595 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
596 "Creating pre-lock hook");
597 } /* end pre-lock hook */
598
599
600 /* Pre-unlock hook. */
601 {
602 this_path = apr_psprintf(pool, "%s%s",
603 svn_repos_pre_unlock_hook(repos, pool),
604 SVN_REPOS__HOOK_DESC_EXT);
605
606 #define SCRIPT_NAME SVN_REPOS__HOOK_PRE_UNLOCK
607
608 contents =
609 "#!/bin/sh" NL
610 "" NL
611 "# PRE-UNLOCK HOOK" NL
612 "#" NL
613 "# The pre-unlock hook is invoked before an exclusive lock is" NL
614 "# destroyed. Subversion runs this hook by invoking a program " NL
615 "# (script, executable, binary, etc.) named '"SCRIPT_NAME"' (for which" NL
616 "# this file is a template), with the following ordered arguments:" NL
617 "#" NL
618 "# [1] REPOS-PATH (the path to this repository)" NL
619 "# [2] PATH (the path in the repository about to be unlocked)" NL
620 "# [3] USER (the user destroying the lock)" NL
621 "#" NL
622 "# The default working directory for the invocation is undefined, so" NL
623 "# the program should set one explicitly if it cares." NL
624 "#" NL
625 "# If the hook program exits with success, the lock is destroyed; but" NL
626 "# if it exits with failure (non-zero), the unlock action is aborted" NL
627 "# and STDERR is returned to the client." NL
628 "" NL
629 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
630 "# invoke other programs to do the real work, though it may do the" NL
631 "# work itself too." NL
632 "#" NL
633 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
634 "# invoke it (typically the user httpd runs as), and that user must" NL
635 "# have filesystem-level permission to access the repository." NL
636 "#" NL
637 "# On a Windows system, you should name the hook program" NL
638 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
639 "# but the basic idea is the same." NL
640 "#" NL
641 "# Here is an example hook script, for a Unix /bin/sh interpreter:" NL
642 "" NL
643 "REPOS=\"$1\"" NL
644 "PATH=\"$2\"" NL
645 "USER=\"$3\"" NL
646 "" NL
647 "# If a lock is owned by a different person, don't allow it be broken." NL
648 "# (Maybe this script could send email to the lock owner?)" NL
649 "" NL
650 "SVNLOOK=" SVN_BINDIR "/svnlook" NL
651 "GREP=/bin/grep" NL
652 "SED=/bin/sed" NL
653 "" NL
654 "LOCK_OWNER=`$SVNLOOK lock \"$REPOS\" \"$PATH\" | \\" NL
655 " $GREP '^Owner: ' | $SED 's/Owner: //'`" NL
656 "" NL
657 "# If we get no result from svnlook, there's no lock, return success:" NL
658 "if [ \"$LOCK_OWNER\" = \"\" ]; then" NL
659 " exit 0" NL
660 "fi" NL
661 "" NL
662 "# If the person unlocking matches the lock's owner, return success:" NL
663 "if [ \"$LOCK_OWNER\" = \"$USER\" ]; then" NL
664 " exit 0" NL
665 "fi" NL
666 "" NL
667 "# Otherwise, we've got an owner mismatch, so return failure:" NL
668 "echo \"Error: $PATH locked by ${LOCK_OWNER}.\" 1>&2" NL
669 "exit 1" NL;
670
671 #undef SCRIPT_NAME
672
673 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
674 "Creating pre-unlock hook");
675 } /* end pre-unlock hook */
676
677
678
679 /* Post-commit hook. */
680 {
681 this_path = apr_psprintf(pool, "%s%s",
682 svn_repos_post_commit_hook(repos, pool),
683 SVN_REPOS__HOOK_DESC_EXT);
684
685 #define SCRIPT_NAME SVN_REPOS__HOOK_POST_COMMIT
686
687 contents =
688 "#!/bin/sh" NL
689 "" NL
690 "# POST-COMMIT HOOK" NL
691 "#" NL
692 "# The post-commit hook is invoked after a commit. Subversion runs" NL
693 "# this hook by invoking a program (script, executable, binary, etc.)" NL
694 "# named '"SCRIPT_NAME"' (for which this file is a template) with the " NL
695 "# following ordered arguments:" NL
696 "#" NL
697 "# [1] REPOS-PATH (the path to this repository)" NL
698 "# [2] REV (the number of the revision just committed)" NL
699 "#" NL
700 "# The default working directory for the invocation is undefined, so" NL
701 "# the program should set one explicitly if it cares." NL
702 "#" NL
703 "# Because the commit has already completed and cannot be undone," NL
704 "# the exit code of the hook program is ignored. The hook program" NL
705 "# can use the 'svnlook' utility to help it examine the" NL
706 "# newly-committed tree." NL
707 "#" NL
708 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
709 "# invoke other programs to do the real work, though it may do the" NL
710 "# work itself too." NL
711 "#" NL
712 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
713 "# invoke it (typically the user httpd runs as), and that user must" NL
714 "# have filesystem-level permission to access the repository." NL
715 "#" NL
716 "# On a Windows system, you should name the hook program" NL
717 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
718 "# but the basic idea is the same." NL
719 "# " NL
720 HOOKS_ENVIRONMENT_TEXT
721 "# " NL
722 "# Here is an example hook script, for a Unix /bin/sh interpreter." NL
723 PREWRITTEN_HOOKS_TEXT
724 "" NL
725 "" NL
726 "REPOS=\"$1\"" NL
727 "REV=\"$2\"" NL
728 NL
729 "commit-email.pl \"$REPOS\" \"$REV\" commit-watchers@example.org" NL
730 "log-commit.py --repository \"$REPOS\" --revision \"$REV\"" NL;
731
732 #undef SCRIPT_NAME
733
734 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
735 _("Creating post-commit hook"));
736 } /* end post-commit hook */
737
738
739 /* Post-lock hook. */
740 {
741 this_path = apr_psprintf(pool, "%s%s",
742 svn_repos_post_lock_hook(repos, pool),
743 SVN_REPOS__HOOK_DESC_EXT);
744
745 #define SCRIPT_NAME SVN_REPOS__HOOK_POST_LOCK
746
747 contents =
748 "#!/bin/sh" NL
749 "" NL
750 "# POST-LOCK HOOK" NL
751 "#" NL
752 "# The post-lock hook is run after a path is locked. Subversion runs" NL
753 "# this hook by invoking a program (script, executable, binary, etc.)" NL
754 "# named '"SCRIPT_NAME"' (for which this file is a template) with the " NL
755 "# following ordered arguments:" NL
756 "#" NL
757 "# [1] REPOS-PATH (the path to this repository)" NL
758 "# [2] USER (the user who created the lock)" NL
759 "#" NL
760 "# The paths that were just locked are passed to the hook via STDIN (as" NL
761 "# of Subversion 1.2, only one path is passed per invocation, but the" NL
762 "# plan is to pass all locked paths at once, so the hook program" NL
763 "# should be written accordingly)." NL
764 "#" NL
765 "# The default working directory for the invocation is undefined, so" NL
766 "# the program should set one explicitly if it cares." NL
767 "#" NL
768 "# Because the lock has already been created and cannot be undone," NL
769 "# the exit code of the hook program is ignored. The hook program" NL
770 "# can use the 'svnlook' utility to help it examine the" NL
771 "# newly-created lock." NL
772 "#" NL
773 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
774 "# invoke other programs to do the real work, though it may do the" NL
775 "# work itself too." NL
776 "#" NL
777 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
778 "# invoke it (typically the user httpd runs as), and that user must" NL
779 "# have filesystem-level permission to access the repository." NL
780 "#" NL
781 "# On a Windows system, you should name the hook program" NL
782 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
783 "# but the basic idea is the same." NL
784 "# " NL
785 "# Here is an example hook script, for a Unix /bin/sh interpreter:" NL
786 "" NL
787 "REPOS=\"$1\"" NL
788 "USER=\"$2\"" NL
789 "" NL
790 "# Send email to interested parties, let them know a lock was created:" NL
791 "mailer.py lock \"$REPOS\" \"$USER\" /path/to/mailer.conf" NL;
792
793 #undef SCRIPT_NAME
794
795 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
796 "Creating post-lock hook");
797 } /* end post-lock hook */
798
799
800 /* Post-unlock hook. */
801 {
802 this_path = apr_psprintf(pool, "%s%s",
803 svn_repos_post_unlock_hook(repos, pool),
804 SVN_REPOS__HOOK_DESC_EXT);
805
806 #define SCRIPT_NAME SVN_REPOS__HOOK_POST_UNLOCK
807
808 contents =
809 "#!/bin/sh" NL
810 "" NL
811 "# POST-UNLOCK HOOK" NL
812 "#" NL
813 "# The post-unlock hook runs after a path is unlocked. Subversion runs" NL
814 "# this hook by invoking a program (script, executable, binary, etc.)" NL
815 "# named '"SCRIPT_NAME"' (for which this file is a template) with the " NL
816 "# following ordered arguments:" NL
817 "#" NL
818 "# [1] REPOS-PATH (the path to this repository)" NL
819 "# [2] USER (the user who destroyed the lock)" NL
820 "#" NL
821 "# The paths that were just unlocked are passed to the hook via STDIN" NL
822 "# (as of Subversion 1.2, only one path is passed per invocation, but" NL
823 "# the plan is to pass all unlocked paths at once, so the hook program" NL
824 "# should be written accordingly)." NL
825 "#" NL
826 "# The default working directory for the invocation is undefined, so" NL
827 "# the program should set one explicitly if it cares." NL
828 "#" NL
829 "# Because the lock has already been destroyed and cannot be undone," NL
830 "# the exit code of the hook program is ignored." NL
831 "#" NL
832 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
833 "# invoke other programs to do the real work, though it may do the" NL
834 "# work itself too." NL
835 "#" NL
836 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
837 "# invoke it (typically the user httpd runs as), and that user must" NL
838 "# have filesystem-level permission to access the repository." NL
839 "#" NL
840 "# On a Windows system, you should name the hook program" NL
841 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
842 "# but the basic idea is the same." NL
843 "# " NL
844 "# Here is an example hook script, for a Unix /bin/sh interpreter:" NL
845 "" NL
846 "REPOS=\"$1\"" NL
847 "USER=\"$2\"" NL
848 "" NL
849 "# Send email to interested parties, let them know a lock was removed:" NL
850 "mailer.py unlock \"$REPOS\" \"$USER\" /path/to/mailer.conf" NL;
851
852 #undef SCRIPT_NAME
853
854 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
855 "Creating post-unlock hook");
856 } /* end post-unlock hook */
857
858
859 /* Post-revprop-change hook. */
860 {
861 this_path = apr_psprintf(pool, "%s%s",
862 svn_repos_post_revprop_change_hook(repos, pool),
863 SVN_REPOS__HOOK_DESC_EXT);
864
865 #define SCRIPT_NAME SVN_REPOS__HOOK_POST_REVPROP_CHANGE
866
867 contents =
868 "#!/bin/sh" NL
869 "" NL
870 "# POST-REVPROP-CHANGE HOOK" NL
871 "#" NL
872 "# The post-revprop-change hook is invoked after a revision property" NL
873 "# has been added, modified or deleted. Subversion runs this hook by" NL
874 "# invoking a program (script, executable, binary, etc.) named" NL
875 "# '"SCRIPT_NAME"' (for which this file is a template), with the" NL
876 "# following ordered arguments:" NL
877 "#" NL
878 "# [1] REPOS-PATH (the path to this repository)" NL
879 "# [2] REV (the revision that was tweaked)" NL
880 "# [3] USER (the username of the person tweaking the property)" NL
881 "# [4] PROPNAME (the property that was changed)" NL
882 "# [5] ACTION (the property was 'A'dded, 'M'odified, or 'D'eleted)" NL
883 "#" NL
884 "# [STDIN] PROPVAL ** the old property value is passed via STDIN." NL
885 "#" NL
886 "# Because the propchange has already completed and cannot be undone," NL
887 "# the exit code of the hook program is ignored. The hook program" NL
888 "# can use the 'svnlook' utility to help it examine the" NL
889 "# new property value." NL
890 "#" NL
891 "# On a Unix system, the normal procedure is to have '"SCRIPT_NAME"'" NL
892 "# invoke other programs to do the real work, though it may do the" NL
893 "# work itself too." NL
894 "#" NL
895 "# Note that '"SCRIPT_NAME"' must be executable by the user(s) who will" NL
896 "# invoke it (typically the user httpd runs as), and that user must" NL
897 "# have filesystem-level permission to access the repository." NL
898 "#" NL
899 "# On a Windows system, you should name the hook program" NL
900 "# '"SCRIPT_NAME".bat' or '"SCRIPT_NAME".exe'," NL
901 "# but the basic idea is the same." NL
902 "# " NL
903 HOOKS_ENVIRONMENT_TEXT
904 "# " NL
905 "# Here is an example hook script, for a Unix /bin/sh interpreter." NL
906 PREWRITTEN_HOOKS_TEXT
907 "" NL
908 "" NL
909 "REPOS=\"$1\"" NL
910 "REV=\"$2\"" NL
911 "USER=\"$3\"" NL
912 "PROPNAME=\"$4\"" NL
913 "ACTION=\"$5\"" NL
914 "" NL
915 "commit-email.pl --revprop-change \"$REPOS\" \"$REV\" \"$USER\" \"$PROPNAME\" "
916 "watchers@example.org" NL;
917
918 #undef SCRIPT_NAME
919
920 SVN_ERR_W(svn_io_file_create(this_path, contents, pool),
921 _("Creating post-revprop-change hook"));
922 } /* end post-revprop-change hook */
923
924 return SVN_NO_ERROR;
925 }
926
927 static svn_error_t *
928 create_conf(svn_repos_t *repos, apr_pool_t *pool)
929 {
930 SVN_ERR_W(create_repos_dir(repos->conf_path, pool),
931 _("Creating conf directory"));
932
933 /* Write a default template for svnserve.conf. */
934 {
935 static const char * const svnserve_conf_contents =
936 "### This file controls the configuration of the svnserve daemon, if you" NL
937 "### use it to allow access to this repository. (If you only allow" NL
938 "### access through http: and/or file: URLs, then this file is" NL
939 "### irrelevant.)" NL
940 "" NL
941 "### Visit http://subversion.tigris.org/ for more information." NL
942 "" NL
943 "[general]" NL
944 "### These options control access to the repository for unauthenticated" NL
945 "### and authenticated users. Valid values are \"write\", \"read\"," NL
946 "### and \"none\". The sample settings below are the defaults." NL
947 "# anon-access = read" NL
948 "# auth-access = write" NL
949 "### The password-db option controls the location of the password" NL
950 "### database file. Unless you specify a path starting with a /," NL
951 "### the file's location is relative to the directory containing" NL
952 "### this configuration file." NL
953 #ifdef SVN_HAVE_SASL
954 "### If use-sasl is set to \"true\" below, this file will NOT be used." NL
955 #endif
956 "### Uncomment the line below to use the default password file." NL
957 "# password-db = passwd" NL
958 "### The authz-db option controls the location of the authorization" NL
959 "### rules for path-based access control. Unless you specify a path" NL
960 "### starting with a /, the file's location is relative to the the" NL
961 "### directory containing this file. If you don't specify an" NL
962 "### authz-db, no path-based access control is done." NL
963 "### Uncomment the line below to use the default authorization file." NL
964 "# authz-db = " SVN_REPOS__CONF_AUTHZ NL
965 "### This option specifies the authentication realm of the repository." NL
966 "### If two repositories have the same authentication realm, they should" NL
967 "### have the same password database, and vice versa. The default realm" NL
968 "### is repository's uuid." NL
969 #ifndef SVN_HAVE_SASL
970 "# realm = My First Repository" NL;
971 #else
972 "# realm = My First Repository" NL
973 "" NL
974 "[sasl]" NL
975 "### This option specifies whether you want to use the Cyrus SASL" NL
976 "### library for authentication. Default is false." NL
977 "# use-sasl = true" NL
978 "### These options specify the desired strength of the security layer" NL
979 "### that you want SASL to provide. 0 means no encryption, 1 means" NL
980 "### integrity-checking only, values larger than 1 are correlated" NL
981 "### to the effective key length for encryption (e.g. 128 means 128-bit" NL
982 "### encryption). The values below are the defaults." NL
983 "# min-encryption = 0" NL
984 "# max-encryption = 256" NL;
985 #endif
986
987 SVN_ERR_W(svn_io_file_create(svn_repos_svnserve_conf(repos, pool),
988 svnserve_conf_contents, pool),
989 _("Creating svnserve.conf file"));
990 }
991
992 {
993 static const char * const passwd_contents =
994 "### This file is an example password file for svnserve." NL
995 "### Its format is similar to that of svnserve.conf. As shown in the" NL
996 "### example below it contains one section labelled [users]." NL
997 "### The name and password for each user follow, one account per line." NL
998 "" NL
999 "[users]" NL
1000 "# harry = harryssecret" NL
1001 "# sally = sallyssecret" NL;
1002
1003 SVN_ERR_W(svn_io_file_create(svn_path_join(repos->conf_path,
1004 SVN_REPOS__CONF_PASSWD,
1005 pool),
1006 passwd_contents, pool),
1007 _("Creating passwd file"));
1008 }
1009
1010 {
1011 static const char * const authz_contents =
1012 "### This file is an example authorization file for svnserve." NL
1013 "### Its format is identical to that of mod_authz_svn authorization" NL
1014 "### files." NL
1015 "### As shown below each section defines authorizations for the path and" NL
1016 "### (optional) repository specified by the section name." NL
1017 "### The authorizations follow. An authorization line can refer to:" NL
1018 "### - a single user," NL
1019 "### - a group of users defined in a special [groups] section," NL
1020 "### - an alias defined in a special [aliases] section," NL
1021 "### - all authenticated users, using the '$authenticated' token," NL
1022 "### - only anonymous users, using the '$anonymous' token," NL
1023 "### - anyone, using the '*' wildcard." NL
1024 "###" NL
1025 "### A match can be inverted by prefixing the rule with '~'. Rules can" NL
1026 "### grant read ('r') access, read-write ('rw') access, or no access" NL
1027 "### ('')." NL
1028 "" NL
1029 "[aliases]" NL
1030 "# joe = /C=XZ/ST=Dessert/L=Snake City/O=Snake Oil, Ltd./OU=Research Institute/CN=Joe Average" NL
1031 "" NL
1032 "[groups]" NL
1033 "# harry_and_sally = harry,sally" NL
1034 "# harry_sally_and_joe = harry,sally,&joe" NL
1035 "" NL
1036 "# [/foo/bar]" NL
1037 "# harry = rw" NL
1038 "# &joe = r" NL
1039 "# * =" NL
1040 "" NL
1041 "# [repository:/baz/fuz]" NL
1042 "# @harry_and_sally = rw" NL
1043 "# * = r" NL;
1044
1045 SVN_ERR_W(svn_io_file_create(svn_path_join(repos->conf_path,
1046 SVN_REPOS__CONF_AUTHZ,
1047 pool),
1048 authz_contents, pool),
1049 _("Creating authz file"));
1050 }
1051
1052 return SVN_NO_ERROR;
1053 }
1054
1055 /* Allocate and return a new svn_repos_t * object, initializing the
1056 directory pathname members based on PATH.
1057 The members FS, FORMAT, and FS_TYPE are *not* initialized (they are null),
1058 and it is the caller's responsibility to fill them in if needed. */
1059 static svn_repos_t *
1060 create_svn_repos_t(const char *path, apr_pool_t *pool)
1061 {
1062 svn_repos_t *repos = apr_pcalloc(pool, sizeof(*repos));
1063
1064 repos->path = apr_pstrdup(pool, path);
1065 repos->db_path = svn_path_join(path, SVN_REPOS__DB_DIR, pool);
1066 repos->conf_path = svn_path_join(path, SVN_REPOS__CONF_DIR, pool);
1067 repos->hook_path = svn_path_join(path, SVN_REPOS__HOOK_DIR, pool);
1068 repos->lock_path = svn_path_join(path, SVN_REPOS__LOCK_DIR, pool);
1069
1070 return repos;
1071 }
1072
1073
1074 static svn_error_t *
1075 create_repos_structure(svn_repos_t *repos,
1076 const char *path,
1077 apr_hash_t *fs_config,
1078 apr_pool_t *pool)
1079 {
1080 /* Create the top-level repository directory. */
1081 SVN_ERR_W(create_repos_dir(path, pool),
1082 _("Could not create top-level directory"));
1083
1084 /* Create the DAV sandbox directory if pre-1.4 or pre-1.5-compatible. */
1085 if (fs_config
1086 && (apr_hash_get(fs_config, SVN_FS_CONFIG_PRE_1_4_COMPATIBLE,
1087 APR_HASH_KEY_STRING)
1088 || apr_hash_get(fs_config, SVN_FS_CONFIG_PRE_1_5_COMPATIBLE,
1089 APR_HASH_KEY_STRING)))
1090 {
1091 const char *dav_path = svn_path_join(repos->path,
1092 SVN_REPOS__DAV_DIR, pool);
1093 SVN_ERR_W(create_repos_dir(dav_path, pool),
1094 _("Creating DAV sandbox dir"));
1095 }
1096
1097 /* Create the lock directory. */
1098 SVN_ERR(create_locks(repos, pool));
1099
1100 /* Create the hooks directory. */
1101 SVN_ERR(create_hooks(repos, pool));
1102
1103 /* Create the conf directory. */
1104 SVN_ERR(create_conf(repos, pool));
1105
1106 /* Write the top-level README file. */
1107 {
1108 const char * const readme_header =
1109 "This is a Subversion repository; use the 'svnadmin' tool to examine" NL
1110 "it. Do not add, delete, or modify files here unless you know how" NL
1111 "to avoid corrupting the repository." NL
1112 "" NL;
1113 const char * const readme_bdb_insert =
1114 "The directory \"" SVN_REPOS__DB_DIR "\" contains a Berkeley DB environment." NL
1115 "you may need to tweak the values in \"" SVN_REPOS__DB_DIR "/DB_CONFIG\" to match the" NL
1116 "requirements of your site." NL
1117 "" NL;
1118 const char * const readme_footer =
1119 "Visit http://subversion.tigris.org/ for more information." NL;
1120 apr_file_t *f;
1121 apr_size_t written;
1122
1123 SVN_ERR(svn_io_file_open(&f,
1124 svn_path_join(path, SVN_REPOS__README, pool),
1125 (APR_WRITE | APR_CREATE | APR_EXCL),
1126 APR_OS_DEFAULT, pool));
1127
1128 SVN_ERR(svn_io_file_write_full(f, readme_header, strlen(readme_header),
1129 &written, pool));
1130 if (strcmp(repos->fs_type, SVN_FS_TYPE_BDB) == 0)
1131 SVN_ERR(svn_io_file_write_full(f, readme_bdb_insert,
1132 strlen(readme_bdb_insert),
1133 &written, pool));
1134 SVN_ERR(svn_io_file_write_full(f, readme_footer, strlen(readme_footer),
1135 &written, pool));
1136
1137 SVN_ERR(svn_io_file_close(f, pool));
1138 }
1139
1140 return SVN_NO_ERROR;
1141 }
1142
1143
1144 /* There is, at present, nothing within the direct responsibility
1145 of libsvn_repos which requires locking. For historical compatibility
1146 reasons, the BDB libsvn_fs backend does not do its own locking, expecting
1147 libsvn_repos to do the locking for it. Here we take care of that
1148 backend-specific requirement.
1149 The kind of lock is controlled by EXCLUSIVE and NONBLOCKING.
1150 The lock is scoped to POOL. */
1151 static svn_error_t *
1152 lock_repos(svn_repos_t *repos,
1153 svn_boolean_t exclusive,
1154 svn_boolean_t nonblocking,
1155 apr_pool_t *pool)
1156 {
1157 if (strcmp(repos->fs_type, SVN_FS_TYPE_BDB) == 0)
1158 {
1159 svn_error_t *err;
1160 const char *lockfile_path = svn_repos_db_lockfile(repos, pool);
1161
1162 err = svn_io_file_lock2(lockfile_path, exclusive, nonblocking, pool);
1163 if (err != NULL && APR_STATUS_IS_EAGAIN(err->apr_err))
1164 return err;
1165 SVN_ERR_W(err, _("Error opening db lockfile"));
1166 }
1167 return SVN_NO_ERROR;
1168 }
1169
1170
1171 svn_error_t *
1172 svn_repos_create(svn_repos_t **repos_p,
1173 const char *path,
1174 const char *unused_1,
1175 const char *unused_2,
1176 apr_hash_t *config,
1177 apr_hash_t *fs_config,
1178 apr_pool_t *pool)
1179 {
1180 svn_repos_t *repos;
1181 svn_error_t *err;
1182
1183 /* Allocate a repository object, filling in the format we will create. */
1184 repos = create_svn_repos_t(path, pool);
1185 repos->format = SVN_REPOS__FORMAT_NUMBER;
1186
1187 /* Discover the type of the filesystem we are about to create. */
1188 if (fs_config)
1189 {
1190 repos->fs_type = apr_hash_get(fs_config, SVN_FS_CONFIG_FS_TYPE,
1191 APR_HASH_KEY_STRING);
1192 if (apr_hash_get(fs_config, SVN_FS_CONFIG_PRE_1_4_COMPATIBLE,
1193 APR_HASH_KEY_STRING))
1194 repos->format = SVN_REPOS__FORMAT_NUMBER_LEGACY;
1195 }
1196
1197 if (! repos->fs_type)
1198 repos->fs_type = DEFAULT_FS_TYPE;
1199
1200 /* Create the various files and subdirectories for the repository. */
1201 SVN_ERR_W(create_repos_structure(repos, path, fs_config, pool),
1202 _("Repository creation failed"));
1203
1204 /* Lock if needed. */
1205 SVN_ERR(lock_repos(repos, FALSE, FALSE, pool));
1206
1207 /* Create an environment for the filesystem. */
1208 if ((err = svn_fs_create(&repos->fs, repos->db_path, fs_config, pool)))
1209 {
1210 /* If there was an error making the filesytem, e.g. unknown/supported
1211 * filesystem type. Clean up after ourselves. Yes this is safe because
1212 * create_repos_structure will fail if the path existed before we started
1213 * so we can't accidentally remove a directory that previously existed. */
1214 svn_error_clear(svn_io_remove_dir2(path, FALSE, NULL, NULL, pool));
1215 return err;
1216 }
1217
1218 /* This repository is ready. Stamp it with a format number. */
1219 SVN_ERR(svn_io_write_version_file
1220 (svn_path_join(path, SVN_REPOS__FORMAT, pool),
1221 repos->format, pool));
1222
1223 *repos_p = repos;
1224 return SVN_NO_ERROR;
1225 }
1226
1227
1228 /* Check if @a path is the root of a repository by checking if the
1229 * path contains the expected files and directories. Return TRUE
1230 * on errors (which would be permission errors, probably) so that
1231 * we the user will see them after we try to open the repository
1232 * for real. */
1233 static svn_boolean_t
1234 check_repos_path(const char *path,
1235 apr_pool_t *pool)
1236 {
1237 svn_node_kind_t kind;
1238 svn_error_t *err;
1239
1240 err = svn_io_check_path(svn_path_join(path, SVN_REPOS__FORMAT, pool),
1241 &kind, pool);
1242 if (err)
1243 {
1244 svn_error_clear(err);
1245 return TRUE;
1246 }
1247 if (kind != svn_node_file)
1248 return FALSE;
1249
1250 /* Check the db/ subdir, but allow it to be a symlink (Subversion
1251 works just fine if it's a symlink). */
1252 err = svn_io_check_resolved_path
1253 (svn_path_join(path, SVN_REPOS__DB_DIR, pool), &kind, pool);
1254 if (err)
1255 {
1256 svn_error_clear(err);
1257 return TRUE;
1258 }
1259 if (kind != svn_node_dir)
1260 return FALSE;
1261
1262 return TRUE;
1263 }
1264
1265
1266 /* Verify that REPOS's format is suitable.
1267 Use POOL for temporary allocation. */
1268 static svn_error_t *
1269 check_repos_format(svn_repos_t *repos,
1270 apr_pool_t *pool)
1271 {
1272 int format;
1273 const char *format_path;
1274
1275 format_path = svn_path_join(repos->path, SVN_REPOS__FORMAT, pool);
1276 SVN_ERR(svn_io_read_version_file(&format, format_path, pool));
1277
1278 if (format != SVN_REPOS__FORMAT_NUMBER &&
1279 format != SVN_REPOS__FORMAT_NUMBER_LEGACY)
1280 {
1281 return svn_error_createf
1282 (SVN_ERR_REPOS_UNSUPPORTED_VERSION, NULL,
1283 _("Expected repository format '%d' or '%d'; found format '%d'"),
1284 SVN_REPOS__FORMAT_NUMBER_LEGACY, SVN_REPOS__FORMAT_NUMBER,
1285 format);
1286 }
1287
1288 repos->format = format;
1289
1290 return SVN_NO_ERROR;
1291 }
1292
1293
1294 /* Set *REPOS_P to a repository at PATH which has been opened.
1295 See lock_repos() above regarding EXCLUSIVE and NONBLOCKING.
1296 OPEN_FS indicates whether the Subversion filesystem should be opened,
1297 the handle being placed into repos->fs.
1298 Do all allocation in POOL. */
1299 static svn_error_t *
1300 get_repos(svn_repos_t **repos_p,
1301 const char *path,
1302 svn_boolean_t exclusive,
1303 svn_boolean_t nonblocking,
1304 svn_boolean_t open_fs,
1305 apr_pool_t *pool)
1306 {
1307 svn_repos_t *repos;
1308
1309 /* Allocate a repository object. */
1310 repos = create_svn_repos_t(path, pool);
1311
1312 /* Verify the validity of our repository format. */
1313 SVN_ERR(check_repos_format(repos, pool));
1314
1315 /* Discover the FS type. */
1316 SVN_ERR(svn_fs_type(&repos->fs_type, repos->db_path, pool));
1317
1318 /* Lock if needed. */
1319 SVN_ERR(lock_repos(repos, exclusive, nonblocking, pool));
1320
1321 /* Open up the filesystem only after obtaining the lock. */
1322 if (open_fs)
1323 SVN_ERR(svn_fs_open(&repos->fs, repos->db_path, NULL, pool));
1324
1325 *repos_p = repos;
1326 return SVN_NO_ERROR;
1327 }
1328
1329
1330
1331 const char *
1332 svn_repos_find_root_path(const char *path,
1333 apr_pool_t *pool)
1334 {
1335 const char *candidate = path;
1336 const char *decoded;
1337 svn_error_t *err;
1338
1339 while (1)
1340 {
1341 /* Try to decode the path, so we don't fail if it contains characters
1342 that aren't supported by the OS filesystem. The subversion fs
1343 isn't restricted by the OS filesystem character set. */
1344 err = svn_utf_cstring_from_utf8(&decoded, candidate, pool);
1345 if (!err && check_repos_path(candidate, pool))
1346 break;
1347 svn_error_clear(err);
1348
1349 if (candidate[0] == '\0' ||
1350 svn_dirent_is_root(candidate, strlen(candidate)))
1351 return NULL;
1352
1353 candidate = svn_path_dirname(candidate, pool);
1354 }
1355
1356 return candidate;
1357 }
1358
1359
1360 svn_error_t *
1361 svn_repos_open(svn_repos_t **repos_p,
1362 const char *path,
1363 apr_pool_t *pool)
1364 {
1365 /* Fetch a repository object initialized with a shared read/write
1366 lock on the database. */
1367
1368 SVN_ERR(get_repos(repos_p, path, FALSE, FALSE, TRUE, pool));
1369
1370 return SVN_NO_ERROR;
1371 }
1372
1373
1374 svn_error_t *
1375 svn_repos_delete(const char *path,
1376 apr_pool_t *pool)
1377 {
1378 const char *db_path = svn_path_join(path, SVN_REPOS__DB_DIR, pool);
1379
1380 /* Delete the filesystem environment... */
1381 SVN_ERR(svn_fs_delete_fs(db_path, pool));
1382
1383 /* ...then blow away everything else. */
1384 SVN_ERR(svn_io_remove_dir2(path, FALSE, NULL, NULL, pool));
1385
1386 return SVN_NO_ERROR;
1387 }
1388
1389
1390 svn_fs_t *
1391 svn_repos_fs(svn_repos_t *repos)
1392 {
1393 if (! repos)
1394 return NULL;
1395 return repos->fs;
1396 }
1397
1398
1399 /* For historical reasons, for the Berkeley DB backend, this code uses
1400 * repository locking, which is motivated by the need to support the
1401 * Berkeley DB error DB_RUN_RECOVERY. (FSFS takes care of locking
1402 * itself, inside its implementation of svn_fs_recover.) Here's how
1403 * it works:
1404 *
1405 * Every accessor of a repository's database takes out a shared lock
1406 * on the repository -- both readers and writers get shared locks, and
1407 * there can be an unlimited number of shared locks simultaneously.
1408 *
1409 * Sometimes, a db access returns the error DB_RUN_RECOVERY. When
1410 * this happens, we need to run svn_fs_recover() on the db
1411 * with no other accessors present. So we take out an exclusive lock
1412 * on the repository. From the moment we request the exclusive lock,
1413 * no more shared locks are granted, and when the last shared lock
1414 * disappears, the exclusive lock is granted. As soon as we get it,
1415 * we can run recovery.
1416 *
1417 * We assume that once any berkeley call returns DB_RUN_RECOVERY, they
1418 * all do, until recovery is run.
1419 */
1420
1421 svn_error_t *
1422 svn_repos_recover3(const char *path,
1423 svn_boolean_t nonblocking,
1424 svn_error_t *(*start_callback)(void *baton),
1425 void *start_callback_baton,
1426 svn_cancel_func_t cancel_func, void *cancel_baton,
1427 apr_pool_t *pool)
1428 {
1429 svn_repos_t *repos;
1430 apr_pool_t *subpool = svn_pool_create(pool);
1431
1432 /* Fetch a repository object; for the Berkeley DB backend, it is
1433 initialized with an EXCLUSIVE lock on the database. This will at
1434 least prevent others from trying to read or write to it while we
1435 run recovery. (Other backends should do their own locking; see
1436 lock_repos.) */
1437 SVN_ERR(get_repos(&repos, path, TRUE, nonblocking,
1438 FALSE, /* don't try to open the db yet. */
1439 subpool));
1440
1441 if (start_callback)
1442 SVN_ERR(start_callback(start_callback_baton));
1443
1444 /* Recover the database to a consistent state. */
1445 SVN_ERR(svn_fs_recover(repos->db_path, cancel_func, cancel_baton, subpool));
1446
1447 /* Close shop and free the subpool, to release the exclusive lock. */
1448 svn_pool_destroy(subpool);
1449
1450 return SVN_NO_ERROR;
1451 }
1452
1453
1454 svn_error_t *
1455 svn_repos_recover2(const char *path,
1456 svn_boolean_t nonblocking,
1457 svn_error_t *(*start_callback)(void *baton),
1458 void *start_callback_baton,
1459 apr_pool_t *pool)
1460 {
1461 return svn_repos_recover3(path, nonblocking,
1462 start_callback, start_callback_baton,
1463 NULL, NULL,
1464 pool);
1465 }
1466
1467 svn_error_t *
1468 svn_repos_recover(const char *path,
1469 apr_pool_t *pool)
1470 {
1471 return svn_repos_recover2(path, FALSE, NULL, NULL, pool);
1472 }
1473
1474 svn_error_t *svn_repos_db_logfiles(apr_array_header_t **logfiles,
1475 const char *path,
1476 svn_boolean_t only_unused,
1477 apr_pool_t *pool)
1478 {
1479 svn_repos_t *repos;
1480 int i;
1481
1482 SVN_ERR(get_repos(&repos, path,
1483 FALSE, FALSE,
1484 FALSE, /* Do not open fs. */
1485 pool));
1486
1487 SVN_ERR(svn_fs_berkeley_logfiles(logfiles,
1488 svn_repos_db_env(repos, pool),
1489 only_unused,
1490 pool));
1491
1492 /* Loop, printing log files. */
1493 for (i = 0; i < (*logfiles)->nelts; i++)
1494 {
1495 const char ** log_file = &(APR_ARRAY_IDX(*logfiles, i, const char *));
1496 *log_file = svn_path_join(SVN_REPOS__DB_DIR, *log_file, pool);
1497 }
1498
1499 return SVN_NO_ERROR;
1500 }
1501
1502 /** Hot copy structure copy context.
1503 */
1504 struct hotcopy_ctx_t {
1505 const char *dest; /* target location to construct */
1506 unsigned int src_len; /* len of the source path*/
1507 };
1508
1509 /** Called by (svn_io_dir_walk).
1510 * Copies the repository structure with exception of @c SVN_REPOS__DB_DIR,
1511 * @c SVN_REPOS__LOCK_DIR and @c SVN_REPOS__FORMAT.
1512 * Those directories and files are handled separetly.
1513 * @a baton is a pointer to (struct hotcopy_ctx_t) specifying
1514 * destination path to copy to and the length of the source path.
1515 *
1516 * @copydoc svn_io_dir_walk()
1517 */
1518 static svn_error_t *hotcopy_structure(void *baton,
1519 const char *path,
1520 const apr_finfo_t *finfo,
1521 apr_pool_t *pool)
1522 {
1523 const struct hotcopy_ctx_t *ctx = ((struct hotcopy_ctx_t *) baton);
1524 const char *sub_path;
1525 const char *target;
1526
1527 if (strlen(path) == ctx->src_len)
1528 {
1529 sub_path = "";
1530 }
1531 else
1532 {
1533 sub_path = &path[ctx->src_len+1];
1534
1535 /* Check if we are inside db directory and if so skip it */
1536 if (svn_path_compare_paths
1537 (svn_path_get_longest_ancestor(SVN_REPOS__DB_DIR, sub_path, pool),
1538 SVN_REPOS__DB_DIR) == 0)
1539 return SVN_NO_ERROR;
1540
1541 if (svn_path_compare_paths
1542 (svn_path_get_longest_ancestor(SVN_REPOS__LOCK_DIR, sub_path, pool),
1543 SVN_REPOS__LOCK_DIR) == 0)
1544 return SVN_NO_ERROR;
1545
1546 if (svn_path_compare_paths
1547 (svn_path_get_longest_ancestor(SVN_REPOS__FORMAT, sub_path, pool),
1548 SVN_REPOS__FORMAT) == 0)
1549 return SVN_NO_ERROR;
1550 }
1551
1552 target = svn_path_join(ctx->dest, sub_path, pool);
1553
1554 if (finfo->filetype == APR_DIR)
1555 {
1556 SVN_ERR(create_repos_dir(target, pool));
1557 }
1558 else if (finfo->filetype == APR_REG)
1559 {
1560
1561 SVN_ERR(svn_io_copy_file(path, target, TRUE, pool));
1562 }
1563
1564 return SVN_NO_ERROR;
1565 }
1566
1567
1568 /** Obtain a lock on db logs lock file. Create one if it does not exist.
1569 */
1570 static svn_error_t *
1571 lock_db_logs_file(svn_repos_t *repos,
1572 svn_boolean_t exclusive,
1573 apr_pool_t *pool)
1574 {
1575 const char * lock_file = svn_repos_db_logs_lockfile(repos, pool);
1576
1577 /* Try to create a lock file, in case if it is missing. As in case of the
1578 repositories created before hotcopy functionality. */
1579 svn_error_clear(create_db_logs_lock(repos, pool));
1580
1581 SVN_ERR(svn_io_file_lock2(lock_file, exclusive, FALSE, pool));
1582
1583 return SVN_NO_ERROR;
1584 }
1585
1586
1587 /* Make a copy of a repository with hot backup of fs. */
1588 svn_error_t *
1589 svn_repos_hotcopy(const char *src_path,
1590 const char *dst_path,
1591 svn_boolean_t clean_logs,
1592 apr_pool_t *pool)
1593 {
1594 svn_repos_t *src_repos;
1595 svn_repos_t *dst_repos;
1596 struct hotcopy_ctx_t hotcopy_context;
1597
1598 /* Try to open original repository */
1599 SVN_ERR(get_repos(&src_repos, src_path,
1600 FALSE, FALSE,
1601 FALSE, /* don't try to open the db yet. */
1602 pool));
1603
1604 /* If we are going to clean logs, then get an exclusive lock on
1605 db-logs.lock, to ensure that no one else will work with logs.
1606
1607 If we are just copying, then get a shared lock to ensure that
1608 no one else will clean logs while we copying them */
1609
1610 SVN_ERR(lock_db_logs_file(src_repos, clean_logs, pool));
1611
1612 /* Copy the repository to a new path, with exception of
1613 specially handled directories */
1614
1615 hotcopy_context.dest = dst_path;
1616 hotcopy_context.src_len = strlen(src_path);
1617 SVN_ERR(svn_io_dir_walk(src_path,
1618 0,
1619 hotcopy_structure,
1620 &hotcopy_context,
1621 pool));
1622
1623 /* Prepare dst_repos object so that we may create locks,
1624 so that we may open repository */
1625
1626 dst_repos = create_svn_repos_t(dst_path, pool);
1627 dst_repos->fs_type = src_repos->fs_type;
1628 dst_repos->format = src_repos->format;
1629
1630 SVN_ERR(create_locks(dst_repos, pool));
1631
1632 SVN_ERR(svn_io_dir_make_sgid(dst_repos->db_path, APR_OS_DEFAULT, pool));
1633
1634 /* Exclusively lock the new repository.
1635 No one should be accessing it at the moment */
1636 SVN_ERR(lock_repos(dst_repos, TRUE, FALSE, pool));
1637
1638 SVN_ERR(svn_fs_hotcopy(src_repos->db_path, dst_repos->db_path,
1639 clean_logs, pool));
1640
1641 /* Destination repository is ready. Stamp it with a format number. */
1642 SVN_ERR(svn_io_write_version_file
1643 (svn_path_join(dst_repos->path, SVN_REPOS__FORMAT, pool),
1644 dst_repos->format, pool));
1645
1646 return SVN_NO_ERROR;
1647 }
1648
1649 /* Return the library version number. */
1650 const svn_version_t *
1651 svn_repos_version(void)
1652 {
1653 SVN_VERSION_BODY;
1654 }
1655
1656
1657
1658 svn_error_t *
1659 svn_repos_stat(svn_dirent_t **dirent,
1660 svn_fs_root_t *root,
1661 const char *path,
1662 apr_pool_t *pool)
1663 {
1664 svn_node_kind_t kind;
1665 svn_dirent_t *ent;
1666 const char *datestring;
1667 apr_hash_t *prophash;
1668
1669 SVN_ERR(svn_fs_check_path(&kind, root, path, pool));
1670
1671 if (kind == svn_node_none)
1672 {
1673 *dirent = NULL;
1674 return SVN_NO_ERROR;
1675 }
1676
1677 ent = apr_pcalloc(pool, sizeof(*ent));
1678 ent->kind = kind;
1679
1680 if (kind == svn_node_file)
1681 SVN_ERR(svn_fs_file_length(&(ent->size), root, path, pool));
1682
1683 SVN_ERR(svn_fs_node_proplist(&prophash, root, path, pool));
1684 if (apr_hash_count(prophash) > 0)
1685 ent->has_props = TRUE;
1686
1687 SVN_ERR(svn_repos_get_committed_info(&(ent->created_rev),
1688 &datestring,
1689 &(ent->last_author),
1690 root, path, pool));
1691 if (datestring)
1692 SVN_ERR(svn_time_from_cstring(&(ent->time), datestring, pool));
1693
1694 *dirent = ent;
1695 return SVN_NO_ERROR;
1696 }
1697
1698 svn_error_t *
1699 svn_repos_remember_client_capabilities(svn_repos_t *repos,
1700 apr_array_header_t *capabilities)
1701 {
1702 repos->client_capabilities = capabilities;
1703 return SVN_NO_ERROR;
1704 }
1705
A mirror of subversion's own subversion repository