svn_error_t * svn_wc_ensure_adm3(const char *path, const char *uuid, const char *url, const char *repos, svn_revnum_t revision, svn_depth_t depth, apr_pool_t *pool) { svn_wc_adm_access_t *adm_access; const svn_wc_entry_t *entry; int format; SVN_ERR(svn_wc_check_wc(path, &format, pool)); /* Early out: we know we're not dealing with an existing wc, so just create one. */ if (format == 0) return init_adm(path, uuid, url, repos, revision, depth, pool); /* Now, get the existing url and repos for PATH. */ SVN_ERR(svn_wc_adm_open3(&adm_access, NULL, path, FALSE, 0, NULL, NULL, pool)); SVN_ERR(svn_wc__entry_versioned(&entry, path, adm_access, FALSE, pool)); SVN_ERR(svn_wc_adm_close2(adm_access, pool)); /* When the directory exists and is scheduled for deletion do not * check the revision or the URL. The revision can be any * arbitrary revision and the URL may differ if the add is * being driven from a merge which will have a different URL. */ if (entry->schedule != svn_wc_schedule_delete) { if (entry->revision != revision) return svn_error_createf (SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL, _("Revision %ld doesn't match existing revision %ld in '%s'"), revision, entry->revision, path); /** ### comparing URLs, should they be canonicalized first? */ if (strcmp(entry->url, url) != 0) return svn_error_createf (SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL, _("URL '%s' doesn't match existing URL '%s' in '%s'"), url, entry->url, path); } return SVN_NO_ERROR; }
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); }
bool Wc::checkWc(const Path & dir) { Pool pool; int wc; svn_error_t * error = svn_wc_check_wc(dir.c_str(), &wc, pool); if ((error != NULL) || (wc == 0)) { return false; } return true; }
/* * Why is this not an svn subcommand? I have this vague idea that it could * be run as part of the build process, with the output embedded in the svn * program. Obviously we don't want to have to run svn when building svn. */ int main(int argc, const char *argv[]) { const char *wc_path, *trail_url; apr_allocator_t *allocator; apr_pool_t *pool; int wc_format; svn_wc_revision_status_t *res; svn_boolean_t no_newline = FALSE, committed = FALSE; svn_error_t *err; apr_getopt_t *os; const apr_getopt_option_t options[] = { {"no-newline", 'n', 0, N_("do not output the trailing newline")}, {"committed", 'c', 0, N_("last changed rather than current revisions")}, {"help", 'h', 0, N_("display this help")}, {"version", SVNVERSION_OPT_VERSION, 0, N_("show program version information")}, {0, 0, 0, 0} }; /* Initialize the app. */ if (svn_cmdline_init("svnversion", stderr) != EXIT_SUCCESS) return EXIT_FAILURE; /* Create our top-level pool. Use a separate mutexless allocator, * given this application is single threaded. */ if (apr_allocator_create(&allocator)) return EXIT_FAILURE; apr_allocator_max_free_set(allocator, SVN_ALLOCATOR_RECOMMENDED_MAX_FREE); pool = svn_pool_create_ex(NULL, allocator); apr_allocator_owner_set(allocator, pool); /* Check library versions */ err = check_lib_versions(); if (err) return svn_cmdline_handle_exit_error(err, pool, "svnversion: "); #if defined(WIN32) || defined(__CYGWIN__) /* Set the working copy administrative directory name. */ if (getenv("SVN_ASP_DOT_NET_HACK")) { err = svn_wc_set_adm_dir("_svn", pool); if (err) return svn_cmdline_handle_exit_error(err, pool, "svnversion: "); } #endif err = svn_cmdline__getopt_init(&os, argc, argv, pool); if (err) return svn_cmdline_handle_exit_error(err, pool, "svnversion: "); os->interleave = 1; while (1) { int opt; const char *arg; apr_status_t status = apr_getopt_long(os, options, &opt, &arg); if (APR_STATUS_IS_EOF(status)) break; if (status != APR_SUCCESS) { usage(pool); return EXIT_FAILURE; } switch (opt) { case 'n': no_newline = TRUE; break; case 'c': committed = TRUE; break; case 'h': help(options, pool); break; case SVNVERSION_OPT_VERSION: SVN_INT_ERR(version(pool)); exit(0); break; default: usage(pool); return EXIT_FAILURE; } } if (os->ind > argc || os->ind < argc - 2) { usage(pool); return EXIT_FAILURE; } SVN_INT_ERR(svn_utf_cstring_to_utf8 (&wc_path, (os->ind < argc) ? os->argv[os->ind] : ".", pool)); wc_path = svn_path_internal_style(wc_path, pool); if (os->ind+1 < argc) SVN_INT_ERR(svn_utf_cstring_to_utf8 (&trail_url, os->argv[os->ind+1], pool)); else trail_url = NULL; SVN_INT_ERR(svn_wc_check_wc(wc_path, &wc_format, pool)); if (! wc_format) { svn_node_kind_t kind; SVN_INT_ERR(svn_io_check_path(wc_path, &kind, pool)); if (kind == svn_node_dir) { SVN_INT_ERR(svn_cmdline_printf(pool, _("exported%s"), no_newline ? "" : "\n")); svn_pool_destroy(pool); return EXIT_SUCCESS; } else { svn_error_clear (svn_cmdline_fprintf(stderr, pool, _("'%s' not versioned, and not exported\n"), wc_path)); svn_pool_destroy(pool); return EXIT_FAILURE; } } SVN_INT_ERR(svn_wc_revision_status(&res, wc_path, trail_url, committed, NULL, NULL, pool)); /* Build compact '123[:456]M?S?' string. */ SVN_INT_ERR(svn_cmdline_printf(pool, "%ld", res->min_rev)); if (res->min_rev != res->max_rev) SVN_INT_ERR(svn_cmdline_printf(pool, ":%ld", res->max_rev)); if (res->modified) SVN_INT_ERR(svn_cmdline_fputs("M", stdout, pool)); if (res->switched) SVN_INT_ERR(svn_cmdline_fputs("S", stdout, pool)); if (res->sparse_checkout) SVN_INT_ERR(svn_cmdline_fputs("P", stdout, pool)); if (! no_newline) SVN_INT_ERR(svn_cmdline_fputs("\n", stdout, pool)); svn_pool_destroy(pool); /* Flush stdout to make sure that the user will see any printing errors. */ SVN_INT_ERR(svn_cmdline_fflush(stdout)); return EXIT_SUCCESS; }