| /* |
| * svnconflict.c: Non-interactive conflict resolution tool for Subversion. |
| * |
| * ==================================================================== |
| * 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. |
| * ==================================================================== |
| */ |
| |
| /* ==================================================================== */ |
| |
| |
| |
| /*** Includes. ***/ |
| |
| #include <string.h> |
| #include <assert.h> |
| |
| #include <apr_strings.h> |
| #include <apr_tables.h> |
| #include <apr_general.h> |
| |
| #include "svn_cmdline.h" |
| #include "svn_pools.h" |
| #include "svn_client.h" |
| #include "svn_config.h" |
| #include "svn_string.h" |
| #include "svn_dirent_uri.h" |
| #include "svn_path.h" |
| #include "svn_error.h" |
| #include "svn_io.h" |
| #include "svn_opt.h" |
| #include "svn_utf.h" |
| #include "svn_auth.h" |
| #include "svn_hash.h" |
| #include "svn_version.h" |
| |
| #include "private/svn_opt_private.h" |
| #include "private/svn_cmdline_private.h" |
| #include "private/svn_subr_private.h" |
| |
| #include "svn_private_config.h" |
| |
| typedef struct svnconflict_opt_state_t { |
| svn_boolean_t version; /* print version information */ |
| svn_boolean_t help; /* print usage message */ |
| const char *auth_username; /* auth username */ |
| const char *auth_password; /* auth password */ |
| const char *config_dir; /* over-riding configuration directory */ |
| apr_array_header_t *config_options; /* over-riding configuration options */ |
| } svnconflict_opt_state_t; |
| |
| typedef struct svnconflict_cmd_baton_t |
| { |
| svnconflict_opt_state_t *opt_state; |
| svn_client_ctx_t *ctx; |
| } svnconflict_cmd_baton_t; |
| |
| |
| /*** Option Processing ***/ |
| |
| /* Add an identifier here for long options that don't have a short |
| option. Options that have both long and short options should just |
| use the short option letter as identifier. */ |
| typedef enum svnconflict_longopt_t { |
| opt_auth_password = SVN_OPT_FIRST_LONGOPT_ID, |
| opt_auth_password_from_stdin, |
| opt_auth_username, |
| opt_config_dir, |
| opt_config_options, |
| opt_version, |
| } svnconflict_longopt_t; |
| |
| /* Option codes and descriptions. |
| * The entire list must be terminated with an entry of nulls. */ |
| static const apr_getopt_option_t svnconflict_options[] = |
| { |
| {"help", 'h', 0, N_("show help on a subcommand")}, |
| {NULL, '?', 0, N_("show help on a subcommand")}, |
| {"version", opt_version, 0, N_("show program version information")}, |
| {"username", opt_auth_username, 1, N_("specify a username ARG")}, |
| {"password", opt_auth_password, 1, |
| N_("specify a password ARG (caution: on many operating\n" |
| " " |
| "systems, other users will be able to see this)")}, |
| {"password-from-stdin", |
| opt_auth_password_from_stdin, 0, |
| N_("read password from stdin")}, |
| {"config-dir", opt_config_dir, 1, |
| N_("read user configuration files from directory ARG")}, |
| {"config-option", opt_config_options, 1, |
| N_("set user configuration option in the format:\n" |
| " " |
| " FILE:SECTION:OPTION=[VALUE]\n" |
| " " |
| "For example:\n" |
| " " |
| " servers:global:http-library=serf")}, |
| {0, 0, 0, 0}, |
| }; |
| |
| |
| |
| /*** Command dispatch. ***/ |
| |
| /* Forward declarations. */ |
| static svn_error_t * svnconflict_help(apr_getopt_t *, void *, apr_pool_t *); |
| static svn_error_t * svnconflict_list(apr_getopt_t *, void *, apr_pool_t *); |
| static svn_error_t * svnconflict_options_text(apr_getopt_t *, void *, |
| apr_pool_t *); |
| static svn_error_t * svnconflict_options_prop(apr_getopt_t *, void *, |
| apr_pool_t *); |
| static svn_error_t * svnconflict_options_tree(apr_getopt_t *, void *, |
| apr_pool_t *); |
| static svn_error_t * svnconflict_resolve_text(apr_getopt_t *, void *, |
| apr_pool_t *); |
| static svn_error_t * svnconflict_resolve_prop(apr_getopt_t *, void *, |
| apr_pool_t *); |
| static svn_error_t * svnconflict_resolve_tree(apr_getopt_t *, void *, |
| apr_pool_t *); |
| |
| /* Our array of available subcommands. |
| * |
| * The entire list must be terminated with an entry of nulls. |
| * |
| * In most of the help text "PATH" is used where a working copy path is |
| * required, "URL" where a repository URL is required and "TARGET" when |
| * either a path or a url can be used. Hmm, should this be part of the |
| * help text? |
| */ |
| |
| /* Options that apply to all commands. */ |
| static const int svnconflict_global_options[] = |
| { opt_auth_username, opt_auth_password, opt_auth_password_from_stdin, |
| opt_config_dir, opt_config_options, 0 }; |
| |
| static const svn_opt_subcommand_desc3_t svnconflict_cmd_table[] = |
| { |
| /* This command is also invoked if we see option "--help", "-h" or "-?". */ |
| { "help", svnconflict_help, {"?", "h"}, {N_( |
| "Describe the usage of this program or its subcommands.\n" |
| "usage: help [SUBCOMMAND...]\n" |
| )}, |
| {0} }, |
| |
| { "list", svnconflict_list, {"ls"}, {N_( |
| "List conflicts at a conflicted path.\n" |
| "usage: list PATH\n" |
| "\n"), N_( |
| " List conflicts at PATH, one per line. Possible conflicts are:\n" |
| " \n" |
| " text-conflict\n" |
| " One or more text merge conflicts are present in a file.\n" |
| " This conflict can be resolved with the resolve-text subcommand.\n" |
| " \n" |
| " prop-conflict: PROPNAME\n" |
| " The property PROPNAME contains a text merge conflic conflict.\n" |
| " This conflict can be resolved with the resolve-prop subcommand.\n" |
| " \n" |
| " tree-conflict: DESCRIPTION\n" |
| " The PATH is a victim of a tree conflict described by DESCRIPTION.\n" |
| " This conflict can be resolved with the resolve-tree subcommand.\n" |
| " If a tree conflict exists, no text or property conflicts exist.\n" |
| " \n" |
| " If PATH is not in conflict, the exit code will be 1, and 0 otherwise.\n" |
| )}, |
| {0}, }, |
| |
| { "options-text", svnconflict_options_text, {0}, {N_( |
| "List options for resolving a text conflict at path.\n" |
| "usage: options-text PATH\n" |
| "\n"), N_( |
| " List text conflict resolution options at PATH, one per line.\n" |
| " Each line contains a numeric option ID, a colon, and a description.\n" |
| " If PATH is not in conflict, the exit code will be 1, and 0 otherwise.\n" |
| )}, |
| {0}, }, |
| |
| { "options-prop", svnconflict_options_prop, {0}, {N_( |
| "List options for resolving a property conflict at path.\n" |
| "usage: options-prop PATH\n" |
| "\n"), N_( |
| " List property conflict resolution options at PATH, one per line.\n" |
| " Each line contains a numeric option ID, a colon, and a description.\n" |
| " If PATH is not in conflict, the exit code will be 1, and 0 otherwise.\n" |
| )}, |
| {0}, }, |
| |
| { "options-tree", svnconflict_options_tree, {0}, {N_( |
| "List options for resolving a tree conflict at path.\n" |
| "usage: options-tree PATH\n" |
| "\n"), N_( |
| " List tree conflict resolution options at PATH, one per line.\n" |
| " Each line contains a numeric option ID, a colon, and a description.\n" |
| " If PATH is not in conflict, the exit code will be 1, and 0 otherwise.\n" |
| )}, |
| {0}, }, |
| |
| { "resolve-text", svnconflict_resolve_text, {0}, {N_( |
| "Resolve the text conflict at path.\n" |
| "usage: resolve-text OPTION_ID PATH\n" |
| "\n"), N_( |
| " Resolve the text conflict at PATH with a given resolution option.\n" |
| " If PATH is not in conflict, the exit code will be 1, and 0 otherwise.\n" |
| )}, |
| {0}, }, |
| |
| { "resolve-prop", svnconflict_resolve_prop, {0}, {N_( |
| "Resolve the property conflict at path.\n" |
| "usage: resolve-prop PROPNAME OPTION_ID PATH\n" |
| "\n"), N_( |
| " Resolve conflicted property PROPNAME at PATH with a given resolution option.\n" |
| " If PATH is not in conflict, the exit code will be 1, and 0 otherwise.\n" |
| )}, |
| {0}, }, |
| |
| { "resolve-tree", svnconflict_resolve_tree, {0}, {N_( |
| "Resolve the tree conflict at path.\n" |
| "usage: resolve-tree OPTION_ID PATH\n" |
| "\n"), N_( |
| " Resolve the tree conflict at PATH with a given resolution option.\n" |
| " If PATH is not in conflict, the exit code will be 1, and 0 otherwise.\n" |
| )}, |
| {0}, }, |
| |
| { NULL, NULL, {0}, {NULL}, {0} } |
| }; |
| |
| /* Version compatibility check */ |
| static svn_error_t * |
| check_lib_versions(void) |
| { |
| static const svn_version_checklist_t checklist[] = |
| { |
| { "svn_subr", svn_subr_version }, |
| { "svn_client", svn_client_version }, |
| { "svn_wc", svn_wc_version }, |
| { "svn_ra", svn_ra_version }, |
| { NULL, NULL } |
| }; |
| SVN_VERSION_DEFINE(my_version); |
| |
| return svn_ver_check_list2(&my_version, checklist, svn_ver_equal); |
| } |
| |
| |
| /*** Subcommands ***/ |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| static svn_error_t * |
| svnconflict_help(apr_getopt_t *os, void *baton, apr_pool_t *pool) |
| { |
| svnconflict_cmd_baton_t *b = baton; |
| svnconflict_opt_state_t *opt_state = b ? b->opt_state : NULL; |
| char help_header[] = |
| N_("usage: svnconflict <subcommand> [args]\n" |
| "Type 'svnconflict --version' to see the program version and RA modules,\n" |
| "\n" |
| "svnconflict provides a non-interactive conflict resolution interface.\n" |
| "It is intended for use by non-interactive scripts which cannot make\n" |
| "use of interactive conflict resolution provided by 'svn resolve'.\n" |
| "\n" |
| "svnconflict operates on a single working copy path only. It is assumed that\n" |
| "scripts are able to discover conflicted paths in the working copy via other\n" |
| "means, such as 'svn status'.\n" |
| "Some advanced operations offered by 'svn resolve' are not supported.\n" |
| "\n" |
| "svnconflict may contact the repository to obtain information about a conflict.\n" |
| "It will never modify the repository, but only read information from it.\n" |
| "svnconflict will not prompt for credentials. If read-access to the repository\n" |
| "requires credentials but no suitable credentials are stored in Subversion's\n" |
| "authentication cache or provided on the command line, the operation may fail.\n" |
| "\nAvailable subcommands:\n"); |
| char help_footer[] = |
| N_("Subversion is a tool for version control.\n" |
| "For additional information, see http://subversion.apache.org/\n"); |
| const char *ra_desc_start |
| = _("The following repository access (RA) modules are available:\n\n"); |
| svn_stringbuf_t *version_footer = svn_stringbuf_create_empty(pool); |
| |
| if (opt_state && opt_state->version) |
| { |
| svn_stringbuf_appendcstr(version_footer, ra_desc_start); |
| SVN_ERR(svn_ra_print_modules(version_footer, pool)); |
| } |
| |
| SVN_ERR(svn_opt_print_help5(os, |
| "svnconflict", /* ### erm, derive somehow? */ |
| opt_state ? opt_state->version : FALSE, |
| FALSE, /* quiet */ |
| FALSE, /* verbose */ |
| version_footer->data, |
| _(help_header), |
| svnconflict_cmd_table, |
| svnconflict_options, |
| svnconflict_global_options, |
| _(help_footer), |
| pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| static svn_error_t * |
| get_conflicts(svn_boolean_t *text_conflicted, |
| apr_array_header_t **props_conflicted, |
| svn_boolean_t *tree_conflicted, |
| svn_client_conflict_t **conflict, |
| const char *local_abspath, |
| svn_client_ctx_t *ctx, |
| apr_pool_t *pool) |
| { |
| svn_boolean_t text; |
| apr_array_header_t *props; |
| svn_boolean_t tree; |
| |
| SVN_ERR(svn_client_conflict_get(conflict, local_abspath, ctx, pool, pool)); |
| SVN_ERR(svn_client_conflict_get_conflicted(&text, &props, &tree, |
| *conflict, pool, pool)); |
| |
| if (!text && props->nelts == 0 && !tree) |
| return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL, |
| _("The path '%s' is not in conflict"), |
| local_abspath); |
| |
| if (text_conflicted) |
| *text_conflicted = text; |
| if (props_conflicted) |
| *props_conflicted = props; |
| if (tree_conflicted) |
| *tree_conflicted = tree; |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| static svn_error_t * |
| svnconflict_list(apr_getopt_t *os, void *baton, apr_pool_t *pool) |
| { |
| svnconflict_cmd_baton_t *b = baton; |
| svn_client_ctx_t *ctx = b->ctx; |
| apr_array_header_t *args; |
| const char *path; |
| const char *local_abspath; |
| svn_client_conflict_t *conflict; |
| svn_boolean_t text_conflicted; |
| apr_array_header_t *props_conflicted; |
| svn_boolean_t tree_conflicted; |
| int i; |
| |
| SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool)); |
| path = APR_ARRAY_IDX(args, 0, const char *); |
| SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool)); |
| |
| SVN_ERR(get_conflicts(&text_conflicted, &props_conflicted, &tree_conflicted, |
| &conflict, local_abspath, ctx, pool)); |
| |
| if (text_conflicted) |
| SVN_ERR(svn_cmdline_printf(pool, "text-conflict\n")); |
| |
| for (i = 0; i < props_conflicted->nelts; i++) |
| { |
| const char *propname = APR_ARRAY_IDX(props_conflicted, i, const char *); |
| SVN_ERR(svn_cmdline_printf(pool, "prop-conflict: %s\n", propname)); |
| } |
| |
| if (tree_conflicted) |
| { |
| const char *incoming_change; |
| const char *local_change; |
| |
| SVN_ERR(svn_client_conflict_tree_get_description(&incoming_change, |
| &local_change, |
| conflict, ctx, |
| pool, pool)); |
| SVN_ERR(svn_cmdline_printf(pool, "tree-conflict: %s %s\n", |
| incoming_change, local_change)); |
| } |
| |
| return SVN_NO_ERROR; |
| } |
| |
| static svn_error_t * |
| print_conflict_options(apr_array_header_t *options, apr_pool_t *pool) |
| { |
| int i; |
| |
| for (i = 0; i < options->nelts; i++) |
| { |
| svn_client_conflict_option_t *option; |
| svn_client_conflict_option_id_t id; |
| const char *label; |
| |
| option = APR_ARRAY_IDX(options, i, svn_client_conflict_option_t *); |
| id = svn_client_conflict_option_get_id(option); |
| label = svn_client_conflict_option_get_label(option, pool); |
| SVN_ERR(svn_cmdline_printf(pool, "%d: %s\n", id, label)); |
| } |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| static svn_error_t * |
| svnconflict_options_text(apr_getopt_t *os, void *baton, apr_pool_t *pool) |
| { |
| svnconflict_cmd_baton_t *b = baton; |
| svn_client_ctx_t *ctx = b->ctx; |
| apr_array_header_t *args; |
| const char *path; |
| const char *local_abspath; |
| svn_client_conflict_t *conflict; |
| svn_boolean_t text_conflicted; |
| apr_array_header_t *options; |
| |
| SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool)); |
| path = APR_ARRAY_IDX(args, 0, const char *); |
| SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool)); |
| |
| SVN_ERR(get_conflicts(&text_conflicted, NULL, NULL, |
| &conflict, local_abspath, ctx, pool)); |
| |
| if (!text_conflicted) |
| return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL, |
| _("The path '%s' has no text conflict"), |
| local_abspath); |
| |
| SVN_ERR(svn_client_conflict_text_get_resolution_options(&options, |
| conflict, ctx, |
| pool, pool)); |
| SVN_ERR(print_conflict_options(options, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| static svn_error_t * |
| svnconflict_options_prop(apr_getopt_t *os, void *baton, apr_pool_t *pool) |
| { |
| svnconflict_cmd_baton_t *b = baton; |
| svn_client_ctx_t *ctx = b->ctx; |
| apr_array_header_t *args; |
| const char *path; |
| const char *local_abspath; |
| svn_client_conflict_t *conflict; |
| apr_array_header_t *props_conflicted; |
| apr_array_header_t *options; |
| |
| SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool)); |
| path = APR_ARRAY_IDX(args, 0, const char *); |
| SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool)); |
| |
| SVN_ERR(get_conflicts(NULL, &props_conflicted, NULL, |
| &conflict, local_abspath, ctx, pool)); |
| |
| if (props_conflicted->nelts == 0) |
| return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL, |
| _("The path '%s' has no property conflict"), |
| local_abspath); |
| |
| SVN_ERR(svn_client_conflict_prop_get_resolution_options(&options, |
| conflict, ctx, |
| pool, pool)); |
| SVN_ERR(print_conflict_options(options, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| static svn_error_t * |
| svnconflict_options_tree(apr_getopt_t *os, void *baton, apr_pool_t *pool) |
| { |
| svnconflict_cmd_baton_t *b = baton; |
| svn_client_ctx_t *ctx = b->ctx; |
| apr_array_header_t *args; |
| const char *path; |
| const char *local_abspath; |
| svn_client_conflict_t *conflict; |
| svn_boolean_t tree_conflicted; |
| apr_array_header_t *options; |
| |
| SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool)); |
| path = APR_ARRAY_IDX(args, 0, const char *); |
| SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool)); |
| |
| SVN_ERR(get_conflicts(NULL, NULL, &tree_conflicted, |
| &conflict, local_abspath, ctx, pool)); |
| |
| if (!tree_conflicted) |
| return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL, |
| _("The path '%s' is not a tree conflict victim"), |
| local_abspath); |
| |
| SVN_ERR(svn_client_conflict_tree_get_details(conflict, ctx, pool)); |
| SVN_ERR(svn_client_conflict_tree_get_resolution_options(&options, |
| conflict, ctx, |
| pool, pool)); |
| SVN_ERR(print_conflict_options(options, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| static svn_error_t * |
| svnconflict_resolve_text(apr_getopt_t *os, void *baton, apr_pool_t *pool) |
| { |
| svnconflict_cmd_baton_t *b = baton; |
| svn_client_ctx_t *ctx = b->ctx; |
| apr_array_header_t *args; |
| const char *option_id_str; |
| int optid; |
| svn_client_conflict_option_id_t option_id; |
| const char *path; |
| const char *local_abspath; |
| svn_client_conflict_t *conflict; |
| svn_boolean_t text_conflicted; |
| |
| SVN_ERR(svn_opt_parse_num_args(&args, os, 2, pool)); |
| option_id_str = APR_ARRAY_IDX(args, 0, const char *); |
| path = APR_ARRAY_IDX(args, 1, const char *); |
| SVN_ERR(svn_cstring_atoi(&optid, option_id_str)); |
| option_id = (svn_client_conflict_option_id_t)optid; |
| SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool)); |
| |
| SVN_ERR(get_conflicts(&text_conflicted, NULL, NULL, |
| &conflict, local_abspath, ctx, pool)); |
| |
| if (!text_conflicted) |
| return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL, |
| _("The path '%s' has no text conflict"), |
| local_abspath); |
| |
| SVN_ERR(svn_client_conflict_text_resolve_by_id(conflict, option_id, ctx, |
| pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| static svn_error_t * |
| svnconflict_resolve_prop(apr_getopt_t *os, void *baton, apr_pool_t *pool) |
| { |
| svnconflict_cmd_baton_t *b = baton; |
| svn_client_ctx_t *ctx = b->ctx; |
| apr_array_header_t *args; |
| const char *option_id_str; |
| int optid; |
| svn_client_conflict_option_id_t option_id; |
| const char *path; |
| const char *propname; |
| const char *local_abspath; |
| svn_client_conflict_t *conflict; |
| apr_array_header_t *props_conflicted; |
| |
| SVN_ERR(svn_opt_parse_num_args(&args, os, 3, pool)); |
| propname = APR_ARRAY_IDX(args, 0, const char *); |
| option_id_str = APR_ARRAY_IDX(args, 1, const char *); |
| path = APR_ARRAY_IDX(args, 2, const char *); |
| SVN_ERR(svn_cstring_atoi(&optid, option_id_str)); |
| option_id = (svn_client_conflict_option_id_t)optid; |
| SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool)); |
| |
| SVN_ERR(get_conflicts(NULL, &props_conflicted, NULL, |
| &conflict, local_abspath, ctx, pool)); |
| |
| if (props_conflicted->nelts == 0) |
| return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL, |
| _("The path '%s' has no property conflict"), |
| local_abspath); |
| |
| SVN_ERR(svn_client_conflict_prop_resolve_by_id(conflict, propname, |
| option_id, ctx, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements the `svn_opt_subcommand_t' interface. */ |
| static svn_error_t * |
| svnconflict_resolve_tree(apr_getopt_t *os, void *baton, apr_pool_t *pool) |
| { |
| svnconflict_cmd_baton_t *b = baton; |
| svn_client_ctx_t *ctx = b->ctx; |
| apr_array_header_t *args; |
| const char *option_id_str; |
| int optid; |
| svn_client_conflict_option_id_t option_id; |
| const char *path; |
| const char *local_abspath; |
| svn_client_conflict_t *conflict; |
| svn_boolean_t tree_conflicted; |
| |
| SVN_ERR(svn_opt_parse_num_args(&args, os, 2, pool)); |
| option_id_str = APR_ARRAY_IDX(args, 0, const char *); |
| path = APR_ARRAY_IDX(args, 1, const char *); |
| SVN_ERR(svn_cstring_atoi(&optid, option_id_str)); |
| option_id = (svn_client_conflict_option_id_t)optid; |
| SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool)); |
| |
| SVN_ERR(get_conflicts(NULL, NULL, &tree_conflicted, |
| &conflict, local_abspath, ctx, pool)); |
| |
| if (!tree_conflicted) |
| return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL, |
| _("The path '%s' is not a tree conflict victim"), |
| local_abspath); |
| |
| SVN_ERR(svn_client_conflict_tree_get_details(conflict, ctx, pool)); |
| SVN_ERR(svn_client_conflict_tree_resolve_by_id(conflict, option_id, ctx, |
| pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| /*** Main. ***/ |
| |
| /* |
| * On success, leave *EXIT_CODE untouched and return SVN_NO_ERROR. On error, |
| * either return an error to be displayed, or set *EXIT_CODE to non-zero and |
| * return SVN_NO_ERROR. |
| */ |
| static svn_error_t * |
| sub_main(int *exit_code, int argc, const char *argv[], apr_pool_t *pool) |
| { |
| svn_error_t *err; |
| int opt_id; |
| apr_getopt_t *os; |
| svnconflict_opt_state_t opt_state = { 0 }; |
| svn_client_ctx_t *ctx; |
| apr_array_header_t *received_opts; |
| svnconflict_cmd_baton_t command_baton; |
| int i; |
| const svn_opt_subcommand_desc3_t *subcommand = NULL; |
| svn_auth_baton_t *ab; |
| svn_config_t *cfg_config; |
| apr_hash_t *cfg_hash; |
| svn_boolean_t read_pass_from_stdin = FALSE; |
| |
| received_opts = apr_array_make(pool, SVN_OPT_MAX_OPTIONS, sizeof(int)); |
| |
| /* Check library versions */ |
| SVN_ERR(check_lib_versions()); |
| |
| #if defined(WIN32) || defined(__CYGWIN__) |
| /* Set the working copy administrative directory name. */ |
| if (getenv("SVN_ASP_DOT_NET_HACK")) |
| { |
| SVN_ERR(svn_wc_set_adm_dir("_svn", pool)); |
| } |
| #endif |
| |
| /* Initialize the RA library. */ |
| SVN_ERR(svn_ra_initialize(pool)); |
| |
| /* No args? Show usage. */ |
| if (argc <= 1) |
| { |
| SVN_ERR(svnconflict_help(NULL, NULL, pool)); |
| *exit_code = EXIT_FAILURE; |
| return SVN_NO_ERROR; |
| } |
| |
| /* Else, parse options. */ |
| SVN_ERR(svn_cmdline__getopt_init(&os, argc, argv, pool)); |
| |
| os->interleave = 1; |
| while (1) |
| { |
| const char *opt_arg; |
| const char *utf8_opt_arg; |
| |
| /* Parse the next option. */ |
| apr_status_t apr_err = apr_getopt_long(os, svnconflict_options, &opt_id, |
| &opt_arg); |
| if (APR_STATUS_IS_EOF(apr_err)) |
| break; |
| else if (apr_err) |
| { |
| SVN_ERR(svnconflict_help(NULL, NULL, pool)); |
| *exit_code = EXIT_FAILURE; |
| return SVN_NO_ERROR; |
| } |
| |
| /* Stash the option code in an array before parsing it. */ |
| APR_ARRAY_PUSH(received_opts, int) = opt_id; |
| |
| switch (opt_id) { |
| case 'h': |
| case '?': |
| opt_state.help = TRUE; |
| break; |
| case opt_version: |
| opt_state.version = TRUE; |
| break; |
| case opt_auth_username: |
| SVN_ERR(svn_utf_cstring_to_utf8(&opt_state.auth_username, |
| opt_arg, pool)); |
| break; |
| case opt_auth_password: |
| SVN_ERR(svn_utf_cstring_to_utf8(&opt_state.auth_password, |
| opt_arg, pool)); |
| break; |
| case opt_auth_password_from_stdin: |
| read_pass_from_stdin = TRUE; |
| break; |
| case opt_config_dir: |
| SVN_ERR(svn_utf_cstring_to_utf8(&utf8_opt_arg, opt_arg, pool)); |
| SVN_ERR(svn_dirent_internal_style_safe(&opt_state.config_dir, NULL, |
| utf8_opt_arg, pool, pool)); |
| break; |
| case opt_config_options: |
| if (!opt_state.config_options) |
| opt_state.config_options = |
| apr_array_make(pool, 1, |
| sizeof(svn_cmdline__config_argument_t*)); |
| |
| SVN_ERR(svn_utf_cstring_to_utf8(&utf8_opt_arg, opt_arg, pool)); |
| SVN_ERR(svn_cmdline__parse_config_option(opt_state.config_options, |
| utf8_opt_arg, "svnconflict: ", |
| pool)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| /* ### This really belongs in libsvn_client. */ |
| SVN_ERR(svn_config_ensure(opt_state.config_dir, pool)); |
| |
| /* If the user asked for help, then the rest of the arguments are |
| the names of subcommands to get help on (if any), or else they're |
| just typos/mistakes. Whatever the case, the subcommand to |
| actually run is svnconflict_help(). */ |
| if (opt_state.help) |
| subcommand = svn_opt_get_canonical_subcommand3(svnconflict_cmd_table, |
| "help"); |
| |
| /* If we're not running the `help' subcommand, then look for a |
| subcommand in the first argument. */ |
| if (subcommand == NULL) |
| { |
| if (os->ind >= os->argc) |
| { |
| if (opt_state.version) |
| { |
| /* Use the "help" subcommand to handle the "--version" option. */ |
| static const svn_opt_subcommand_desc3_t pseudo_cmd = |
| { "--version", svnconflict_help, {0}, {""}, |
| {opt_version, /* must accept its own option */ |
| opt_config_dir /* all commands accept this */ |
| } }; |
| |
| subcommand = &pseudo_cmd; |
| } |
| else |
| { |
| svn_error_clear |
| (svn_cmdline_fprintf(stderr, pool, |
| _("Subcommand argument required\n"))); |
| svn_error_clear(svnconflict_help(NULL, NULL, pool)); |
| *exit_code = EXIT_FAILURE; |
| return SVN_NO_ERROR; |
| } |
| } |
| else |
| { |
| const char *first_arg; |
| |
| SVN_ERR(svn_utf_cstring_to_utf8(&first_arg, os->argv[os->ind++], |
| pool)); |
| subcommand = svn_opt_get_canonical_subcommand3(svnconflict_cmd_table, |
| first_arg); |
| if (subcommand == NULL) |
| { |
| svn_error_clear |
| (svn_cmdline_fprintf(stderr, pool, |
| _("Unknown subcommand: '%s'\n"), |
| first_arg)); |
| svn_error_clear(svnconflict_help(NULL, NULL, pool)); |
| *exit_code = EXIT_FAILURE; |
| return SVN_NO_ERROR; |
| } |
| } |
| } |
| |
| /* Check that the subcommand wasn't passed any inappropriate options. */ |
| for (i = 0; i < received_opts->nelts; i++) |
| { |
| opt_id = APR_ARRAY_IDX(received_opts, i, int); |
| |
| /* All commands implicitly accept --help, so just skip over this |
| when we see it. Note that we don't want to include this option |
| in their "accepted options" list because it would be awfully |
| redundant to display it in every commands' help text. */ |
| if (opt_id == 'h' || opt_id == '?') |
| continue; |
| |
| if (! svn_opt_subcommand_takes_option4(subcommand, opt_id, |
| svnconflict_global_options)) |
| { |
| const char *optstr; |
| const apr_getopt_option_t *badopt = |
| svn_opt_get_option_from_code3(opt_id, svnconflict_options, |
| subcommand, pool); |
| svn_opt_format_option(&optstr, badopt, FALSE, pool); |
| if (subcommand->name[0] == '-') |
| svn_error_clear(svnconflict_help(NULL, NULL, pool)); |
| else |
| svn_error_clear |
| (svn_cmdline_fprintf |
| (stderr, pool, _("Subcommand '%s' doesn't accept option '%s'\n" |
| "Type 'svnconflict help %s' for usage.\n"), |
| subcommand->name, optstr, subcommand->name)); |
| *exit_code = EXIT_FAILURE; |
| return SVN_NO_ERROR; |
| } |
| } |
| |
| err = svn_config_get_config(&cfg_hash, opt_state.config_dir, pool); |
| if (err) |
| { |
| /* Fallback to default config if the config directory isn't readable |
| or is not a directory. */ |
| if (APR_STATUS_IS_EACCES(err->apr_err) |
| || SVN__APR_STATUS_IS_ENOTDIR(err->apr_err)) |
| { |
| svn_handle_warning2(stderr, err, "svnconflict: "); |
| svn_error_clear(err); |
| |
| SVN_ERR(svn_config__get_default_config(&cfg_hash, pool)); |
| } |
| else |
| return err; |
| } |
| |
| /* Update the options in the config */ |
| if (opt_state.config_options) |
| { |
| svn_error_clear( |
| svn_cmdline__apply_config_options(cfg_hash, |
| opt_state.config_options, |
| "svnconflict: ", |
| "--config-option")); |
| } |
| |
| cfg_config = svn_hash_gets(cfg_hash, SVN_CONFIG_CATEGORY_CONFIG); |
| |
| /* Get password from stdin if necessary */ |
| if (read_pass_from_stdin) |
| { |
| SVN_ERR(svn_cmdline__stdin_readline(&opt_state.auth_password, pool, pool)); |
| } |
| |
| |
| /* Create a client context object. */ |
| command_baton.opt_state = &opt_state; |
| SVN_ERR(svn_client_create_context2(&ctx, cfg_hash, pool)); |
| command_baton.ctx = ctx; |
| |
| /* Set up Authentication stuff. */ |
| SVN_ERR(svn_cmdline_create_auth_baton2( |
| &ab, |
| TRUE, /* non-interactive */ |
| opt_state.auth_username, |
| opt_state.auth_password, |
| opt_state.config_dir, |
| TRUE, /* no auth cache */ |
| FALSE, FALSE, FALSE, FALSE, FALSE, /* reject invalid SSL certs */ |
| cfg_config, |
| NULL, NULL, |
| pool)); |
| |
| ctx->auth_baton = ab; |
| |
| /* We don't use legacy libsvn_wc conflict handlers. */ |
| { |
| ctx->conflict_func = NULL; |
| ctx->conflict_baton = NULL; |
| ctx->conflict_func2 = NULL; |
| ctx->conflict_baton2 = NULL; |
| } |
| |
| /* And now we finally run the subcommand. */ |
| err = (*subcommand->cmd_func)(os, &command_baton, pool); |
| if (err) |
| { |
| /* For argument-related problems, suggest using the 'help' |
| subcommand. */ |
| if (err->apr_err == SVN_ERR_CL_INSUFFICIENT_ARGS |
| || err->apr_err == SVN_ERR_CL_ARG_PARSING_ERROR) |
| { |
| err = svn_error_quick_wrapf( |
| err, _("Try 'svnconflict help %s' for more information"), |
| subcommand->name); |
| } |
| if (err->apr_err == SVN_ERR_WC_UPGRADE_REQUIRED) |
| { |
| err = svn_error_quick_wrap(err, |
| _("Please see the 'svn upgrade' command")); |
| } |
| |
| /* Tell the user about 'svn cleanup' if any error on the stack |
| was about locked working copies. */ |
| if (svn_error_find_cause(err, SVN_ERR_WC_LOCKED)) |
| { |
| err = svn_error_quick_wrap( |
| err, _("Run 'svn cleanup' to remove locks " |
| "(type 'svn help cleanup' for details)")); |
| } |
| |
| if (err->apr_err == SVN_ERR_SQLITE_BUSY) |
| { |
| err = svn_error_quick_wrap(err, |
| _("Another process is blocking the " |
| "working copy database, or the " |
| "underlying filesystem does not " |
| "support file locking; if the working " |
| "copy is on a network filesystem, make " |
| "sure file locking has been enabled " |
| "on the file server")); |
| } |
| |
| if (svn_error_find_cause(err, SVN_ERR_RA_CANNOT_CREATE_TUNNEL) && |
| (opt_state.auth_username || opt_state.auth_password)) |
| { |
| err = svn_error_quick_wrap( |
| err, _("When using svn+ssh:// URLs, keep in mind that the " |
| "--username and --password options are ignored " |
| "because authentication is performed by SSH, not " |
| "Subversion")); |
| } |
| |
| return err; |
| } |
| |
| return SVN_NO_ERROR; |
| } |
| |
| int |
| main(int argc, const char *argv[]) |
| { |
| apr_pool_t *pool; |
| int exit_code = EXIT_SUCCESS; |
| svn_error_t *err; |
| |
| /* Initialize the app. */ |
| if (svn_cmdline_init("svn", stderr) != EXIT_SUCCESS) |
| return EXIT_FAILURE; |
| |
| /* Create our top-level pool. Use a separate mutexless allocator, |
| * given this application is single threaded. |
| */ |
| pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); |
| |
| err = sub_main(&exit_code, argc, argv, pool); |
| |
| /* Flush stdout and report if it fails. It would be flushed on exit anyway |
| but this makes sure that output is not silently lost if it fails. */ |
| err = svn_error_compose_create(err, svn_cmdline_fflush(stdout)); |
| |
| if (err) |
| { |
| exit_code = EXIT_FAILURE; |
| svn_cmdline_handle_exit_error(err, NULL, "svnconflict: "); |
| } |
| |
| svn_pool_destroy(pool); |
| |
| svn_cmdline__cancellation_exit(); |
| |
| return exit_code; |
| } |
