Alien-SVN
view release on metacpan or search on metacpan
src/subversion/CHANGES view on Meta::CPAN
* SSL client and server certificate verification
* authentication info now stored in ~/.subversion/auth/
* svn diff on a copied file only shows local mods, not the whole file
* svn propget now takes a --strict option to control output
* svnadmin load now takes a --parent-dir option
* added the new 'svndumpfilter' program
* svnlook now has 'cat', 'propget', and 'proplist' commands to enable
viewing this information on transactions
* 'svn copy' from another repository now adds without history
* tag/branch conversion disabled in cvs2svn until it gets fixed
* the 'anonymous' user is no longer used; we simply avoid attaching an
author property when an author is not available
* improvements to ignored-file handling
* Python ConfigParser-style variable expansion for config file (#1165)
Developer-visible changes:
* introduced the svn_filesize_t type (#639)
* realmstring added to the svn_auth framework
* the "result checksum" moved to the editor.close_file function
* more checksumming here and there
* initial work to enable binary properties via ra_dav
src/subversion/LICENSE view on Meta::CPAN
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
src/subversion/LICENSE view on Meta::CPAN
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
src/subversion/doc/user/cvs-crossover-guide.html view on Meta::CPAN
<dt>Explanation:</dt>
<dd>The <tt>svn copy</tt> command schedules a file or directory
for addition to the repository, recording the "source" of the
copy. After committing, <tt>svn log</tt> on the copied item
will trace history back through the original copy-source. The
<tt>svn move</tt> command is exactly equivalent to running
<tt>svn copy</tt>, followed by an <tt>svn delete</tt> on the
copy-source: the result is a new item scheduled for addition
(with copy-history attached) and the original item scheduled for
deletion.</dd>
</dl>
</td>
</tr>
</table>
<dl class="bookref">
<dt>Book References:</dt>
<dd><a href="http://svnbook.red-bean.com/svnbook/ch03s05.html#svn-ch-3-sect-4.2">Make Changes to Your Working Copy</a></dd>
src/subversion/doc/user/lj_article.txt view on Meta::CPAN
* Advanced network layer. The Subversion network server is Apache,
and client and server speak WebDAV(2) to one another. (See the
'design' section below.)
* Faster network access. A binary diffing algorithm is used to
store and transmit deltas in *both* directions, regardless of
whether a file is of text or binary type.
* Filesystem "properties". Each file or directory has an invisible
hashtable attached. You can invent and store any arbitrary
key/value pairs you wish: owner, perms, icons, app-creator,
mime-type, personal notes, etc. This is a general-purpose feature
for users. Properties are versioned, just like file contents.
And some properties are auto-detected, like the mime-type of a
file (no more remembering to use the '-kb' switch!)
* Extensible and hackable. Subversion has no historical baggage; it
was designed and then implemented as a collection of shared C
libraries with well-defined APIs. This makes Subversion extremely
maintainable and usable by other applications and languages.
src/subversion/subversion/bindings/swig/core.i view on Meta::CPAN
void *walk_baton,
svn_swig_py_config_auth_walk_func,
svn_swig_pl_config_auth_walk_func,
svn_swig_rb_config_auth_walk_func)
#endif
/* -----------------------------------------------------------------------
* For all the various functions that set a callback baton create a reference
* for the baton (which in this case is an SV pointing to the callback)
* and make that a return from the function. The perl side should
* then store the return in the object the baton is attached to.
* If the function already returns a value then this value is follows that
* function. In the case of the prompt functions auth_open_helper in Core.pm
* is used to split up these values.
*/
#ifdef SWIGPERL
%typemap(argout) void *CALLBACK_BATON (SV * _global_callback) {
/* callback baton */
%append_output(sv_2mortal(newRV_inc(_global_callback)));
}
src/subversion/subversion/bindings/swig/perl/native/Client.pm view on Meta::CPAN
is true, this will be a recursive operation.
=item $client-E<gt>revprop_get($propname, $url, $revision, $pool);
Returns two values, the first of which is the value of $propname on revision
$revision in the repository represented by $url. The second value is the
actual revision queried.
Note that unlike its cousin $client-E<gt>propget(), this routine doesn't affect
working copy at all; it's a pure network operation that queries an
B<unversioned> property attached to a revision. This can be used to query
log messages, dates, authors, and the like.
=item $client-E<gt>revprop_list($url, $revision, $pool);
Returns two values, the first of which is a reference to a hash containing
the properties attached to $revision in the repository represented by $url.
The second value is the actual revision queried.
Note that unlike its cousin $client-E<gt>proplist(), this routine doesn't read a
working copy at all; it's a pure network operation that reads B<unversioned>
properties attached to a revision.
=item $client-E<gt>revprop_set($propname, $propval, $url, $revision, $force, $pool);
Set $propname to $propval on revision $revision in the repository represented
by $url.
Returns the actual revision affected. A $propval of undef will delete the
property.
If $force is true, allow newlines in the author property.
If $propname is an svn-controlled property (i.e. prefixed with svn:), then
the caller is responsible for ensuring that the value is UTF8-encoded and
uses LF line-endings.
Note that unlike its cousin $client-E<gt>propset(), this routine doesn't affect
the working copy at all; it's a pure network operation that changes an
B<unversioned> property attached to a revision. This can be used to tweak
log messages, dates, authors, and the like. Be careful: it's a lossy
operation, meaning that any existing value is replaced with the new value,
with no way to retrieve the prior value.
Also note that unless the administrator creates a pre-revprop-change hook
in the repository, this feature will fail.
=item $client-E<gt>status($path, $revision, \&status_func, $recursive, $get_all, $update, $no_ignore, $pool);
Similar to $client-E<gt>status2(), but with ignore_externals always set to FALSE, and with the status_func receiving a svn_wc_status2_t instead of a svn_wc_status_t object.
src/subversion/subversion/bindings/swig/perl/native/Client.pm view on Meta::CPAN
The following attribute methods are provided that allow you to set various
configuration or retrieve it. They all take value(s) to set the attribute and
return the new value of the attribute or no parameters which returns the
current value.
=over 4
=item $client-E<gt>auth(SVN::Client::get_username_provider());
Provides access to the auth_baton in the svn_client_ctx_t attached to the
SVN::Client object.
This method will accept an array or array ref of values returned from the
authentication provider functions see L</"AUTHENTICATION PROVIDERS">, which
it will convert to an auth_baton for you. This is the preferred method of
setting the auth_baton.
It will also accept a scalar that references a _p_svn_auth_baton_t such as
those returned from SVN::Core::auth_open and SVN::Core::auth_open_helper.
src/subversion/subversion/bindings/swig/perl/native/Core.pm view on Meta::CPAN
Prompt providers return two values instead of one. The
2nd parameter is a reference to whatever was passed into
them as the callback. auth_open_helper splits up these
arguments, passing the provider objects into auth_open
which gives it an auth_baton and putting the other
ones in an array. The first return value of this
function is the auth_baton, the second is a reference
to an array containing the references to the callbacks.
These callback arrays should be stored in the object
the auth_baton is attached to.
=back
=cut
sub auth_open_helper {
my $args = shift;
my (@auth_providers,@auth_callbacks);
foreach my $arg (@{$args}) {
src/subversion/subversion/bindings/swig/perl/native/Fs.pm view on Meta::CPAN
base revision will be $rev, which should be a number.
=item $fs-E<gt>change_rev_prop
=item $fs-E<gt>generate_lock_token()
Generate a unique lock-token using C<$fs>.
TODO - translate this to apply to Perl:
This can be used in to populate lock-E<gt>token before calling
svn_fs_attach_lock().
=item $fs-E<gt>get_access()
The filesystem's current access context, as a C<_p_svn_fs_access_t>
object. Returns undef if no access context has been set with
the C<set_access()> method.
=item $fs-E<gt>get_lock
=item $fs-E<gt>get_locks
src/subversion/subversion/bindings/swig/ruby/svn/client.rb view on Meta::CPAN
alias pset propset
alias ps propset
def propdel(name, *args)
propset(name, nil, *args)
end
alias prop_del propdel
alias pdel propdel
alias pd propdel
# Returns a value of a property, with +name+ attached to +target+,
# as a Hash such as <tt>{uri1 => value1, uri2 => value2, ...}</tt>.
def propget(name, target, rev=nil, peg_rev=nil, depth_or_recurse=nil,
changelists_names=nil)
rev ||= "HEAD"
peg_rev ||= rev
depth = Core::Depth.infinity_or_empty_from_recurse(depth_or_recurse)
changelists_names = [changelists_names] unless changelists_names.is_a?(Array) or changelists_names.nil?
Client.propget3(name, target, peg_rev, rev, depth, changelists_names, self).first
end
alias prop_get propget
alias pget propget
alias pg propget
# Obsoleted document.
#
# Returns list of properties attached to +target+ as an Array of
# Svn::Client::PropListItem.
# Paths and URIs are available as +target+.
def proplist(target, peg_rev=nil, rev=nil, depth_or_recurse=nil,
changelists_names=nil, &block)
rev ||= "HEAD"
peg_rev ||= rev
items = []
depth = Core::Depth.infinity_or_empty_from_recurse(depth_or_recurse)
receiver = Proc.new do |path, prop_hash|
items << PropListItem.new(path, prop_hash)
src/subversion/subversion/include/svn_client.h view on Meta::CPAN
* (such as svn_fs_change_rev_prop2() and svn_ra_change_rev_prop2()).
*
* If @a force is TRUE, allow newlines in the author property.
*
* If @a propname is an svn-controlled property (i.e. prefixed with
* #SVN_PROP_PREFIX), then the caller is responsible for ensuring that
* the value UTF8-encoded and uses LF line-endings.
*
* Note that unlike its cousin svn_client_propset3(), this routine
* doesn't affect the working copy at all; it's a pure network
* operation that changes an *unversioned* property attached to a
* revision. This can be used to tweak log messages, dates, authors,
* and the like. Be careful: it's a lossy operation.
* @a ctx->notify_func2 and @a ctx->notify_baton2 are the notification
* functions and baton which are called upon successful setting of the
* property.
*
* Also note that unless the administrator creates a
* pre-revprop-change hook in the repository, this feature will fail.
*
src/subversion/subversion/include/svn_client.h view on Meta::CPAN
svn_client_ctx_t *ctx,
apr_pool_t *pool);
/** Set @a *propval to the value of @a propname on revision @a revision
* in the repository represented by @a URL. Use the authentication baton
* in @a ctx for authentication, and @a pool for all memory allocation.
* Return the actual rev queried in @a *set_rev.
*
* Note that unlike its cousin svn_client_propget(), this routine
* doesn't affect the working copy at all; it's a pure network
* operation that queries an *unversioned* property attached to a
* revision. This can query log messages, dates, authors, and the
* like.
*/
svn_error_t *
svn_client_revprop_get(const char *propname,
svn_string_t **propval,
const char *URL,
const svn_opt_revision_t *revision,
svn_revnum_t *set_rev,
svn_client_ctx_t *ctx,
src/subversion/subversion/include/svn_client.h view on Meta::CPAN
*/
SVN_DEPRECATED
svn_error_t *
svn_client_proplist(apr_array_header_t **props,
const char *target,
const svn_opt_revision_t *revision,
svn_boolean_t recurse,
svn_client_ctx_t *ctx,
apr_pool_t *pool);
/** Set @a *props to a hash of the revision props attached to @a revision in
* the repository represented by @a URL. Use the authentication baton cached
* in @a ctx for authentication, and @a pool for all memory allocation.
* Return the actual rev queried in @a *set_rev.
*
* The allocated hash maps (<tt>const char *</tt>) property names to
* (#svn_string_t *) property values.
*
* Note that unlike its cousin svn_client_proplist(), this routine
* doesn't read a working copy at all; it's a pure network operation
* that reads *unversioned* properties attached to a revision.
*/
svn_error_t *
svn_client_revprop_list(apr_hash_t **props,
const char *URL,
const svn_opt_revision_t *revision,
svn_revnum_t *set_rev,
svn_client_ctx_t *ctx,
apr_pool_t *pool);
/** @} */
src/subversion/subversion/include/svn_fs.h view on Meta::CPAN
apr_time_t expiration_date,
svn_revnum_t current_rev,
svn_boolean_t steal_lock,
apr_pool_t *pool);
/** Generate a unique lock-token using @a fs. Return in @a *token,
* allocated in @a pool.
*
* This can be used in to populate lock->token before calling
* svn_fs_attach_lock().
*/
svn_error_t *
svn_fs_generate_lock_token(const char **token,
svn_fs_t *fs,
apr_pool_t *pool);
/** Remove the lock on @a path represented by @a token in @a fs.
*
* If @a token doesn't point to a lock, return #SVN_ERR_FS_BAD_LOCK_TOKEN.
src/subversion/subversion/include/svn_props.h view on Meta::CPAN
/* Defines for reserved ("svn:") property names. */
/** All Subversion property names start with this. */
#define SVN_PROP_PREFIX "svn:"
/** Visible properties
*
* These are regular properties that are attached to ordinary files
* and dirs, and are visible (and tweakable) by svn client programs
* and users. Adding these properties causes specific effects.
*
* @note the values of these properties are always UTF8-encoded with
* LF line-endings. It is the burden of svn library users to enforce
* this. Use svn_prop_needs_translation() to discover if a
* certain property needs translation, and you can use
* svn_subst_translate_string()/svn_subst_detranslate_string()
* to do the translation.
*
src/subversion/subversion/include/svn_props.h view on Meta::CPAN
#define SVN_PROP_ENTRY_LOCK_TOKEN SVN_PROP_ENTRY_PREFIX "lock-token"
/** When custom, user-defined properties are passed over the wire, they will
* have this prefix added to their name.
*/
#define SVN_PROP_CUSTOM_PREFIX SVN_PROP_PREFIX "custom:"
/** @} */
/**
* These are reserved properties attached to a "revision" object in
* the repository filesystem. They can be queried by using
* svn_fs_revision_prop().
*
* @defgroup svn_props_revision_props Revision properties
* @{
*/
/** The fs revision property that stores a commit's author. */
#define SVN_PROP_REVISION_AUTHOR SVN_PROP_PREFIX "author"
src/subversion/subversion/include/svn_props.h view on Meta::CPAN
SVN_PROP_REVISION_ORIG_DATE, \
SVNSYNC_PROP_LOCK, \
SVNSYNC_PROP_FROM_URL, \
SVNSYNC_PROP_FROM_UUID, \
SVNSYNC_PROP_LAST_MERGED_REV, \
SVNSYNC_PROP_CURRENTLY_COPYING,
/** @} */
/**
* These are reserved properties attached to a "transaction" object in
* the repository filesystem in advance of the pre-commit hook script
* running on the server, but then automatically removed from the
* transaction before its promotion to a new revision.
*
* @defgroup svn_props_ephemeral_txnprops Ephemeral transaction properties
* @{
*/
/** The prefix used for all (ephemeral) transaction properties.
*
src/subversion/subversion/include/svn_ra.h view on Meta::CPAN
* If the server advertises the #SVN_RA_CAPABILITY_ATOMIC_REVPROPS capability
* and @a old_value_p is not @c NULL, then changing the property will fail with
* an error chain that contains #SVN_ERR_FS_PROP_BASEVALUE_MISMATCH if the
* present value of the property is not @a *old_value_p. (This is an atomic
* test-and-set).
* @a *old_value_p may be @c NULL, representing that the property must be not
* already set.
*
* If the capability is not advertised, then @a old_value_p MUST be @c NULL.
*
* Please note that properties attached to revisions are @em unversioned.
*
* Use @a pool for memory allocation.
*
* @see svn_fs_change_rev_prop2(), svn_error_find_cause().
*
* @since New in 1.7.
*/
svn_error_t *
svn_ra_change_rev_prop2(svn_ra_session_t *session,
svn_revnum_t rev,
src/subversion/subversion/include/svn_ra.h view on Meta::CPAN
*/
SVN_DEPRECATED
svn_error_t *
svn_ra_change_rev_prop(svn_ra_session_t *session,
svn_revnum_t rev,
const char *name,
const svn_string_t *value,
apr_pool_t *pool);
/**
* Set @a *props to the list of unversioned properties attached to revision
* @a rev in the repository of @a session. The hash maps
* (<tt>const char *</tt>) names to (<tt>@c svn_string_t *</tt>) values.
*
* Use @a pool for memory allocation.
*
* @since New in 1.2.
*/
svn_error_t *
svn_ra_rev_proplist(svn_ra_session_t *session,
svn_revnum_t rev,
apr_hash_t **props,
apr_pool_t *pool);
/**
* Set @a *value to the value of unversioned property @a name attached to
* revision @a rev in the repository of @a session. If @a rev has no
* property by that name, set @a *value to @c NULL.
*
* Use @a pool for memory allocation.
*
* @since New in 1.2.
*/
svn_error_t *
svn_ra_rev_prop(svn_ra_session_t *session,
svn_revnum_t rev,
src/subversion/subversion/include/svn_repos.h view on Meta::CPAN
* Get libsvn_repos version information.
*
* @since New in 1.1.
*/
const svn_version_t *
svn_repos_version(void);
/* Some useful enums. They need to be declared here for the notification
system to pick them up. */
/** The different "actions" attached to nodes in the dumpfile. */
enum svn_node_action
{
svn_node_action_change,
svn_node_action_add,
svn_node_action_delete,
svn_node_action_replace
};
/** The different policies for processing the UUID in the dumpfile. */
enum svn_repos_load_uuid
src/subversion/subversion/include/svn_repos.h view on Meta::CPAN
* equal to @a path.
*/
const char *
svn_repos_find_root_path(const char *path,
apr_pool_t *pool);
/** Set @a *repos_p to a repository object for the repository at @a path.
*
* Allocate @a *repos_p in @a pool.
*
* Acquires a shared lock on the repository, and attaches a cleanup
* function to @a pool to remove the lock. If no lock can be acquired,
* returns error, with undefined effect on @a *repos_p. If an exclusive
* lock is present, this blocks until it's gone. @a fs_config will be
* passed to the filesystem initialization function and may be @c NULL.
*
* @since New in 1.7.
*/
svn_error_t *
svn_repos_open2(svn_repos_t **repos_p,
const char *path,
src/subversion/subversion/include/svn_repos.h view on Meta::CPAN
* maintain their own distinct version information (revision numbers,
* authors, log messages, change timestamps, etc.), Subversion binds
* multiple paths changed as part of a single commit operation into a
* set, calls the whole thing a revision, and hangs commit metadata
* (author, date, log message, etc.) off of that revision. So, commit
* metadata is shared across all the paths changed as part of a given
* commit operation.
*
* It is common (or, at least, we hope it is) for log messages to give
* detailed information about changes made in the commit to which the log
* message is attached. Such information might include a mention of all
* the files changed, what was changed in them, and so on. But this
* causes a problem when presenting information to readers who aren't
* authorized to read every path in the repository. Simply knowing that
* a given path exists may be a security leak, even if the user can't see
* the contents of the data located at that path.
*
* So Subversion does what it reasonably can to prevent the leak of this
* information, and does so via a staged revision access policy. A
* reader can be said to have one of three levels of access to a given
* revision's metadata, based solely on the reader's access rights to the
src/subversion/subversion/libsvn_client/merge.c view on Meta::CPAN
local_abspath, merge_b->pool);
/* And notify the deletion */
SVN_ERR(record_update_delete(merge_b, fb->parent_baton, local_abspath,
svn_node_file, scratch_pool));
}
else
{
/* The files differ, so raise a conflict instead of deleting */
/* This is use case 5 described in the paper attached to issue
* #2282. See also notes/tree-conflicts/detection.txt
*/
SVN_ERR(record_tree_conflict(merge_b, local_abspath, fb->parent_baton,
svn_node_file,
svn_wc_conflict_action_delete,
svn_wc_conflict_reason_edited,
NULL, TRUE,
scratch_pool));
}
src/subversion/subversion/libsvn_client/merge.c view on Meta::CPAN
same = FALSE;
}
}
if (! same)
{
/* If the attempt to delete an existing directory failed,
* the directory has local modifications (e.g. locally added
* files, or property changes). Flag a tree conflict. */
/* This handles use case 5 described in the paper attached to issue
* #2282. See also notes/tree-conflicts/detection.txt
*/
SVN_ERR(record_tree_conflict(merge_b, local_abspath, db->parent_baton,
svn_node_dir,
svn_wc_conflict_action_delete,
svn_wc_conflict_reason_edited,
NULL, TRUE,
scratch_pool));
}
else
src/subversion/subversion/libsvn_fs_base/lock.c view on Meta::CPAN
SVN_ERR_FS_OUT_OF_DATE, NULL,
_("Path '%s' doesn't exist in HEAD revision"),
args->path);
else
return svn_error_createf(
SVN_ERR_FS_NOT_FOUND, NULL,
_("Path '%s' doesn't exist in HEAD revision"),
args->path);
}
/* There better be a username attached to the fs. */
if (!trail->fs->access_ctx || !trail->fs->access_ctx->username)
return SVN_FS__ERR_NO_USER(trail->fs);
/* Is the caller attempting to lock an out-of-date working file? */
if (SVN_IS_VALID_REVNUM(args->current_rev))
{
svn_revnum_t created_rev;
SVN_ERR(svn_fs_base__get_path_created_rev(&created_rev, args->path,
trail, trail->pool));
src/subversion/subversion/libsvn_fs_base/lock.c view on Meta::CPAN
{
/* Sanity check: The lock token must exist, and must match. */
if (args->token == NULL)
return svn_fs_base__err_no_lock_token(trail->fs, args->path);
else if (strcmp(lock_token, args->token) != 0)
return SVN_FS__ERR_NO_SUCH_LOCK(trail->fs, args->path);
SVN_ERR(svn_fs_bdb__lock_get(&lock, trail->fs, lock_token,
trail, trail->pool));
/* There better be a username attached to the fs. */
if (!trail->fs->access_ctx || !trail->fs->access_ctx->username)
return SVN_FS__ERR_NO_USER(trail->fs);
/* And that username better be the same as the lock's owner. */
if (strcmp(trail->fs->access_ctx->username, lock->owner) != 0)
return SVN_FS__ERR_LOCK_OWNER_MISMATCH(
trail->fs,
trail->fs->access_ctx->username,
lock->owner);
}
src/subversion/subversion/libsvn_fs_base/lock.c view on Meta::CPAN
SVN_ERR(svn_stream_close(stream));
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* Utility function: verify that a lock can be used.
If no username is attached to the FS, return SVN_ERR_FS_NO_USER.
If the FS username doesn't match LOCK's owner, return
SVN_ERR_FS_LOCK_OWNER_MISMATCH.
If FS hasn't been supplied with a matching lock-token for LOCK,
return SVN_ERR_FS_BAD_LOCK_TOKEN.
Otherwise return SVN_NO_ERROR.
*/
static svn_error_t *
src/subversion/subversion/libsvn_fs_base/lock.c view on Meta::CPAN
{
/* Discover all locks at or below the path. */
SVN_ERR(svn_fs_bdb__locks_get(trail->fs, path, svn_depth_infinity,
get_locks_callback,
trail->fs, trail, pool));
}
else
{
svn_lock_t *lock;
/* Discover any lock attached to the path. */
SVN_ERR(svn_fs_base__get_lock_helper(&lock, path, trail, pool));
if (lock)
SVN_ERR(verify_lock(trail->fs, lock, pool));
}
return SVN_NO_ERROR;
}
src/subversion/subversion/libsvn_fs_base/tree.c view on Meta::CPAN
{
/* How do commits work in Subversion?
*
* When you're ready to commit, here's what you have:
*
* 1. A transaction, with a mutable tree hanging off it.
* 2. A base revision, against which TXN_TREE was made.
* 3. A latest revision, which may be newer than the base rev.
*
* The problem is that if latest != base, then one can't simply
* attach the txn root as the root of the new revision, because that
* would lose all the changes between base and latest. It is also
* not acceptable to insist that base == latest; in a busy
* repository, commits happen too fast to insist that everyone keep
* their entire tree up-to-date at all times. Non-overlapping
* changes should not interfere with each other.
*
* The solution is to merge the changes between base and latest into
* the txn tree [see the function merge()]. The txn tree is the
* only one of the three trees that is mutable, so it has to be the
* one to adjust.
src/subversion/subversion/libsvn_fs_fs/lock.c view on Meta::CPAN
wlb.fs = fs;
SVN_ERR(walk_digest_files(fs->path, digest_path, locks_walker, &wlb,
have_write_lock, pool));
return SVN_NO_ERROR;
}
/* Utility function: verify that a lock can be used. Interesting
errors returned from this function:
SVN_ERR_FS_NO_USER: No username attached to FS.
SVN_ERR_FS_LOCK_OWNER_MISMATCH: FS's username doesn't match LOCK's owner.
SVN_ERR_FS_BAD_LOCK_TOKEN: FS doesn't hold matching lock-token for LOCK.
*/
static svn_error_t *
verify_lock(svn_fs_t *fs,
svn_lock_t *lock,
apr_pool_t *pool)
{
if ((! fs->access_ctx) || (! fs->access_ctx->username))
return svn_error_createf
src/subversion/subversion/libsvn_fs_fs/lock.c view on Meta::CPAN
if (recurse)
{
/* Discover all locks at or below the path. */
const char *digest_path;
SVN_ERR(digest_path_from_path(&digest_path, fs->path, path, pool));
SVN_ERR(walk_locks(fs, digest_path, get_locks_callback,
fs, have_write_lock, pool));
}
else
{
/* Discover and verify any lock attached to the path. */
svn_lock_t *lock;
SVN_ERR(get_lock_helper(fs, &lock, path, have_write_lock, pool));
if (lock)
SVN_ERR(verify_lock(fs, lock, pool));
}
return SVN_NO_ERROR;
}
/* Baton used for lock_body below. */
struct lock_baton {
src/subversion/subversion/libsvn_fs_fs/lock.c view on Meta::CPAN
SVN_ERR_FS_OUT_OF_DATE, NULL,
_("Path '%s' doesn't exist in HEAD revision"),
lb->path);
else
return svn_error_createf(
SVN_ERR_FS_NOT_FOUND, NULL,
_("Path '%s' doesn't exist in HEAD revision"),
lb->path);
}
/* We need to have a username attached to the fs. */
if (!lb->fs->access_ctx || !lb->fs->access_ctx->username)
return SVN_FS__ERR_NO_USER(lb->fs);
/* Is the caller attempting to lock an out-of-date working file? */
if (SVN_IS_VALID_REVNUM(lb->current_rev))
{
svn_revnum_t created_rev;
SVN_ERR(svn_fs_fs__node_created_rev(&created_rev, root, lb->path,
pool));
src/subversion/subversion/libsvn_fs_fs/lock.c view on Meta::CPAN
/* This could return SVN_ERR_FS_BAD_LOCK_TOKEN or SVN_ERR_FS_LOCK_EXPIRED. */
SVN_ERR(get_lock(&lock, ub->fs, ub->path, TRUE, TRUE, pool));
/* Unless breaking the lock, we do some checks. */
if (! ub->break_lock)
{
/* Sanity check: the incoming token should match lock->token. */
if (strcmp(ub->token, lock->token) != 0)
return SVN_FS__ERR_NO_SUCH_LOCK(ub->fs, lock->path);
/* There better be a username attached to the fs. */
if (! (ub->fs->access_ctx && ub->fs->access_ctx->username))
return SVN_FS__ERR_NO_USER(ub->fs);
/* And that username better be the same as the lock's owner. */
if (strcmp(ub->fs->access_ctx->username, lock->owner) != 0)
return SVN_FS__ERR_LOCK_OWNER_MISMATCH(
ub->fs, ub->fs->access_ctx->username, lock->owner);
}
/* Remove lock and lock token files. */
src/subversion/subversion/libsvn_fs_fs/tree.c view on Meta::CPAN
{
/* How do commits work in Subversion?
*
* When you're ready to commit, here's what you have:
*
* 1. A transaction, with a mutable tree hanging off it.
* 2. A base revision, against which TXN_TREE was made.
* 3. A latest revision, which may be newer than the base rev.
*
* The problem is that if latest != base, then one can't simply
* attach the txn root as the root of the new revision, because that
* would lose all the changes between base and latest. It is also
* not acceptable to insist that base == latest; in a busy
* repository, commits happen too fast to insist that everyone keep
* their entire tree up-to-date at all times. Non-overlapping
* changes should not interfere with each other.
*
* The solution is to merge the changes between base and latest into
* the txn tree [see the function merge()]. The txn tree is the
* only one of the three trees that is mutable, so it has to be the
* one to adjust.
src/subversion/subversion/libsvn_fs_util/fs-util.c view on Meta::CPAN
/* The current character is NOT a '/'. If we were eating
slashes, we need not do that any more. */
if (eating_slashes)
eating_slashes = FALSE;
}
/* Copy the current character into our new buffer. */
newpath[newpath_i++] = path[path_i];
}
/* Did we leave a '/' attached to the end of NEWPATH (other than in
the root directory case)? */
if ((newpath[newpath_i - 1] == '/') && (newpath_i > 1))
newpath[newpath_i - 1] = '\0';
else
newpath[newpath_i] = '\0';
return newpath;
}
svn_error_t *
src/subversion/subversion/libsvn_ra_local/ra_plugin.c view on Meta::CPAN
static svn_error_t *
get_username(svn_ra_session_t *session,
apr_pool_t *scratch_pool)
{
svn_ra_local__session_baton_t *sess = session->priv;
/* If we've already found the username don't ask for it again. */
if (! sess->username)
{
/* Get a username somehow, so we have some svn:author property to
attach to a commit. */
if (sess->callbacks->auth_baton)
{
void *creds;
svn_auth_cred_username_t *username_creds;
svn_auth_iterstate_t *iterstate;
SVN_ERR(svn_auth_first_credentials(&creds, &iterstate,
SVN_AUTH_CRED_USERNAME,
sess->uuid, /* realmstring */
sess->callbacks->auth_baton,
src/subversion/subversion/libsvn_ra_local/ra_plugin.c view on Meta::CPAN
svn_error_clear(svn_auth_save_credentials(iterstate,
scratch_pool));
}
else
sess->username = "";
}
else
sess->username = "";
}
/* If we have a real username, attach it to the filesystem so that it can
be used to validate locks. Even if there already is a user context
associated, it may contain irrelevant lock tokens, so always create a new.
*/
if (*sess->username)
{
svn_fs_access_t *access_ctx;
SVN_ERR(svn_fs_create_access(&access_ctx, sess->username,
session->pool));
SVN_ERR(svn_fs_set_access(sess->fs, access_ctx));
src/subversion/subversion/libsvn_ra_local/ra_plugin.c view on Meta::CPAN
apr_array_header_t **inherited_props,
svn_ra_local__session_baton_t *sess,
svn_fs_root_t *root,
const char *path,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_revnum_t cmt_rev;
const char *cmt_date, *cmt_author;
/* Create a hash with props attached to the fs node. */
if (props)
{
SVN_ERR(svn_fs_node_proplist(props, root, path, result_pool));
}
/* Get inherited properties if requested. */
if (inherited_props)
{
SVN_ERR(svn_repos_fs_get_inherited_props(inherited_props, root, path,
NULL, NULL, NULL,
src/subversion/subversion/libsvn_ra_serf/inherited_props.c view on Meta::CPAN
apr_ltoa(pool, iprops_ctx->revision),
alloc);
svn_ra_serf__add_tag_buckets(body_bkt, "S:" SVN_DAV__PATH,
iprops_ctx->path, alloc);
svn_ra_serf__add_close_tag_buckets(body_bkt, alloc,
"S:" SVN_DAV__INHERITED_PROPS_REPORT);
*bkt = body_bkt;
return SVN_NO_ERROR;
}
/* Request a inherited-props-report from the URL attached to RA_SESSION,
and fill the IPROPS array hash with the results. */
svn_error_t *
svn_ra_serf__get_inherited_props(svn_ra_session_t *ra_session,
apr_array_header_t **iprops,
const char *path,
svn_revnum_t revision,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_error_t *err;
src/subversion/subversion/libsvn_ra_serf/ra_serf.h view on Meta::CPAN
apr_pool_t *pool);
/* Implements svn_ra__vtable_t.get_locks(). */
svn_error_t *
svn_ra_serf__get_locks(svn_ra_session_t *ra_session,
apr_hash_t **locks,
const char *path,
svn_depth_t depth,
apr_pool_t *pool);
/* Request a mergeinfo-report from the URL attached to SESSION,
and fill in the MERGEINFO hash with the results.
Implements svn_ra__vtable_t.get_mergeinfo().
*/
svn_error_t *
svn_ra_serf__get_mergeinfo(svn_ra_session_t *ra_session,
apr_hash_t **mergeinfo,
const apr_array_header_t *paths,
svn_revnum_t revision,
svn_mergeinfo_inheritance_t inherit,
src/subversion/subversion/libsvn_subr/cache-membuffer.c view on Meta::CPAN
* remembered in the setter function, an error will be returned.
*/
#ifdef SVN_DEBUG_CACHE_MEMBUFFER
/* The prefix passed to svn_cache__create_membuffer_cache() effectively
* defines the type of all items stored by that cache instance. We'll take
* the last 7 bytes + \0 as plaintext for easy identification by the dev.
*/
#define PREFIX_TAIL_LEN 8
/* This record will be attached to any cache entry. It tracks item data
* (content), key and type as hash values and is the baseline against which
* the getters will compare their results to detect inconsistencies.
*/
typedef struct entry_tag_t
{
/* MD5 checksum over the serialized the item data.
*/
unsigned char content_hash [APR_MD5_DIGESTSIZE];
/* Hash value of the svn_cache_t instance that wrote the item
src/subversion/subversion/libsvn_subr/deprecated.c view on Meta::CPAN
if (! first_time)
SVN_ERR(svn_cmdline_fputs(")", stream, pool));
if (help)
{
const apr_getopt_option_t *option;
svn_boolean_t have_options = FALSE;
SVN_ERR(svn_cmdline_fprintf(stream, pool, ": %s", _(cmd->help)));
/* Loop over all valid option codes attached to the subcommand */
for (i = 0; i < SVN_OPT_MAX_OPTIONS; i++)
{
if (cmd->valid_options[i])
{
if (!have_options)
{
SVN_ERR(svn_cmdline_fputs(_("\nValid options:\n"),
stream, pool));
have_options = TRUE;
}
src/subversion/subversion/libsvn_subr/opt.c view on Meta::CPAN
SVN_ERR(svn_cmdline_fputs(")", stream, pool));
if (help)
{
const apr_getopt_option_t *option;
const char *long_alias;
svn_boolean_t have_options = FALSE;
SVN_ERR(svn_cmdline_fprintf(stream, pool, ": %s", _(cmd->help)));
/* Loop over all valid option codes attached to the subcommand */
for (i = 0; i < SVN_OPT_MAX_OPTIONS; i++)
{
if (cmd->valid_options[i])
{
if (!have_options)
{
SVN_ERR(svn_cmdline_fputs(_("\nValid options:\n"),
stream, pool));
have_options = TRUE;
}
src/subversion/subversion/libsvn_subr/prompt.c view on Meta::CPAN
/* Allocate and open *TERMINAL. If NOECHO is TRUE, try to turn off
terminal echo. Use POOL for all allocations.*/
static svn_error_t *
terminal_open(terminal_handle_t **terminal, svn_boolean_t noecho,
apr_pool_t *pool)
{
apr_status_t status;
#ifdef WIN32
/* On Windows, we'll use the console API directly if the process has
a console attached; otherwise we'll just use stdin and stderr. */
const HANDLE conin = CreateFileW(L"CONIN$", GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
*terminal = apr_palloc(pool, sizeof(terminal_handle_t));
if (conin != INVALID_HANDLE_VALUE)
{
/* The process has a console. */
CloseHandle(conin);
terminal_handle_init(*terminal, NULL, NULL, noecho, FALSE, NULL);
src/subversion/subversion/libsvn_subr/win32_crashrpt.c view on Meta::CPAN
write_function_detail(stack_frame, i, log_file);
}
}
i++;
}
#else
#error Unknown processortype, please disable SVN_USE_WIN32_CRASHHANDLER
#endif
}
/* Check if a debugger is attached to this process */
static BOOL
is_debugger_present()
{
HANDLE kernel32_dll = LoadLibrary("kernel32.dll");
BOOL result;
ISDEBUGGERPRESENT IsDebuggerPresent_ =
(ISDEBUGGERPRESENT)GetProcAddress(kernel32_dll, "IsDebuggerPresent");
if (IsDebuggerPresent_ && IsDebuggerPresent_())
src/subversion/subversion/libsvn_wc/wc-metadata.sql view on Meta::CPAN
/* ------------------------------------------------------------------------- */
/* Format 99 drops all columns not needed due to previous format upgrades.
Before we release 1.7, these statements will be pulled into a format bump
and all the tables will be cleaned up. We don't know what that format
number will be, however, so we're just marking it as 99 for now. */
-- format: 99
/* TODO: Un-confuse *_revision column names in the EXTERNALS table to
"-r<operative> foo@<peg>", as suggested by the patch attached to
http://svn.haxx.se/dev/archive-2011-09/0478.shtml */
/* TODO: Remove column parent_relpath from EXTERNALS. We're not using it and
never will. It's not interesting like in the NODES table: the external's
parent path may be *anything*: unversioned, "behind" a another WC... */
/* Now "drop" the tree_conflict_data column from actual_node. */
CREATE TABLE ACTUAL_NODE_BACKUP (
wc_id INTEGER NOT NULL,
local_relpath TEXT NOT NULL,
parent_relpath TEXT,
src/subversion/subversion/mod_dav_svn/dav_svn.h view on Meta::CPAN
/*** deadprops.c ***/
extern const dav_hooks_propdb dav_svn__hooks_propdb;
/*** lock.c ***/
extern const dav_hooks_locks dav_svn__hooks_locks;
/*** version.c ***/
/* For an autoversioning commit, a helper function which attaches an
auto-generated 'svn:log' property to a txn, as well as a property
that indicates the revision was made via autoversioning. */
svn_error_t *
dav_svn__attach_auto_revprops(svn_fs_txn_t *txn,
const char *fs_path,
apr_pool_t *pool);
/* Hook function of types 'checkout' and 'checkin', as defined in
mod_dav.h's versioning provider hooks table (see dav_hooks_vsn). */
dav_error *
dav_svn__checkout(dav_resource *resource,
int auto_checkout,
int is_unreserved,
( run in 1.572 second using v1.01-cache-2.11-cpan-e1769b4cff6 )