diff options
Diffstat (limited to 'subversion/libsvn_wc/entries.c')
| -rw-r--r-- | subversion/libsvn_wc/entries.c | 2738 |
1 files changed, 2738 insertions, 0 deletions
diff --git a/subversion/libsvn_wc/entries.c b/subversion/libsvn_wc/entries.c new file mode 100644 index 0000000..f6a73bf --- /dev/null +++ b/subversion/libsvn_wc/entries.c @@ -0,0 +1,2738 @@ +/* + * entries.c : manipulating the administrative `entries' file. + * + * ==================================================================== + * 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 <assert.h> + +#include <apr_strings.h> + +#include "svn_error.h" +#include "svn_types.h" +#include "svn_time.h" +#include "svn_pools.h" +#include "svn_dirent_uri.h" +#include "svn_path.h" +#include "svn_ctype.h" +#include "svn_string.h" +#include "svn_hash.h" + +#include "wc.h" +#include "adm_files.h" +#include "conflicts.h" +#include "entries.h" +#include "lock.h" +#include "tree_conflicts.h" +#include "wc_db.h" +#include "wc-queries.h" /* for STMT_* */ + +#include "svn_private_config.h" +#include "private/svn_wc_private.h" +#include "private/svn_sqlite.h" + +#define MAYBE_ALLOC(x,p) ((x) ? (x) : apr_pcalloc((p), sizeof(*(x)))) + + +/* Temporary structures which mirror the tables in wc-metadata.sql. + For detailed descriptions of each field, see that file. */ +typedef struct db_node_t { + apr_int64_t wc_id; + const char *local_relpath; + int op_depth; + apr_int64_t repos_id; + const char *repos_relpath; + const char *parent_relpath; + svn_wc__db_status_t presence; + svn_revnum_t revision; + svn_node_kind_t kind; + svn_checksum_t *checksum; + svn_filesize_t recorded_size; + svn_revnum_t changed_rev; + apr_time_t changed_date; + const char *changed_author; + svn_depth_t depth; + apr_time_t recorded_time; + apr_hash_t *properties; + svn_boolean_t file_external; + apr_array_header_t *inherited_props; +} db_node_t; + +typedef struct db_actual_node_t { + apr_int64_t wc_id; + const char *local_relpath; + const char *parent_relpath; + apr_hash_t *properties; + const char *conflict_old; + const char *conflict_new; + const char *conflict_working; + const char *prop_reject; + const char *changelist; + /* ### enum for text_mod */ + const char *tree_conflict_data; +} db_actual_node_t; + + + +/*** reading and writing the entries file ***/ + + +/* */ +static svn_wc_entry_t * +alloc_entry(apr_pool_t *pool) +{ + svn_wc_entry_t *entry = apr_pcalloc(pool, sizeof(*entry)); + entry->revision = SVN_INVALID_REVNUM; + entry->copyfrom_rev = SVN_INVALID_REVNUM; + entry->cmt_rev = SVN_INVALID_REVNUM; + entry->kind = svn_node_none; + entry->working_size = SVN_WC_ENTRY_WORKING_SIZE_UNKNOWN; + entry->depth = svn_depth_infinity; + entry->file_external_peg_rev.kind = svn_opt_revision_unspecified; + entry->file_external_rev.kind = svn_opt_revision_unspecified; + return entry; +} + + +/* Is the entry in a 'hidden' state in the sense of the 'show_hidden' + * switches on svn_wc_entries_read(), svn_wc_walk_entries*(), etc.? */ +svn_error_t * +svn_wc__entry_is_hidden(svn_boolean_t *hidden, const svn_wc_entry_t *entry) +{ + /* In English, the condition is: "the entry is not present, and I haven't + scheduled something over the top of it." */ + if (entry->deleted + || entry->absent + || entry->depth == svn_depth_exclude) + { + /* These kinds of nodes cannot be marked for deletion (which also + means no "replace" either). */ + SVN_ERR_ASSERT(entry->schedule == svn_wc_schedule_add + || entry->schedule == svn_wc_schedule_normal); + + /* Hidden if something hasn't been added over it. + + ### is this even possible with absent or excluded nodes? */ + *hidden = entry->schedule != svn_wc_schedule_add; + } + else + *hidden = FALSE; + + return SVN_NO_ERROR; +} + + +/* Hit the database to check the file external information for the given + entry. The entry will be modified in place. */ +static svn_error_t * +check_file_external(svn_wc_entry_t *entry, + svn_wc__db_t *db, + const char *local_abspath, + const char *wri_abspath, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + svn_wc__db_status_t status; + svn_node_kind_t kind; + const char *repos_relpath; + svn_revnum_t peg_revision; + svn_revnum_t revision; + svn_error_t *err; + + err = svn_wc__db_external_read(&status, &kind, NULL, NULL, NULL, + &repos_relpath, &peg_revision, &revision, + db, local_abspath, wri_abspath, + result_pool, scratch_pool); + + if (err) + { + if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND) + return svn_error_trace(err); + + svn_error_clear(err); + return SVN_NO_ERROR; + } + + if (status == svn_wc__db_status_normal + && kind == svn_node_file) + { + entry->file_external_path = repos_relpath; + if (SVN_IS_VALID_REVNUM(peg_revision)) + { + entry->file_external_peg_rev.kind = svn_opt_revision_number; + entry->file_external_peg_rev.value.number = peg_revision; + entry->file_external_rev = entry->file_external_peg_rev; + } + if (SVN_IS_VALID_REVNUM(revision)) + { + entry->file_external_rev.kind = svn_opt_revision_number; + entry->file_external_rev.value.number = revision; + } + } + + return SVN_NO_ERROR; +} + + +/* Fill in the following fields of ENTRY: + + REVISION + REPOS + UUID + CMT_REV + CMT_DATE + CMT_AUTHOR + DEPTH + DELETED + + Return: KIND, REPOS_RELPATH, CHECKSUM +*/ +static svn_error_t * +get_info_for_deleted(svn_wc_entry_t *entry, + svn_node_kind_t *kind, + const char **repos_relpath, + const svn_checksum_t **checksum, + svn_wc__db_lock_t **lock, + svn_wc__db_t *db, + const char *entry_abspath, + const svn_wc_entry_t *parent_entry, + svn_boolean_t have_base, + svn_boolean_t have_more_work, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + if (have_base && !have_more_work) + { + /* This is the delete of a BASE node */ + SVN_ERR(svn_wc__db_base_get_info(NULL, kind, + &entry->revision, + repos_relpath, + &entry->repos, + &entry->uuid, + &entry->cmt_rev, + &entry->cmt_date, + &entry->cmt_author, + &entry->depth, + checksum, + NULL, + lock, + &entry->has_props, NULL, + NULL, + db, + entry_abspath, + result_pool, + scratch_pool)); + } + else + { + const char *work_del_abspath; + const char *parent_repos_relpath; + const char *parent_abspath; + + /* This is a deleted child of a copy/move-here, + so we need to scan up the WORKING tree to find the root of + the deletion. Then examine its parent to discover its + future location in the repository. */ + SVN_ERR(svn_wc__db_read_pristine_info(NULL, kind, + &entry->cmt_rev, + &entry->cmt_date, + &entry->cmt_author, + &entry->depth, + checksum, + NULL, + &entry->has_props, NULL, + db, + entry_abspath, + result_pool, + scratch_pool)); + /* working_size and text_time unavailable */ + + SVN_ERR(svn_wc__db_scan_deletion(NULL, + NULL, + &work_del_abspath, NULL, + db, entry_abspath, + scratch_pool, scratch_pool)); + + SVN_ERR_ASSERT(work_del_abspath != NULL); + parent_abspath = svn_dirent_dirname(work_del_abspath, scratch_pool); + + /* The parent directory of the delete root must be added, so we + can find the required information there */ + SVN_ERR(svn_wc__db_scan_addition(NULL, NULL, + &parent_repos_relpath, + &entry->repos, + &entry->uuid, + NULL, NULL, NULL, NULL, + db, parent_abspath, + result_pool, scratch_pool)); + + /* Now glue it all together */ + *repos_relpath = svn_relpath_join(parent_repos_relpath, + svn_dirent_is_child(parent_abspath, + entry_abspath, + NULL), + result_pool); + + + /* Even though this is the delete of a WORKING node, there might still + be a BASE node somewhere below with an interesting revision */ + if (have_base) + { + svn_wc__db_status_t status; + SVN_ERR(svn_wc__db_base_get_info(&status, NULL, &entry->revision, + NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, lock, NULL, NULL, + NULL, + db, entry_abspath, + result_pool, scratch_pool)); + + if (status == svn_wc__db_status_not_present) + entry->deleted = TRUE; + } + } + + /* Do some extra work for the child nodes. */ + if (!SVN_IS_VALID_REVNUM(entry->revision) && parent_entry != NULL) + { + /* For child nodes without a revision, pick up the parent's + revision. */ + entry->revision = parent_entry->revision; + } + + return SVN_NO_ERROR; +} + + +/* + * Encode tree conflict descriptions into a single string. + * + * Set *CONFLICT_DATA to a string, allocated in POOL, that encodes the tree + * conflicts in CONFLICTS in a form suitable for storage in a single string + * field in a WC entry. CONFLICTS is a hash of zero or more pointers to + * svn_wc_conflict_description2_t objects, index by their basenames. All of the + * conflict victim paths must be siblings. + * + * Do all allocations in POOL. + * + * @see svn_wc__read_tree_conflicts() + */ +static svn_error_t * +write_tree_conflicts(const char **conflict_data, + apr_hash_t *conflicts, + apr_pool_t *pool) +{ + svn_skel_t *skel = svn_skel__make_empty_list(pool); + apr_hash_index_t *hi; + + for (hi = apr_hash_first(pool, conflicts); hi; hi = apr_hash_next(hi)) + { + svn_skel_t *c_skel; + + SVN_ERR(svn_wc__serialize_conflict(&c_skel, svn__apr_hash_index_val(hi), + pool, pool)); + svn_skel__prepend(c_skel, skel); + } + + *conflict_data = svn_skel__unparse(skel, pool)->data; + + return SVN_NO_ERROR; +} + + +/* Read one entry from wc_db. It will be allocated in RESULT_POOL and + returned in *NEW_ENTRY. + + DIR_ABSPATH is the name of the directory to read this entry from, and + it will be named NAME (use "" for "this dir"). + + DB specifies the wc_db database, and WC_ID specifies which working copy + this information is being read from. + + If this node is "this dir", then PARENT_ENTRY should be NULL. Otherwise, + it should refer to the entry for the child's parent directory. + + Temporary allocations are made in SCRATCH_POOL. */ +static svn_error_t * +read_one_entry(const svn_wc_entry_t **new_entry, + svn_wc__db_t *db, + apr_int64_t wc_id, + const char *dir_abspath, + const char *name, + const svn_wc_entry_t *parent_entry, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + svn_node_kind_t kind; + svn_wc__db_status_t status; + svn_wc__db_lock_t *lock; + const char *repos_relpath; + const svn_checksum_t *checksum; + svn_filesize_t translated_size; + svn_wc_entry_t *entry = alloc_entry(result_pool); + const char *entry_abspath; + const char *original_repos_relpath; + const char *original_root_url; + svn_boolean_t conflicted; + svn_boolean_t have_base; + svn_boolean_t have_more_work; + + entry->name = name; + + entry_abspath = svn_dirent_join(dir_abspath, entry->name, scratch_pool); + + SVN_ERR(svn_wc__db_read_info( + &status, + &kind, + &entry->revision, + &repos_relpath, + &entry->repos, + &entry->uuid, + &entry->cmt_rev, + &entry->cmt_date, + &entry->cmt_author, + &entry->depth, + &checksum, + NULL, + &original_repos_relpath, + &original_root_url, + NULL, + &entry->copyfrom_rev, + &lock, + &translated_size, + &entry->text_time, + &entry->changelist, + &conflicted, + NULL /* op_root */, + &entry->has_props /* have_props */, + &entry->has_prop_mods /* props_mod */, + &have_base, + &have_more_work, + NULL /* have_work */, + db, + entry_abspath, + result_pool, + scratch_pool)); + + if (entry->has_prop_mods) + entry->has_props = TRUE; + + if (strcmp(entry->name, SVN_WC_ENTRY_THIS_DIR) == 0) + { + /* get the tree conflict data. */ + apr_hash_t *tree_conflicts = NULL; + const apr_array_header_t *conflict_victims; + int k; + + SVN_ERR(svn_wc__db_read_conflict_victims(&conflict_victims, db, + dir_abspath, + scratch_pool, + scratch_pool)); + + for (k = 0; k < conflict_victims->nelts; k++) + { + int j; + const apr_array_header_t *child_conflicts; + const char *child_name; + const char *child_abspath; + + child_name = APR_ARRAY_IDX(conflict_victims, k, const char *); + child_abspath = svn_dirent_join(dir_abspath, child_name, + scratch_pool); + + SVN_ERR(svn_wc__read_conflicts(&child_conflicts, + db, child_abspath, + FALSE /* create tempfiles */, + scratch_pool, scratch_pool)); + + for (j = 0; j < child_conflicts->nelts; j++) + { + const svn_wc_conflict_description2_t *conflict = + APR_ARRAY_IDX(child_conflicts, j, + svn_wc_conflict_description2_t *); + + if (conflict->kind == svn_wc_conflict_kind_tree) + { + if (!tree_conflicts) + tree_conflicts = apr_hash_make(scratch_pool); + svn_hash_sets(tree_conflicts, child_name, conflict); + } + } + } + + if (tree_conflicts) + { + SVN_ERR(write_tree_conflicts(&entry->tree_conflict_data, + tree_conflicts, result_pool)); + } + } + + if (status == svn_wc__db_status_normal + || status == svn_wc__db_status_incomplete) + { + /* Plain old BASE node. */ + entry->schedule = svn_wc_schedule_normal; + + /* Grab inherited repository information, if necessary. */ + if (repos_relpath == NULL) + { + SVN_ERR(svn_wc__db_scan_base_repos(&repos_relpath, + &entry->repos, + &entry->uuid, + db, + entry_abspath, + result_pool, + scratch_pool)); + } + + entry->incomplete = (status == svn_wc__db_status_incomplete); + } + else if (status == svn_wc__db_status_deleted) + { + svn_node_kind_t path_kind; + + /* ### we don't have to worry about moves, so this is a delete. */ + entry->schedule = svn_wc_schedule_delete; + + /* If there are multiple working layers or no BASE layer, then + this is a WORKING delete or WORKING not-present. */ + if (have_more_work || !have_base) + entry->copied = TRUE; + else if (have_base && !have_more_work) + entry->copied = FALSE; + else + { + const char *work_del_abspath; + SVN_ERR(svn_wc__db_scan_deletion(NULL, NULL, + &work_del_abspath, NULL, + db, entry_abspath, + scratch_pool, scratch_pool)); + + if (work_del_abspath) + entry->copied = TRUE; + } + + /* If there is still a directory on-disk we keep it, if not it is + already deleted. Simple, isn't it? + + Before single-db we had to keep the administative area alive until + after the commit really deletes it. Setting keep alive stopped the + commit processing from deleting the directory. We don't delete it + any more, so all we have to do is provide some 'sane' value. + */ + SVN_ERR(svn_io_check_path(entry_abspath, &path_kind, scratch_pool)); + entry->keep_local = (path_kind == svn_node_dir); + } + else if (status == svn_wc__db_status_added) + { + svn_wc__db_status_t work_status; + const char *op_root_abspath; + const char *scanned_original_relpath; + svn_revnum_t original_revision; + + /* For child nodes, pick up the parent's revision. */ + if (*entry->name != '\0') + { + assert(parent_entry != NULL); + assert(entry->revision == SVN_INVALID_REVNUM); + + entry->revision = parent_entry->revision; + } + + if (have_base) + { + svn_wc__db_status_t base_status; + + /* ENTRY->REVISION is overloaded. When a node is schedule-add + or -replace, then REVISION refers to the BASE node's revision + that is being overwritten. We need to fetch it now. */ + SVN_ERR(svn_wc__db_base_get_info(&base_status, NULL, + &entry->revision, + NULL, NULL, NULL, + NULL, NULL, NULL, + NULL, NULL, NULL, + NULL, NULL, NULL, NULL, + db, entry_abspath, + scratch_pool, + scratch_pool)); + + if (base_status == svn_wc__db_status_not_present) + { + /* The underlying node is DELETED in this revision. */ + entry->deleted = TRUE; + + /* This is an add since there isn't a node to replace. */ + entry->schedule = svn_wc_schedule_add; + } + else + entry->schedule = svn_wc_schedule_replace; + } + else + { + /* There is NO 'not-present' BASE_NODE for this node. + Therefore, we are looking at some kind of add/copy + rather than a replace. */ + + /* ### if this looks like a plain old add, then rev=0. */ + if (!SVN_IS_VALID_REVNUM(entry->copyfrom_rev) + && !SVN_IS_VALID_REVNUM(entry->cmt_rev)) + entry->revision = 0; + + entry->schedule = svn_wc_schedule_add; + } + + /* If we don't have "real" data from the entry (obstruction), + then we cannot begin a scan for data. The original node may + have important data. Set up stuff to kill that idea off, + and finish up this entry. */ + { + SVN_ERR(svn_wc__db_scan_addition(&work_status, + &op_root_abspath, + &repos_relpath, + &entry->repos, + &entry->uuid, + &scanned_original_relpath, + NULL, NULL, /* original_root|uuid */ + &original_revision, + db, + entry_abspath, + result_pool, scratch_pool)); + + /* In wc.db we want to keep the valid revision of the not-present + BASE_REV, but when we used entries we set the revision to 0 + when adding a new node over a not present base node. */ + if (work_status == svn_wc__db_status_added + && entry->deleted) + entry->revision = 0; + } + + if (!SVN_IS_VALID_REVNUM(entry->cmt_rev) + && scanned_original_relpath == NULL) + { + /* There is NOT a last-changed revision (last-changed date and + author may be unknown, but we can always check the rev). + The absence of a revision implies this node was added WITHOUT + any history. Avoid the COPIED checks in the else block. */ + /* ### scan_addition may need to be updated to avoid returning + ### status_copied in this case. */ + } + /* For backwards-compatiblity purposes we treat moves just like + * regular copies. */ + else if (work_status == svn_wc__db_status_copied || + work_status == svn_wc__db_status_moved_here) + { + entry->copied = TRUE; + + /* If this is a child of a copied subtree, then it should be + schedule_normal. */ + if (original_repos_relpath == NULL) + { + /* ### what if there is a BASE node under there? */ + entry->schedule = svn_wc_schedule_normal; + } + + /* Copied nodes need to mirror their copyfrom_rev, if they + don't have a revision of their own already. */ + if (!SVN_IS_VALID_REVNUM(entry->revision) + || entry->revision == 0 /* added */) + entry->revision = original_revision; + } + + /* Does this node have copyfrom_* information? */ + if (scanned_original_relpath != NULL) + { + svn_boolean_t is_copied_child; + svn_boolean_t is_mixed_rev = FALSE; + + SVN_ERR_ASSERT(work_status == svn_wc__db_status_copied || + work_status == svn_wc__db_status_moved_here); + + /* If this node inherits copyfrom information from an + ancestor node, then it must be a copied child. */ + is_copied_child = (original_repos_relpath == NULL); + + /* If this node has copyfrom information on it, then it may + be an actual copy-root, or it could be participating in + a mixed-revision copied tree. So if we don't already know + this is a copied child, then we need to look for this + mixed-revision situation. */ + if (!is_copied_child) + { + const char *parent_abspath; + svn_error_t *err; + const char *parent_repos_relpath; + const char *parent_root_url; + + /* When we insert entries into the database, we will + construct additional copyfrom records for mixed-revision + copies. The old entries would simply record the different + revision in the entry->revision field. That is not + available within wc-ng, so additional copies are made + (see the logic inside write_entry()). However, when + reading these back *out* of the database, the additional + copies look like new "Added" nodes rather than a simple + mixed-rev working copy. + + That would be a behavior change if we did not compensate. + If there is copyfrom information for this node, then the + code below looks at the parent to detect if it *also* has + copyfrom information, and if the copyfrom_url would align + properly. If it *does*, then we omit storing copyfrom_url + and copyfrom_rev (ie. inherit the copyfrom info like a + normal child), and update entry->revision with the + copyfrom_rev in order to (re)create the mixed-rev copied + subtree that was originally presented for storage. */ + + /* Get the copyfrom information from our parent. + + Note that the parent could be added/copied/moved-here. + There is no way for it to be deleted/moved-away and + have *this* node appear as copied. */ + parent_abspath = svn_dirent_dirname(entry_abspath, + scratch_pool); + err = svn_wc__db_scan_addition(NULL, + &op_root_abspath, + NULL, NULL, NULL, + &parent_repos_relpath, + &parent_root_url, + NULL, NULL, + db, parent_abspath, + scratch_pool, + scratch_pool); + if (err) + { + if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND) + return svn_error_trace(err); + svn_error_clear(err); + } + else if (parent_root_url != NULL + && strcmp(original_root_url, parent_root_url) == 0) + { + const char *relpath_to_entry = svn_dirent_is_child( + op_root_abspath, entry_abspath, NULL); + const char *entry_repos_relpath = svn_relpath_join( + parent_repos_relpath, relpath_to_entry, scratch_pool); + + /* The copyfrom repos roots matched. + + Now we look to see if the copyfrom path of the parent + would align with our own path. If so, then it means + this copyfrom was spontaneously created and inserted + for mixed-rev purposes and can be eliminated without + changing the semantics of a mixed-rev copied subtree. + + See notes/api-errata/wc003.txt for some additional + detail, and potential issues. */ + if (strcmp(entry_repos_relpath, + original_repos_relpath) == 0) + { + is_copied_child = TRUE; + is_mixed_rev = TRUE; + } + } + } + + if (is_copied_child) + { + /* We won't be settig the copyfrom_url, yet need to + clear out the copyfrom_rev. Thus, this node becomes a + child of a copied subtree (rather than its own root). */ + entry->copyfrom_rev = SVN_INVALID_REVNUM; + + /* Children in a copied subtree are schedule normal + since we don't plan to actually *do* anything with + them. Their operation is implied by ancestors. */ + entry->schedule = svn_wc_schedule_normal; + + /* And *finally* we turn this entry into the mixed + revision node that it was intended to be. This + node's revision is taken from the copyfrom record + that we spontaneously constructed. */ + if (is_mixed_rev) + entry->revision = original_revision; + } + else if (original_repos_relpath != NULL) + { + entry->copyfrom_url = + svn_path_url_add_component2(original_root_url, + original_repos_relpath, + result_pool); + } + else + { + /* NOTE: if original_repos_relpath == NULL, then the + second call to scan_addition() will not have occurred. + Thus, this use of OP_ROOT_ABSPATH still contains the + original value where we fetched a value for + SCANNED_REPOS_RELPATH. */ + const char *relpath_to_entry = svn_dirent_is_child( + op_root_abspath, entry_abspath, NULL); + const char *entry_repos_relpath = svn_relpath_join( + scanned_original_relpath, relpath_to_entry, scratch_pool); + + entry->copyfrom_url = + svn_path_url_add_component2(original_root_url, + entry_repos_relpath, + result_pool); + } + } + } + else if (status == svn_wc__db_status_not_present) + { + /* ### buh. 'deleted' nodes are actually supposed to be + ### schedule "normal" since we aren't going to actually *do* + ### anything to this node at commit time. */ + entry->schedule = svn_wc_schedule_normal; + entry->deleted = TRUE; + } + else if (status == svn_wc__db_status_server_excluded) + { + entry->absent = TRUE; + } + else if (status == svn_wc__db_status_excluded) + { + entry->schedule = svn_wc_schedule_normal; + entry->depth = svn_depth_exclude; + } + else + { + /* ### we should have handled all possible status values. */ + SVN_ERR_MALFUNCTION(); + } + + /* ### higher levels want repos information about deleted nodes, even + ### tho they are not "part of" a repository any more. */ + if (entry->schedule == svn_wc_schedule_delete) + { + SVN_ERR(get_info_for_deleted(entry, + &kind, + &repos_relpath, + &checksum, + &lock, + db, entry_abspath, + parent_entry, + have_base, have_more_work, + result_pool, scratch_pool)); + } + + /* ### default to the infinite depth if we don't know it. */ + if (entry->depth == svn_depth_unknown) + entry->depth = svn_depth_infinity; + + if (kind == svn_node_dir) + entry->kind = svn_node_dir; + else if (kind == svn_node_file) + entry->kind = svn_node_file; + else if (kind == svn_node_symlink) + entry->kind = svn_node_file; /* ### no symlink kind */ + else + entry->kind = svn_node_unknown; + + /* We should always have a REPOS_RELPATH, except for: + - deleted nodes + - certain obstructed nodes + - not-present nodes + - absent nodes + - excluded nodes + + ### the last three should probably have an "implied" REPOS_RELPATH + */ + SVN_ERR_ASSERT(repos_relpath != NULL + || entry->schedule == svn_wc_schedule_delete + || status == svn_wc__db_status_not_present + || status == svn_wc__db_status_server_excluded + || status == svn_wc__db_status_excluded); + if (repos_relpath) + entry->url = svn_path_url_add_component2(entry->repos, + repos_relpath, + result_pool); + + if (checksum) + { + /* We got a SHA-1, get the corresponding MD-5. */ + if (checksum->kind != svn_checksum_md5) + SVN_ERR(svn_wc__db_pristine_get_md5(&checksum, db, + entry_abspath, checksum, + scratch_pool, scratch_pool)); + + SVN_ERR_ASSERT(checksum->kind == svn_checksum_md5); + entry->checksum = svn_checksum_to_cstring(checksum, result_pool); + } + + if (conflicted) + { + svn_skel_t *conflict; + svn_boolean_t text_conflicted; + svn_boolean_t prop_conflicted; + SVN_ERR(svn_wc__db_read_conflict(&conflict, db, entry_abspath, + scratch_pool, scratch_pool)); + + SVN_ERR(svn_wc__conflict_read_info(NULL, NULL, &text_conflicted, + &prop_conflicted, NULL, + db, dir_abspath, conflict, + scratch_pool, scratch_pool)); + + if (text_conflicted) + { + const char *my_abspath; + const char *their_old_abspath; + const char *their_abspath; + SVN_ERR(svn_wc__conflict_read_text_conflict(&my_abspath, + &their_old_abspath, + &their_abspath, + db, dir_abspath, + conflict, scratch_pool, + scratch_pool)); + + if (my_abspath) + entry->conflict_wrk = svn_dirent_basename(my_abspath, result_pool); + + if (their_old_abspath) + entry->conflict_old = svn_dirent_basename(their_old_abspath, + result_pool); + + if (their_abspath) + entry->conflict_new = svn_dirent_basename(their_abspath, + result_pool); + } + + if (prop_conflicted) + { + const char *prej_abspath; + + SVN_ERR(svn_wc__conflict_read_prop_conflict(&prej_abspath, NULL, + NULL, NULL, NULL, + db, dir_abspath, + conflict, scratch_pool, + scratch_pool)); + + if (prej_abspath) + entry->prejfile = svn_dirent_basename(prej_abspath, result_pool); + } + } + + if (lock) + { + entry->lock_token = lock->token; + entry->lock_owner = lock->owner; + entry->lock_comment = lock->comment; + entry->lock_creation_date = lock->date; + } + + /* Let's check for a file external. ugh. */ + if (status == svn_wc__db_status_normal + && kind == svn_node_file) + SVN_ERR(check_file_external(entry, db, entry_abspath, dir_abspath, + result_pool, scratch_pool)); + + entry->working_size = translated_size; + + *new_entry = entry; + + return SVN_NO_ERROR; +} + +/* Read entries for PATH/LOCAL_ABSPATH from DB. The entries + will be allocated in RESULT_POOL, with temporary allocations in + SCRATCH_POOL. The entries are returned in RESULT_ENTRIES. */ +static svn_error_t * +read_entries_new(apr_hash_t **result_entries, + svn_wc__db_t *db, + const char *local_abspath, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + apr_hash_t *entries; + const apr_array_header_t *children; + apr_pool_t *iterpool = svn_pool_create(scratch_pool); + int i; + const svn_wc_entry_t *parent_entry; + apr_int64_t wc_id = 1; /* ### hacky. should remove. */ + + entries = apr_hash_make(result_pool); + + SVN_ERR(read_one_entry(&parent_entry, db, wc_id, local_abspath, + "" /* name */, + NULL /* parent_entry */, + result_pool, iterpool)); + svn_hash_sets(entries, "", parent_entry); + + /* Use result_pool so that the child names (used by reference, rather + than copied) appear in result_pool. */ + SVN_ERR(svn_wc__db_read_children(&children, db, + local_abspath, + result_pool, iterpool)); + for (i = children->nelts; i--; ) + { + const char *name = APR_ARRAY_IDX(children, i, const char *); + const svn_wc_entry_t *entry; + + svn_pool_clear(iterpool); + + SVN_ERR(read_one_entry(&entry, + db, wc_id, local_abspath, name, parent_entry, + result_pool, iterpool)); + svn_hash_sets(entries, entry->name, entry); + } + + svn_pool_destroy(iterpool); + + *result_entries = entries; + + return SVN_NO_ERROR; +} + + +/* Read a pair of entries from wc_db in the directory DIR_ABSPATH. Return + the directory's entry in *PARENT_ENTRY and NAME's entry in *ENTRY. The + two returned pointers will be the same if NAME=="" ("this dir"). + + The parent entry must exist. + + The requested entry MAY exist. If it does not, then NULL will be returned. + + The resulting entries are allocated in RESULT_POOL, and all temporary + allocations are made in SCRATCH_POOL. */ +static svn_error_t * +read_entry_pair(const svn_wc_entry_t **parent_entry, + const svn_wc_entry_t **entry, + svn_wc__db_t *db, + const char *dir_abspath, + const char *name, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + apr_int64_t wc_id = 1; /* ### hacky. should remove. */ + + SVN_ERR(read_one_entry(parent_entry, db, wc_id, dir_abspath, + "" /* name */, + NULL /* parent_entry */, + result_pool, scratch_pool)); + + /* If we need the entry for "this dir", then return the parent_entry + in both outputs. Otherwise, read the child node. */ + if (*name == '\0') + { + /* If the retrieved node is a FILE, then we have a problem. We asked + for a directory. This implies there is an obstructing, unversioned + directory where a FILE should be. We navigated from the obstructing + subdir up to the parent dir, then returned the FILE found there. + + Let's return WC_MISSING cuz the caller thought we had a dir, but + that (versioned subdir) isn't there. */ + if ((*parent_entry)->kind == svn_node_file) + { + *parent_entry = NULL; + return svn_error_createf(SVN_ERR_WC_MISSING, NULL, + _("'%s' is not a versioned working copy"), + svn_dirent_local_style(dir_abspath, + scratch_pool)); + } + + *entry = *parent_entry; + } + else + { + const apr_array_header_t *children; + int i; + + /* Default to not finding the child. */ + *entry = NULL; + + /* Determine whether the parent KNOWS about this child. If it does + not, then we should not attempt to look for it. + + For example: the parent doesn't "know" about the child, but the + versioned directory *does* exist on disk. We don't want to look + into that subdir. */ + SVN_ERR(svn_wc__db_read_children(&children, db, dir_abspath, + scratch_pool, scratch_pool)); + for (i = children->nelts; i--; ) + { + const char *child = APR_ARRAY_IDX(children, i, const char *); + + if (strcmp(child, name) == 0) + { + svn_error_t *err; + + err = read_one_entry(entry, + db, wc_id, dir_abspath, name, *parent_entry, + result_pool, scratch_pool); + if (err) + { + if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND) + return svn_error_trace(err); + + /* No problem. Clear the error and leave the default value + of "missing". */ + svn_error_clear(err); + } + + /* Found it. No need to keep searching. */ + break; + } + } + /* if the loop ends without finding a child, then we have the default + ENTRY value of NULL. */ + } + + return SVN_NO_ERROR; +} + + +/* */ +static svn_error_t * +read_entries(apr_hash_t **entries, + svn_wc__db_t *db, + const char *wcroot_abspath, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + int wc_format; + + SVN_ERR(svn_wc__db_temp_get_format(&wc_format, db, wcroot_abspath, + scratch_pool)); + + if (wc_format < SVN_WC__WC_NG_VERSION) + return svn_error_trace(svn_wc__read_entries_old(entries, + wcroot_abspath, + result_pool, + scratch_pool)); + + return svn_error_trace(read_entries_new(entries, db, wcroot_abspath, + result_pool, scratch_pool)); +} + + +/* For a given LOCAL_ABSPATH, using DB, set *ADM_ABSPATH to the directory in + which the entry information is located, and *ENTRY_NAME to the entry name + to access that entry. + + KIND is as in svn_wc__get_entry(). + + Return the results in RESULT_POOL and use SCRATCH_POOL for temporary + allocations. */ +static svn_error_t * +get_entry_access_info(const char **adm_abspath, + const char **entry_name, + svn_wc__db_t *db, + const char *local_abspath, + svn_node_kind_t kind, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + svn_wc_adm_access_t *adm_access; + svn_boolean_t read_from_subdir = FALSE; + + /* If the caller didn't know the node kind, then stat the path. Maybe + it is really there, and we can speed up the steps below. */ + if (kind == svn_node_unknown) + { + svn_node_kind_t on_disk; + + /* Do we already have an access baton for LOCAL_ABSPATH? */ + adm_access = svn_wc__adm_retrieve_internal2(db, local_abspath, + scratch_pool); + if (adm_access) + { + /* Sweet. The node is a directory. */ + on_disk = svn_node_dir; + } + else + { + svn_boolean_t special; + + /* What's on disk? */ + SVN_ERR(svn_io_check_special_path(local_abspath, &on_disk, &special, + scratch_pool)); + } + + if (on_disk != svn_node_dir) + { + /* If this is *anything* besides a directory (FILE, NONE, or + UNKNOWN), then we cannot treat it as a versioned directory + containing entries to read. Leave READ_FROM_SUBDIR as FALSE, + so that the parent will be examined. + + For NONE and UNKNOWN, it may be that metadata exists for the + node, even though on-disk is unhelpful. + + If NEED_PARENT_STUB is TRUE, and the entry is not a DIRECTORY, + then we'll error. + + If NEED_PARENT_STUB if FALSE, and we successfully read a stub, + then this on-disk node is obstructing the read. */ + } + else + { + /* We found a directory for this UNKNOWN node. Determine whether + we need to read inside it. */ + read_from_subdir = TRUE; + } + } + else if (kind == svn_node_dir) + { + read_from_subdir = TRUE; + } + + if (read_from_subdir) + { + /* KIND must be a DIR or UNKNOWN (and we found a subdir). We want + the "real" data, so treat LOCAL_ABSPATH as a versioned directory. */ + *adm_abspath = apr_pstrdup(result_pool, local_abspath); + *entry_name = ""; + } + else + { + /* FILE node needs to read the parent directory. Or a DIR node + needs to read from the parent to get at the stub entry. Or this + is an UNKNOWN node, and we need to examine the parent. */ + svn_dirent_split(adm_abspath, entry_name, local_abspath, result_pool); + } + + return SVN_NO_ERROR; +} + + +svn_error_t * +svn_wc__get_entry(const svn_wc_entry_t **entry, + svn_wc__db_t *db, + const char *local_abspath, + svn_boolean_t allow_unversioned, + svn_node_kind_t kind, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + const char *dir_abspath; + const char *entry_name; + + SVN_ERR(get_entry_access_info(&dir_abspath, &entry_name, db, local_abspath, + kind, scratch_pool, scratch_pool)); + + { + const svn_wc_entry_t *parent_entry; + svn_error_t *err; + + /* NOTE: if KIND is UNKNOWN and we decided to examine the *parent* + directory, then it is possible we moved out of the working copy. + If the on-disk node is a DIR, and we asked for a stub, then we + obviously can't provide that (parent has no info). If the on-disk + node is a FILE/NONE/UNKNOWN, then it is obstructing the real + LOCAL_ABSPATH (or it was never a versioned item). In all these + cases, the read_entries() will (properly) throw an error. + + NOTE: if KIND is a DIR and we asked for the real data, but it is + obstructed on-disk by some other node kind (NONE, FILE, UNKNOWN), + then this will throw an error. */ + + err = read_entry_pair(&parent_entry, entry, + db, dir_abspath, entry_name, + result_pool, scratch_pool); + if (err) + { + if (err->apr_err != SVN_ERR_WC_MISSING || kind != svn_node_unknown + || *entry_name != '\0') + return svn_error_trace(err); + svn_error_clear(err); + + /* The caller didn't know the node type, we saw a directory there, + we attempted to read IN that directory, and then wc_db reports + that it is NOT a working copy directory. It is possible that + one of two things has happened: + + 1) a directory is obstructing a file in the parent + 2) the (versioned) directory's contents have been removed + + Let's assume situation (1); if that is true, then we can just + return the newly-found data. + + If we assumed (2), then a valid result still won't help us + since the caller asked for the actual contents, not the stub + (which is why we read *into* the directory). However, if we + assume (1) and get back a stub, then we have verified a + missing, versioned directory, and can return an error + describing that. + + Redo the fetch, but "insist" we are trying to find a file. + This will read from the parent directory of the "file". */ + err = svn_wc__get_entry(entry, db, local_abspath, allow_unversioned, + svn_node_file, result_pool, scratch_pool); + if (err == SVN_NO_ERROR) + return SVN_NO_ERROR; + if (err->apr_err != SVN_ERR_NODE_UNEXPECTED_KIND) + return svn_error_trace(err); + svn_error_clear(err); + + /* We asked for a FILE, but the node found is a DIR. Thus, we + are looking at a stub. Originally, we tried to read into the + subdir because NEED_PARENT_STUB is FALSE. The stub we just + read is not going to work for the caller, so inform them of + the missing subdirectory. */ + SVN_ERR_ASSERT(*entry != NULL && (*entry)->kind == svn_node_dir); + return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL, + _("Admin area of '%s' is missing"), + svn_dirent_local_style(local_abspath, + scratch_pool)); + } + } + + if (*entry == NULL) + { + if (allow_unversioned) + return SVN_NO_ERROR; + return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL, + _("'%s' is not under version control"), + svn_dirent_local_style(local_abspath, + scratch_pool)); + } + + /* The caller had the wrong information. */ + if ((kind == svn_node_file && (*entry)->kind != svn_node_file) + || (kind == svn_node_dir && (*entry)->kind != svn_node_dir)) + return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL, + _("'%s' is not of the right kind"), + svn_dirent_local_style(local_abspath, + scratch_pool)); + + return SVN_NO_ERROR; +} + +/* TODO ### Rewrite doc string to mention ENTRIES_ALL; not ADM_ACCESS. + + Prune the deleted entries from the cached entries in ADM_ACCESS, and + return that collection in *ENTRIES_PRUNED. SCRATCH_POOL is used for local, + short term, memory allocation, RESULT_POOL for permanent stuff. */ +static svn_error_t * +prune_deleted(apr_hash_t **entries_pruned, + apr_hash_t *entries_all, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + apr_hash_index_t *hi; + + if (!entries_all) + { + *entries_pruned = NULL; + return SVN_NO_ERROR; + } + + /* I think it will be common for there to be no deleted entries, so + it is worth checking for that case as we can optimise it. */ + for (hi = apr_hash_first(scratch_pool, entries_all); + hi; + hi = apr_hash_next(hi)) + { + svn_boolean_t hidden; + + SVN_ERR(svn_wc__entry_is_hidden(&hidden, + svn__apr_hash_index_val(hi))); + if (hidden) + break; + } + + if (! hi) + { + /* There are no deleted entries, so we can use the full hash */ + *entries_pruned = entries_all; + return SVN_NO_ERROR; + } + + /* Construct pruned hash without deleted entries */ + *entries_pruned = apr_hash_make(result_pool); + for (hi = apr_hash_first(scratch_pool, entries_all); + hi; + hi = apr_hash_next(hi)) + { + const void *key = svn__apr_hash_index_key(hi); + const svn_wc_entry_t *entry = svn__apr_hash_index_val(hi); + svn_boolean_t hidden; + + SVN_ERR(svn_wc__entry_is_hidden(&hidden, entry)); + if (!hidden) + svn_hash_sets(*entries_pruned, key, entry); + } + + return SVN_NO_ERROR; +} + +struct entries_read_baton_t +{ + apr_hash_t **new_entries; + svn_wc__db_t *db; + const char *local_abspath; + apr_pool_t *result_pool; +}; + +static svn_error_t * +entries_read_txn(void *baton, svn_sqlite__db_t *db, apr_pool_t *scratch_pool) +{ + struct entries_read_baton_t *erb = baton; + + SVN_ERR(read_entries(erb->new_entries, erb->db, erb->local_abspath, + erb->result_pool, scratch_pool)); + + return NULL; +} + +svn_error_t * +svn_wc__entries_read_internal(apr_hash_t **entries, + svn_wc_adm_access_t *adm_access, + svn_boolean_t show_hidden, + apr_pool_t *pool) +{ + apr_hash_t *new_entries; + + new_entries = svn_wc__adm_access_entries(adm_access); + if (! new_entries) + { + svn_wc__db_t *db = svn_wc__adm_get_db(adm_access); + const char *local_abspath = svn_wc__adm_access_abspath(adm_access); + apr_pool_t *result_pool = svn_wc__adm_access_pool_internal(adm_access); + svn_sqlite__db_t *sdb; + struct entries_read_baton_t erb; + + /* ### Use the borrow DB api to handle all calls in a single read + ### transaction. This api is used extensively in our test suite + ### via the entries-read application. */ + + SVN_ERR(svn_wc__db_temp_borrow_sdb(&sdb, db, local_abspath, pool)); + + erb.db = db; + erb.local_abspath = local_abspath; + erb.new_entries = &new_entries; + erb.result_pool = result_pool; + + SVN_ERR(svn_sqlite__with_lock(sdb, entries_read_txn, &erb, pool)); + + svn_wc__adm_access_set_entries(adm_access, new_entries); + } + + if (show_hidden) + *entries = new_entries; + else + SVN_ERR(prune_deleted(entries, new_entries, + svn_wc__adm_access_pool_internal(adm_access), + pool)); + + return SVN_NO_ERROR; +} + +svn_error_t * +svn_wc_entries_read(apr_hash_t **entries, + svn_wc_adm_access_t *adm_access, + svn_boolean_t show_hidden, + apr_pool_t *pool) +{ + return svn_error_trace(svn_wc__entries_read_internal(entries, adm_access, + show_hidden, pool)); +} + +/* No transaction required: called from write_entry which is itself + transaction-wrapped. */ +static svn_error_t * +insert_node(svn_sqlite__db_t *sdb, + const db_node_t *node, + apr_pool_t *scratch_pool) +{ + svn_sqlite__stmt_t *stmt; + + SVN_ERR_ASSERT(node->op_depth > 0 || node->repos_relpath); + + SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_INSERT_NODE)); + SVN_ERR(svn_sqlite__bindf(stmt, "isdsnnnnsnrisnnni", + node->wc_id, + node->local_relpath, + node->op_depth, + node->parent_relpath, + /* Setting depth for files? */ + svn_depth_to_word(node->depth), + node->changed_rev, + node->changed_date, + node->changed_author, + node->recorded_time)); + + if (node->repos_relpath) + { + SVN_ERR(svn_sqlite__bind_int64(stmt, 5, + node->repos_id)); + SVN_ERR(svn_sqlite__bind_text(stmt, 6, + node->repos_relpath)); + SVN_ERR(svn_sqlite__bind_revnum(stmt, 7, node->revision)); + } + + if (node->presence == svn_wc__db_status_normal) + SVN_ERR(svn_sqlite__bind_text(stmt, 8, "normal")); + else if (node->presence == svn_wc__db_status_not_present) + SVN_ERR(svn_sqlite__bind_text(stmt, 8, "not-present")); + else if (node->presence == svn_wc__db_status_base_deleted) + SVN_ERR(svn_sqlite__bind_text(stmt, 8, "base-deleted")); + else if (node->presence == svn_wc__db_status_incomplete) + SVN_ERR(svn_sqlite__bind_text(stmt, 8, "incomplete")); + else if (node->presence == svn_wc__db_status_excluded) + SVN_ERR(svn_sqlite__bind_text(stmt, 8, "excluded")); + else if (node->presence == svn_wc__db_status_server_excluded) + SVN_ERR(svn_sqlite__bind_text(stmt, 8, "server-excluded")); + + if (node->kind == svn_node_none) + SVN_ERR(svn_sqlite__bind_text(stmt, 10, "unknown")); + else + SVN_ERR(svn_sqlite__bind_text(stmt, 10, + svn_node_kind_to_word(node->kind))); + + if (node->kind == svn_node_file) + { + if (!node->checksum + && node->op_depth == 0 + && node->presence != svn_wc__db_status_not_present + && node->presence != svn_wc__db_status_excluded + && node->presence != svn_wc__db_status_server_excluded) + return svn_error_createf(SVN_ERR_WC_CORRUPT, NULL, + _("The file '%s' has no checksum"), + svn_dirent_local_style(node->local_relpath, + scratch_pool)); + + SVN_ERR(svn_sqlite__bind_checksum(stmt, 14, node->checksum, + scratch_pool)); + } + + if (node->properties) /* ### Never set, props done later */ + SVN_ERR(svn_sqlite__bind_properties(stmt, 15, node->properties, + scratch_pool)); + + if (node->recorded_size != SVN_INVALID_FILESIZE) + SVN_ERR(svn_sqlite__bind_int64(stmt, 16, node->recorded_size)); + + if (node->file_external) + SVN_ERR(svn_sqlite__bind_int(stmt, 20, 1)); + + if (node->inherited_props) + SVN_ERR(svn_sqlite__bind_iprops(stmt, 23, node->inherited_props, + scratch_pool)); + + SVN_ERR(svn_sqlite__insert(NULL, stmt)); + + return SVN_NO_ERROR; +} + + +/* */ +static svn_error_t * +insert_actual_node(svn_sqlite__db_t *sdb, + svn_wc__db_t *db, + const char *wri_abspath, + const db_actual_node_t *actual_node, + apr_pool_t *scratch_pool) +{ + svn_sqlite__stmt_t *stmt; + svn_skel_t *conflict_data = NULL; + + SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_INSERT_ACTUAL_NODE)); + + SVN_ERR(svn_sqlite__bind_int64(stmt, 1, actual_node->wc_id)); + SVN_ERR(svn_sqlite__bind_text(stmt, 2, actual_node->local_relpath)); + SVN_ERR(svn_sqlite__bind_text(stmt, 3, actual_node->parent_relpath)); + + if (actual_node->properties) + SVN_ERR(svn_sqlite__bind_properties(stmt, 4, actual_node->properties, + scratch_pool)); + + if (actual_node->changelist) + SVN_ERR(svn_sqlite__bind_text(stmt, 5, actual_node->changelist)); + + SVN_ERR(svn_wc__upgrade_conflict_skel_from_raw( + &conflict_data, + db, wri_abspath, + actual_node->local_relpath, + actual_node->conflict_old, + actual_node->conflict_working, + actual_node->conflict_new, + actual_node->prop_reject, + actual_node->tree_conflict_data, + actual_node->tree_conflict_data + ? strlen(actual_node->tree_conflict_data) + : 0, + scratch_pool, scratch_pool)); + + if (conflict_data) + { + svn_stringbuf_t *data = svn_skel__unparse(conflict_data, scratch_pool); + + SVN_ERR(svn_sqlite__bind_blob(stmt, 6, data->data, data->len)); + } + + /* Execute and reset the insert clause. */ + return svn_error_trace(svn_sqlite__insert(NULL, stmt)); +} + +static svn_boolean_t +is_switched(db_node_t *parent, + db_node_t *child, + apr_pool_t *scratch_pool) +{ + if (parent && child) + { + if (parent->repos_id != child->repos_id) + return TRUE; + + if (parent->repos_relpath && child->repos_relpath) + { + const char *unswitched + = svn_relpath_join(parent->repos_relpath, + svn_relpath_basename(child->local_relpath, + scratch_pool), + scratch_pool); + if (strcmp(unswitched, child->repos_relpath)) + return TRUE; + } + } + + return FALSE; +} + +struct write_baton { + db_node_t *base; + db_node_t *work; + db_node_t *below_work; + apr_hash_t *tree_conflicts; +}; + +#define WRITE_ENTRY_ASSERT(expr) \ + if (!(expr)) \ + return svn_error_createf(SVN_ERR_ASSERTION_FAIL, NULL, \ + _("Unable to upgrade '%s' at line %d"), \ + svn_dirent_local_style( \ + svn_dirent_join(root_abspath, \ + local_relpath, \ + scratch_pool), \ + scratch_pool), __LINE__) + +/* Write the information for ENTRY to WC_DB. The WC_ID, REPOS_ID and + REPOS_ROOT will all be used for writing ENTRY. + ### transitioning from straight sql to using the wc_db APIs. For the + ### time being, we'll need both parameters. */ +static svn_error_t * +write_entry(struct write_baton **entry_node, + const struct write_baton *parent_node, + svn_wc__db_t *db, + svn_sqlite__db_t *sdb, + apr_int64_t wc_id, + apr_int64_t repos_id, + const svn_wc_entry_t *entry, + const svn_wc__text_base_info_t *text_base_info, + const char *local_relpath, + const char *tmp_entry_abspath, + const char *root_abspath, + const svn_wc_entry_t *this_dir, + svn_boolean_t create_locks, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + db_node_t *base_node = NULL; + db_node_t *working_node = NULL, *below_working_node = NULL; + db_actual_node_t *actual_node = NULL; + const char *parent_relpath; + apr_hash_t *tree_conflicts; + + if (*local_relpath == '\0') + parent_relpath = NULL; + else + parent_relpath = svn_relpath_dirname(local_relpath, scratch_pool); + + /* This is how it should work, it doesn't work like this yet because + we need proper op_depth to layer the working nodes. + + Using "svn add", "svn rm", "svn cp" only files can be replaced + pre-wcng; directories can only be normal, deleted or added. + Files cannot be replaced within a deleted directory, so replaced + files can only exist in a normal directory, or a directory that + is added+copied. In a normal directory a replaced file needs a + base node and a working node, in an added+copied directory a + replaced file needs two working nodes at different op-depths. + + With just the above operations the conversion for files and + directories is straightforward: + + pre-wcng wcng + parent child parent child + + normal normal base base + add+copied normal+copied work work + normal+copied normal+copied work work + normal delete base base+work + delete delete base+work base+work + add+copied delete work work + normal add base work + add add work work + add+copied add work work + normal add+copied base work + add add+copied work work + add+copied add+copied work work + normal replace base base+work + add+copied replace work work+work + normal replace+copied base base+work + add+copied replace+copied work work+work + + However "svn merge" make this more complicated. The pre-wcng + "svn merge" is capable of replacing a directory, that is it can + mark the whole tree deleted, and then copy another tree on top. + The entries then represent the replacing tree overlayed on the + deleted tree. + + original replace schedule in + tree tree combined tree + + A A replace+copied + A/f delete+copied + A/g A/g replace+copied + A/h add+copied + A/B A/B replace+copied + A/B/f delete+copied + A/B/g A/B/g replace+copied + A/B/h add+copied + A/C delete+copied + A/C/f delete+copied + A/D add+copied + A/D/f add+copied + + The original tree could be normal tree, or an add+copied tree. + Committing such a merge generally worked, but making further tree + modifications before commit sometimes failed. + + The root of the replace is handled like the file replace: + + pre-wcng wcng + parent child parent child + + normal replace+copied base base+work + add+copied replace+copied work work+work + + although obviously the node is a directory rather then a file. + There are then more conversion states where the parent is + replaced. + + pre-wcng wcng + parent child parent child + + replace+copied add [base|work]+work work + replace+copied add+copied [base|work]+work work + replace+copied delete+copied [base|work]+work [base|work]+work + delete+copied delete+copied [base|work]+work [base|work]+work + replace+copied replace+copied [base|work]+work [base|work]+work + */ + + WRITE_ENTRY_ASSERT(parent_node || entry->schedule == svn_wc_schedule_normal); + + WRITE_ENTRY_ASSERT(!parent_node || parent_node->base + || parent_node->below_work || parent_node->work); + + switch (entry->schedule) + { + case svn_wc_schedule_normal: + if (entry->copied || + (entry->depth == svn_depth_exclude + && parent_node && !parent_node->base && parent_node->work)) + working_node = MAYBE_ALLOC(working_node, result_pool); + else + base_node = MAYBE_ALLOC(base_node, result_pool); + break; + + case svn_wc_schedule_add: + working_node = MAYBE_ALLOC(working_node, result_pool); + if (entry->deleted) + { + if (parent_node->base) + base_node = MAYBE_ALLOC(base_node, result_pool); + else + below_working_node = MAYBE_ALLOC(below_working_node, result_pool); + } + break; + + case svn_wc_schedule_delete: + working_node = MAYBE_ALLOC(working_node, result_pool); + if (parent_node->base) + base_node = MAYBE_ALLOC(base_node, result_pool); + if (parent_node->work) + below_working_node = MAYBE_ALLOC(below_working_node, result_pool); + break; + + case svn_wc_schedule_replace: + working_node = MAYBE_ALLOC(working_node, result_pool); + if (parent_node->base) + base_node = MAYBE_ALLOC(base_node, result_pool); + else + below_working_node = MAYBE_ALLOC(below_working_node, result_pool); + break; + } + + /* Something deleted in this revision means there should always be a + BASE node to indicate the not-present node. */ + if (entry->deleted) + { + WRITE_ENTRY_ASSERT(base_node || below_working_node); + WRITE_ENTRY_ASSERT(!entry->incomplete); + if (base_node) + base_node->presence = svn_wc__db_status_not_present; + else + below_working_node->presence = svn_wc__db_status_not_present; + } + else if (entry->absent) + { + WRITE_ENTRY_ASSERT(base_node && !working_node && !below_working_node); + WRITE_ENTRY_ASSERT(!entry->incomplete); + base_node->presence = svn_wc__db_status_server_excluded; + } + + if (entry->copied) + { + if (entry->copyfrom_url) + { + working_node->repos_id = repos_id; + working_node->repos_relpath = svn_uri_skip_ancestor( + this_dir->repos, entry->copyfrom_url, + result_pool); + working_node->revision = entry->copyfrom_rev; + working_node->op_depth + = svn_wc__db_op_depth_for_upgrade(local_relpath); + } + else if (parent_node->work && parent_node->work->repos_relpath) + { + working_node->repos_id = repos_id; + working_node->repos_relpath + = svn_relpath_join(parent_node->work->repos_relpath, + svn_relpath_basename(local_relpath, NULL), + result_pool); + working_node->revision = parent_node->work->revision; + working_node->op_depth = parent_node->work->op_depth; + } + else if (parent_node->below_work + && parent_node->below_work->repos_relpath) + { + working_node->repos_id = repos_id; + working_node->repos_relpath + = svn_relpath_join(parent_node->below_work->repos_relpath, + svn_relpath_basename(local_relpath, NULL), + result_pool); + working_node->revision = parent_node->below_work->revision; + working_node->op_depth = parent_node->below_work->op_depth; + } + else + return svn_error_createf(SVN_ERR_ENTRY_MISSING_URL, NULL, + _("No copyfrom URL for '%s'"), + svn_dirent_local_style(local_relpath, + scratch_pool)); + } + + if (entry->conflict_old) + { + actual_node = MAYBE_ALLOC(actual_node, scratch_pool); + if (parent_relpath && entry->conflict_old) + actual_node->conflict_old = svn_relpath_join(parent_relpath, + entry->conflict_old, + scratch_pool); + else + actual_node->conflict_old = entry->conflict_old; + if (parent_relpath && entry->conflict_new) + actual_node->conflict_new = svn_relpath_join(parent_relpath, + entry->conflict_new, + scratch_pool); + else + actual_node->conflict_new = entry->conflict_new; + if (parent_relpath && entry->conflict_wrk) + actual_node->conflict_working = svn_relpath_join(parent_relpath, + entry->conflict_wrk, + scratch_pool); + else + actual_node->conflict_working = entry->conflict_wrk; + } + + if (entry->prejfile) + { + actual_node = MAYBE_ALLOC(actual_node, scratch_pool); + actual_node->prop_reject = svn_relpath_join((entry->kind == svn_node_dir + ? local_relpath + : parent_relpath), + entry->prejfile, + scratch_pool); + } + + if (entry->changelist) + { + actual_node = MAYBE_ALLOC(actual_node, scratch_pool); + actual_node->changelist = entry->changelist; + } + + /* ### set the text_mod value? */ + + if (entry_node && entry->tree_conflict_data) + { + /* Issues #3840/#3916: 1.6 stores multiple tree conflicts on the + parent node, 1.7 stores them directly on the conflited nodes. + So "((skel1) (skel2))" becomes "(skel1)" and "(skel2)" */ + svn_skel_t *skel; + + skel = svn_skel__parse(entry->tree_conflict_data, + strlen(entry->tree_conflict_data), + scratch_pool); + tree_conflicts = apr_hash_make(result_pool); + skel = skel->children; + while(skel) + { + svn_wc_conflict_description2_t *conflict; + svn_skel_t *new_skel; + const char *key; + + /* *CONFLICT is allocated so it is safe to use a non-const pointer */ + SVN_ERR(svn_wc__deserialize_conflict( + (const svn_wc_conflict_description2_t**)&conflict, + skel, + svn_dirent_join(root_abspath, + local_relpath, + scratch_pool), + scratch_pool, scratch_pool)); + + WRITE_ENTRY_ASSERT(conflict->kind == svn_wc_conflict_kind_tree); + + /* Fix dubious data stored by old clients, local adds don't have + a repository URL. */ + if (conflict->reason == svn_wc_conflict_reason_added) + conflict->src_left_version = NULL; + + SVN_ERR(svn_wc__serialize_conflict(&new_skel, conflict, + scratch_pool, scratch_pool)); + + /* Store in hash to be retrieved when writing the child + row. */ + key = svn_dirent_skip_ancestor(root_abspath, conflict->local_abspath); + svn_hash_sets(tree_conflicts, apr_pstrdup(result_pool, key), + svn_skel__unparse(new_skel, result_pool)->data); + skel = skel->next; + } + } + else + tree_conflicts = NULL; + + if (parent_node && parent_node->tree_conflicts) + { + const char *tree_conflict_data = + svn_hash_gets(parent_node->tree_conflicts, local_relpath); + if (tree_conflict_data) + { + actual_node = MAYBE_ALLOC(actual_node, scratch_pool); + actual_node->tree_conflict_data = tree_conflict_data; + } + + /* Reset hash so that we don't write the row again when writing + actual-only nodes */ + svn_hash_sets(parent_node->tree_conflicts, local_relpath, NULL); + } + + if (entry->file_external_path != NULL) + { + base_node = MAYBE_ALLOC(base_node, result_pool); + } + + + /* Insert the base node. */ + if (base_node) + { + base_node->wc_id = wc_id; + base_node->local_relpath = local_relpath; + base_node->op_depth = 0; + base_node->parent_relpath = parent_relpath; + base_node->revision = entry->revision; + base_node->recorded_time = entry->text_time; + base_node->recorded_size = entry->working_size; + + if (entry->depth != svn_depth_exclude) + base_node->depth = entry->depth; + else + { + base_node->presence = svn_wc__db_status_excluded; + base_node->depth = svn_depth_infinity; + } + + if (entry->deleted) + { + WRITE_ENTRY_ASSERT(base_node->presence + == svn_wc__db_status_not_present); + /* ### should be svn_node_unknown, but let's store what we have. */ + base_node->kind = entry->kind; + } + else if (entry->absent) + { + WRITE_ENTRY_ASSERT(base_node->presence + == svn_wc__db_status_server_excluded); + /* ### should be svn_node_unknown, but let's store what we have. */ + base_node->kind = entry->kind; + + /* Store the most likely revision in the node to avoid + base nodes without a valid revision. Of course + we remember that the data is still incomplete. */ + if (!SVN_IS_VALID_REVNUM(base_node->revision) && parent_node->base) + base_node->revision = parent_node->base->revision; + } + else + { + base_node->kind = entry->kind; + + if (base_node->presence != svn_wc__db_status_excluded) + { + /* All subdirs are initially incomplete, they stop being + incomplete when the entries file in the subdir is + upgraded and remain incomplete if that doesn't happen. */ + if (entry->kind == svn_node_dir + && strcmp(entry->name, SVN_WC_ENTRY_THIS_DIR)) + { + base_node->presence = svn_wc__db_status_incomplete; + + /* Store the most likely revision in the node to avoid + base nodes without a valid revision. Of course + we remember that the data is still incomplete. */ + if (parent_node->base) + base_node->revision = parent_node->base->revision; + } + else if (entry->incomplete) + { + /* ### nobody should have set the presence. */ + WRITE_ENTRY_ASSERT(base_node->presence + == svn_wc__db_status_normal); + base_node->presence = svn_wc__db_status_incomplete; + } + } + } + + if (entry->kind == svn_node_dir) + base_node->checksum = NULL; + else + { + if (text_base_info && text_base_info->revert_base.sha1_checksum) + base_node->checksum = text_base_info->revert_base.sha1_checksum; + else if (text_base_info && text_base_info->normal_base.sha1_checksum) + base_node->checksum = text_base_info->normal_base.sha1_checksum; + else + base_node->checksum = NULL; + + /* The base MD5 checksum is available in the entry, unless there + * is a copied WORKING node. If possible, verify that the entry + * checksum matches the base file that we found. */ + if (! (working_node && entry->copied)) + { + svn_checksum_t *entry_md5_checksum, *found_md5_checksum; + SVN_ERR(svn_checksum_parse_hex(&entry_md5_checksum, + svn_checksum_md5, + entry->checksum, scratch_pool)); + if (text_base_info && text_base_info->revert_base.md5_checksum) + found_md5_checksum = text_base_info->revert_base.md5_checksum; + else if (text_base_info + && text_base_info->normal_base.md5_checksum) + found_md5_checksum = text_base_info->normal_base.md5_checksum; + else + found_md5_checksum = NULL; + if (entry_md5_checksum && found_md5_checksum && + !svn_checksum_match(entry_md5_checksum, found_md5_checksum)) + return svn_error_createf(SVN_ERR_WC_CORRUPT, NULL, + _("Bad base MD5 checksum for '%s'; " + "expected: '%s'; found '%s'; "), + svn_dirent_local_style( + svn_dirent_join(root_abspath, + local_relpath, + scratch_pool), + scratch_pool), + svn_checksum_to_cstring_display( + entry_md5_checksum, scratch_pool), + svn_checksum_to_cstring_display( + found_md5_checksum, scratch_pool)); + else + { + /* ### Not sure what conditions this should cover. */ + /* SVN_ERR_ASSERT(entry->deleted || ...); */ + } + } + } + + if (this_dir->repos) + { + base_node->repos_id = repos_id; + + if (entry->url != NULL) + { + base_node->repos_relpath = svn_uri_skip_ancestor( + this_dir->repos, entry->url, + result_pool); + } + else + { + const char *relpath = svn_uri_skip_ancestor(this_dir->repos, + this_dir->url, + scratch_pool); + if (relpath == NULL || *relpath == '\0') + base_node->repos_relpath = entry->name; + else + base_node->repos_relpath = + svn_dirent_join(relpath, entry->name, result_pool); + } + } + + /* TODO: These values should always be present, if they are missing + during an upgrade, set a flag, and then ask the user to talk to the + server. + + Note: cmt_rev is the distinguishing value. The others may be 0 or + NULL if the corresponding revprop has been deleted. */ + base_node->changed_rev = entry->cmt_rev; + base_node->changed_date = entry->cmt_date; + base_node->changed_author = entry->cmt_author; + + if (entry->file_external_path) + base_node->file_external = TRUE; + + /* Switched nodes get an empty iprops cache. */ + if (parent_node + && is_switched(parent_node->base, base_node, scratch_pool)) + base_node->inherited_props + = apr_array_make(scratch_pool, 0, sizeof(svn_prop_inherited_item_t*)); + + SVN_ERR(insert_node(sdb, base_node, scratch_pool)); + + /* We have to insert the lock after the base node, because the node + must exist to lookup various bits of repos related information for + the abs path. */ + if (entry->lock_token && create_locks) + { + svn_wc__db_lock_t lock; + + lock.token = entry->lock_token; + lock.owner = entry->lock_owner; + lock.comment = entry->lock_comment; + lock.date = entry->lock_creation_date; + + SVN_ERR(svn_wc__db_lock_add(db, tmp_entry_abspath, &lock, + scratch_pool)); + } + } + + if (below_working_node) + { + db_node_t *work + = parent_node->below_work ? parent_node->below_work : parent_node->work; + + below_working_node->wc_id = wc_id; + below_working_node->local_relpath = local_relpath; + below_working_node->op_depth = work->op_depth; + below_working_node->parent_relpath = parent_relpath; + below_working_node->presence = svn_wc__db_status_normal; + below_working_node->kind = entry->kind; + below_working_node->repos_id = work->repos_id; + + /* This is just guessing. If the node below would have been switched + or if it was updated to a different version, the guess would + fail. But we don't have better information pre wc-ng :( */ + if (work->repos_relpath) + below_working_node->repos_relpath + = svn_relpath_join(work->repos_relpath, entry->name, + result_pool); + else + below_working_node->repos_relpath = NULL; + below_working_node->revision = parent_node->work->revision; + + /* The revert_base checksum isn't available in the entry structure, + so the caller provides it. */ + + /* text_base_info is NULL for files scheduled to be added. */ + below_working_node->checksum = NULL; + if (text_base_info) + { + if (entry->schedule == svn_wc_schedule_delete) + below_working_node->checksum = + text_base_info->normal_base.sha1_checksum; + else + below_working_node->checksum = + text_base_info->revert_base.sha1_checksum; + } + below_working_node->recorded_size = 0; + below_working_node->changed_rev = SVN_INVALID_REVNUM; + below_working_node->changed_date = 0; + below_working_node->changed_author = NULL; + below_working_node->depth = svn_depth_infinity; + below_working_node->recorded_time = 0; + below_working_node->properties = NULL; + + if (working_node + && entry->schedule == svn_wc_schedule_delete + && working_node->repos_relpath) + { + /* We are lucky, our guesses above are not necessary. The known + correct information is in working. But our op_depth design + expects more information here */ + below_working_node->repos_relpath = working_node->repos_relpath; + below_working_node->repos_id = working_node->repos_id; + below_working_node->revision = working_node->revision; + + /* Nice for 'svn status' */ + below_working_node->changed_rev = entry->cmt_rev; + below_working_node->changed_date = entry->cmt_date; + below_working_node->changed_author = entry->cmt_author; + + /* And now remove it from WORKING, because in wc-ng code + should read it from the lower layer */ + working_node->repos_relpath = NULL; + working_node->repos_id = 0; + working_node->revision = SVN_INVALID_REVNUM; + } + + SVN_ERR(insert_node(sdb, below_working_node, scratch_pool)); + } + + /* Insert the working node. */ + if (working_node) + { + working_node->wc_id = wc_id; + working_node->local_relpath = local_relpath; + working_node->parent_relpath = parent_relpath; + working_node->changed_rev = SVN_INVALID_REVNUM; + working_node->recorded_time = entry->text_time; + working_node->recorded_size = entry->working_size; + + if (entry->depth != svn_depth_exclude) + working_node->depth = entry->depth; + else + { + working_node->presence = svn_wc__db_status_excluded; + working_node->depth = svn_depth_infinity; + } + + if (entry->kind == svn_node_dir) + working_node->checksum = NULL; + else + { + working_node->checksum = NULL; + /* text_base_info is NULL for files scheduled to be added. */ + if (text_base_info) + working_node->checksum = text_base_info->normal_base.sha1_checksum; + + + /* If an MD5 checksum is present in the entry, we can verify that + * it matches the MD5 of the base file we found earlier. */ +#ifdef SVN_DEBUG + if (entry->checksum && text_base_info) + { + svn_checksum_t *md5_checksum; + SVN_ERR(svn_checksum_parse_hex(&md5_checksum, svn_checksum_md5, + entry->checksum, result_pool)); + SVN_ERR_ASSERT( + md5_checksum && text_base_info->normal_base.md5_checksum); + SVN_ERR_ASSERT(svn_checksum_match( + md5_checksum, text_base_info->normal_base.md5_checksum)); + } +#endif + } + + working_node->kind = entry->kind; + if (working_node->presence != svn_wc__db_status_excluded) + { + /* All subdirs start of incomplete, and stop being incomplete + when the entries file in the subdir is upgraded. */ + if (entry->kind == svn_node_dir + && strcmp(entry->name, SVN_WC_ENTRY_THIS_DIR)) + { + working_node->presence = svn_wc__db_status_incomplete; + working_node->kind = svn_node_dir; + } + else if (entry->schedule == svn_wc_schedule_delete) + { + working_node->presence = svn_wc__db_status_base_deleted; + working_node->kind = entry->kind; + } + else + { + /* presence == normal */ + working_node->kind = entry->kind; + + if (entry->incomplete) + { + /* We shouldn't be overwriting another status. */ + WRITE_ENTRY_ASSERT(working_node->presence + == svn_wc__db_status_normal); + working_node->presence = svn_wc__db_status_incomplete; + } + } + } + + /* These should generally be unset for added and deleted files, + and contain whatever information we have for copied files. Let's + just store whatever we have. + + Note: cmt_rev is the distinguishing value. The others may be 0 or + NULL if the corresponding revprop has been deleted. */ + if (working_node->presence != svn_wc__db_status_base_deleted) + { + working_node->changed_rev = entry->cmt_rev; + working_node->changed_date = entry->cmt_date; + working_node->changed_author = entry->cmt_author; + } + + if (entry->schedule == svn_wc_schedule_delete + && parent_node->work + && parent_node->work->presence == svn_wc__db_status_base_deleted) + { + working_node->op_depth = parent_node->work->op_depth; + } + else if (!entry->copied) + { + working_node->op_depth + = svn_wc__db_op_depth_for_upgrade(local_relpath); + } + + SVN_ERR(insert_node(sdb, working_node, scratch_pool)); + } + + /* Insert the actual node. */ + if (actual_node) + { + actual_node = MAYBE_ALLOC(actual_node, scratch_pool); + + actual_node->wc_id = wc_id; + actual_node->local_relpath = local_relpath; + actual_node->parent_relpath = parent_relpath; + + SVN_ERR(insert_actual_node(sdb, db, tmp_entry_abspath, + actual_node, scratch_pool)); + } + + if (entry_node) + { + *entry_node = apr_palloc(result_pool, sizeof(**entry_node)); + (*entry_node)->base = base_node; + (*entry_node)->work = working_node; + (*entry_node)->below_work = below_working_node; + (*entry_node)->tree_conflicts = tree_conflicts; + } + + if (entry->file_external_path) + { + /* TODO: Maybe add a file external registration inside EXTERNALS here, + to allow removing file externals that aren't referenced from + svn:externals. + + The svn:externals values are processed anyway after everything is + upgraded */ + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +write_actual_only_entries(apr_hash_t *tree_conflicts, + svn_sqlite__db_t *sdb, + svn_wc__db_t *db, + const char *wri_abspath, + apr_int64_t wc_id, + const char *parent_relpath, + apr_pool_t *scratch_pool) +{ + apr_hash_index_t *hi; + + for (hi = apr_hash_first(scratch_pool, tree_conflicts); + hi; + hi = apr_hash_next(hi)) + { + db_actual_node_t *actual_node = NULL; + + actual_node = MAYBE_ALLOC(actual_node, scratch_pool); + actual_node->wc_id = wc_id; + actual_node->local_relpath = svn__apr_hash_index_key(hi); + actual_node->parent_relpath = parent_relpath; + actual_node->tree_conflict_data = svn__apr_hash_index_val(hi); + + SVN_ERR(insert_actual_node(sdb, db, wri_abspath, actual_node, + scratch_pool)); + } + + return SVN_NO_ERROR; +} + +svn_error_t * +svn_wc__write_upgraded_entries(void **dir_baton, + void *parent_baton, + svn_wc__db_t *db, + svn_sqlite__db_t *sdb, + apr_int64_t repos_id, + apr_int64_t wc_id, + const char *dir_abspath, + const char *new_root_abspath, + apr_hash_t *entries, + apr_hash_t *text_bases_info, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + const svn_wc_entry_t *this_dir; + apr_hash_index_t *hi; + apr_pool_t *iterpool = svn_pool_create(scratch_pool); + const char *old_root_abspath, *dir_relpath; + struct write_baton *parent_node = parent_baton; + struct write_baton *dir_node; + + /* Get a copy of the "this dir" entry for comparison purposes. */ + this_dir = svn_hash_gets(entries, SVN_WC_ENTRY_THIS_DIR); + + /* If there is no "this dir" entry, something is wrong. */ + if (! this_dir) + return svn_error_createf(SVN_ERR_ENTRY_NOT_FOUND, NULL, + _("No default entry in directory '%s'"), + svn_dirent_local_style(dir_abspath, + iterpool)); + old_root_abspath = svn_dirent_get_longest_ancestor(dir_abspath, + new_root_abspath, + scratch_pool); + + SVN_ERR_ASSERT(old_root_abspath[0]); + + dir_relpath = svn_dirent_skip_ancestor(old_root_abspath, dir_abspath); + + /* Write out "this dir" */ + SVN_ERR(write_entry(&dir_node, parent_node, db, sdb, + wc_id, repos_id, this_dir, NULL, dir_relpath, + svn_dirent_join(new_root_abspath, dir_relpath, + iterpool), + old_root_abspath, + this_dir, FALSE, result_pool, iterpool)); + + for (hi = apr_hash_first(scratch_pool, entries); hi; + hi = apr_hash_next(hi)) + { + const char *name = svn__apr_hash_index_key(hi); + const svn_wc_entry_t *this_entry = svn__apr_hash_index_val(hi); + const char *child_abspath, *child_relpath; + svn_wc__text_base_info_t *text_base_info + = svn_hash_gets(text_bases_info, name); + + svn_pool_clear(iterpool); + + /* Don't rewrite the "this dir" entry! */ + if (strcmp(name, SVN_WC_ENTRY_THIS_DIR) == 0) + continue; + + /* Write the entry. Pass TRUE for create locks, because we still + use this function for upgrading old working copies. */ + child_abspath = svn_dirent_join(dir_abspath, name, iterpool); + child_relpath = svn_dirent_skip_ancestor(old_root_abspath, child_abspath); + SVN_ERR(write_entry(NULL, dir_node, db, sdb, + wc_id, repos_id, + this_entry, text_base_info, child_relpath, + svn_dirent_join(new_root_abspath, child_relpath, + iterpool), + old_root_abspath, + this_dir, TRUE, iterpool, iterpool)); + } + + if (dir_node->tree_conflicts) + SVN_ERR(write_actual_only_entries(dir_node->tree_conflicts, sdb, db, + new_root_abspath, wc_id, dir_relpath, + iterpool)); + + *dir_baton = dir_node; + svn_pool_destroy(iterpool); + return SVN_NO_ERROR; +} + + +svn_wc_entry_t * +svn_wc_entry_dup(const svn_wc_entry_t *entry, apr_pool_t *pool) +{ + svn_wc_entry_t *dupentry = apr_palloc(pool, sizeof(*dupentry)); + + /* Perform a trivial copy ... */ + *dupentry = *entry; + + /* ...and then re-copy stuff that needs to be duped into our pool. */ + if (entry->name) + dupentry->name = apr_pstrdup(pool, entry->name); + if (entry->url) + dupentry->url = apr_pstrdup(pool, entry->url); + if (entry->repos) + dupentry->repos = apr_pstrdup(pool, entry->repos); + if (entry->uuid) + dupentry->uuid = apr_pstrdup(pool, entry->uuid); + if (entry->copyfrom_url) + dupentry->copyfrom_url = apr_pstrdup(pool, entry->copyfrom_url); + if (entry->conflict_old) + dupentry->conflict_old = apr_pstrdup(pool, entry->conflict_old); + if (entry->conflict_new) + dupentry->conflict_new = apr_pstrdup(pool, entry->conflict_new); + if (entry->conflict_wrk) + dupentry->conflict_wrk = apr_pstrdup(pool, entry->conflict_wrk); + if (entry->prejfile) + dupentry->prejfile = apr_pstrdup(pool, entry->prejfile); + if (entry->checksum) + dupentry->checksum = apr_pstrdup(pool, entry->checksum); + if (entry->cmt_author) + dupentry->cmt_author = apr_pstrdup(pool, entry->cmt_author); + if (entry->lock_token) + dupentry->lock_token = apr_pstrdup(pool, entry->lock_token); + if (entry->lock_owner) + dupentry->lock_owner = apr_pstrdup(pool, entry->lock_owner); + if (entry->lock_comment) + dupentry->lock_comment = apr_pstrdup(pool, entry->lock_comment); + if (entry->changelist) + dupentry->changelist = apr_pstrdup(pool, entry->changelist); + + /* NOTE: we do not dup cachable_props or present_props since they + are deprecated. Use "" to indicate "nothing cachable or cached". */ + dupentry->cachable_props = ""; + dupentry->present_props = ""; + + if (entry->tree_conflict_data) + dupentry->tree_conflict_data = apr_pstrdup(pool, + entry->tree_conflict_data); + if (entry->file_external_path) + dupentry->file_external_path = apr_pstrdup(pool, + entry->file_external_path); + return dupentry; +} + + +/*** Generic Entry Walker */ + +/* A recursive entry-walker, helper for svn_wc_walk_entries3(). + * + * For this directory (DIRPATH, ADM_ACCESS), call the "found_entry" callback + * in WALK_CALLBACKS, passing WALK_BATON to it. Then, for each versioned + * entry in this directory, call the "found entry" callback and then recurse + * (if it is a directory and if DEPTH allows). + * + * If SHOW_HIDDEN is true, include entries that are in a 'deleted' or + * 'absent' state (and not scheduled for re-addition), else skip them. + * + * Call CANCEL_FUNC with CANCEL_BATON to allow cancellation. + */ +static svn_error_t * +walker_helper(const char *dirpath, + svn_wc_adm_access_t *adm_access, + const svn_wc_entry_callbacks2_t *walk_callbacks, + void *walk_baton, + svn_depth_t depth, + svn_boolean_t show_hidden, + svn_cancel_func_t cancel_func, + void *cancel_baton, + apr_pool_t *pool) +{ + apr_pool_t *subpool = svn_pool_create(pool); + apr_hash_t *entries; + apr_hash_index_t *hi; + svn_wc_entry_t *dot_entry; + svn_error_t *err; + svn_wc__db_t *db = svn_wc__adm_get_db(adm_access); + + err = svn_wc__entries_read_internal(&entries, adm_access, show_hidden, + pool); + + if (err) + SVN_ERR(walk_callbacks->handle_error(dirpath, err, walk_baton, pool)); + + /* As promised, always return the '.' entry first. */ + dot_entry = svn_hash_gets(entries, SVN_WC_ENTRY_THIS_DIR); + if (! dot_entry) + return walk_callbacks->handle_error + (dirpath, svn_error_createf(SVN_ERR_ENTRY_NOT_FOUND, NULL, + _("Directory '%s' has no THIS_DIR entry"), + svn_dirent_local_style(dirpath, pool)), + walk_baton, pool); + + /* Call the "found entry" callback for this directory as a "this dir" + * entry. Note that if this directory has been reached by recursion, this + * is the second visit as it will already have been visited once as a + * child entry of its parent. */ + + err = walk_callbacks->found_entry(dirpath, dot_entry, walk_baton, subpool); + + + if(err) + SVN_ERR(walk_callbacks->handle_error(dirpath, err, walk_baton, pool)); + + if (depth == svn_depth_empty) + return SVN_NO_ERROR; + + /* Loop over each of the other entries. */ + for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi)) + { + const char *name = svn__apr_hash_index_key(hi); + const svn_wc_entry_t *current_entry = svn__apr_hash_index_val(hi); + const char *entrypath; + const char *entry_abspath; + svn_boolean_t hidden; + + svn_pool_clear(subpool); + + /* See if someone wants to cancel this operation. */ + if (cancel_func) + SVN_ERR(cancel_func(cancel_baton)); + + /* Skip the "this dir" entry. */ + if (strcmp(current_entry->name, SVN_WC_ENTRY_THIS_DIR) == 0) + continue; + + entrypath = svn_dirent_join(dirpath, name, subpool); + SVN_ERR(svn_wc__entry_is_hidden(&hidden, current_entry)); + SVN_ERR(svn_dirent_get_absolute(&entry_abspath, entrypath, subpool)); + + /* Call the "found entry" callback for this entry. (For a directory, + * this is the first visit: as a child.) */ + if (current_entry->kind == svn_node_file + || depth >= svn_depth_immediates) + { + err = walk_callbacks->found_entry(entrypath, current_entry, + walk_baton, subpool); + + if (err) + SVN_ERR(walk_callbacks->handle_error(entrypath, err, + walk_baton, pool)); + } + + /* Recurse into this entry if appropriate. */ + if (current_entry->kind == svn_node_dir + && !hidden + && depth >= svn_depth_immediates) + { + svn_wc_adm_access_t *entry_access; + svn_depth_t depth_below_here = depth; + + if (depth == svn_depth_immediates) + depth_below_here = svn_depth_empty; + + entry_access = svn_wc__adm_retrieve_internal2(db, entry_abspath, + subpool); + + if (entry_access) + SVN_ERR(walker_helper(entrypath, entry_access, + walk_callbacks, walk_baton, + depth_below_here, show_hidden, + cancel_func, cancel_baton, + subpool)); + } + } + + svn_pool_destroy(subpool); + return SVN_NO_ERROR; +} + +svn_error_t * +svn_wc__walker_default_error_handler(const char *path, + svn_error_t *err, + void *walk_baton, + apr_pool_t *pool) +{ + /* Note: don't trace this. We don't want to insert a false "stack frame" + onto an error generated elsewhere. */ + return svn_error_trace(err); +} + + +/* The public API. */ +svn_error_t * +svn_wc_walk_entries3(const char *path, + svn_wc_adm_access_t *adm_access, + const svn_wc_entry_callbacks2_t *walk_callbacks, + void *walk_baton, + svn_depth_t walk_depth, + svn_boolean_t show_hidden, + svn_cancel_func_t cancel_func, + void *cancel_baton, + apr_pool_t *pool) +{ + const char *local_abspath; + svn_wc__db_t *db = svn_wc__adm_get_db(adm_access); + svn_error_t *err; + svn_node_kind_t kind; + svn_depth_t depth; + + SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool)); + err = svn_wc__db_read_info(NULL, &kind, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, &depth, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, + db, local_abspath, + pool, pool); + if (err) + { + if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND) + return svn_error_trace(err); + /* Remap into SVN_ERR_UNVERSIONED_RESOURCE. */ + svn_error_clear(err); + return walk_callbacks->handle_error( + path, svn_error_createf(SVN_ERR_UNVERSIONED_RESOURCE, NULL, + _("'%s' is not under version control"), + svn_dirent_local_style(local_abspath, pool)), + walk_baton, pool); + } + + if (kind == svn_node_file || depth == svn_depth_exclude) + { + const svn_wc_entry_t *entry; + + /* ### we should stop passing out entry structures. + ### + ### we should not call handle_error for an error the *callback* + ### gave us. let it deal with the problem before returning. */ + + if (!show_hidden) + { + svn_boolean_t hidden; + SVN_ERR(svn_wc__db_node_hidden(&hidden, db, local_abspath, pool)); + + if (hidden) + { + /* The fool asked to walk a "hidden" node. Report the node as + unversioned. + + ### this is incorrect behavior. see depth_test 36. the walk + ### API will be revamped to avoid entry structures. we should + ### be able to solve the problem with the new API. (since we + ### shouldn't return a hidden entry here) */ + return walk_callbacks->handle_error( + path, svn_error_createf( + SVN_ERR_UNVERSIONED_RESOURCE, NULL, + _("'%s' is not under version control"), + svn_dirent_local_style(local_abspath, pool)), + walk_baton, pool); + } + } + + SVN_ERR(svn_wc__get_entry(&entry, db, local_abspath, FALSE, + svn_node_file, pool, pool)); + + err = walk_callbacks->found_entry(path, entry, walk_baton, pool); + if (err) + return walk_callbacks->handle_error(path, err, walk_baton, pool); + + return SVN_NO_ERROR; + } + + if (kind == svn_node_dir) + return walker_helper(path, adm_access, walk_callbacks, walk_baton, + walk_depth, show_hidden, cancel_func, cancel_baton, + pool); + + return walk_callbacks->handle_error( + path, svn_error_createf(SVN_ERR_NODE_UNKNOWN_KIND, NULL, + _("'%s' has an unrecognized node kind"), + svn_dirent_local_style(local_abspath, pool)), + walk_baton, pool); +} |
