svn_wc_info_t *
svn_wc_info_dup(const svn_wc_info_t *info,
apr_pool_t *pool)
{
svn_wc_info_t *new_info = apr_pmemdup(pool, info, sizeof(*new_info));
if (info->changelist)
new_info->changelist = apr_pstrdup(pool, info->changelist);
new_info->checksum = svn_checksum_dup(info->checksum, pool);
if (info->conflicts)
{
int i;
apr_array_header_t *new_conflicts
= apr_array_make(pool, info->conflicts->nelts, info->conflicts->elt_size);
for (i = 0; i < info->conflicts->nelts; i++)
{
APR_ARRAY_PUSH(new_conflicts, svn_wc_conflict_description2_t *)
= svn_wc__conflict_description2_dup(
APR_ARRAY_IDX(info->conflicts, i,
const svn_wc_conflict_description2_t *),
pool);
}
new_info->conflicts = new_conflicts;
}
svn_x509_certinfo_t *
svn_x509_certinfo_dup(const svn_x509_certinfo_t *certinfo,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_x509_certinfo_t *result = apr_palloc(result_pool, sizeof(*result));
result->subject = deep_copy_name_attrs(certinfo->subject, result_pool);
result->issuer = deep_copy_name_attrs(certinfo->issuer, result_pool);
result->valid_from = certinfo->valid_from;
result->valid_to = certinfo->valid_to;
result->digest = svn_checksum_dup(certinfo->digest, result_pool);
result->hostnames = deep_copy_array(certinfo->hostnames, result_pool);
return result;
}
/* Increment records[rep] if both are non-NULL and REP contains a sha1.
* Allocate keys and values in RESULT_POOL.
*/
static svn_error_t *record(apr_hash_t *records,
representation_t *rep,
apr_pool_t *result_pool)
{
struct key_t *key;
struct value_t *value;
/* Skip if we ignore this particular kind of reps, or if the rep doesn't
* exist or doesn't have the checksum we are after. (The latter case
* often corresponds to node_rev->kind == svn_node_dir.)
*/
if (records == NULL || rep == NULL || rep->sha1_checksum == NULL)
return SVN_NO_ERROR;
/* Construct the key.
*
* Must use calloc() because apr_hash_* pay attention to padding bytes too.
*/
key = apr_pcalloc(result_pool, sizeof(*key));
key->revision = rep->revision;
key->offset = rep->offset;
/* Update or create the value. */
if ((value = apr_hash_get(records, key, sizeof(*key))))
{
/* Paranoia. */
SVN_ERR_ASSERT(value->sha1_checksum != NULL);
SVN_ERR_ASSERT(svn_checksum_match(value->sha1_checksum,
rep->sha1_checksum));
/* Real work. */
value->refcount++;
}
else
{
value = apr_palloc(result_pool, sizeof(*value));
value->sha1_checksum = svn_checksum_dup(rep->sha1_checksum, result_pool);
value->refcount = 1;
}
/* Store them. */
apr_hash_set(records, key, sizeof(*key), value);
return SVN_NO_ERROR;
}
/* This function's caller ignores most errors it returns.
If you extend this function, check the callsite to see if you have
to make it not-ignore additional error codes. */
svn_error_t *
svn_fs_fs__get_rep_reference(representation_t **rep,
svn_fs_t *fs,
svn_checksum_t *checksum,
apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
SVN_ERR_ASSERT(ffd->rep_sharing_allowed);
if (! ffd->rep_cache_db)
SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
/* We only allow SHA1 checksums in this table. */
if (checksum->kind != svn_checksum_sha1)
return svn_error_create(SVN_ERR_BAD_CHECKSUM_KIND, NULL,
_("Only SHA1 checksums can be used as keys in the "
"rep_cache table.\n"));
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db, STMT_GET_REP));
SVN_ERR(svn_sqlite__bindf(stmt, "s",
svn_checksum_to_cstring(checksum, pool)));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
if (have_row)
{
*rep = apr_pcalloc(pool, sizeof(**rep));
(*rep)->sha1_checksum = svn_checksum_dup(checksum, pool);
(*rep)->revision = svn_sqlite__column_revnum(stmt, 0);
(*rep)->offset = svn_sqlite__column_int64(stmt, 1);
(*rep)->size = svn_sqlite__column_int64(stmt, 2);
(*rep)->expanded_size = svn_sqlite__column_int64(stmt, 3);
}
else
*rep = NULL;
if (*rep)
SVN_ERR(rep_has_been_born(*rep, fs, pool));
return svn_sqlite__reset(stmt);
}