#include "svn_dirent_uri.h"
#include "svn_path.h"
#include "svn_types.h"
#include "svn_pools.h"
#include "tree_conflicts.h"
#include "wc.h"
#include "private/svn_skel.h"
#include "private/svn_wc_private.h"
#include "private/svn_token.h"
#include "svn_private_config.h"
static const svn_token_map_t node_kind_map[] =
{
{ "none", svn_node_none },
{ "file", svn_node_file },
{ "dir", svn_node_dir },
{ "", svn_node_unknown },
{ NULL }
};
const svn_token_map_t svn_wc__operation_map[] =
{
{ "none", svn_wc_operation_none },
{ "update", svn_wc_operation_update },
{ "switch", svn_wc_operation_switch },
{ "merge", svn_wc_operation_merge },
{ NULL }
};
const svn_token_map_t svn_wc__conflict_action_map[] =
{
{ "edited", svn_wc_conflict_action_edit },
{ "deleted", svn_wc_conflict_action_delete },
{ "added", svn_wc_conflict_action_add },
{ "replaced", svn_wc_conflict_action_replace },
{ NULL }
};
const svn_token_map_t svn_wc__conflict_reason_map[] =
{
{ "edited", svn_wc_conflict_reason_edited },
{ "deleted", svn_wc_conflict_reason_deleted },
{ "missing", svn_wc_conflict_reason_missing },
{ "obstructed", svn_wc_conflict_reason_obstructed },
{ "added", svn_wc_conflict_reason_added },
{ "replaced", svn_wc_conflict_reason_replaced },
{ "unversioned", svn_wc_conflict_reason_unversioned },
{ NULL }
};
static svn_boolean_t
is_valid_version_info_skel(const svn_skel_t *skel)
{
return (svn_skel__list_length(skel) == 5
&& svn_skel__matches_atom(skel->children, "version")
&& 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);
}
static svn_boolean_t
is_valid_conflict_skel(const svn_skel_t *skel)
{
int i;
if (svn_skel__list_length(skel) != 8
|| !svn_skel__matches_atom(skel->children, "conflict"))
return FALSE;
skel = skel->children->next;
for (i = 5; i--; skel = skel->next)
if (!skel->is_atom)
return FALSE;
return (is_valid_version_info_skel(skel)
&& is_valid_version_info_skel(skel->next));
}
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;
}
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;
}
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_create(repos_root,
repos_relpath,
peg_rev,
kind,
result_pool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__deserialize_conflict(const svn_wc_conflict_description2_t **conflict,
const svn_skel_t *skel,
const char *dir_path,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *victim_basename;
const char *victim_abspath;
svn_node_kind_t node_kind;
svn_wc_operation_t operation;
svn_wc_conflict_action_t action;
svn_wc_conflict_reason_t reason;
const svn_wc_conflict_version_t *src_left_version;
const svn_wc_conflict_version_t *src_right_version;
int n;
svn_wc_conflict_description2_t *new_conflict;
if (!is_valid_conflict_skel(skel))
return svn_error_createf(SVN_ERR_WC_CORRUPT, NULL,
_("Invalid conflict info '%s' in tree conflict "
"description"),
skel ? svn_skel__unparse(skel, scratch_pool)->data
: "(null)");
victim_basename = apr_pstrmemdup(scratch_pool,
skel->children->next->data,
skel->children->next->len);
if (victim_basename[0] == '\0')
return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
_("Empty 'victim' field in tree conflict "
"description"));
SVN_ERR(read_enum_field(&n, node_kind_map, skel->children->next->next));
node_kind = (svn_node_kind_t)n;
if (node_kind != svn_node_file && node_kind != svn_node_dir)
return svn_error_create(SVN_ERR_WC_CORRUPT, NULL,
_("Invalid 'node_kind' field in tree conflict description"));
SVN_ERR(read_enum_field(&n, svn_wc__operation_map,
skel->children->next->next->next));
operation = (svn_wc_operation_t)n;
SVN_ERR(svn_dirent_get_absolute(&victim_abspath,
svn_dirent_join(dir_path, victim_basename, scratch_pool),
scratch_pool));
SVN_ERR(read_enum_field(&n, svn_wc__conflict_action_map,
skel->children->next->next->next->next));
action = n;
SVN_ERR(read_enum_field(&n, svn_wc__conflict_reason_map,
skel->children->next->next->next->next->next));
reason = n;
skel = skel->children->next->next->next->next->next->next;
SVN_ERR(read_node_version_info(&src_left_version, skel,
result_pool, scratch_pool));
SVN_ERR(read_node_version_info(&src_right_version, skel->next,
result_pool, scratch_pool));
new_conflict = svn_wc_conflict_description_create_tree2(victim_abspath,
node_kind, operation, src_left_version, src_right_version,
result_pool);
new_conflict->action = action;
new_conflict->reason = reason;
*conflict = new_conflict;
return SVN_NO_ERROR;
}
static void
skel_prepend_enum(svn_skel_t *skel,
const svn_token_map_t *map,
int n,
apr_pool_t *result_pool)
{
svn_skel__prepend(svn_skel__str_atom(svn_token__to_word(map, n),
result_pool), skel);
}
static svn_error_t *
prepend_version_info_skel(svn_skel_t *parent_skel,
const svn_wc_conflict_version_t *version_info,
apr_pool_t *pool)
{
svn_skel_t *skel = svn_skel__make_empty_list(pool);
skel_prepend_enum(skel, node_kind_map, version_info->node_kind, pool);
svn_skel__prepend(svn_skel__str_atom(version_info->path_in_repos
? version_info->path_in_repos
: "", pool), skel);
svn_skel__prepend(svn_skel__str_atom(apr_psprintf(pool, "%ld",
version_info->peg_rev),
pool), skel);
svn_skel__prepend(svn_skel__str_atom(version_info->repos_url
? version_info->repos_url
: "", pool), skel);
svn_skel__prepend(svn_skel__str_atom("version", pool), skel);
SVN_ERR_ASSERT(is_valid_version_info_skel(skel));
svn_skel__prepend(skel, parent_skel);
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__serialize_conflict(svn_skel_t **skel,
const svn_wc_conflict_description2_t *conflict,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
static const svn_wc_conflict_version_t null_version = {
NULL, SVN_INVALID_REVNUM, NULL, svn_node_unknown };
svn_skel_t *c_skel = svn_skel__make_empty_list(result_pool);
const char *victim_basename;
if (conflict->src_right_version)
SVN_ERR(prepend_version_info_skel(c_skel, conflict->src_right_version,
result_pool));
else
SVN_ERR(prepend_version_info_skel(c_skel, &null_version, result_pool));
if (conflict->src_left_version)
SVN_ERR(prepend_version_info_skel(c_skel, conflict->src_left_version,
result_pool));
else
SVN_ERR(prepend_version_info_skel(c_skel, &null_version, result_pool));
skel_prepend_enum(c_skel, svn_wc__conflict_reason_map, conflict->reason,
result_pool);
skel_prepend_enum(c_skel, svn_wc__conflict_action_map, conflict->action,
result_pool);
skel_prepend_enum(c_skel, svn_wc__operation_map, conflict->operation,
result_pool);
SVN_ERR_ASSERT(conflict->node_kind == svn_node_dir
|| conflict->node_kind == svn_node_file);
skel_prepend_enum(c_skel, node_kind_map, conflict->node_kind, result_pool);
victim_basename = svn_dirent_basename(conflict->local_abspath, result_pool);
SVN_ERR_ASSERT(strlen(victim_basename) > 0);
svn_skel__prepend(svn_skel__str_atom(victim_basename, result_pool), c_skel);
svn_skel__prepend(svn_skel__str_atom("conflict", result_pool), c_skel);
SVN_ERR_ASSERT(is_valid_conflict_skel(c_skel));
*skel = c_skel;
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__del_tree_conflict(svn_wc_context_t *wc_ctx,
const char *victim_abspath,
apr_pool_t *scratch_pool)
{
SVN_ERR_ASSERT(svn_dirent_is_absolute(victim_abspath));
SVN_ERR(svn_wc__db_op_set_tree_conflict(wc_ctx->db, victim_abspath,
NULL, scratch_pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__add_tree_conflict(svn_wc_context_t *wc_ctx,
const svn_wc_conflict_description2_t *conflict,
apr_pool_t *scratch_pool)
{
const svn_wc_conflict_description2_t *existing_conflict;
SVN_ERR(svn_wc__db_op_read_tree_conflict(&existing_conflict, wc_ctx->db,
conflict->local_abspath,
scratch_pool, scratch_pool));
if (existing_conflict != NULL)
return svn_error_createf(SVN_ERR_WC_CORRUPT, NULL,
_("Attempt to add tree conflict that already "
"exists at '%s'"),
svn_dirent_local_style(conflict->local_abspath,
scratch_pool));
return svn_error_trace(
svn_wc__db_op_set_tree_conflict(wc_ctx->db, conflict->local_abspath,
conflict, scratch_pool));
}
svn_error_t *
svn_wc__get_tree_conflict(const svn_wc_conflict_description2_t **tree_conflict,
svn_wc_context_t *wc_ctx,
const char *victim_abspath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
SVN_ERR_ASSERT(svn_dirent_is_absolute(victim_abspath));
return svn_error_trace(
svn_wc__db_op_read_tree_conflict(tree_conflict, wc_ctx->db, victim_abspath,
result_pool, scratch_pool));
}
svn_error_t *
svn_wc__get_all_tree_conflicts(apr_hash_t **tree_conflicts,
svn_wc_context_t *wc_ctx,
const char *local_abspath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_hash_t *conflicts;
apr_hash_index_t *hi;
SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
SVN_ERR(svn_wc__db_op_read_all_tree_conflicts(&conflicts, wc_ctx->db,
local_abspath,
result_pool, scratch_pool));
*tree_conflicts = apr_hash_make(result_pool);
for (hi = apr_hash_first(scratch_pool, conflicts); hi;
hi = apr_hash_next(hi))
{
const char *name = svn__apr_hash_index_key(hi);
const svn_wc_conflict_description2_t *conflict
= svn__apr_hash_index_val(hi);
const char *abspath = svn_dirent_join(local_abspath, name, scratch_pool);
apr_hash_set(*tree_conflicts, abspath, APR_HASH_KEY_STRING, conflict);
}
return SVN_NO_ERROR;
}