/* Helper for svn_repos_dump_fs.
Write a revision record of REV in FS to writable STREAM, using POOL.
*/
static svn_error_t *
write_revision_record(svn_stream_t *stream,
svn_fs_t *fs,
svn_revnum_t rev,
apr_pool_t *pool)
{
apr_size_t len;
apr_hash_t *props;
svn_stringbuf_t *encoded_prophash;
apr_time_t timetemp;
svn_string_t *datevalue;
svn_stream_t *propstream;
/* Read the revision props even if we're aren't going to dump
them for verification purposes */
SVN_ERR(svn_fs_revision_proplist(&props, fs, rev, pool));
/* Run revision date properties through the time conversion to
canonicalize them. */
/* ### Remove this when it is no longer needed for sure. */
datevalue = apr_hash_get(props, SVN_PROP_REVISION_DATE,
APR_HASH_KEY_STRING);
if (datevalue)
{
SVN_ERR(svn_time_from_cstring(&timetemp, datevalue->data, pool));
datevalue = svn_string_create(svn_time_to_cstring(timetemp, pool),
pool);
apr_hash_set(props, SVN_PROP_REVISION_DATE, APR_HASH_KEY_STRING,
datevalue);
}
encoded_prophash = svn_stringbuf_create_ensure(0, pool);
propstream = svn_stream_from_stringbuf(encoded_prophash, pool);
SVN_ERR(svn_hash_write2(props, propstream, "PROPS-END", pool));
SVN_ERR(svn_stream_close(propstream));
/* ### someday write a revision-content-checksum */
SVN_ERR(svn_stream_printf(stream, pool,
SVN_REPOS_DUMPFILE_REVISION_NUMBER
": %ld\n", rev));
SVN_ERR(svn_stream_printf(stream, pool,
SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n",
encoded_prophash->len));
/* Write out a regular Content-length header for the benefit of
non-Subversion RFC-822 parsers. */
SVN_ERR(svn_stream_printf(stream, pool,
SVN_REPOS_DUMPFILE_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n\n",
encoded_prophash->len));
len = encoded_prophash->len;
SVN_ERR(svn_stream_write(stream, encoded_prophash->data, &len));
len = 1;
return svn_stream_write(stream, "\n", &len);
}
/* Print dumpstream-formatted information about REVISION.
* Implements the `svn_ra_replay_revstart_callback_t' interface.
*/
static svn_error_t *
replay_revstart(svn_revnum_t revision,
void *replay_baton,
const svn_delta_editor_t **editor,
void **edit_baton,
apr_hash_t *rev_props,
apr_pool_t *pool)
{
struct replay_baton *rb = replay_baton;
apr_hash_t *normal_props;
svn_stringbuf_t *propstring;
svn_stream_t *stdout_stream;
svn_stream_t *revprop_stream;
SVN_ERR(svn_stream_for_stdout(&stdout_stream, pool));
/* Revision-number: 19 */
SVN_ERR(svn_stream_printf(stdout_stream, pool,
SVN_REPOS_DUMPFILE_REVISION_NUMBER
": %ld\n", revision));
SVN_ERR(svn_rdump__normalize_props(&normal_props, rev_props, pool));
propstring = svn_stringbuf_create_ensure(0, pool);
revprop_stream = svn_stream_from_stringbuf(propstring, pool);
SVN_ERR(svn_hash_write2(normal_props, revprop_stream, "PROPS-END", pool));
SVN_ERR(svn_stream_close(revprop_stream));
/* Prop-content-length: 13 */
SVN_ERR(svn_stream_printf(stdout_stream, pool,
SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n", propstring->len));
/* Content-length: 29 */
SVN_ERR(svn_stream_printf(stdout_stream, pool,
SVN_REPOS_DUMPFILE_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n\n", propstring->len));
/* Property data. */
SVN_ERR(svn_stream_write(stdout_stream, propstring->data,
&(propstring->len)));
SVN_ERR(svn_stream_printf(stdout_stream, pool, "\n"));
SVN_ERR(svn_stream_close(stdout_stream));
SVN_ERR(svn_rdump__get_dump_editor(editor, edit_baton, revision,
rb->stdout_stream, rb->extra_ra_session,
check_cancel, NULL, pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__write_old_wcprops(const char *path,
apr_hash_t *prophash,
svn_node_kind_t kind,
apr_pool_t *scratch_pool)
{
apr_pool_t *pool = scratch_pool;
const char *parent_dir;
const char *base_name;
svn_stream_t *stream;
const char *temp_dir_path;
const char *temp_prop_path;
const char *prop_path;
int wc_format_version;
if (kind == svn_node_dir)
parent_dir = path;
else
svn_path_split(path, &parent_dir, &base_name, pool);
/* At this point, we know we need to open a file in the admin area
of parent_dir. First check that parent_dir is a working copy: */
SVN_ERR(svn_wc_check_wc(parent_dir, &wc_format_version, pool));
if (wc_format_version == 0)
return svn_error_createf(SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
_("'%s' is not a working copy"),
svn_path_local_style(parent_dir, pool));
/* Write to a temp file, then rename into place. */
temp_dir_path = svn_wc__adm_child(parent_dir, SVN_WC__ADM_TMP, pool);
SVN_ERR(svn_stream_open_unique(&stream, &temp_prop_path,
temp_dir_path,
svn_io_file_del_none,
pool, pool));
SVN_ERR_W(svn_hash_write2(prophash, stream, SVN_HASH_TERMINATOR,
pool),
apr_psprintf(pool,
_("Cannot write property hash for '%s'"),
svn_path_local_style(path, pool)));
svn_stream_close(stream);
/* Close file, then do an atomic "move". */
SVN_ERR(svn_wc__prop_path(&prop_path, path, kind, svn_wc__props_wcprop,
pool));
SVN_ERR(svn_io_file_rename(temp_prop_path, prop_path, pool));
return svn_io_set_file_read_only(prop_path, FALSE, pool);
}
svn_error_t *
svn_config_write_auth_data(apr_hash_t *hash,
const char *cred_kind,
const char *realmstring,
const char *config_dir,
apr_pool_t *pool)
{
apr_file_t *authfile = NULL;
svn_stream_t *stream;
const char *auth_path;
SVN_ERR(svn_auth__file_path(&auth_path, cred_kind, realmstring, config_dir,
pool));
if (! auth_path)
return svn_error_create(SVN_ERR_NO_AUTH_FILE_PATH, NULL,
_("Unable to locate auth file"));
/* Add the realmstring to the hash, so programs (or users) can
verify exactly which set of credentials this file holds. */
svn_hash_sets(hash, SVN_CONFIG_REALMSTRING_KEY,
svn_string_create(realmstring, pool));
SVN_ERR_W(svn_io_file_open(&authfile, auth_path,
(APR_WRITE | APR_CREATE | APR_TRUNCATE
| APR_BUFFERED),
APR_OS_DEFAULT, pool),
_("Unable to open auth file for writing"));
stream = svn_stream_from_aprfile2(authfile, FALSE, pool);
SVN_ERR_W(svn_hash_write2(hash, stream, SVN_HASH_TERMINATOR, pool),
apr_psprintf(pool, _("Error writing hash to '%s'"),
svn_dirent_local_style(auth_path, pool)));
SVN_ERR(svn_stream_close(stream));
/* To be nice, remove the realmstring from the hash again, just in
case the caller wants their hash unchanged. */
svn_hash_sets(hash, SVN_CONFIG_REALMSTRING_KEY, NULL);
return SVN_NO_ERROR;
}
svn_error_t *
svn_config_write_auth_data(apr_hash_t *hash,
const char *cred_kind,
const char *realmstring,
const char *config_dir,
apr_pool_t *pool)
{
svn_stream_t *stream;
const char *auth_path, *tmp_path;
SVN_ERR(svn_auth__file_path(&auth_path, cred_kind, realmstring, config_dir,
pool));
if (! auth_path)
return svn_error_create(SVN_ERR_NO_AUTH_FILE_PATH, NULL,
_("Unable to locate auth file"));
/* Add the realmstring to the hash, so programs (or users) can
verify exactly which set of credentials this file holds.
### What if realmstring key is already in the hash? */
svn_hash_sets(hash, SVN_CONFIG_REALMSTRING_KEY,
svn_string_create(realmstring, pool));
SVN_ERR_W(svn_stream_open_unique(&stream, &tmp_path,
svn_dirent_dirname(auth_path, pool),
svn_io_file_del_on_pool_cleanup,
pool, pool),
_("Unable to open auth file for writing"));
SVN_ERR_W(svn_hash_write2(hash, stream, SVN_HASH_TERMINATOR, pool),
apr_psprintf(pool, _("Error writing hash to '%s'"),
svn_dirent_local_style(auth_path, pool)));
SVN_ERR(svn_stream_close(stream));
SVN_ERR(svn_io_file_rename2(tmp_path, auth_path, FALSE, pool));
/* To be nice, remove the realmstring from the hash again, just in
case the caller wants their hash unchanged.
### Should we also do this when a write error occurs? */
svn_hash_sets(hash, SVN_CONFIG_REALMSTRING_KEY, NULL);
return SVN_NO_ERROR;
}
/* Print a revision record header for REVISION to STDOUT_STREAM. Use
* SESSION to contact the repository for revision properties and
* such.
*/
static svn_error_t *
dump_revision_header(svn_ra_session_t *session,
svn_stream_t *stdout_stream,
svn_revnum_t revision,
apr_pool_t *pool)
{
apr_hash_t *prophash;
svn_stringbuf_t *propstring;
svn_stream_t *propstream;
SVN_ERR(svn_stream_printf(stdout_stream, pool,
SVN_REPOS_DUMPFILE_REVISION_NUMBER
": %ld\n", revision));
prophash = apr_hash_make(pool);
propstring = svn_stringbuf_create_empty(pool);
SVN_ERR(svn_ra_rev_proplist(session, revision, &prophash, pool));
propstream = svn_stream_from_stringbuf(propstring, pool);
SVN_ERR(svn_hash_write2(prophash, propstream, "PROPS-END", pool));
SVN_ERR(svn_stream_close(propstream));
/* Property-content-length: 14; Content-length: 14 */
SVN_ERR(svn_stream_printf(stdout_stream, pool,
SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n",
propstring->len));
SVN_ERR(svn_stream_printf(stdout_stream, pool,
SVN_REPOS_DUMPFILE_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n\n",
propstring->len));
/* The properties */
SVN_ERR(svn_stream_write(stdout_stream, propstring->data,
&(propstring->len)));
SVN_ERR(svn_stream_printf(stdout_stream, pool, "\n"));
return SVN_NO_ERROR;
}
/* Write to DIGEST_PATH a representation of CHILDREN (which may be
empty, if the versioned path in FS represented by DIGEST_PATH has
no children) and LOCK (which may be NULL if that versioned path is
lock itself locked). Set the permissions of DIGEST_PATH to those of
PERMS_REFERENCE. Use POOL for all allocations.
*/
static svn_error_t *
write_digest_file(apr_hash_t *children,
svn_lock_t *lock,
const char *fs_path,
const char *digest_path,
const char *perms_reference,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
svn_stream_t *stream;
apr_hash_index_t *hi;
apr_hash_t *hash = apr_hash_make(pool);
const char *tmp_path;
SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_join(fs_path, PATH_LOCKS_DIR,
pool), fs_path, pool));
SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_dirname(digest_path, pool),
fs_path, pool));
if (lock)
{
const char *creation_date = NULL, *expiration_date = NULL;
if (lock->creation_date)
creation_date = svn_time_to_cstring(lock->creation_date, pool);
if (lock->expiration_date)
expiration_date = svn_time_to_cstring(lock->expiration_date, pool);
hash_store(hash, PATH_KEY, sizeof(PATH_KEY)-1,
lock->path, APR_HASH_KEY_STRING, pool);
hash_store(hash, TOKEN_KEY, sizeof(TOKEN_KEY)-1,
lock->token, APR_HASH_KEY_STRING, pool);
hash_store(hash, OWNER_KEY, sizeof(OWNER_KEY)-1,
lock->owner, APR_HASH_KEY_STRING, pool);
hash_store(hash, COMMENT_KEY, sizeof(COMMENT_KEY)-1,
lock->comment, APR_HASH_KEY_STRING, pool);
hash_store(hash, IS_DAV_COMMENT_KEY, sizeof(IS_DAV_COMMENT_KEY)-1,
lock->is_dav_comment ? "1" : "0", 1, pool);
hash_store(hash, CREATION_DATE_KEY, sizeof(CREATION_DATE_KEY)-1,
creation_date, APR_HASH_KEY_STRING, pool);
hash_store(hash, EXPIRATION_DATE_KEY, sizeof(EXPIRATION_DATE_KEY)-1,
expiration_date, APR_HASH_KEY_STRING, pool);
}
if (apr_hash_count(children))
{
svn_stringbuf_t *children_list = svn_stringbuf_create("", pool);
for (hi = apr_hash_first(pool, children); hi; hi = apr_hash_next(hi))
{
svn_stringbuf_appendbytes(children_list,
svn__apr_hash_index_key(hi),
svn__apr_hash_index_klen(hi));
svn_stringbuf_appendbyte(children_list, '\n');
}
hash_store(hash, CHILDREN_KEY, sizeof(CHILDREN_KEY)-1,
children_list->data, children_list->len, pool);
}
SVN_ERR(svn_stream_open_unique(&stream, &tmp_path,
svn_dirent_dirname(digest_path, pool),
svn_io_file_del_none, pool, pool));
if ((err = svn_hash_write2(hash, stream, SVN_HASH_TERMINATOR, pool)))
{
svn_error_clear(svn_stream_close(stream));
return svn_error_createf(err->apr_err,
err,
_("Cannot write lock/entries hashfile '%s'"),
svn_dirent_local_style(tmp_path, pool));
}
SVN_ERR(svn_stream_close(stream));
SVN_ERR(svn_io_file_rename(tmp_path, digest_path, pool));
SVN_ERR(svn_io_copy_perms(perms_reference, digest_path, pool));
return SVN_NO_ERROR;
}
