/* fs_skels.c --- conversion between fs native types and skeletons
*
* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
* ====================================================================
*/
#include <string.h>
#include <apr_md5.h>
#include <apr_sha1.h>
#include "svn_error.h"
#include "svn_string.h"
#include "svn_types.h"
#include "svn_time.h"
#include "private/svn_skel.h"
#include "private/svn_dep_compat.h"
#include "private/svn_subr_private.h"
#include "svn_checksum.h"
#include "fs_skels.h"
#include "../id.h"
static svn_error_t *
skel_err(const char *skel_type)
{
return svn_error_createf(SVN_ERR_FS_MALFORMED_SKEL, NULL,
"Malformed%s%s skeleton",
skel_type ? " " : "",
skel_type ? skel_type : "");
}
/*** Validity Checking ***/
static svn_boolean_t
is_valid_checksum_skel(svn_skel_t *skel)
{
if (svn_skel__list_length(skel) != 2)
return FALSE;
if (svn_skel__matches_atom(skel->children, "md5")
&& skel->children->next->is_atom)
return TRUE;
if (svn_skel__matches_atom(skel->children, "sha1")
&& skel->children->next->is_atom)
return TRUE;
return FALSE;
}
static svn_boolean_t
is_valid_revision_skel(svn_skel_t *skel)
{
int len = svn_skel__list_length(skel);
if ((len == 2)
&& svn_skel__matches_atom(skel->children, "revision")
&& skel->children->next->is_atom)
return TRUE;
return FALSE;
}
static svn_boolean_t
is_valid_transaction_skel(svn_skel_t *skel, transaction_kind_t *kind)
{
int len = svn_skel__list_length(skel);
if (len != 5)
return FALSE;
/* Determine (and verify) the kind. */
if (svn_skel__matches_atom(skel->children, "transaction"))
*kind = transaction_kind_normal;
else if (svn_skel__matches_atom(skel->children, "committed"))
*kind = transaction_kind_committed;
else if (svn_skel__matches_atom(skel->children, "dead"))
*kind = transaction_kind_dead;
else
return FALSE;
if (skel->children->next->is_atom
&& skel->children->next->next->is_atom
&& (! skel->children->next->next->next->is_atom)
&& (! skel->children->next->next->next->next->is_atom))
return TRUE;
return FALSE;
}
static svn_boolean_t
is_valid_rep_delta_chunk_skel(svn_skel_t *skel)
{
int len;
svn_skel_t *window;
svn_skel_t *diff;
/* check the delta skel. */
if ((svn_skel__list_length(skel) != 2)
|| (! skel->children->is_atom))
return FALSE;
/* check the window. */
window = skel->children->next;
len = svn_skel__list_length(window);
if ((len < 3) || (len > 4))
return FALSE;
if (! ((! window->children->is_atom)
&& (window->children->next->is_atom)
&& (window->children->next->next->is_atom)))
return FALSE;
if ((len == 4)
&& (! window->children->next->next->next->is_atom))
return FALSE;
/* check the diff. ### currently we support only svndiff version
0 delta data. */
diff = window->children;
if ((svn_skel__list_length(diff) == 3)
&& (svn_skel__matches_atom(diff->children, "svndiff"))
&& ((svn_skel__matches_atom(diff->children->next, "0"))
|| (svn_skel__matches_atom(diff->children->next, "1")))
&& (diff->children->next->next->is_atom))
return TRUE;
return FALSE;
}
static svn_boolean_t
is_valid_representation_skel(svn_skel_t *skel)
{
int len = svn_skel__list_length(skel);
svn_skel_t *header;
int header_len;
/* the rep has at least two items in it, a HEADER list, and at least
one piece of kind-specific data. */
if (len < 2)
return FALSE;
/* check the header. it must have KIND and TXN atoms, and
optionally 1 or 2 checksums (which is a list form). */
header = skel->children;
header_len = svn_skel__list_length(header);
if (! (((header_len == 2) /* 2 means old repository, checksum absent */
&& (header->children->is_atom)
&& (header->children->next->is_atom))
|| ((header_len == 3) /* 3 means md5 checksum present */
&& (header->children->is_atom)
&& (header->children->next->is_atom)
&& (is_valid_checksum_skel(header->children->next->next)))
|| ((header_len == 4) /* 3 means md5 and sha1 checksums present */
&& (header->children->is_atom)
&& (header->children->next->is_atom)
&& (is_valid_checksum_skel(header->children->next->next))
&& (is_valid_checksum_skel(header->children->next->next->next)))))
return FALSE;
/* check for fulltext rep. */
if ((len == 2)
&& (svn_skel__matches_atom(header->children, "fulltext")))
return TRUE;
/* check for delta rep. */
if ((len >= 2)
&& (svn_skel__matches_atom(header->children, "delta")))
{
/* it's a delta rep. check the validity. */
svn_skel_t *chunk = skel->children->next;
/* loop over chunks, checking each one. */
while (chunk)
{
if (! is_valid_rep_delta_chunk_skel(chunk))
return FALSE;
chunk = chunk->next;
}
/* all good on this delta rep. */
return TRUE;
}
return FALSE;
}
static svn_boolean_t
is_valid_node_revision_header_skel(svn_skel_t *skel, svn_skel_t **kind_p)
{
int len = svn_skel__list_length(skel);
if (len < 2)
return FALSE;
/* set the *KIND_P pointer. */
*kind_p = skel->children;
/* check for valid lengths. */
if (! ((len == 2) || (len == 3) || (len == 4) || (len == 6)))
return FALSE;
/* got mergeinfo stuff? */
if ((len > 4)
&& (! (skel->children->next->next->next->next->is_atom
&& skel->children->next->next->next->next->next->is_atom)))
return FALSE;
/* got predecessor count? */
if ((len > 3)
&& (! skel->children->next->next->next->is_atom))
return FALSE;
/* got predecessor? */
if ((len > 2)
&& (! skel->children->next->next->is_atom))
return FALSE;
/* got the basics? */
if (! (skel->children->is_atom
&& skel->children->next->is_atom
&& (skel->children->next->data[0] == '/')))
return FALSE;
return TRUE;
}
static svn_boolean_t
is_valid_node_revision_skel(svn_skel_t *skel)
{
int len = svn_skel__list_length(skel);
svn_skel_t *header = skel->children;
svn_skel_t *kind;
if (len < 1)
return FALSE;
if (! is_valid_node_revision_header_skel(header, &kind))
return FALSE;
if (svn_skel__matches_atom(kind, "dir"))
{
if (! ((len == 3)
&& header->next->is_atom
&& header->next->next->is_atom))
return FALSE;
}
else if (svn_skel__matches_atom(kind, "file"))
{
if (len < 3)
return FALSE;
if (! header->next->is_atom)
return FALSE;
/* As of SVN_FS_BASE__MIN_REP_SHARING_FORMAT version, the
DATA-KEY slot can be a 2-tuple. */
if (! header->next->next->is_atom)
{
if (! ((svn_skel__list_length(header->next->next) == 2)
&& header->next->next->children->is_atom
&& header->next->next->children->len
&& header->next->next->children->next->is_atom
&& header->next->next->children->next->len))
return FALSE;
}
if ((len > 3) && (! header->next->next->next->is_atom))
return FALSE;
if (len > 4)
return FALSE;
}
return TRUE;
}
static svn_boolean_t
is_valid_copy_skel(svn_skel_t *skel)
{
return ((svn_skel__list_length(skel) == 4)
&& (svn_skel__matches_atom(skel->children, "copy")
|| svn_skel__matches_atom(skel->children, "soft-copy"))
&& skel->children->next->is_atom
&& skel->children->next->next->is_atom
&& skel->children->next->next->next->is_atom);
}
static svn_boolean_t
is_valid_change_skel(svn_skel_t *skel, svn_fs_path_change_kind_t *kind)
{
if ((svn_skel__list_length(skel) == 6)
&& svn_skel__matches_atom(skel->children, "change")
&& skel->children->next->is_atom
&& skel->children->next->next->is_atom
&& skel->children->next->next->next->is_atom
&& skel->children->next->next->next->next->is_atom
&& skel->children->next->next->next->next->next->is_atom)
{
svn_skel_t *kind_skel = skel->children->next->next->next;
/* check the kind (and return it) */
if (svn_skel__matches_atom(kind_skel, "reset"))
{
if (kind)
*kind = svn_fs_path_change_reset;
return TRUE;
}
if (svn_skel__matches_atom(kind_skel, "add"))
{
if (kind)
*kind = svn_fs_path_change_add;
return TRUE;
}
if (svn_skel__matches_atom(kind_skel, "delete"))
{
if (kind)
*kind = svn_fs_path_change_delete;
return TRUE;
}
if (svn_skel__matches_atom(kind_skel, "replace"))
{
if (kind)
*kind = svn_fs_path_change_replace;
return TRUE;
}
if (svn_skel__matches_atom(kind_skel, "modify"))
{
if (kind)
*kind = svn_fs_path_change_modify;
return TRUE;
}
}
return FALSE;
}
static svn_boolean_t
is_valid_lock_skel(svn_skel_t *skel)
{
if ((svn_skel__list_length(skel) == 8)
&& svn_skel__matches_atom(skel->children, "lock")
&& skel->children->next->is_atom
&& skel->children->next->next->is_atom
&& skel->children->next->next->next->is_atom
&& skel->children->next->next->next->next->is_atom
&& skel->children->next->next->next->next->next->is_atom
&& skel->children->next->next->next->next->next->next->is_atom
&& skel->children->next->next->next->next->next->next->next->is_atom)
return TRUE;
return FALSE;
}
/*** Parsing (conversion from skeleton to native FS type) ***/
svn_error_t *
svn_fs_base__parse_revision_skel(revision_t **revision_p,
svn_skel_t *skel,
apr_pool_t *pool)
{
revision_t *revision;
/* Validate the skel. */
if (! is_valid_revision_skel(skel))
return skel_err("revision");
/* Create the returned structure */
revision = apr_pcalloc(pool, sizeof(*revision));
revision->txn_id = apr_pstrmemdup(pool, skel->children->next->data,
skel->children->next->len);
/* Return the structure. */
*revision_p = revision;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__parse_transaction_skel(transaction_t **transaction_p,
svn_skel_t *skel,
apr_pool_t *pool)
{
transaction_t *transaction;
transaction_kind_t kind;
svn_skel_t *root_id, *base_id_or_rev, *proplist, *copies;
int len;
/* Validate the skel. */
if (! is_valid_transaction_skel(skel, &kind))
return skel_err("transaction");
root_id = skel->children->next;
base_id_or_rev = skel->children->next->next;
proplist = skel->children->next->next->next;
copies = skel->children->next->next->next->next;
/* Create the returned structure */
transaction = apr_pcalloc(pool, sizeof(*transaction));
/* KIND */
transaction->kind = kind;
/* REVISION or BASE-ID */
if (kind == transaction_kind_committed)
{
/* Committed transactions have a revision number... */
transaction->base_id = NULL;
transaction->revision =
SVN_STR_TO_REV(apr_pstrmemdup(pool, base_id_or_rev->data,
base_id_or_rev->len));
if (! SVN_IS_VALID_REVNUM(transaction->revision))
return skel_err("transaction");
}
else
{
/* ...where unfinished transactions have a base node-revision-id. */
transaction->revision = SVN_INVALID_REVNUM;
transaction->base_id = svn_fs_base__id_parse(base_id_or_rev->data,
base_id_or_rev->len, pool);
}
/* ROOT-ID */
transaction->root_id = svn_fs_base__id_parse(root_id->data,
root_id->len, pool);
/* PROPLIST */
SVN_ERR(svn_skel__parse_proplist(&(transaction->proplist),
proplist, pool));
/* COPIES */
if ((len = svn_skel__list_length(copies)))
{
const char *copy_id;
apr_array_header_t *txncopies;
svn_skel_t *cpy = copies->children;
txncopies = apr_array_make(pool, len, sizeof(copy_id));
while (cpy)
{
copy_id = apr_pstrmemdup(pool, cpy->data, cpy->len);
APR_ARRAY_PUSH(txncopies, const char *) = copy_id;
cpy = cpy->next;
}
transaction->copies = txncopies;
}
/* Return the structure. */
*transaction_p = transaction;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__parse_representation_skel(representation_t **rep_p,
svn_skel_t *skel,
apr_pool_t *pool)
{
representation_t *rep;
svn_skel_t *header_skel;
/* Validate the skel. */
if (! is_valid_representation_skel(skel))
return skel_err("representation");
header_skel = skel->children;
/* Create the returned structure */
rep = apr_pcalloc(pool, sizeof(*rep));
/* KIND */
if (svn_skel__matches_atom(header_skel->children, "fulltext"))
rep->kind = rep_kind_fulltext;
else
rep->kind = rep_kind_delta;
/* TXN */
rep->txn_id = apr_pstrmemdup(pool, header_skel->children->next->data,
header_skel->children->next->len);
/* MD5 */
if (header_skel->children->next->next)
{
svn_skel_t *checksum_skel = header_skel->children->next->next;
rep->md5_checksum =
svn_checksum__from_digest_md5((const unsigned char *)
(checksum_skel->children->next->data),
pool);
/* SHA1 */
if (header_skel->children->next->next->next)
{
checksum_skel = header_skel->children->next->next->next;
rep->sha1_checksum =
svn_checksum__from_digest_sha1(
(const unsigned char *)(checksum_skel->children->next->data),
pool);
}
}
/* KIND-SPECIFIC stuff */
if (rep->kind == rep_kind_fulltext)
{
/* "fulltext"-specific. */
rep->contents.fulltext.string_key
= apr_pstrmemdup(pool,
skel->children->next->data,
skel->children->next->len);
}
else
{
/* "delta"-specific. */
svn_skel_t *chunk_skel = skel->children->next;
rep_delta_chunk_t *chunk;
apr_array_header_t *chunks;
/* Alloc the chunk array. */
chunks = apr_array_make(pool, svn_skel__list_length(skel) - 1,
sizeof(chunk));
/* Process the chunks. */
while (chunk_skel)
{
svn_skel_t *window_skel = chunk_skel->children->next;
svn_skel_t *diff_skel = window_skel->children;
apr_int64_t val;
apr_uint64_t uval;
const char *str;
/* Allocate a chunk and its window */
chunk = apr_palloc(pool, sizeof(*chunk));
/* Populate the window */
str = apr_pstrmemdup(pool, diff_skel->children->next->data,
diff_skel->children->next->len);
SVN_ERR(svn_cstring_strtoui64(&uval, str, 0, 255, 10));
chunk->version = (apr_byte_t)uval;
chunk->string_key
= apr_pstrmemdup(pool,
diff_skel->children->next->next->data,
diff_skel->children->next->next->len);
str = apr_pstrmemdup(pool, window_skel->children->next->data,
window_skel->children->next->len);
SVN_ERR(svn_cstring_strtoui64(&uval, str, 0, APR_SIZE_MAX, 10));
chunk->size = (apr_size_t)uval;
chunk->rep_key
= apr_pstrmemdup(pool,
window_skel->children->next->next->data,
window_skel->children->next->next->len);
str = apr_pstrmemdup(pool, chunk_skel->children->data,
chunk_skel->children->len);
SVN_ERR(svn_cstring_strtoi64(&val, str, 0, APR_INT64_MAX, 10));
chunk->offset = (svn_filesize_t)val;
/* Add this chunk to the array. */
APR_ARRAY_PUSH(chunks, rep_delta_chunk_t *) = chunk;
/* Next... */
chunk_skel = chunk_skel->next;
}
/* Add the chunks array to the representation. */
rep->contents.delta.chunks = chunks;
}
/* Return the structure. */
*rep_p = rep;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__parse_node_revision_skel(node_revision_t **noderev_p,
svn_skel_t *skel,
apr_pool_t *pool)
{
node_revision_t *noderev;
svn_skel_t *header_skel, *cur_skel;
/* Validate the skel. */
if (! is_valid_node_revision_skel(skel))
return skel_err("node-revision");
header_skel = skel->children;
/* Create the returned structure */
noderev = apr_pcalloc(pool, sizeof(*noderev));
/* KIND */
if (svn_skel__matches_atom(header_skel->children, "dir"))
noderev->kind = svn_node_dir;
else
noderev->kind = svn_node_file;
/* CREATED-PATH */
noderev->created_path = apr_pstrmemdup(pool,
header_skel->children->next->data,
header_skel->children->next->len);
/* PREDECESSOR-ID */
if (header_skel->children->next->next)
{
cur_skel = header_skel->children->next->next;
if (cur_skel->len)
noderev->predecessor_id = svn_fs_base__id_parse(cur_skel->data,
cur_skel->len, pool);
/* PREDECESSOR-COUNT */
noderev->predecessor_count = -1;
if (cur_skel->next)
{
const char *str;
cur_skel = cur_skel->next;
if (cur_skel->len)
{
str = apr_pstrmemdup(pool, cur_skel->data, cur_skel->len);
SVN_ERR(svn_cstring_atoi(&noderev->predecessor_count, str));
}
/* HAS-MERGEINFO and MERGEINFO-COUNT */
if (cur_skel->next)
{
int val;
cur_skel = cur_skel->next;
str = apr_pstrmemdup(pool, cur_skel->data, cur_skel->len);
SVN_ERR(svn_cstring_atoi(&val, str));
noderev->has_mergeinfo = (val != 0);
str = apr_pstrmemdup(pool, cur_skel->next->data,
cur_skel->next->len);
SVN_ERR(svn_cstring_atoi64(&noderev->mergeinfo_count, str));
}
}
}
/* PROP-KEY */
if (skel->children->next->len)
noderev->prop_key = apr_pstrmemdup(pool, skel->children->next->data,
skel->children->next->len);
/* DATA-KEY */
if (skel->children->next->next->is_atom)
{
/* This is a real data rep key. */
if (skel->children->next->next->len)
noderev->data_key = apr_pstrmemdup(pool,
skel->children->next->next->data,
skel->children->next->next->len);
noderev->data_key_uniquifier = NULL;
}
else
{
/* This is a 2-tuple with a data rep key and a uniquifier. */
noderev->data_key =
apr_pstrmemdup(pool,
skel->children->next->next->children->data,
skel->children->next->next->children->len);
noderev->data_key_uniquifier =
apr_pstrmemdup(pool,
skel->children->next->next->children->next->data,
skel->children->next->next->children->next->len);
}
/* EDIT-DATA-KEY (optional, files only) */
if ((noderev->kind == svn_node_file)
&& skel->children->next->next->next
&& skel->children->next->next->next->len)
noderev->edit_key
= apr_pstrmemdup(pool, skel->children->next->next->next->data,
skel->children->next->next->next->len);
/* Return the structure. */
*noderev_p = noderev;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__parse_copy_skel(copy_t **copy_p,
svn_skel_t *skel,
apr_pool_t *pool)
{
copy_t *copy;
/* Validate the skel. */
if (! is_valid_copy_skel(skel))
return skel_err("copy");
/* Create the returned structure */
copy = apr_pcalloc(pool, sizeof(*copy));
/* KIND */
if (svn_skel__matches_atom(skel->children, "soft-copy"))
copy->kind = copy_kind_soft;
else
copy->kind = copy_kind_real;
/* SRC-PATH */
copy->src_path = apr_pstrmemdup(pool,
skel->children->next->data,
skel->children->next->len);
/* SRC-TXN-ID */
copy->src_txn_id = apr_pstrmemdup(pool,
skel->children->next->next->data,
skel->children->next->next->len);
/* DST-NODE-ID */
copy->dst_noderev_id
= svn_fs_base__id_parse(skel->children->next->next->next->data,
skel->children->next->next->next->len, pool);
/* Return the structure. */
*copy_p = copy;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__parse_entries_skel(apr_hash_t **entries_p,
svn_skel_t *skel,
apr_pool_t *pool)
{
apr_hash_t *entries = NULL;
int len = svn_skel__list_length(skel);
svn_skel_t *elt;
if (! (len >= 0))
return skel_err("entries");
if (len > 0)
{
/* Else, allocate a hash and populate it. */
entries = apr_hash_make(pool);
/* Check entries are well-formed as we go along. */
for (elt = skel->children; elt; elt = elt->next)
{
const char *name;
svn_fs_id_t *id;
/* ENTRY must be a list of two elements. */
if (svn_skel__list_length(elt) != 2)
return skel_err("entries");
/* Get the entry's name and ID. */
name = apr_pstrmemdup(pool, elt->children->data,
elt->children->len);
id = svn_fs_base__id_parse(elt->children->next->data,
elt->children->next->len, pool);
/* Add the entry to the hash. */
apr_hash_set(entries, name, elt->children->len, id);
}
}
/* Return the structure. */
*entries_p = entries;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__parse_change_skel(change_t **change_p,
svn_skel_t *skel,
apr_pool_t *pool)
{
change_t *change;
svn_fs_path_change_kind_t kind;
/* Validate the skel. */
if (! is_valid_change_skel(skel, &kind))
return skel_err("change");
/* Create the returned structure */
change = apr_pcalloc(pool, sizeof(*change));
/* PATH */
change->path = apr_pstrmemdup(pool, skel->children->next->data,
skel->children->next->len);
/* NODE-REV-ID */
if (skel->children->next->next->len)
change->noderev_id = svn_fs_base__id_parse
(skel->children->next->next->data, skel->children->next->next->len,
pool);
/* KIND */
change->kind = kind;
/* TEXT-MOD */
if (skel->children->next->next->next->next->len)
change->text_mod = TRUE;
/* PROP-MOD */
if (skel->children->next->next->next->next->next->len)
change->prop_mod = TRUE;
/* Return the structure. */
*change_p = change;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__parse_lock_skel(svn_lock_t **lock_p,
svn_skel_t *skel,
apr_pool_t *pool)
{
svn_lock_t *lock;
const char *timestr;
/* Validate the skel. */
if (! is_valid_lock_skel(skel))
return skel_err("lock");
/* Create the returned structure */
lock = apr_pcalloc(pool, sizeof(*lock));
/* PATH */
lock->path = apr_pstrmemdup(pool, skel->children->next->data,
skel->children->next->len);
/* LOCK-TOKEN */
lock->token = apr_pstrmemdup(pool,
skel->children->next->next->data,
skel->children->next->next->len);
/* OWNER */
lock->owner = apr_pstrmemdup(pool,
skel->children->next->next->next->data,
skel->children->next->next->next->len);
/* COMMENT (could be just an empty atom) */
if (skel->children->next->next->next->next->len)
lock->comment =
apr_pstrmemdup(pool,
skel->children->next->next->next->next->data,
skel->children->next->next->next->next->len);
/* XML_P */
if (svn_skel__matches_atom
(skel->children->next->next->next->next->next, "1"))
lock->is_dav_comment = TRUE;
else
lock->is_dav_comment = FALSE;
/* CREATION-DATE */
timestr = apr_pstrmemdup
(pool,
skel->children->next->next->next->next->next->next->data,
skel->children->next->next->next->next->next->next->len);
SVN_ERR(svn_time_from_cstring(&(lock->creation_date),
timestr, pool));
/* EXPIRATION-DATE (could be just an empty atom) */
if (skel->children->next->next->next->next->next->next->next->len)
{
timestr =
apr_pstrmemdup
(pool,
skel->children->next->next->next->next->next->next->next->data,
skel->children->next->next->next->next->next->next->next->len);
SVN_ERR(svn_time_from_cstring(&(lock->expiration_date),
timestr, pool));
}
/* Return the structure. */
*lock_p = lock;
return SVN_NO_ERROR;
}
/*** Unparsing (conversion from native FS type to skeleton) ***/
svn_error_t *
svn_fs_base__unparse_revision_skel(svn_skel_t **skel_p,
const revision_t *revision,
apr_pool_t *pool)
{
svn_skel_t *skel;
/* Create the skel. */
skel = svn_skel__make_empty_list(pool);
/* TXN_ID */
svn_skel__prepend(svn_skel__str_atom(revision->txn_id, pool), skel);
/* "revision" */
svn_skel__prepend(svn_skel__str_atom("revision", pool), skel);
/* Validate and return the skel. */
if (! is_valid_revision_skel(skel))
return skel_err("revision");
*skel_p = skel;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__unparse_transaction_skel(svn_skel_t **skel_p,
const transaction_t *transaction,
apr_pool_t *pool)
{
svn_skel_t *skel;
svn_skel_t *proplist_skel, *copies_skel, *header_skel;
svn_string_t *id_str;
transaction_kind_t kind;
/* Create the skel. */
skel = svn_skel__make_empty_list(pool);
switch (transaction->kind)
{
case transaction_kind_committed:
header_skel = svn_skel__str_atom("committed", pool);
if ((transaction->base_id)
|| (! SVN_IS_VALID_REVNUM(transaction->revision)))
return skel_err("transaction");
break;
case transaction_kind_dead:
header_skel = svn_skel__str_atom("dead", pool);
if ((! transaction->base_id)
|| (SVN_IS_VALID_REVNUM(transaction->revision)))
return skel_err("transaction");
break;
case transaction_kind_normal:
header_skel = svn_skel__str_atom("transaction", pool);
if ((! transaction->base_id)
|| (SVN_IS_VALID_REVNUM(transaction->revision)))
return skel_err("transaction");
break;
default:
return skel_err("transaction");
}
/* COPIES */
copies_skel = svn_skel__make_empty_list(pool);
if (transaction->copies && transaction->copies->nelts)
{
int i;
for (i = transaction->copies->nelts - 1; i >= 0; i--)
{
svn_skel__prepend(svn_skel__str_atom(
APR_ARRAY_IDX(transaction->copies, i,
const char *),
pool),
copies_skel);
}
}
svn_skel__prepend(copies_skel, skel);
/* PROPLIST */
SVN_ERR(svn_skel__unparse_proplist(&proplist_skel,
transaction->proplist, pool));
svn_skel__prepend(proplist_skel, skel);
/* REVISION or BASE-ID */
if (transaction->kind == transaction_kind_committed)
{
/* Committed transactions have a revision number... */
svn_skel__prepend(svn_skel__str_atom(apr_psprintf(pool, "%ld",
transaction->revision),
pool), skel);
}
else
{
/* ...where other transactions have a base node revision ID. */
id_str = svn_fs_base__id_unparse(transaction->base_id, pool);
svn_skel__prepend(svn_skel__mem_atom(id_str->data, id_str->len, pool),
skel);
}
/* ROOT-ID */
id_str = svn_fs_base__id_unparse(transaction->root_id, pool);
svn_skel__prepend(svn_skel__mem_atom(id_str->data, id_str->len, pool), skel);
/* KIND (see above) */
svn_skel__prepend(header_skel, skel);
/* Validate and return the skel. */
if (! is_valid_transaction_skel(skel, &kind))
return skel_err("transaction");
if (kind != transaction->kind)
return skel_err("transaction");
*skel_p = skel;
return SVN_NO_ERROR;
}
/* Construct a skel representing CHECKSUM, allocated in POOL, and prepend
* it onto the existing skel SKEL. */
static svn_error_t *
prepend_checksum(svn_skel_t *skel,
svn_checksum_t *checksum,
apr_pool_t *pool)
{
svn_skel_t *checksum_skel = svn_skel__make_empty_list(pool);
switch (checksum->kind)
{
case svn_checksum_md5:
svn_skel__prepend(svn_skel__mem_atom(checksum->digest,
APR_MD5_DIGESTSIZE, pool),
checksum_skel);
svn_skel__prepend(svn_skel__str_atom("md5", pool), checksum_skel);
break;
case svn_checksum_sha1:
svn_skel__prepend(svn_skel__mem_atom(checksum->digest,
APR_SHA1_DIGESTSIZE, pool),
checksum_skel);
svn_skel__prepend(svn_skel__str_atom("sha1", pool), checksum_skel);
break;
default:
return skel_err("checksum");
}
svn_skel__prepend(checksum_skel, skel);
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__unparse_representation_skel(svn_skel_t **skel_p,
const representation_t *rep,
int format,
apr_pool_t *pool)
{
svn_skel_t *skel = svn_skel__make_empty_list(pool);
svn_skel_t *header_skel = svn_skel__make_empty_list(pool);
/** Some parts of the header are common to all representations; do
those parts first. **/
/* SHA1 */
if ((format >= SVN_FS_BASE__MIN_REP_SHARING_FORMAT) && rep->sha1_checksum)
SVN_ERR(prepend_checksum(header_skel, rep->sha1_checksum, pool));
/* MD5 */
{
svn_checksum_t *md5_checksum = rep->md5_checksum;
if (! md5_checksum)
md5_checksum = svn_checksum_create(svn_checksum_md5, pool);
SVN_ERR(prepend_checksum(header_skel, md5_checksum, pool));
}
/* TXN */
if (rep->txn_id)
svn_skel__prepend(svn_skel__str_atom(rep->txn_id, pool), header_skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), header_skel);
/** Do the kind-specific stuff. **/
if (rep->kind == rep_kind_fulltext)
{
/*** Fulltext Representation. ***/
/* STRING-KEY */
if ((! rep->contents.fulltext.string_key)
|| (! *rep->contents.fulltext.string_key))
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
else
svn_skel__prepend(svn_skel__str_atom(rep->contents.fulltext.string_key,
pool), skel);
/* "fulltext" */
svn_skel__prepend(svn_skel__str_atom("fulltext", pool), header_skel);
/* header */
svn_skel__prepend(header_skel, skel);
}
else if (rep->kind == rep_kind_delta)
{
/*** Delta Representation. ***/
int i;
apr_array_header_t *chunks = rep->contents.delta.chunks;
/* Loop backwards through the windows, creating and prepending skels. */
for (i = chunks->nelts; i > 0; i--)
{
svn_skel_t *window_skel = svn_skel__make_empty_list(pool);
svn_skel_t *chunk_skel = svn_skel__make_empty_list(pool);
svn_skel_t *diff_skel = svn_skel__make_empty_list(pool);
const char *size_str, *offset_str, *version_str;
rep_delta_chunk_t *chunk = APR_ARRAY_IDX(chunks, i - 1,
rep_delta_chunk_t *);
/* OFFSET */
offset_str = apr_psprintf(pool, "%" SVN_FILESIZE_T_FMT,
chunk->offset);
/* SIZE */
size_str = apr_psprintf(pool, "%" APR_SIZE_T_FMT, chunk->size);
/* VERSION */
version_str = apr_psprintf(pool, "%d", chunk->version);
/* DIFF */
if ((! chunk->string_key) || (! *chunk->string_key))
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), diff_skel);
else
svn_skel__prepend(svn_skel__str_atom(chunk->string_key, pool),
diff_skel);
svn_skel__prepend(svn_skel__str_atom(version_str, pool), diff_skel);
svn_skel__prepend(svn_skel__str_atom("svndiff", pool), diff_skel);
/* REP-KEY */
if ((! chunk->rep_key) || (! *(chunk->rep_key)))
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool),
window_skel);
else
svn_skel__prepend(svn_skel__str_atom(chunk->rep_key, pool),
window_skel);
svn_skel__prepend(svn_skel__str_atom(size_str, pool), window_skel);
svn_skel__prepend(diff_skel, window_skel);
/* window header. */
svn_skel__prepend(window_skel, chunk_skel);
svn_skel__prepend(svn_skel__str_atom(offset_str, pool),
chunk_skel);
/* Add this window item to the main skel. */
svn_skel__prepend(chunk_skel, skel);
}
/* "delta" */
svn_skel__prepend(svn_skel__str_atom("delta", pool), header_skel);
/* header */
svn_skel__prepend(header_skel, skel);
}
else /* unknown kind */
SVN_ERR_MALFUNCTION();
/* Validate and return the skel. */
if (! is_valid_representation_skel(skel))
return skel_err("representation");
*skel_p = skel;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__unparse_node_revision_skel(svn_skel_t **skel_p,
const node_revision_t *noderev,
int format,
apr_pool_t *pool)
{
svn_skel_t *skel;
svn_skel_t *header_skel;
const char *num_str;
/* Create the skel. */
skel = svn_skel__make_empty_list(pool);
header_skel = svn_skel__make_empty_list(pool);
/* Store mergeinfo stuffs only if the schema level supports it. */
if (format >= SVN_FS_BASE__MIN_MERGEINFO_FORMAT)
{
/* MERGEINFO-COUNT */
num_str = apr_psprintf(pool, "%" APR_INT64_T_FMT,
noderev->mergeinfo_count);
svn_skel__prepend(svn_skel__str_atom(num_str, pool), header_skel);
/* HAS-MERGEINFO */
svn_skel__prepend(svn_skel__mem_atom(noderev->has_mergeinfo ? "1" : "0",
1, pool), header_skel);
/* PREDECESSOR-COUNT padding (only if we *don't* have a valid
value; if we do, we'll pick that up below) */
if (noderev->predecessor_count == -1)
{
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), header_skel);
}
}
/* PREDECESSOR-COUNT */
if (noderev->predecessor_count != -1)
{
const char *count_str = apr_psprintf(pool, "%d",
noderev->predecessor_count);
svn_skel__prepend(svn_skel__str_atom(count_str, pool), header_skel);
}
/* PREDECESSOR-ID */
if (noderev->predecessor_id)
{
svn_string_t *id_str = svn_fs_base__id_unparse(noderev->predecessor_id,
pool);
svn_skel__prepend(svn_skel__mem_atom(id_str->data, id_str->len, pool),
header_skel);
}
else
{
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), header_skel);
}
/* CREATED-PATH */
svn_skel__prepend(svn_skel__str_atom(noderev->created_path, pool),
header_skel);
/* KIND */
if (noderev->kind == svn_node_file)
svn_skel__prepend(svn_skel__str_atom("file", pool), header_skel);
else if (noderev->kind == svn_node_dir)
svn_skel__prepend(svn_skel__str_atom("dir", pool), header_skel);
else
SVN_ERR_MALFUNCTION();
/* ### do we really need to check *node->FOO_key ? if a key doesn't
### exist, then the field should be NULL ... */
/* EDIT-DATA-KEY (optional) */
if ((noderev->edit_key) && (*noderev->edit_key))
svn_skel__prepend(svn_skel__str_atom(noderev->edit_key, pool), skel);
/* DATA-KEY | (DATA-KEY DATA-KEY-UNIQID) */
if ((noderev->data_key_uniquifier) && (*noderev->data_key_uniquifier))
{
/* Build a 2-tuple with a rep key and uniquifier. */
svn_skel_t *data_key_skel = svn_skel__make_empty_list(pool);
/* DATA-KEY-UNIQID */
svn_skel__prepend(svn_skel__str_atom(noderev->data_key_uniquifier,
pool),
data_key_skel);
/* DATA-KEY */
if ((noderev->data_key) && (*noderev->data_key))
svn_skel__prepend(svn_skel__str_atom(noderev->data_key, pool),
data_key_skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), data_key_skel);
/* Add our 2-tuple to the main skel. */
svn_skel__prepend(data_key_skel, skel);
}
else
{
/* Just store the rep key (or empty placeholder) in the main skel. */
if ((noderev->data_key) && (*noderev->data_key))
svn_skel__prepend(svn_skel__str_atom(noderev->data_key, pool), skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
}
/* PROP-KEY */
if ((noderev->prop_key) && (*noderev->prop_key))
svn_skel__prepend(svn_skel__str_atom(noderev->prop_key, pool), skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
/* HEADER */
svn_skel__prepend(header_skel, skel);
/* Validate and return the skel. */
if (! is_valid_node_revision_skel(skel))
return skel_err("node-revision");
*skel_p = skel;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__unparse_copy_skel(svn_skel_t **skel_p,
const copy_t *copy,
apr_pool_t *pool)
{
svn_skel_t *skel;
svn_string_t *tmp_str;
/* Create the skel. */
skel = svn_skel__make_empty_list(pool);
/* DST-NODE-ID */
tmp_str = svn_fs_base__id_unparse(copy->dst_noderev_id, pool);
svn_skel__prepend(svn_skel__mem_atom(tmp_str->data, tmp_str->len, pool),
skel);
/* SRC-TXN-ID */
if ((copy->src_txn_id) && (*copy->src_txn_id))
svn_skel__prepend(svn_skel__str_atom(copy->src_txn_id, pool), skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
/* SRC-PATH */
if ((copy->src_path) && (*copy->src_path))
svn_skel__prepend(svn_skel__str_atom(copy->src_path, pool), skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
/* "copy" */
if (copy->kind == copy_kind_real)
svn_skel__prepend(svn_skel__str_atom("copy", pool), skel);
else
svn_skel__prepend(svn_skel__str_atom("soft-copy", pool), skel);
/* Validate and return the skel. */
if (! is_valid_copy_skel(skel))
return skel_err("copy");
*skel_p = skel;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__unparse_entries_skel(svn_skel_t **skel_p,
apr_hash_t *entries,
apr_pool_t *pool)
{
svn_skel_t *skel = svn_skel__make_empty_list(pool);
apr_hash_index_t *hi;
/* Create the skel. */
if (entries)
{
/* Loop over hash entries */
for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_ssize_t klen;
svn_fs_id_t *value;
svn_string_t *id_str;
svn_skel_t *entry_skel = svn_skel__make_empty_list(pool);
apr_hash_this(hi, &key, &klen, &val);
value = val;
/* VALUE */
id_str = svn_fs_base__id_unparse(value, pool);
svn_skel__prepend(svn_skel__mem_atom(id_str->data, id_str->len,
pool),
entry_skel);
/* NAME */
svn_skel__prepend(svn_skel__mem_atom(key, klen, pool), entry_skel);
/* Add entry to the entries skel. */
svn_skel__prepend(entry_skel, skel);
}
}
/* Return the skel. */
*skel_p = skel;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__unparse_change_skel(svn_skel_t **skel_p,
const change_t *change,
apr_pool_t *pool)
{
svn_skel_t *skel;
svn_string_t *tmp_str;
svn_fs_path_change_kind_t kind;
/* Create the skel. */
skel = svn_skel__make_empty_list(pool);
/* PROP-MOD */
if (change->prop_mod)
svn_skel__prepend(svn_skel__str_atom("1", pool), skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
/* TEXT-MOD */
if (change->text_mod)
svn_skel__prepend(svn_skel__str_atom("1", pool), skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
/* KIND */
switch (change->kind)
{
case svn_fs_path_change_reset:
svn_skel__prepend(svn_skel__str_atom("reset", pool), skel);
break;
case svn_fs_path_change_add:
svn_skel__prepend(svn_skel__str_atom("add", pool), skel);
break;
case svn_fs_path_change_delete:
svn_skel__prepend(svn_skel__str_atom("delete", pool), skel);
break;
case svn_fs_path_change_replace:
svn_skel__prepend(svn_skel__str_atom("replace", pool), skel);
break;
case svn_fs_path_change_modify:
default:
svn_skel__prepend(svn_skel__str_atom("modify", pool), skel);
break;
}
/* NODE-REV-ID */
if (change->noderev_id)
{
tmp_str = svn_fs_base__id_unparse(change->noderev_id, pool);
svn_skel__prepend(svn_skel__mem_atom(tmp_str->data, tmp_str->len, pool),
skel);
}
else
{
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
}
/* PATH */
svn_skel__prepend(svn_skel__str_atom(change->path, pool), skel);
/* "change" */
svn_skel__prepend(svn_skel__str_atom("change", pool), skel);
/* Validate and return the skel. */
if (! is_valid_change_skel(skel, &kind))
return skel_err("change");
if (kind != change->kind)
return skel_err("change");
*skel_p = skel;
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_base__unparse_lock_skel(svn_skel_t **skel_p,
const svn_lock_t *lock,
apr_pool_t *pool)
{
svn_skel_t *skel;
/* Create the skel. */
skel = svn_skel__make_empty_list(pool);
/* EXP-DATE is optional. If not present, just use an empty atom. */
if (lock->expiration_date)
svn_skel__prepend(svn_skel__str_atom(
svn_time_to_cstring(lock->expiration_date, pool),
pool), skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
/* CREATION-DATE */
svn_skel__prepend(svn_skel__str_atom(
svn_time_to_cstring(lock->creation_date, pool),
pool), skel);
/* XML_P */
if (lock->is_dav_comment)
svn_skel__prepend(svn_skel__str_atom("1", pool), skel);
else
svn_skel__prepend(svn_skel__str_atom("0", pool), skel);
/* COMMENT */
if (lock->comment)
svn_skel__prepend(svn_skel__str_atom(lock->comment, pool), skel);
else
svn_skel__prepend(svn_skel__mem_atom(NULL, 0, pool), skel);
/* OWNER */
svn_skel__prepend(svn_skel__str_atom(lock->owner, pool), skel);
/* LOCK-TOKEN */
svn_skel__prepend(svn_skel__str_atom(lock->token, pool), skel);
/* PATH */
svn_skel__prepend(svn_skel__str_atom(lock->path, pool), skel);
/* "lock" */
svn_skel__prepend(svn_skel__str_atom("lock", pool), skel);
/* Validate and return the skel. */
if (! is_valid_lock_skel(skel))
return skel_err("lock");
*skel_p = skel;
return SVN_NO_ERROR;
}