static svn_error_t *
split_url_syntax(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
apr_status_t apr_err;
*msg = "svn_ra_local__split_URL: syntax validation";
if (msg_only)
return SVN_NO_ERROR;
/* TEST 1: Make sure we can recognize bad URLs (this should not
require a filesystem) */
/* Use `blah' for scheme instead of `file' */
apr_err = try_split_url("blah:///bin/svn", pool);
if (apr_err != SVN_ERR_RA_ILLEGAL_URL)
return svn_error_create
(SVN_ERR_TEST_FAILED, NULL,
"svn_ra_local__split_URL failed to catch bad URL (scheme)");
/* Use only single slash after scheme */
apr_err = try_split_url("file:/path/to/repos", pool);
if (apr_err != SVN_ERR_RA_ILLEGAL_URL)
return svn_error_create
(SVN_ERR_TEST_FAILED, NULL,
"svn_ra_local__split_URL failed to catch bad URL (slashes)");
/* Use only a hostname, with no path */
apr_err = try_split_url("file://hostname", pool);
if (apr_err != SVN_ERR_RA_ILLEGAL_URL)
return svn_error_create
(SVN_ERR_TEST_FAILED, NULL,
"svn_ra_local__split_URL failed to catch bad URL (no path)");
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_fs__dag_set_entry(dag_node_t *node,
const char *entry_name,
const svn_fs_id_t *id,
svn_node_kind_t kind,
const char *txn_id,
apr_pool_t *pool)
{
/* Check it's a directory. */
if (node->kind != svn_node_dir)
return svn_error_create
(SVN_ERR_FS_NOT_DIRECTORY, NULL,
_("Attempted to set entry in non-directory node"));
/* Check it's mutable. */
if (! svn_fs_fs__dag_check_mutable(node))
return svn_error_create
(SVN_ERR_FS_NOT_MUTABLE, NULL,
_("Attempted to set entry in immutable node"));
return set_entry(node, entry_name, id, kind, txn_id, pool);
}
svn_error_t *
svn_spillbuf__reader_getc(char *c,
svn_spillbuf_reader_t *reader,
apr_pool_t *scratch_pool)
{
apr_size_t amt;
SVN_ERR(svn_spillbuf__reader_read(&amt, reader, c, 1, scratch_pool));
if (amt == 0)
return svn_error_create(SVN_ERR_STREAM_UNEXPECTED_EOF, NULL, NULL);
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_neon__replay_range(svn_ra_session_t *session,
svn_revnum_t start_revision,
svn_revnum_t end_revision,
svn_revnum_t low_water_mark,
svn_boolean_t send_deltas,
svn_ra_replay_revstart_callback_t revstart_func,
svn_ra_replay_revfinish_callback_t revfinish_func,
void *replay_baton,
apr_pool_t *pool)
{
return svn_error_create(SVN_ERR_RA_NOT_IMPLEMENTED, NULL, NULL);
}
static svn_error_t *
reconcile_errors(svn_error_t *commit_err,
svn_error_t *unlock_err,
svn_error_t *bump_err,
apr_pool_t *pool)
{
svn_error_t *err;
/* Early release (for good behavior). */
if (! (commit_err || unlock_err || bump_err))
return SVN_NO_ERROR;
/* If there was a commit error, start off our error chain with
that. */
if (commit_err)
{
commit_err = svn_error_quick_wrap
(commit_err, _("Commit failed (details follow):"));
err = commit_err;
}
/* Else, create a new "general" error that will lead off the errors
that follow. */
else
err = svn_error_create(SVN_ERR_BASE, NULL,
_("Commit succeeded, but other errors follow:"));
/* If there was an unlock error... */
if (unlock_err)
{
/* Wrap the error with some headers. */
unlock_err = svn_error_quick_wrap
(unlock_err, _("Error unlocking locked dirs (details follow):"));
/* Append this error to the chain. */
svn_error_compose(err, unlock_err);
}
/* If there was a bumping error... */
if (bump_err)
{
/* Wrap the error with some headers. */
bump_err = svn_error_quick_wrap
(bump_err, _("Error bumping revisions post-commit (details follow):"));
/* Append this error to the chain. */
svn_error_compose(err, bump_err);
}
return err;
}
svn_error_t *
svn_cl__make_log_msg_baton(void **baton,
svn_cl__opt_state_t *opt_state,
const char *base_dir /* UTF-8! */,
apr_hash_t *config,
apr_pool_t *pool)
{
struct log_msg_baton *lmb = apr_palloc(pool, sizeof(*lmb));
if (opt_state->filedata)
{
if (strlen(opt_state->filedata->data) < opt_state->filedata->len)
{
/* The data contains a zero byte, and therefore can't be
represented as a C string. Punt now; it's probably not
a deliberate encoding, and even if it is, we still
can't handle it. */
return svn_error_create(SVN_ERR_CL_BAD_LOG_MESSAGE, NULL,
_("Log message contains a zero byte"));
}
lmb->message = opt_state->filedata->data;
}
else
{
lmb->message = opt_state->message;
}
lmb->editor_cmd = opt_state->editor_cmd;
if (opt_state->encoding)
{
lmb->message_encoding = opt_state->encoding;
}
else if (config)
{
svn_config_t *cfg = apr_hash_get(config, SVN_CONFIG_CATEGORY_CONFIG,
APR_HASH_KEY_STRING);
svn_config_get(cfg, &(lmb->message_encoding),
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_LOG_ENCODING,
NULL);
}
lmb->base_dir = base_dir ? base_dir : "";
lmb->tmpfile_left = NULL;
lmb->config = config;
lmb->keep_locks = opt_state->no_unlock;
lmb->non_interactive = opt_state->non_interactive;
lmb->pool = pool;
*baton = lmb;
return SVN_NO_ERROR;
}
/*
* ASN.1 DER decoding routines
*/
static svn_error_t *
asn1_get_len(const unsigned char **p, const unsigned char *end,
ptrdiff_t *len)
{
if ((end - *p) < 1)
return svn_error_create(SVN_ERR_ASN1_OUT_OF_DATA, NULL, NULL);
if ((**p & 0x80) == 0)
*len = *(*p)++;
else
switch (**p & 0x7F)
{
case 1:
if ((end - *p) < 2)
return svn_error_create(SVN_ERR_ASN1_OUT_OF_DATA, NULL, NULL);
*len = (*p)[1];
(*p) += 2;
break;
case 2:
if ((end - *p) < 3)
return svn_error_create(SVN_ERR_ASN1_OUT_OF_DATA, NULL, NULL);
*len = ((*p)[1] << 8) | (*p)[2];
(*p) += 3;
break;
default:
return svn_error_create(SVN_ERR_ASN1_INVALID_LENGTH, NULL, NULL);
break;
}
if (*len > (end - *p))
return svn_error_create(SVN_ERR_ASN1_OUT_OF_DATA, NULL, NULL);
return SVN_NO_ERROR;
}
/* For HTTPv1 servers, do a PROPFIND dance on the VCC to fetch the youngest
revnum. If BASECOLL_URL is non-NULL, then the corresponding baseline
collection URL is also returned.
Do the work over CONN.
*BASECOLL_URL (if requested) will be allocated in RESULT_POOL. All
temporary allocations will be made in SCRATCH_POOL. */
static svn_error_t *
v1_get_youngest_revnum(svn_revnum_t *youngest,
const char **basecoll_url,
svn_ra_serf__session_t *session,
const char *vcc_url,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *baseline_url;
const char *bc_url;
/* Fetching DAV:checked-in from the VCC (with no Label: to specify a
revision) will return the latest Baseline resource's URL. */
SVN_ERR(svn_ra_serf__fetch_dav_prop(&baseline_url, session, vcc_url,
SVN_INVALID_REVNUM,
"checked-in",
scratch_pool, scratch_pool));
if (!baseline_url)
{
return svn_error_create(SVN_ERR_RA_DAV_OPTIONS_REQ_FAILED, NULL,
_("The OPTIONS response did not include "
"the requested checked-in value"));
}
baseline_url = svn_urlpath__canonicalize(baseline_url, scratch_pool);
/* From the Baseline resource, we can fetch the DAV:baseline-collection
and DAV:version-name properties. The latter is the revision number,
which is formally the name used in Label: headers. */
/* First check baseline information cache. */
SVN_ERR(svn_ra_serf__blncache_get_baseline_info(&bc_url,
youngest,
session->blncache,
baseline_url,
scratch_pool));
if (!bc_url)
{
SVN_ERR(retrieve_baseline_info(youngest, &bc_url, session,
baseline_url, SVN_INVALID_REVNUM,
scratch_pool, scratch_pool));
SVN_ERR(svn_ra_serf__blncache_set(session->blncache,
baseline_url, *youngest,
bc_url, scratch_pool));
}
if (basecoll_url != NULL)
*basecoll_url = apr_pstrdup(result_pool, bc_url);
return SVN_NO_ERROR;
}
/* Parse the conflict info fields from SKEL into *VERSION_INFO. */
static svn_error_t *
read_node_version_info(const svn_wc_conflict_version_t **version_info,
const svn_skel_t *skel,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
int n;
const char *repos_root;
const char *repos_relpath;
svn_revnum_t peg_rev;
svn_node_kind_t kind;
if (!is_valid_version_info_skel(skel))
return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
_("Invalid version info in tree conflict "
"description"));
repos_root = apr_pstrmemdup(scratch_pool,
skel->children->next->data,
skel->children->next->len);
if (*repos_root == '\0')
{
*version_info = NULL;
return SVN_NO_ERROR;
}
/* Apply the Subversion 1.7+ url canonicalization rules to a pre 1.7 url */
repos_root = svn_uri_canonicalize(repos_root, result_pool);
peg_rev = SVN_STR_TO_REV(apr_pstrmemdup(scratch_pool,
skel->children->next->next->data,
skel->children->next->next->len));
repos_relpath = apr_pstrmemdup(result_pool,
skel->children->next->next->next->data,
skel->children->next->next->next->len);
SVN_ERR(read_enum_field(&n, node_kind_map,
skel->children->next->next->next->next));
kind = (svn_node_kind_t)n;
*version_info = svn_wc_conflict_version_create2(repos_root,
NULL,
repos_relpath,
peg_rev,
kind,
result_pool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_fs_unlock(svn_repos_t *repos,
const char *path,
const char *token,
svn_boolean_t break_lock,
apr_pool_t *pool)
{
svn_error_t *err;
svn_fs_access_t *access_ctx = NULL;
const char *username = NULL;
apr_array_header_t *paths;
apr_hash_t *hooks_env;
/* Parse the hooks-env file (if any). */
SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, repos->hooks_env_path,
pool, pool));
/* Setup an array of paths in anticipation of the ra layers handling
multiple locks in one request (1.3 most likely). This is only
used by svn_repos__hooks_post_lock. */
paths = apr_array_make(pool, 1, sizeof(const char *));
APR_ARRAY_PUSH(paths, const char *) = path;
SVN_ERR(svn_fs_get_access(&access_ctx, repos->fs));
if (access_ctx)
SVN_ERR(svn_fs_access_get_username(&username, access_ctx));
if (! break_lock && ! username)
return svn_error_createf
(SVN_ERR_FS_NO_USER, NULL,
_("Cannot unlock path '%s', no authenticated username available"),
path);
/* Run pre-unlock hook. This could throw error, preventing
svn_fs_unlock() from happening. */
SVN_ERR(svn_repos__hooks_pre_unlock(repos, hooks_env, path, username, token,
break_lock, pool));
/* Unlock. */
SVN_ERR(svn_fs_unlock(repos->fs, path, token, break_lock, pool));
/* Run post-unlock hook. */
if ((err = svn_repos__hooks_post_unlock(repos, hooks_env, paths,
username, pool)))
return svn_error_create
(SVN_ERR_REPOS_POST_UNLOCK_HOOK_FAILED, err,
_("Unlock succeeded, but post-unlock hook failed"));
return SVN_NO_ERROR;
}
/**
* a quick way to create error messages
*/
static void
fail(apr_pool_t *pool, apr_status_t status, const char *fmt, ...)
{
va_list ap;
char *msg;
svn_error_t * error;
va_start(ap, fmt);
msg = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
error = svn_error_create(status, nullptr, msg);
throw ClientException(error);
}
static svn_error_t *
start_gls(svn_ra_serf__xml_parser_t *parser,
void *userData,
svn_ra_serf__dav_props_t name,
const char **attrs)
{
gls_context_t *gls_ctx = userData;
if ((! gls_ctx->inside_report)
&& strcmp(name.name, "get-location-segments-report") == 0)
{
gls_ctx->inside_report = TRUE;
}
else if (gls_ctx->inside_report
&& strcmp(name.name, "location-segment") == 0)
{
const char *rev_str;
svn_revnum_t range_start = SVN_INVALID_REVNUM;
svn_revnum_t range_end = SVN_INVALID_REVNUM;
const char *path = NULL;
path = svn_xml_get_attr_value("path", attrs);
rev_str = svn_xml_get_attr_value("range-start", attrs);
if (rev_str)
range_start = SVN_STR_TO_REV(rev_str);
rev_str = svn_xml_get_attr_value("range-end", attrs);
if (rev_str)
range_end = SVN_STR_TO_REV(rev_str);
if (SVN_IS_VALID_REVNUM(range_start) && SVN_IS_VALID_REVNUM(range_end))
{
svn_location_segment_t *segment = apr_pcalloc(gls_ctx->subpool,
sizeof(*segment));
segment->path = path;
segment->range_start = range_start;
segment->range_end = range_end;
SVN_ERR(gls_ctx->receiver(segment,
gls_ctx->receiver_baton,
gls_ctx->subpool));
svn_pool_clear(gls_ctx->subpool);
}
else
{
return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
_("Expected valid revision range"));
}
}
return SVN_NO_ERROR;
}
/* This implements svn_editor_cb_add_absent_t */
static svn_error_t *
add_absent_cb(void *baton,
const char *relpath,
svn_node_kind_t kind,
svn_revnum_t replaces_rev,
apr_pool_t *scratch_pool)
{
/* This is a programming error. Code should not attempt to create these
kinds of nodes within the FS. */
/* ### use a custom error code */
return svn_error_create(
SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("The filesystem does not support 'absent' nodes"));
}
/* Display a prompt and read a one-line response into the provided buffer,
removing a trailing newline if present. */
static svn_error_t *
prompt_and_read_line(const char *prompt,
char *buffer,
size_t max)
{
int len;
printf("%s: ", prompt);
if (fgets(buffer, max, stdin) == NULL)
return svn_error_create(0, NULL, "error reading stdin");
len = strlen(buffer);
if (len > 0 && buffer[len-1] == '\n')
buffer[len-1] = 0;
return SVN_NO_ERROR;
}
/* Loads the properties of a node to a temporary file */
static svn_error_t *delta_load_properties(de_node_baton_t *node)
{
char *filename;
apr_file_t *file = NULL;
apr_status_t status;
apr_pool_t *pool = svn_pool_create(node->pool);
filename = rhash_get(prop_hash, node->path, APR_HASH_KEY_STRING);
if (filename == NULL) {
/* No properties is ok, too */
svn_pool_destroy(pool);
return SVN_NO_ERROR;
}
status = apr_file_open(&file, filename, APR_READ, 0600, pool);
if (status) {
apr_pool_t *epool = svn_pool_create(NULL);
char *errbuf = apr_palloc(epool, ERRBUFFER_SIZE);
svn_pool_destroy(pool);
return svn_error_create(status, NULL, apr_strerror(status, errbuf, ERRBUFFER_SIZE));
}
if (property_hash_load(node->properties, file, node->pool)) {
apr_file_close(file);
DEBUG_MSG("ERROR reading from %s\n", filename);
return svn_error_create(1, NULL, "Error reading properties file");
}
apr_file_close(file);
/* Delete the old file if it exists */
apr_file_remove(filename, pool);
rhash_set(prop_hash, node->path, APR_HASH_KEY_STRING, NULL, 0);
svn_pool_destroy(pool);
return SVN_NO_ERROR;
}
static svn_error_t *
change_txn_prop(svn_fs_txn_t *txn,
const char *propname,
const svn_string_t *value,
apr_pool_t *scratch_pool)
{
if (strcmp(propname, SVN_PROP_REVISION_AUTHOR) == 0)
return svn_error_create(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
"Attempted to modify 'svn:author' property "
"on a transaction");
SVN_ERR(svn_repos_fs_change_txn_prop(txn, propname, value, scratch_pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_x__dag_dir_entries(apr_hash_t **entries,
dag_node_t *node,
apr_pool_t *pool)
{
node_revision_t *noderev;
SVN_ERR(get_node_revision(&noderev, node));
if (noderev->kind != svn_node_dir)
return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,
_("Can't get entries of non-directory"));
return svn_fs_x__rep_contents_dir(entries, node->fs, noderev, pool);
}
/* Don't call this function directly! Use svn_atomic__init_once(). */
static svn_error_t *
init_sqlite(void *baton, apr_pool_t *pool)
{
if (sqlite3_libversion_number() < SQLITE_VERSION_NUMBER)
{
return svn_error_createf(
SVN_ERR_SQLITE_ERROR, NULL,
_("SQLite compiled for %s, but running with %s"),
SQLITE_VERSION, sqlite3_libversion());
}
#if APR_HAS_THREADS
/* SQLite 3.5 allows verification of its thread-safety at runtime.
Older versions are simply expected to have been configured with
--enable-threadsafe, which compiles with -DSQLITE_THREADSAFE=1
(or -DTHREADSAFE, for older versions). */
if (! sqlite3_threadsafe())
return svn_error_create(SVN_ERR_SQLITE_ERROR, NULL,
_("SQLite is required to be compiled and run in "
"thread-safe mode"));
/* If SQLite has been already initialized, sqlite3_config() returns
SQLITE_MISUSE. */
{
int err = sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
if (err != SQLITE_OK && err != SQLITE_MISUSE)
return svn_error_create(SQLITE_ERROR_CODE(err), NULL,
_("Could not configure SQLite"));
}
SQLITE_ERR_MSG(sqlite3_initialize(), _("Could not initialize SQLite"));
#endif /* APR_HAS_THRADS */
return SVN_NO_ERROR;
}
static svn_error_t *
rollback_transaction(svn_sqlite__db_t *db,
svn_error_t *error_to_wrap)
{
svn_sqlite__stmt_t *stmt;
svn_error_t *err;
err = get_internal_statement(&stmt, db, STMT_INTERNAL_ROLLBACK_TRANSACTION);
if (!err)
{
err = svn_error_trace(svn_sqlite__step_done(stmt));
if (err && err->apr_err == SVN_ERR_SQLITE_BUSY)
{
/* ### Houston, we have a problem!
We are trying to rollback but we can't because some
statements are still busy. This leaves the database
unusable for future transactions as the current transaction
is still open.
As we are returning the actual error as the most relevant
error in the chain, our caller might assume that it can
retry/compensate on this error (e.g. SVN_WC_LOCKED), while
in fact the SQLite database is unusable until the statements
started within this transaction are reset and the transaction
aborted.
We try to compensate by resetting all prepared but unreset
statements; but we leave the busy error in the chain anyway to
help diagnosing the original error and help in finding where
a reset statement is missing. */
err = svn_error_trace(reset_all_statements(db, err));
err = svn_error_compose_create(
svn_error_trace(svn_sqlite__step_done(stmt)),
err);
}
}
if (err)
{
/* Rollback failed, use a specific error code. */
err = svn_error_create(SVN_SQLITE__ERR_ROLLBACK_FAILED, err,
_("SQLite transaction rollback failed"));
}
return svn_error_compose_create(error_to_wrap, err);
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__cat(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
apr_array_header_t *targets;
int i;
svn_stream_t *out;
apr_pool_t *subpool = svn_pool_create(pool);
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, pool));
/* Cat cannot operate on an implicit '.' so a filename is required */
if (! targets->nelts)
return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL);
SVN_ERR(svn_stream_for_stdout(&out, pool));
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
const char *truepath;
svn_opt_revision_t peg_revision;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Get peg revisions. */
SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target,
subpool));
SVN_ERR(svn_cl__try(svn_client_cat2(out, truepath, &peg_revision,
&(opt_state->start_revision),
ctx, subpool),
NULL, opt_state->quiet,
SVN_ERR_UNVERSIONED_RESOURCE,
SVN_ERR_ENTRY_NOT_FOUND,
SVN_ERR_CLIENT_IS_DIRECTORY,
SVN_NO_ERROR));
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* Parse the enumeration value in VALUE into a plain
* 'int', using MAP to convert from strings to enumeration values.
* In MAP, a null .str field marks the end of the map.
*/
static svn_error_t *
read_enum_field(int *result,
const svn_token_map_t *map,
const svn_skel_t *skel)
{
int value = svn_token__from_mem(map, skel->data, skel->len);
if (value == SVN_TOKEN_UNKNOWN)
return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
_("Unknown enumeration value in tree conflict "
"description"));
*result = value;
return SVN_NO_ERROR;
}
svn_error_t *
svn_sqlite__exec(svn_sqlite__db_t *db, const char *sql)
{
char *err_msg;
int sqlite_err = sqlite3_exec(db->db3, sql, NULL, NULL, &err_msg);
if (sqlite_err != SQLITE_OK)
{
svn_error_t *err = svn_error_create(SQLITE_ERROR_CODE(sqlite_err), NULL,
err_msg);
sqlite3_free(err_msg);
return err;
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_verify_no_work(svn_sqlite__db_t *sdb)
{
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_LOOK_FOR_WORK));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
SVN_ERR(svn_sqlite__reset(stmt));
if (have_row)
return svn_error_create(SVN_ERR_WC_CLEANUP_REQUIRED, NULL,
NULL /* nothing to add. */);
return SVN_NO_ERROR;
}
static svn_error_t *
stream_write(svn_stream_t *out,
const char *data,
apr_size_t len)
{
apr_size_t write_len = len;
/* We're gonna bail on an incomplete write here only because we know
that this stream is really stdout, which should never be blocking
on us. */
SVN_ERR(svn_stream_write(out, data, &write_len));
if (write_len != len)
return svn_error_create(SVN_ERR_STREAM_UNEXPECTED_EOF, NULL,
_("Error writing to stream"));
return SVN_NO_ERROR;
}
/* Implements svn_cache__deserialize_func_t */
static svn_error_t *
deserialize_id(void **out,
const char *data,
apr_size_t data_len,
apr_pool_t *pool)
{
svn_fs_id_t *id = svn_fs_fs__id_parse(data, data_len, pool);
if (id == NULL)
{
return svn_error_create(SVN_ERR_FS_NOT_ID, NULL,
_("Bad ID in cache"));
}
*out = id;
return SVN_NO_ERROR;
}
/* Go up the directory tree from LOCAL_ABSPATH, looking for a versioned
* directory. If found, return its path in *EXISTING_PARENT_ABSPATH.
* Otherwise, return SVN_ERR_CLIENT_NO_VERSIONED_PARENT. */
static svn_error_t *
find_existing_parent(const char **existing_parent_abspath,
svn_client_ctx_t *ctx,
const char *local_abspath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_node_kind_t kind;
const char *parent_abspath;
svn_wc_context_t *wc_ctx = ctx->wc_ctx;
SVN_ERR(svn_wc_read_kind(&kind, wc_ctx, local_abspath, FALSE, scratch_pool));
if (kind == svn_node_dir)
{
svn_boolean_t is_deleted;
SVN_ERR(svn_wc__node_is_status_deleted(&is_deleted,
wc_ctx, local_abspath,
scratch_pool));
if (!is_deleted)
{
*existing_parent_abspath = apr_pstrdup(result_pool, local_abspath);
return SVN_NO_ERROR;
}
}
if (svn_dirent_is_root(local_abspath, strlen(local_abspath)))
return svn_error_create(SVN_ERR_CLIENT_NO_VERSIONED_PARENT, NULL, NULL);
if (svn_wc_is_adm_dir(svn_dirent_basename(local_abspath, scratch_pool),
scratch_pool))
return svn_error_createf(SVN_ERR_RESERVED_FILENAME_SPECIFIED, NULL,
_("'%s' ends in a reserved name"),
svn_dirent_local_style(local_abspath,
scratch_pool));
parent_abspath = svn_dirent_dirname(local_abspath, scratch_pool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
SVN_ERR(find_existing_parent(existing_parent_abspath, ctx, parent_abspath,
result_pool, scratch_pool));
return SVN_NO_ERROR;
}
static svn_error_t *
write_rep(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
struct rep_args new_args;
struct rep_args args;
const char *new_rep = "((fulltext 0 ) a83t2Z0q)";
const char *rep = "((fulltext 0 ) kfogel31337)";
svn_fs_t *fs;
*msg = "write a new rep, then overwrite it";
if (msg_only)
return SVN_NO_ERROR;
/* Create a new fs and repos */
SVN_ERR(svn_test__create_fs
(&fs, "test-repo-write-rep",
"bdb", pool));
/* Set up transaction baton */
new_args.fs = fs;
new_args.skel = svn_fs_base__parse_skel(new_rep, strlen(new_rep), pool);
new_args.key = NULL;
/* Write new rep to reps table. */
SVN_ERR(svn_fs_base__retry_txn(new_args.fs,
txn_body_write_new_rep, &new_args, pool));
/* Make sure we got a valid key. */
if (new_args.key == NULL)
return svn_error_create(SVN_ERR_FS_GENERAL, NULL,
"error writing new representation");
/* Set up transaction baton for re-writing reps. */
args.fs = new_args.fs;
args.skel = svn_fs_base__parse_skel(rep, strlen(rep), pool);
args.key = new_args.key;
/* Overwrite first rep in reps table. */
SVN_ERR(svn_fs_base__retry_txn(new_args.fs,
txn_body_write_rep, &args, pool));
return SVN_NO_ERROR;
}
/* This implements `svn_opt_subcommand_t'. */
static svn_error_t *
subcommand_index (apr_getopt_t *os, void *baton, apr_pool_t *pool)
{
struct svnindex_opt_state *opt_state = baton;
svn_repos_t *repos;
svn_fs_t *fs;
svn_stream_t *stderr_stream = NULL;
struct recode_write_baton stderr_stream_rwb = { 0 };
svn_revnum_t lower = SVN_INVALID_REVNUM, upper = SVN_INVALID_REVNUM;
svn_revnum_t youngest;
SVN_ERR (open_repos (&repos, opt_state->repository_path, pool));
fs = svn_repos_fs (repos);
SVN_ERR (svn_fs_youngest_rev (&youngest, fs, pool));
/* Find the revision numbers at which to start and end. */
SVN_ERR (get_revnum (&lower, &opt_state->start_revision,
youngest, repos, pool));
SVN_ERR (get_revnum (&upper, &opt_state->end_revision,
youngest, repos, pool));
if (lower > upper)
return svn_error_create
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("First revision cannot be higher than second"));
/* Progress feedback goes to stderr, unless they asked to suppress
it. */
if (! opt_state->quiet)
{
stderr_stream = svn_stream_create (&stderr_stream_rwb, pool);
stderr_stream_rwb.pool = pool;
stderr_stream_rwb.out = stderr;
svn_stream_set_write (stderr_stream, recode_write);
}
SVN_ERR (svnindex__index (repos,
stderr_stream,
lower, upper,
opt_state->verbose,
opt_state->db,
check_cancel,
NULL,
pool));
return SVN_NO_ERROR;
}
/* Implements svn_cache__deserialize_func_t */
static svn_error_t *
deserialize_revnum(void **out,
void *data,
apr_size_t data_len,
apr_pool_t *pool)
{
const svn_revnum_t *in_rev = (const svn_revnum_t *) data;
svn_revnum_t *out_rev;
if (data_len != sizeof(*in_rev))
return svn_error_create(SVN_ERR_REVNUM_PARSE_FAILURE, NULL,
_("Bad size for revision number in cache"));
out_rev = apr_palloc(pool, sizeof(*out_rev));
*out_rev = *in_rev;
*out = out_rev;
return SVN_NO_ERROR;
}
static svn_error_t *initialize(void *baton, apr_pool_t *pool)
{
int result;
SVN_ERR(svn_ra_svn__sasl_common_init(pool));
/* The second parameter tells SASL to look for a configuration file
named subversion.conf. */
result = sasl_server_init(callbacks, SVN_RA_SVN_SASL_NAME);
if (result != SASL_OK)
{
svn_error_t *err = svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
sasl_errstring(result, NULL, NULL));
return svn_error_quick_wrap(err,
_("Could not initialize the SASL library"));
}
return SVN_NO_ERROR;
}
