/* Get the format version from a wc-1 directory. If it is not a working copy directory, then it sets VERSION to zero and returns no error. */ static svn_error_t * get_old_version(int *version, const char *abspath, apr_pool_t *scratch_pool) { svn_error_t *err; const char *format_file_path; svn_node_kind_t kind; /* Try reading the format number from the entries file. */ format_file_path = svn_wc__adm_child(abspath, SVN_WC__ADM_ENTRIES, scratch_pool); /* Since trying to open a non-existent file is quite expensive, try a quick stat call first. In wc-ng w/cs, this will be an early exit. */ SVN_ERR(svn_io_check_path(format_file_path, &kind, scratch_pool)); if (kind == svn_node_none) { *version = 0; return SVN_NO_ERROR; } err = svn_io_read_version_file(version, format_file_path, scratch_pool); if (err == NULL) return SVN_NO_ERROR; if (err->apr_err != SVN_ERR_BAD_VERSION_FILE_FORMAT && !APR_STATUS_IS_ENOENT(err->apr_err) && !APR_STATUS_IS_ENOTDIR(err->apr_err)) return svn_error_createf(SVN_ERR_WC_MISSING, err, _("'%s' does not exist"), svn_dirent_local_style(abspath, scratch_pool)); svn_error_clear(err); /* This must be a really old working copy! Fall back to reading the format file. Note that the format file might not exist in newer working copies (format 7 and higher), but in that case, the entries file should have contained the format number. */ format_file_path = svn_wc__adm_child(abspath, SVN_WC__ADM_FORMAT, scratch_pool); err = svn_io_read_version_file(version, format_file_path, scratch_pool); if (err == NULL) return SVN_NO_ERROR; /* Whatever error may have occurred... we can just ignore. This is not a working copy directory. Signal the caller. */ svn_error_clear(err); *version = 0; return SVN_NO_ERROR; }
svn_error_t * svn_wc__check_killme(svn_wc_adm_access_t *adm_access, svn_boolean_t *exists, svn_boolean_t *kill_adm_only, apr_pool_t *pool) { const char *path; svn_error_t *err; svn_stringbuf_t *contents; path = svn_wc__adm_child(svn_wc_adm_access_path(adm_access), SVN_WC__ADM_KILLME, pool); err = svn_stringbuf_from_file2(&contents, path, pool); if (err) { if (APR_STATUS_IS_ENOENT(err->apr_err)) { /* Killme file doesn't exist. */ *exists = FALSE; svn_error_clear(err); err = SVN_NO_ERROR; } return err; } *exists = TRUE; /* If the killme file contains the string 'adm-only' then only the administrative area should be removed. */ *kill_adm_only = strcmp(contents->data, SVN_WC__KILL_ADM_ONLY) == 0; return SVN_NO_ERROR; }
svn_error_t * svn_wc__adm_destroy(svn_wc__db_t *db, const char *dir_abspath, svn_cancel_func_t cancel_func, void *cancel_baton, apr_pool_t *scratch_pool) { const char *adm_abspath; SVN_ERR_ASSERT(svn_dirent_is_absolute(dir_abspath)); SVN_ERR(svn_wc__write_check(db, dir_abspath, scratch_pool)); SVN_ERR(svn_wc__db_get_wcroot(&adm_abspath, db, dir_abspath, scratch_pool, scratch_pool)); /* Well, the coast is clear for blowing away the administrative directory, which also removes remaining locks */ /* Now close the DB, and we can delete the working copy */ if (strcmp(adm_abspath, dir_abspath) == 0) { SVN_ERR(svn_wc__db_drop_root(db, adm_abspath, scratch_pool)); SVN_ERR(svn_io_remove_dir2(svn_wc__adm_child(adm_abspath, NULL, scratch_pool), FALSE, cancel_func, cancel_baton, scratch_pool)); } return SVN_NO_ERROR; }
/* Set up a new adm area for PATH, with REPOS_* as the repos info, and INITIAL_REV as the starting revision. The entries file starts out marked as 'incomplete. The adm area starts out locked; remember to unlock it when done. */ static svn_error_t * init_adm(svn_wc__db_t *db, const char *local_abspath, const char *repos_relpath, const char *repos_root_url, const char *repos_uuid, svn_revnum_t initial_rev, svn_depth_t depth, apr_pool_t *pool) { /* First, make an empty administrative area. */ SVN_ERR(svn_io_dir_make_hidden(svn_wc__adm_child(local_abspath, NULL, pool), APR_OS_DEFAULT, pool)); /** Make subdirectories. ***/ /* SVN_WC__ADM_PRISTINE */ SVN_ERR(make_adm_subdir(local_abspath, SVN_WC__ADM_PRISTINE, FALSE, pool)); /* ### want to add another directory? do a format bump to ensure that ### all existing working copies get the new directories. or maybe ### create-on-demand (more expensive) */ /** Init the tmp area. ***/ SVN_ERR(init_adm_tmp_area(local_abspath, pool)); /* Create the SDB. */ SVN_ERR(svn_wc__db_init(db, local_abspath, repos_relpath, repos_root_url, repos_uuid, initial_rev, depth, pool)); /* Stamp ENTRIES and FORMAT files for old clients. */ SVN_ERR(svn_io_file_create(svn_wc__adm_child(local_abspath, SVN_WC__ADM_ENTRIES, pool), SVN_WC__NON_ENTRIES_STRING, pool)); SVN_ERR(svn_io_file_create(svn_wc__adm_child(local_abspath, SVN_WC__ADM_FORMAT, pool), SVN_WC__NON_ENTRIES_STRING, pool)); return SVN_NO_ERROR; }
svn_error_t * svn_wc__db_util_open_db(svn_sqlite__db_t **sdb, const char *dir_abspath, const char *sdb_fname, svn_sqlite__mode_t smode, svn_boolean_t exclusive, const char *const *my_statements, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { const char *sdb_abspath = svn_wc__adm_child(dir_abspath, sdb_fname, scratch_pool); if (smode != svn_sqlite__mode_rwcreate) { svn_node_kind_t kind; /* A file stat is much cheaper then a failed database open handled by SQLite. */ SVN_ERR(svn_io_check_path(sdb_abspath, &kind, scratch_pool)); if (kind != svn_node_file) return svn_error_createf(APR_ENOENT, NULL, _("Working copy database '%s' not found"), svn_dirent_local_style(sdb_abspath, scratch_pool)); } #ifndef WIN32 else { apr_file_t *f; /* A standard SQLite build creates a DB with mode 644 ^ !umask which means the file doesn't have group/world write access even when umask allows it. By ensuring the file exists before SQLite gets involved we give it the permissions allowed by umask. */ SVN_ERR(svn_io_file_open(&f, sdb_abspath, (APR_READ | APR_WRITE | APR_CREATE), APR_OS_DEFAULT, scratch_pool)); SVN_ERR(svn_io_file_close(f, scratch_pool)); } #endif SVN_ERR(svn_sqlite__open(sdb, sdb_abspath, smode, my_statements ? my_statements : statements, 0, NULL, result_pool, scratch_pool)); if (exclusive) SVN_ERR(svn_sqlite__exec_statements(*sdb, STMT_PRAGMA_LOCKING_MODE)); SVN_ERR(svn_sqlite__create_scalar_function(*sdb, "relpath_depth", 1, relpath_depth_sqlite, NULL)); return SVN_NO_ERROR; }
svn_error_t * svn_wc__remove_adm_file(const svn_wc_adm_access_t *adm_access, const char *filename, apr_pool_t *scratch_pool) { const char *path = svn_wc__adm_child(svn_wc_adm_access_path(adm_access), filename, scratch_pool); return svn_io_remove_file(path, scratch_pool); }
svn_error_t * svn_wc__make_killme(svn_wc_adm_access_t *adm_access, svn_boolean_t adm_only, apr_pool_t *pool) { const char *path; SVN_ERR(svn_wc__adm_write_check(adm_access, pool)); path = svn_wc__adm_child(svn_wc_adm_access_path(adm_access), SVN_WC__ADM_KILLME, pool); return svn_io_file_create(path, adm_only ? SVN_WC__KILL_ADM_ONLY : "", pool); }
svn_error_t * svn_wc__open_adm_stream(svn_stream_t **stream, const char *dir_abspath, const char *fname, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { const char *local_abspath; SVN_ERR_ASSERT(svn_dirent_is_absolute(dir_abspath)); local_abspath = svn_wc__adm_child(dir_abspath, fname, scratch_pool); return svn_error_trace(svn_stream_open_readonly(stream, local_abspath, result_pool, scratch_pool)); }
svn_error_t * svn_wc__adm_destroy(svn_wc_adm_access_t *adm_access, apr_pool_t *scratch_pool) { const char *path; SVN_ERR(svn_wc__adm_write_check(adm_access, scratch_pool)); /* Well, the coast is clear for blowing away the administrative directory, which also removes the lock file */ path = svn_wc__adm_child(svn_wc_adm_access_path(adm_access), NULL, scratch_pool); SVN_ERR(svn_io_remove_dir2(path, FALSE, NULL, NULL, scratch_pool)); return svn_wc_adm_close2(adm_access, scratch_pool); }
svn_error_t * svn_wc__write_old_wcprops(const char *path, apr_hash_t *prophash, svn_node_kind_t kind, apr_pool_t *scratch_pool) { apr_pool_t *pool = scratch_pool; const char *parent_dir; const char *base_name; svn_stream_t *stream; const char *temp_dir_path; const char *temp_prop_path; const char *prop_path; int wc_format_version; if (kind == svn_node_dir) parent_dir = path; else svn_path_split(path, &parent_dir, &base_name, pool); /* At this point, we know we need to open a file in the admin area of parent_dir. First check that parent_dir is a working copy: */ SVN_ERR(svn_wc_check_wc(parent_dir, &wc_format_version, pool)); if (wc_format_version == 0) return svn_error_createf(SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL, _("'%s' is not a working copy"), svn_path_local_style(parent_dir, pool)); /* Write to a temp file, then rename into place. */ temp_dir_path = svn_wc__adm_child(parent_dir, SVN_WC__ADM_TMP, pool); SVN_ERR(svn_stream_open_unique(&stream, &temp_prop_path, temp_dir_path, svn_io_file_del_none, pool, pool)); SVN_ERR_W(svn_hash_write2(prophash, stream, SVN_HASH_TERMINATOR, pool), apr_psprintf(pool, _("Cannot write property hash for '%s'"), svn_path_local_style(path, pool))); svn_stream_close(stream); /* Close file, then do an atomic "move". */ SVN_ERR(svn_wc__prop_path(&prop_path, path, kind, svn_wc__props_wcprop, pool)); SVN_ERR(svn_io_file_rename(temp_prop_path, prop_path, pool)); return svn_io_set_file_read_only(prop_path, FALSE, pool); }
svn_boolean_t svn_wc__adm_area_exists(const char *adm_abspath, apr_pool_t *pool) { const char *path = svn_wc__adm_child(adm_abspath, NULL, pool); svn_node_kind_t kind; svn_error_t *err; err = svn_io_check_path(path, &kind, pool); if (err) { svn_error_clear(err); /* Return early, since kind is undefined in this case. */ return FALSE; } return kind != svn_node_none; }
svn_error_t * svn_wc__adm_cleanup_tmp_area(svn_wc__db_t *db, const char *adm_abspath, apr_pool_t *scratch_pool) { const char *tmp_path; SVN_ERR_ASSERT(svn_dirent_is_absolute(adm_abspath)); SVN_ERR(svn_wc__write_check(db, adm_abspath, scratch_pool)); /* Get the path to the tmp area, and blow it away. */ tmp_path = svn_wc__adm_child(adm_abspath, SVN_WC__ADM_TMP, scratch_pool); SVN_ERR(svn_io_remove_dir2(tmp_path, TRUE, NULL, NULL, scratch_pool)); /* Now, rebuild the tmp area. */ return svn_error_trace(init_adm_tmp_area(adm_abspath, scratch_pool)); }
svn_error_t * svn_wc__db_util_open_db(svn_sqlite__db_t **sdb, const char *dir_abspath, const char *sdb_fname, svn_sqlite__mode_t smode, svn_boolean_t exclusive, apr_int32_t timeout, const char *const *my_statements, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { const char *sdb_abspath = svn_wc__adm_child(dir_abspath, sdb_fname, scratch_pool); if (smode != svn_sqlite__mode_rwcreate) { svn_node_kind_t kind; /* A file stat is much cheaper than a failed database open handled by SQLite. */ SVN_ERR(svn_io_check_path(sdb_abspath, &kind, scratch_pool)); if (kind != svn_node_file) return svn_error_createf(APR_ENOENT, NULL, _("Working copy database '%s' not found"), svn_dirent_local_style(sdb_abspath, scratch_pool)); } SVN_ERR(svn_sqlite__open(sdb, sdb_abspath, smode, my_statements ? my_statements : statements, 0, NULL, timeout, result_pool, scratch_pool)); if (exclusive) SVN_ERR(svn_sqlite__exec_statements(*sdb, STMT_PRAGMA_LOCKING_MODE)); SVN_ERR(svn_sqlite__create_scalar_function(*sdb, "relpath_depth", 1, TRUE /* deterministic */, relpath_depth_sqlite, NULL)); return SVN_NO_ERROR; }
svn_error_t * svn_wc__adm_cleanup_tmp_area(const svn_wc_adm_access_t *adm_access, apr_pool_t *scratch_pool) { const char *tmp_path; /* If the admin area doesn't even *exist*, then the temp area is definitely cleaned up. */ if (!svn_wc__adm_area_exists(adm_access, scratch_pool)) return SVN_NO_ERROR; SVN_ERR(svn_wc__adm_write_check(adm_access, scratch_pool)); /* Get the path to the tmp area, and blow it away. */ tmp_path = svn_wc__adm_child(svn_wc_adm_access_path(adm_access), SVN_WC__ADM_TMP, scratch_pool); SVN_ERR(svn_io_remove_dir2(tmp_path, TRUE, NULL, NULL, scratch_pool)); /* Now, rebuild the tmp area. */ return init_adm_tmp_area(adm_access, scratch_pool); }
svn_error_t * svn_wc_create_tmp_file2(apr_file_t **fp, const char **new_name, const char *path, svn_io_file_del_t delete_when, apr_pool_t *pool) { const char *temp_dir; apr_file_t *file; SVN_ERR_ASSERT(fp || new_name); temp_dir = svn_wc__adm_child(path, SVN_WC__ADM_TMP, pool); SVN_ERR(svn_io_open_unique_file3(&file, new_name, temp_dir, delete_when, pool, pool)); if (fp) *fp = file; else SVN_ERR(svn_io_file_close(file, pool)); return SVN_NO_ERROR; }
svn_error_t * svn_wc__db_util_open_db(svn_sqlite__db_t **sdb, const char *dir_abspath, const char *sdb_fname, svn_sqlite__mode_t smode, const char *const *my_statements, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { const char *sdb_abspath = svn_wc__adm_child(dir_abspath, sdb_fname, scratch_pool); if (smode != svn_sqlite__mode_rwcreate) { svn_node_kind_t kind; /* A file stat is much cheaper then a failed database open handled by SQLite. */ SVN_ERR(svn_io_check_path(sdb_abspath, &kind, scratch_pool)); if (kind != svn_node_file) return svn_error_createf(APR_ENOENT, NULL, _("Working copy database '%s' not found"), svn_dirent_local_style(sdb_abspath, scratch_pool)); } SVN_ERR(svn_sqlite__open(sdb, sdb_abspath, smode, my_statements ? my_statements : statements, 0, NULL, result_pool, scratch_pool)); SVN_ERR(svn_sqlite__create_scalar_function(*sdb, "relpath_depth", 1, relpath_depth, NULL)); return SVN_NO_ERROR; }
svn_error_t * svn_wc__db_wcroot_parse_local_abspath(svn_wc__db_wcroot_t **wcroot, const char **local_relpath, svn_wc__db_t *db, const char *local_abspath, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { const char *local_dir_abspath; const char *original_abspath = local_abspath; svn_node_kind_t kind; const char *build_relpath; svn_wc__db_wcroot_t *probe_wcroot; svn_wc__db_wcroot_t *found_wcroot = NULL; const char *scan_abspath; svn_sqlite__db_t *sdb = NULL; svn_boolean_t moved_upwards = FALSE; svn_boolean_t always_check = FALSE; int wc_format = 0; const char *adm_relpath; /* Non-NULL if WCROOT is found through a symlink: */ const char *symlink_wcroot_abspath = NULL; /* ### we need more logic for finding the database (if it is located ### outside of the wcroot) and then managing all of that within DB. ### for now: play quick & dirty. */ probe_wcroot = svn_hash_gets(db->dir_data, local_abspath); if (probe_wcroot != NULL) { *wcroot = probe_wcroot; /* We got lucky. Just return the thing BEFORE performing any I/O. */ /* ### validate SMODE against how we opened wcroot->sdb? and against ### DB->mode? (will we record per-dir mode?) */ /* ### for most callers, we could pass NULL for result_pool. */ *local_relpath = compute_relpath(probe_wcroot, local_abspath, result_pool); return SVN_NO_ERROR; } /* ### at some point in the future, we may need to find a way to get ### rid of this stat() call. it is going to happen for EVERY call ### into wc_db which references a file. calls for directories could ### get an early-exit in the hash lookup just above. */ SVN_ERR(get_path_kind(&kind, db, local_abspath, scratch_pool)); if (kind != svn_node_dir) { /* If the node specified by the path is NOT present, then it cannot possibly be a directory containing ".svn/wc.db". If it is a file, then it cannot contain ".svn/wc.db". For both of these cases, strip the basename off of the path and move up one level. Keep record of what we strip, though, since we'll need it later to construct local_relpath. */ svn_dirent_split(&local_dir_abspath, &build_relpath, local_abspath, scratch_pool); /* Is this directory in our hash? */ probe_wcroot = svn_hash_gets(db->dir_data, local_dir_abspath); if (probe_wcroot != NULL) { const char *dir_relpath; *wcroot = probe_wcroot; /* Stashed directory's local_relpath + basename. */ dir_relpath = compute_relpath(probe_wcroot, local_dir_abspath, NULL); *local_relpath = svn_relpath_join(dir_relpath, build_relpath, result_pool); return SVN_NO_ERROR; } /* If the requested path is not on the disk, then we don't know how many ancestors need to be scanned until we start hitting content on the disk. Set ALWAYS_CHECK to keep looking for .svn/entries rather than bailing out after the first check. */ if (kind == svn_node_none) always_check = TRUE; /* Start the scanning at LOCAL_DIR_ABSPATH. */ local_abspath = local_dir_abspath; } else { /* Start the local_relpath empty. If *this* directory contains the wc.db, then relpath will be the empty string. */ build_relpath = ""; /* Remember the dir containing LOCAL_ABSPATH (they're the same). */ local_dir_abspath = local_abspath; } /* LOCAL_ABSPATH refers to a directory at this point. At this point, we've determined that an associated WCROOT is NOT in the DB's hash table for this directory. Let's find an existing one in the ancestors, or create one when we find the actual wcroot. */ /* Assume that LOCAL_ABSPATH is a directory, and look for the SQLite database in the right place. If we find it... great! If not, then peel off some components, and try again. */ adm_relpath = svn_wc_get_adm_dir(scratch_pool); while (TRUE) { svn_error_t *err; svn_node_kind_t adm_subdir_kind; const char *adm_subdir = svn_dirent_join(local_abspath, adm_relpath, scratch_pool); SVN_ERR(svn_io_check_path(adm_subdir, &adm_subdir_kind, scratch_pool)); if (adm_subdir_kind == svn_node_dir) { /* We always open the database in read/write mode. If the database isn't writable in the filesystem, SQLite will internally open it as read-only, and we'll get an error if we try to do a write operation. We could decide what to do on a per-operation basis, but since we're caching database handles, it make sense to be as permissive as the filesystem allows. */ err = svn_wc__db_util_open_db(&sdb, local_abspath, SDB_FILE, svn_sqlite__mode_readwrite, db->exclusive, db->timeout, NULL, db->state_pool, scratch_pool); if (err == NULL) { #ifdef SVN_DEBUG /* Install self-verification trigger statements. */ err = svn_sqlite__exec_statements(sdb, STMT_VERIFICATION_TRIGGERS); if (err && err->apr_err == SVN_ERR_SQLITE_ERROR) { /* Verification triggers can fail to install on old 1.7-dev * formats which didn't have a NODES table yet. Ignore sqlite * errors so such working copies can be upgraded. */ svn_error_clear(err); } else SVN_ERR(err); #endif break; } if (err->apr_err != SVN_ERR_SQLITE_ERROR && !APR_STATUS_IS_ENOENT(err->apr_err)) return svn_error_trace(err); svn_error_clear(err); /* If we have not moved upwards, then check for a wc-1 working copy. Since wc-1 has a .svn in every directory, and we didn't find one in the original directory, then we aren't looking at a wc-1. If the original path is not present, then we have to check on every iteration. The content may be the immediate parent, or possibly five ancetors higher. We don't test for directory presence (just for the presence of subdirs/files), so we don't know when we can stop checking ... so just check always. */ if (!moved_upwards || always_check) { SVN_ERR(get_old_version(&wc_format, local_abspath, scratch_pool)); if (wc_format != 0) break; } } /* We couldn't open the SDB within the specified directory, so move up one more directory. */ if (svn_dirent_is_root(local_abspath, strlen(local_abspath))) { /* Hit the root without finding a wcroot. */ /* The wcroot could be a symlink to a directory. * (Issue #2557, #3987). If so, try again, this time scanning * for a db within the directory the symlink points to, * rather than within the symlink's parent directory. */ if (kind == svn_node_symlink) { svn_node_kind_t resolved_kind; local_abspath = original_abspath; SVN_ERR(svn_io_check_resolved_path(local_abspath, &resolved_kind, scratch_pool)); if (resolved_kind == svn_node_dir) { /* Is this directory recorded in our hash? */ found_wcroot = svn_hash_gets(db->dir_data, local_abspath); if (found_wcroot) break; symlink_wcroot_abspath = local_abspath; SVN_ERR(read_link_target(&local_abspath, local_abspath, scratch_pool)); try_symlink_as_dir: kind = svn_node_dir; moved_upwards = FALSE; local_dir_abspath = local_abspath; build_relpath = ""; continue; } } return svn_error_createf(SVN_ERR_WC_NOT_WORKING_COPY, NULL, _("'%s' is not a working copy"), svn_dirent_local_style(original_abspath, scratch_pool)); } local_abspath = svn_dirent_dirname(local_abspath, scratch_pool); moved_upwards = TRUE; symlink_wcroot_abspath = NULL; /* Is the parent directory recorded in our hash? */ found_wcroot = svn_hash_gets(db->dir_data, local_abspath); if (found_wcroot != NULL) break; } if (found_wcroot != NULL) { /* We found a hash table entry for an ancestor, so we stopped scanning since all subdirectories use the same WCROOT. */ *wcroot = found_wcroot; } else if (wc_format == 0) { /* We finally found the database. Construct a wcroot_t for it. */ apr_int64_t wc_id; int format; svn_error_t *err; err = fetch_sdb_info(&wc_id, &format, sdb, scratch_pool); if (err) { if (err->apr_err == SVN_ERR_WC_CORRUPT) return svn_error_quick_wrapf( err, _("Missing a row in WCROOT for '%s'."), svn_dirent_local_style(original_abspath, scratch_pool)); return svn_error_trace(err); } /* WCROOT.local_abspath may be NULL when the database is stored inside the wcroot, but we know the abspath is this directory (ie. where we found it). */ err = svn_wc__db_pdh_create_wcroot(wcroot, apr_pstrdup(db->state_pool, symlink_wcroot_abspath ? symlink_wcroot_abspath : local_abspath), sdb, wc_id, format, db->verify_format, db->state_pool, scratch_pool); if (err && (err->apr_err == SVN_ERR_WC_UNSUPPORTED_FORMAT || err->apr_err == SVN_ERR_WC_UPGRADE_REQUIRED) && kind == svn_node_symlink) { /* We found an unsupported WC after traversing upwards from a * symlink. Fall through to code below to check if the symlink * points at a supported WC. */ svn_error_clear(err); *wcroot = NULL; } else if (err) { /* Close handle if we are not going to use it to support upgrading with exclusive wc locking. */ return svn_error_compose_create(err, svn_sqlite__close(sdb)); } } else { /* We found something that looks like a wc-1 working copy directory. However, if the format version is 12 and the .svn/entries file is only 3 bytes long, then it's a breadcrumb in a wc-ng working copy that's missing an .svn/wc.db, or its .svn/wc.db is corrupt. */ if (wc_format == SVN_WC__WC_NG_VERSION /* 12 */) { apr_finfo_t info; /* Check attributes of .svn/entries */ const char *admin_abspath = svn_wc__adm_child( local_abspath, SVN_WC__ADM_ENTRIES, scratch_pool); svn_error_t *err = svn_io_stat(&info, admin_abspath, APR_FINFO_SIZE, scratch_pool); /* If the former does not succeed, something is seriously wrong. */ if (err) return svn_error_createf( SVN_ERR_WC_CORRUPT, err, _("The working copy at '%s' is corrupt."), svn_dirent_local_style(local_abspath, scratch_pool)); svn_error_clear(err); if (3 == info.size) { /* Check existence of .svn/wc.db */ admin_abspath = svn_wc__adm_child(local_abspath, SDB_FILE, scratch_pool); err = svn_io_stat(&info, admin_abspath, APR_FINFO_SIZE, scratch_pool); if (err && APR_STATUS_IS_ENOENT(err->apr_err)) { svn_error_clear(err); return svn_error_createf( SVN_ERR_WC_CORRUPT, NULL, _("The working copy database at '%s' is missing."), svn_dirent_local_style(local_abspath, scratch_pool)); } else /* We should never have reached this point in the code if .svn/wc.db exists; therefore it's best to assume it's corrupt. */ return svn_error_createf( SVN_ERR_WC_CORRUPT, err, _("The working copy database at '%s' is corrupt."), svn_dirent_local_style(local_abspath, scratch_pool)); } } SVN_ERR(svn_wc__db_pdh_create_wcroot(wcroot, apr_pstrdup(db->state_pool, symlink_wcroot_abspath ? symlink_wcroot_abspath : local_abspath), NULL, UNKNOWN_WC_ID, wc_format, db->verify_format, db->state_pool, scratch_pool)); } if (*wcroot) { const char *dir_relpath; if (symlink_wcroot_abspath) { /* The WCROOT was found through a symlink pointing at the root of * the WC. Cache the WCROOT under the symlink's path. */ local_dir_abspath = symlink_wcroot_abspath; } /* The subdirectory's relpath is easily computed relative to the wcroot that we just found. */ dir_relpath = compute_relpath(*wcroot, local_dir_abspath, NULL); /* And the result local_relpath may include a filename. */ *local_relpath = svn_relpath_join(dir_relpath, build_relpath, result_pool); } if (kind == svn_node_symlink) { svn_boolean_t retry_if_dir = FALSE; svn_wc__db_status_t status; svn_boolean_t conflicted; svn_error_t *err; /* Check if the symlink is versioned or obstructs a versioned node * in this DB -- in that case, use this wcroot. Else, if the symlink * points to a directory, try to find a wcroot in that directory * instead. */ if (*wcroot) { err = svn_wc__db_read_info_internal(&status, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &conflicted, NULL, NULL, NULL, NULL, NULL, NULL, *wcroot, *local_relpath, scratch_pool, scratch_pool); if (err) { if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND && !SVN_WC__ERR_IS_NOT_CURRENT_WC(err)) return svn_error_trace(err); svn_error_clear(err); retry_if_dir = TRUE; /* The symlink is unversioned. */ } else { /* The symlink is versioned, or obstructs a versioned node. * Ignore non-conflicted not-present/excluded nodes. * This allows the symlink to redirect the wcroot query to a * directory, regardless of 'invisible' nodes in this WC. */ retry_if_dir = ((status == svn_wc__db_status_not_present || status == svn_wc__db_status_excluded || status == svn_wc__db_status_server_excluded) && !conflicted); } } else retry_if_dir = TRUE; if (retry_if_dir) { svn_node_kind_t resolved_kind; SVN_ERR(svn_io_check_resolved_path(original_abspath, &resolved_kind, scratch_pool)); if (resolved_kind == svn_node_dir) { symlink_wcroot_abspath = original_abspath; SVN_ERR(read_link_target(&local_abspath, original_abspath, scratch_pool)); /* This handle was opened in this function but is not going to be used further so close it. */ if (sdb) SVN_ERR(svn_sqlite__close(sdb)); goto try_symlink_as_dir; } } } /* We've found the appropriate WCROOT for the requested path. Stash it into that path's directory. */ svn_hash_sets(db->dir_data, apr_pstrdup(db->state_pool, local_dir_abspath), *wcroot); /* Did we traverse up to parent directories? */ if (!moved_upwards) { /* We did NOT move to a parent of the original requested directory. We've constructed and filled in a WCROOT for the request, so we are done. */ return SVN_NO_ERROR; } /* The WCROOT that we just found/built was for the LOCAL_ABSPATH originally passed into this function. We stepped *at least* one directory above that. We should now associate the WROOT for each parent directory that does not (yet) have one. */ scan_abspath = local_dir_abspath; do { const char *parent_dir = svn_dirent_dirname(scan_abspath, scratch_pool); svn_wc__db_wcroot_t *parent_wcroot; parent_wcroot = svn_hash_gets(db->dir_data, parent_dir); if (parent_wcroot == NULL) { svn_hash_sets(db->dir_data, apr_pstrdup(db->state_pool, parent_dir), *wcroot); } /* Move up a directory, stopping when we reach the directory where we found/built the WCROOT. */ scan_abspath = parent_dir; } while (strcmp(scan_abspath, local_abspath) != 0); return SVN_NO_ERROR; }
static svn_error_t * make_empty_adm(const char *path, apr_pool_t *pool) { path = svn_wc__adm_child(path, NULL, pool); return svn_io_dir_make_hidden(path, APR_OS_DEFAULT, pool); }