/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__cat(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; int i; svn_stream_t *out; apr_pool_t *subpool = svn_pool_create(pool); svn_boolean_t seen_nonexistent_target = FALSE; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, pool)); /* Cat cannot operate on an implicit '.' so a filename is required */ if (! targets->nelts) return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL); SVN_ERR(svn_stream_for_stdout(&out, pool)); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); const char *truepath; svn_opt_revision_t peg_revision; svn_boolean_t success; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Get peg revisions. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool)); SVN_ERR(svn_cl__try(svn_client_cat2(out, truepath, &peg_revision, &(opt_state->start_revision), ctx, subpool), &success, opt_state->quiet, SVN_ERR_UNVERSIONED_RESOURCE, SVN_ERR_ENTRY_NOT_FOUND, SVN_ERR_CLIENT_IS_DIRECTORY, SVN_ERR_FS_NOT_FOUND, SVN_NO_ERROR)); if (! success) seen_nonexistent_target = TRUE; } svn_pool_destroy(subpool); if (seen_nonexistent_target) return svn_error_create( SVN_ERR_ILLEGAL_TARGET, NULL, _("Could not cat all targets because some targets don't exist")); else return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__cat(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; int i; svn_stream_t *out; apr_pool_t *subpool = svn_pool_create(pool); SVN_ERR(svn_opt_args_to_target_array2(&targets, os, opt_state->targets, pool)); /* Cat cannot operate on an implicit '.' so a filename is required */ if (! targets->nelts) return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL); SVN_ERR(svn_stream_for_stdout(&out, pool)); for (i = 0; i < targets->nelts; i++) { const char *target = ((const char **) (targets->elts))[i]; const char *truepath; svn_opt_revision_t peg_revision; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Get peg revisions. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool)); SVN_ERR(svn_cl__try( svn_client_cat2(out, truepath, &peg_revision, &(opt_state->start_revision), ctx, subpool), NULL, opt_state->quiet, SVN_ERR_UNVERSIONED_RESOURCE, SVN_ERR_ENTRY_NOT_FOUND, SVN_ERR_CLIENT_IS_DIRECTORY, SVN_NO_ERROR)); } svn_pool_destroy(subpool); return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__add(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; int i; apr_pool_t *subpool; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, pool)); if (! targets->nelts) return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL); if (! opt_state->quiet) svn_cl__get_notifier(&ctx->notify_func2, &ctx->notify_baton2, FALSE, FALSE, FALSE, pool); if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_infinity; subpool = svn_pool_create(pool); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); SVN_ERR(svn_cl__try (svn_client_add4(target, opt_state->depth, opt_state->force, opt_state->no_ignore, opt_state->parents, ctx, subpool), NULL, opt_state->quiet, SVN_ERR_ENTRY_EXISTS, SVN_ERR_WC_PATH_NOT_FOUND, SVN_NO_ERROR)); } svn_pool_destroy(subpool); return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__upgrade(apr_getopt_t *os, void *baton, apr_pool_t *scratch_pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; apr_pool_t *iterpool; int i; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, scratch_pool)); /* Add "." if user passed 0 arguments */ svn_opt_push_implicit_dot_target(targets, scratch_pool); SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool)); SVN_ERR(svn_cl__check_targets_are_local_paths(targets)); iterpool = svn_pool_create(scratch_pool); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_pool_clear(iterpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); SVN_ERR(svn_client_upgrade(target, ctx, scratch_pool)); } svn_pool_destroy(iterpool); return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__resolve(apr_getopt_t *os, void *baton, apr_pool_t *scratch_pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; svn_wc_conflict_choice_t conflict_choice; svn_error_t *err; apr_array_header_t *targets; int i; apr_pool_t *iterpool; svn_boolean_t had_error = FALSE; switch (opt_state->accept_which) { case svn_cl__accept_working: conflict_choice = svn_wc_conflict_choose_merged; break; case svn_cl__accept_base: conflict_choice = svn_wc_conflict_choose_base; break; case svn_cl__accept_theirs_conflict: conflict_choice = svn_wc_conflict_choose_theirs_conflict; break; case svn_cl__accept_mine_conflict: conflict_choice = svn_wc_conflict_choose_mine_conflict; break; case svn_cl__accept_theirs_full: conflict_choice = svn_wc_conflict_choose_theirs_full; break; case svn_cl__accept_mine_full: conflict_choice = svn_wc_conflict_choose_mine_full; break; case svn_cl__accept_unspecified: if (opt_state->non_interactive) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("missing --accept option")); conflict_choice = svn_wc_conflict_choose_unspecified; break; default: return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("invalid 'accept' ARG")); } SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, scratch_pool)); if (! targets->nelts) svn_opt_push_implicit_dot_target(targets, scratch_pool); if (opt_state->depth == svn_depth_unknown) { if (opt_state->accept_which == svn_cl__accept_unspecified) opt_state->depth = svn_depth_infinity; else opt_state->depth = svn_depth_empty; } SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool)); SVN_ERR(svn_cl__check_targets_are_local_paths(targets)); iterpool = svn_pool_create(scratch_pool); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_pool_clear(iterpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); err = svn_client_resolve(target, opt_state->depth, conflict_choice, ctx, iterpool); if (err) { svn_handle_warning2(stderr, err, "svn: "); svn_error_clear(err); had_error = TRUE; } } svn_pool_destroy(iterpool); if (had_error) return svn_error_create(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL, _("Failure occurred resolving one or more " "conflicts")); return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__add(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; int i; apr_pool_t *iterpool; apr_array_header_t *errors = apr_array_make(pool, 0, sizeof(apr_status_t)); SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, pool)); if (! targets->nelts) return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL); if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_infinity; SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, pool)); SVN_ERR(svn_cl__check_targets_are_local_paths(targets)); iterpool = svn_pool_create(pool); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_pool_clear(iterpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); SVN_ERR(svn_cl__try (svn_client_add5(target, opt_state->depth, opt_state->force, opt_state->no_ignore, opt_state->no_autoprops, opt_state->parents, ctx, iterpool), errors, opt_state->quiet, SVN_ERR_ENTRY_EXISTS, SVN_ERR_WC_PATH_NOT_FOUND, 0)); } svn_pool_destroy(iterpool); if (errors->nelts > 0) { svn_error_t *err; err = svn_error_create(SVN_ERR_ILLEGAL_TARGET, NULL, NULL); for (i = 0; i < errors->nelts; i++) { apr_status_t status = APR_ARRAY_IDX(errors, i, apr_status_t); if (status == SVN_ERR_WC_PATH_NOT_FOUND) err = svn_error_quick_wrap(err, _("Could not add all targets because " "some targets don't exist")); else if (status == SVN_ERR_ENTRY_EXISTS) err = svn_error_quick_wrap(err, _("Could not add all targets because " "some targets are already versioned")); } return svn_error_trace(err); } return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__list(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; int i; apr_pool_t *subpool = svn_pool_create(pool); apr_uint32_t dirent_fields; struct print_baton pb; svn_boolean_t seen_nonexistent_target = FALSE; svn_error_t *err; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, pool)); /* Add "." if user passed 0 arguments */ svn_opt_push_implicit_dot_target(targets, pool); if (opt_state->xml) { /* The XML output contains all the information, so "--verbose" does not apply. */ if (opt_state->verbose) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("'verbose' option invalid in XML mode")); /* If output is not incremental, output the XML header and wrap everything in a top-level element. This makes the output in its entirety a well-formed XML document. */ if (! opt_state->incremental) SVN_ERR(svn_cl__xml_print_header("lists", pool)); } else { if (opt_state->incremental) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("'incremental' option only valid in XML " "mode")); } if (opt_state->verbose || opt_state->xml) dirent_fields = SVN_DIRENT_ALL; else dirent_fields = SVN_DIRENT_KIND; /* the only thing we actually need... */ pb.ctx = ctx; pb.verbose = opt_state->verbose; if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_immediates; /* For each target, try to list it. */ for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); const char *truepath; svn_opt_revision_t peg_revision; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Get peg revisions. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool)); if (opt_state->xml) { svn_stringbuf_t *sb = svn_stringbuf_create("", pool); svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "list", "path", truepath[0] == '\0' ? "." : truepath, NULL); SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout)); } err = svn_client_list2(truepath, &peg_revision, &(opt_state->start_revision), opt_state->depth, dirent_fields, (opt_state->xml || opt_state->verbose), opt_state->xml ? print_dirent_xml : print_dirent, &pb, ctx, subpool); if (err) { /* If one of the targets is a non-existent URL or wc-entry, don't bail out. Just warn and move on to the next target. */ if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND || err->apr_err == SVN_ERR_FS_NOT_FOUND) svn_handle_warning2(stderr, err, "svn: "); else return svn_error_trace(err); svn_error_clear(err); err = NULL; seen_nonexistent_target = TRUE; } if (opt_state->xml) { svn_stringbuf_t *sb = svn_stringbuf_create("", pool); svn_xml_make_close_tag(&sb, pool, "list"); SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout)); } } svn_pool_destroy(subpool); if (opt_state->xml && ! opt_state->incremental) SVN_ERR(svn_cl__xml_print_footer("lists", pool)); if (seen_nonexistent_target) return svn_error_create( SVN_ERR_ILLEGAL_TARGET, NULL, _("Could not list all targets because some targets don't exist")); else return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__blame(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_pool_t *subpool; apr_array_header_t *targets; blame_baton_t bl; int i; svn_boolean_t end_revision_unspecified = FALSE; svn_diff_file_options_t *diff_options = svn_diff_file_options_create(pool); svn_boolean_t seen_nonexistent_target = FALSE; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, pool)); /* Blame needs a file on which to operate. */ if (! targets->nelts) return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL); if (opt_state->end_revision.kind == svn_opt_revision_unspecified) { if (opt_state->start_revision.kind != svn_opt_revision_unspecified) { /* In the case that -rX was specified, we actually want to set the range to be -r1:X. */ opt_state->end_revision = opt_state->start_revision; opt_state->start_revision.kind = svn_opt_revision_number; opt_state->start_revision.value.number = 1; } else end_revision_unspecified = TRUE; } if (opt_state->start_revision.kind == svn_opt_revision_unspecified) { opt_state->start_revision.kind = svn_opt_revision_number; opt_state->start_revision.value.number = 1; } /* The final conclusion from issue #2431 is that blame info is client output (unlike 'svn cat' which plainly cats the file), so the EOL style should be the platform local one. */ if (! opt_state->xml) SVN_ERR(svn_stream_for_stdout(&bl.out, pool)); else bl.sbuf = svn_stringbuf_create("", pool); bl.opt_state = opt_state; subpool = svn_pool_create(pool); if (opt_state->extensions) { apr_array_header_t *opts; opts = svn_cstring_split(opt_state->extensions, " \t\n\r", TRUE, pool); SVN_ERR(svn_diff_file_options_parse(diff_options, opts, pool)); } if (opt_state->xml) { if (opt_state->verbose) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("'verbose' option invalid in XML mode")); /* If output is not incremental, output the XML header and wrap everything in a top-level element. This makes the output in its entirety a well-formed XML document. */ if (! opt_state->incremental) SVN_ERR(svn_cl__xml_print_header("blame", pool)); } else { if (opt_state->incremental) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("'incremental' option only valid in XML " "mode")); } for (i = 0; i < targets->nelts; i++) { svn_error_t *err; const char *target = APR_ARRAY_IDX(targets, i, const char *); const char *truepath; svn_opt_revision_t peg_revision; svn_client_blame_receiver3_t receiver; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Check for a peg revision. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool)); if (end_revision_unspecified) { if (peg_revision.kind != svn_opt_revision_unspecified) opt_state->end_revision = peg_revision; else if (svn_path_is_url(target)) opt_state->end_revision.kind = svn_opt_revision_head; else opt_state->end_revision.kind = svn_opt_revision_working; } if (opt_state->xml) { /* "<target ...>" */ /* We don't output this tag immediately, which avoids creating a target element if this path is skipped. */ const char *outpath = truepath; if (! svn_path_is_url(target)) outpath = svn_dirent_local_style(truepath, subpool); svn_xml_make_open_tag(&bl.sbuf, pool, svn_xml_normal, "target", "path", outpath, NULL); receiver = blame_receiver_xml; } else receiver = blame_receiver; err = svn_client_blame5(truepath, &peg_revision, &opt_state->start_revision, &opt_state->end_revision, diff_options, opt_state->force, opt_state->use_merge_history, receiver, &bl, ctx, subpool); if (err) { if (err->apr_err == SVN_ERR_CLIENT_IS_BINARY_FILE) { svn_error_clear(err); SVN_ERR(svn_cmdline_fprintf(stderr, subpool, _("Skipping binary file: '%s'\n"), target)); } else if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND || err->apr_err == SVN_ERR_FS_NOT_FILE || err->apr_err == SVN_ERR_FS_NOT_FOUND) { svn_handle_warning2(stderr, err, "svn: "); svn_error_clear(err); err = NULL; seen_nonexistent_target = TRUE; } else { return svn_error_trace(err); } } else if (opt_state->xml) { /* "</target>" */ svn_xml_make_close_tag(&(bl.sbuf), pool, "target"); SVN_ERR(svn_cl__error_checked_fputs(bl.sbuf->data, stdout)); } if (opt_state->xml) svn_stringbuf_setempty(bl.sbuf); } svn_pool_destroy(subpool); if (opt_state->xml && ! opt_state->incremental) SVN_ERR(svn_cl__xml_print_footer("blame", pool)); if (seen_nonexistent_target) return svn_error_create( SVN_ERR_ILLEGAL_TARGET, NULL, _("Could not perform blame on all targets because some " "targets don't exist")); else return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__info(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets = NULL; apr_pool_t *subpool = svn_pool_create(pool); int i; svn_error_t *err; svn_boolean_t saw_a_problem = FALSE; svn_opt_revision_t peg_revision; svn_info_receiver_t receiver; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, pool)); /* Add "." if user passed 0 arguments. */ svn_opt_push_implicit_dot_target(targets, pool); if (opt_state->xml) { receiver = print_info_xml; /* If output is not incremental, output the XML header and wrap everything in a top-level element. This makes the output in its entirety a well-formed XML document. */ if (! opt_state->incremental) SVN_ERR(svn_cl__xml_print_header("info", pool)); } else { receiver = print_info; if (opt_state->incremental) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("'incremental' option only valid in XML " "mode")); } if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_empty; for (i = 0; i < targets->nelts; i++) { const char *truepath; const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Get peg revisions. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool)); /* If no peg-rev was attached to a URL target, then assume HEAD. */ if ((svn_path_is_url(target)) && (peg_revision.kind == svn_opt_revision_unspecified)) peg_revision.kind = svn_opt_revision_head; err = svn_client_info2(truepath, &peg_revision, &(opt_state->start_revision), receiver, NULL, opt_state->depth, opt_state->changelists, ctx, subpool); if (err) { /* If one of the targets is a non-existent URL or wc-entry, don't bail out. Just warn and move on to the next target. */ if (err->apr_err == SVN_ERR_UNVERSIONED_RESOURCE || err->apr_err == SVN_ERR_ENTRY_NOT_FOUND) { SVN_ERR(svn_cmdline_fprintf (stderr, subpool, _("%s: (Not a versioned resource)\n\n"), svn_path_local_style(target, pool))); } else if (err->apr_err == SVN_ERR_RA_ILLEGAL_URL) { SVN_ERR(svn_cmdline_fprintf (stderr, subpool, _("%s: (Not a valid URL)\n\n"), svn_path_local_style(target, pool))); } else { return err; } svn_error_clear(err); err = NULL; saw_a_problem = TRUE; } } svn_pool_destroy(subpool); if (opt_state->xml && (! opt_state->incremental)) SVN_ERR(svn_cl__xml_print_footer("info", pool)); if (saw_a_problem) return svn_error_create(SVN_ERR_BASE, NULL, NULL); else return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__propget(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; const char *pname, *pname_utf8; apr_array_header_t *args, *targets; svn_stream_t *out; if (opt_state->verbose && (opt_state->revprop || opt_state->strict || opt_state->xml)) return svn_error_create(SVN_ERR_CL_MUTUALLY_EXCLUSIVE_ARGS, NULL, _("--verbose cannot be used with --revprop or " "--strict or --xml")); /* PNAME is first argument (and PNAME_UTF8 will be a UTF-8 version thereof) */ SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool)); pname = APR_ARRAY_IDX(args, 0, const char *); SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool)); if (! svn_prop_name_is_valid(pname_utf8)) return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL, _("'%s' is not a valid Subversion property name"), pname_utf8); SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, pool)); /* Add "." if user passed 0 file arguments */ svn_opt_push_implicit_dot_target(targets, pool); /* Open a stream to stdout. */ SVN_ERR(svn_stream_for_stdout(&out, pool)); if (opt_state->revprop) /* operate on a revprop */ { svn_revnum_t rev; const char *URL; svn_string_t *propval; SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets, &URL, ctx, pool)); /* Let libsvn_client do the real work. */ SVN_ERR(svn_client_revprop_get(pname_utf8, &propval, URL, &(opt_state->start_revision), &rev, ctx, pool)); if (propval != NULL) { if (opt_state->xml) { svn_stringbuf_t *sb = NULL; char *revstr = apr_psprintf(pool, "%ld", rev); SVN_ERR(svn_cl__xml_print_header("properties", pool)); svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "revprops", "rev", revstr, NULL); svn_cmdline__print_xml_prop(&sb, pname_utf8, propval, pool); svn_xml_make_close_tag(&sb, pool, "revprops"); SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout)); SVN_ERR(svn_cl__xml_print_footer("properties", pool)); } else { svn_string_t *printable_val = propval; /* If this is a special Subversion property, it is stored as UTF8 and LF, so convert to the native locale and eol-style. */ if (svn_prop_needs_translation(pname_utf8)) SVN_ERR(svn_subst_detranslate_string(&printable_val, propval, TRUE, pool)); SVN_ERR(stream_write(out, printable_val->data, printable_val->len)); if (! opt_state->strict) SVN_ERR(stream_write(out, APR_EOL_STR, strlen(APR_EOL_STR))); } } } else /* operate on a normal, versioned property (not a revprop) */ { apr_pool_t *subpool = svn_pool_create(pool); int i; if (opt_state->xml) SVN_ERR(svn_cl__xml_print_header("properties", subpool)); if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_empty; /* Strict mode only makes sense for a single target. So make sure we have only a single target, and that we're not being asked to recurse on that target. */ if (opt_state->strict && ((targets->nelts > 1) || (opt_state->depth != svn_depth_empty))) return svn_error_create (SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("Strict output of property values only available for single-" "target, non-recursive propget operations")); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); apr_hash_t *props; svn_boolean_t print_filenames; svn_boolean_t omit_newline; svn_boolean_t like_proplist; const char *truepath; svn_opt_revision_t peg_revision; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Check for a peg revision. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool)); if (!svn_path_is_url(truepath)) SVN_ERR(svn_dirent_get_absolute(&truepath, truepath, subpool)); SVN_ERR(svn_client_propget4(&props, pname_utf8, truepath, &peg_revision, &(opt_state->start_revision), NULL, opt_state->depth, opt_state->changelists, ctx, subpool, subpool)); /* Any time there is more than one thing to print, or where the path associated with a printed thing is not obvious, we'll print filenames. That is, unless we've been told not to do so with the --strict option. */ print_filenames = ((opt_state->depth > svn_depth_empty || targets->nelts > 1 || apr_hash_count(props) > 1 || opt_state->verbose) && (! opt_state->strict)); omit_newline = opt_state->strict; like_proplist = opt_state->verbose && !opt_state->strict; if (opt_state->xml) SVN_ERR(print_properties_xml(pname_utf8, props, subpool)); else SVN_ERR(print_properties(out, svn_path_is_url(target), pname_utf8, props, print_filenames, omit_newline, like_proplist, subpool)); } if (opt_state->xml) SVN_ERR(svn_cl__xml_print_footer("properties", subpool)); svn_pool_destroy(subpool); } return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__propset(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; const char *pname, *pname_utf8; svn_string_t *propval = NULL; svn_boolean_t propval_came_from_cmdline; apr_array_header_t *args, *targets; int i; /* PNAME and PROPVAL expected as first 2 arguments if filedata was NULL, else PNAME alone will precede the targets. Get a UTF-8 version of the name, too. */ SVN_ERR(svn_opt_parse_num_args(&args, os, opt_state->filedata ? 1 : 2, pool)); pname = APR_ARRAY_IDX(args, 0, const char *); SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool)); if (! svn_prop_name_is_valid(pname_utf8)) return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL, _("'%s' is not a valid Subversion property name"), pname_utf8); /* Get the PROPVAL from either an external file, or from the command line. */ if (opt_state->filedata) { propval = svn_string_create_from_buf(opt_state->filedata, pool); propval_came_from_cmdline = FALSE; } else { propval = svn_string_create(APR_ARRAY_IDX(args, 1, const char *), pool); propval_came_from_cmdline = TRUE; } /* We only want special Subversion property values to be in UTF-8 and LF line endings. All other propvals are taken literally. */ if (svn_prop_needs_translation(pname_utf8)) SVN_ERR(svn_subst_translate_string(&propval, propval, opt_state->encoding, pool)); else if (opt_state->encoding) return svn_error_create (SVN_ERR_UNSUPPORTED_FEATURE, NULL, _("--encoding option applies only to textual" " Subversion-controlled properties")); /* Suck up all the remaining arguments into a targets array */ SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, pool)); if (! opt_state->quiet) svn_cl__get_notifier(&ctx->notify_func2, &ctx->notify_baton2, FALSE, FALSE, FALSE, pool); /* Implicit "." is okay for revision properties; it just helps us find the right repository. */ if (opt_state->revprop) svn_opt_push_implicit_dot_target(targets, pool); SVN_ERR(svn_opt__eat_peg_revisions(&targets, targets, pool)); if (opt_state->revprop) /* operate on a revprop */ { svn_revnum_t rev; const char *URL; SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets, &URL, pool)); /* Let libsvn_client do the real work. */ SVN_ERR(svn_client_revprop_set2(pname_utf8, propval, NULL, URL, &(opt_state->start_revision), &rev, opt_state->force, ctx, pool)); } else if (opt_state->start_revision.kind != svn_opt_revision_unspecified) { return svn_error_createf (SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("Cannot specify revision for setting versioned property '%s'"), pname); } else /* operate on a normal, versioned property (not a revprop) */ { apr_pool_t *subpool = svn_pool_create(pool); if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_empty; /* The customary implicit dot rule has been prone to user error * here. People would do intuitive things like * * $ svn propset svn:executable script * * and then be surprised to get an error like: * * svn: Illegal target for the requested operation * svn: Cannot set svn:executable on a directory () * * So we don't do the implicit dot thing anymore. A * target * must always be explicitly provided when setting a versioned * property. See * * http://subversion.tigris.org/issues/show_bug.cgi?id=924 * * for more details. */ if (targets->nelts == 0) { if (propval_came_from_cmdline) { return svn_error_createf (SVN_ERR_CL_INSUFFICIENT_ARGS, NULL, _("Explicit target required ('%s' interpreted as prop value)"), propval->data); } else { return svn_error_create (SVN_ERR_CL_INSUFFICIENT_ARGS, NULL, _("Explicit target argument required")); } } for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_commit_info_t *commit_info; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); SVN_ERR(svn_cl__try(svn_client_propset3 (&commit_info, pname_utf8, propval, target, opt_state->depth, opt_state->force, SVN_INVALID_REVNUM, opt_state->changelists, NULL, ctx, subpool), NULL, opt_state->quiet, SVN_ERR_UNVERSIONED_RESOURCE, SVN_ERR_ENTRY_NOT_FOUND, SVN_NO_ERROR)); if (! opt_state->quiet) svn_cl__check_boolean_prop_val(pname_utf8, propval->data, subpool); } svn_pool_destroy(subpool); } return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__proplist(apr_getopt_t *os, void *baton, apr_pool_t *scratch_pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, scratch_pool)); /* Add "." if user passed 0 file arguments */ svn_opt_push_implicit_dot_target(targets, scratch_pool); if (opt_state->revprop) /* operate on revprops */ { svn_revnum_t rev; const char *URL; apr_hash_t *proplist; SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets, &URL, ctx, scratch_pool)); /* Let libsvn_client do the real work. */ SVN_ERR(svn_client_revprop_list(&proplist, URL, &(opt_state->start_revision), &rev, ctx, scratch_pool)); if (opt_state->xml) { svn_stringbuf_t *sb = NULL; char *revstr = apr_psprintf(scratch_pool, "%ld", rev); SVN_ERR(svn_cl__xml_print_header("properties", scratch_pool)); svn_xml_make_open_tag(&sb, scratch_pool, svn_xml_normal, "revprops", "rev", revstr, NULL); SVN_ERR(svn_cl__print_xml_prop_hash (&sb, proplist, (! opt_state->verbose), scratch_pool)); svn_xml_make_close_tag(&sb, scratch_pool, "revprops"); SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout)); SVN_ERR(svn_cl__xml_print_footer("properties", scratch_pool)); } else { SVN_ERR (svn_cmdline_printf(scratch_pool, _("Unversioned properties on revision %ld:\n"), rev)); SVN_ERR(svn_cl__print_prop_hash (NULL, proplist, (! opt_state->verbose), scratch_pool)); } } else /* operate on normal, versioned properties (not revprops) */ { int i; apr_pool_t *iterpool; svn_proplist_receiver_t pl_receiver; svn_boolean_t had_errors = FALSE; if (opt_state->xml) { SVN_ERR(svn_cl__xml_print_header("properties", scratch_pool)); pl_receiver = proplist_receiver_xml; } else { pl_receiver = proplist_receiver; } if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_empty; iterpool = svn_pool_create(scratch_pool); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); proplist_baton_t pl_baton; const char *truepath; svn_opt_revision_t peg_revision; svn_boolean_t success; svn_pool_clear(iterpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); pl_baton.is_url = svn_path_is_url(target); pl_baton.opt_state = opt_state; /* Check for a peg revision. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, iterpool)); SVN_ERR(svn_cl__try( svn_client_proplist3(truepath, &peg_revision, &(opt_state->start_revision), opt_state->depth, opt_state->changelists, pl_receiver, &pl_baton, ctx, iterpool), &success, opt_state->quiet, SVN_ERR_UNVERSIONED_RESOURCE, SVN_ERR_ENTRY_NOT_FOUND, SVN_NO_ERROR)); if (!success) had_errors = TRUE; } svn_pool_destroy(iterpool); if (opt_state->xml) SVN_ERR(svn_cl__xml_print_footer("properties", scratch_pool)); /* Error out *after* we closed the XML element */ if (had_errors) return svn_error_create(SVN_ERR_ILLEGAL_TARGET, NULL, _("Could not display info for all targets " "because some targets don't exist")); } return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__null_list(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; int i; apr_pool_t *subpool = svn_pool_create(pool); apr_uint32_t dirent_fields; struct print_baton pb = { FALSE }; svn_boolean_t seen_nonexistent_target = FALSE; svn_error_t *err; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, pool)); /* Add "." if user passed 0 arguments */ svn_opt_push_implicit_dot_target(targets, pool); if (opt_state->verbose) dirent_fields = SVN_DIRENT_ALL; else dirent_fields = SVN_DIRENT_KIND; /* the only thing we actually need... */ pb.ctx = ctx; pb.verbose = opt_state->verbose; if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_immediates; /* For each target, try to list it. */ for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); const char *truepath; svn_opt_revision_t peg_revision; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Get peg revisions. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool)); err = svn_client_list3(truepath, &peg_revision, &(opt_state->start_revision), opt_state->depth, dirent_fields, opt_state->verbose, FALSE, /* include externals */ print_dirent, &pb, ctx, subpool); if (err) { /* If one of the targets is a non-existent URL or wc-entry, don't bail out. Just warn and move on to the next target. */ if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND || err->apr_err == SVN_ERR_FS_NOT_FOUND) svn_handle_warning2(stderr, err, "svnbench: "); else return svn_error_trace(err); svn_error_clear(err); err = NULL; seen_nonexistent_target = TRUE; } else if (!opt_state->quiet) SVN_ERR(svn_cmdline_printf(pool, _("%15s directories\n" "%15s files\n" "%15s locks\n"), svn__ui64toa_sep(pb.directories, ',', pool), svn__ui64toa_sep(pb.files, ',', pool), svn__ui64toa_sep(pb.locks, ',', pool))); } svn_pool_destroy(subpool); if (seen_nonexistent_target) return svn_error_create( SVN_ERR_ILLEGAL_TARGET, NULL, _("Could not list all targets because some targets don't exist")); else return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__resolve(apr_getopt_t *os, void *baton, apr_pool_t *scratch_pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; svn_wc_conflict_choice_t conflict_choice; svn_error_t *err; apr_array_header_t *targets; int i; apr_pool_t *iterpool; switch (opt_state->accept_which) { case svn_cl__accept_working: conflict_choice = svn_wc_conflict_choose_merged; break; case svn_cl__accept_base: conflict_choice = svn_wc_conflict_choose_base; break; case svn_cl__accept_theirs_conflict: conflict_choice = svn_wc_conflict_choose_theirs_conflict; break; case svn_cl__accept_mine_conflict: conflict_choice = svn_wc_conflict_choose_mine_conflict; break; case svn_cl__accept_theirs_full: conflict_choice = svn_wc_conflict_choose_theirs_full; break; case svn_cl__accept_mine_full: conflict_choice = svn_wc_conflict_choose_mine_full; break; case svn_cl__accept_unspecified: return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("missing --accept option")); default: return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("invalid 'accept' ARG")); } SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, scratch_pool)); if (! targets->nelts) return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL); if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_empty; SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool)); SVN_ERR(svn_cl__check_targets_are_local_paths(targets)); iterpool = svn_pool_create(scratch_pool); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_pool_clear(iterpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); err = svn_client_resolve(target, opt_state->depth, conflict_choice, ctx, iterpool); if (err) { svn_handle_warning2(stderr, err, "svn: "); svn_error_clear(err); } } svn_pool_destroy(iterpool); return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__null_blame(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_pool_t *iterpool; apr_array_header_t *targets; int i; svn_boolean_t end_revision_unspecified = FALSE; svn_boolean_t seen_nonexistent_target = FALSE; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, pool)); /* Blame needs a file on which to operate. */ if (! targets->nelts) return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL); if (opt_state->end_revision.kind == svn_opt_revision_unspecified) { if (opt_state->start_revision.kind != svn_opt_revision_unspecified) { /* In the case that -rX was specified, we actually want to set the range to be -r1:X. */ opt_state->end_revision = opt_state->start_revision; opt_state->start_revision.kind = svn_opt_revision_number; opt_state->start_revision.value.number = 1; } else end_revision_unspecified = TRUE; } if (opt_state->start_revision.kind == svn_opt_revision_unspecified) { opt_state->start_revision.kind = svn_opt_revision_number; opt_state->start_revision.value.number = 1; } /* The final conclusion from issue #2431 is that blame info is client output (unlike 'svn cat' which plainly cats the file), so the EOL style should be the platform local one. */ iterpool = svn_pool_create(pool); for (i = 0; i < targets->nelts; i++) { svn_error_t *err; const char *target = APR_ARRAY_IDX(targets, i, const char *); const char *parsed_path; svn_opt_revision_t peg_revision; svn_pool_clear(iterpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Check for a peg revision. */ SVN_ERR(svn_opt_parse_path(&peg_revision, &parsed_path, target, iterpool)); if (end_revision_unspecified) { if (peg_revision.kind != svn_opt_revision_unspecified) opt_state->end_revision = peg_revision; else if (svn_path_is_url(target)) opt_state->end_revision.kind = svn_opt_revision_head; else opt_state->end_revision.kind = svn_opt_revision_working; } err = bench_null_blame(parsed_path, &peg_revision, &opt_state->start_revision, &opt_state->end_revision, opt_state->use_merge_history, opt_state->quiet, ctx, iterpool); if (err) { if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND || err->apr_err == SVN_ERR_ENTRY_NOT_FOUND || err->apr_err == SVN_ERR_FS_NOT_FILE || err->apr_err == SVN_ERR_FS_NOT_FOUND) { svn_handle_warning2(stderr, err, "svn: "); svn_error_clear(err); err = NULL; seen_nonexistent_target = TRUE; } else { return svn_error_trace(err); } } } svn_pool_destroy(iterpool); if (seen_nonexistent_target) return svn_error_create( SVN_ERR_ILLEGAL_TARGET, NULL, _("Could not perform blame on all targets because some " "targets don't exist")); else return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__status(apr_getopt_t *os, void *baton, apr_pool_t *scratch_pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; apr_pool_t *iterpool; apr_hash_t *master_cl_hash = apr_hash_make(scratch_pool); int i; svn_opt_revision_t rev; struct status_baton sb; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, FALSE, scratch_pool)); /* Add "." if user passed 0 arguments */ svn_opt_push_implicit_dot_target(targets, scratch_pool); SVN_ERR(svn_cl__check_targets_are_local_paths(targets)); /* We want our -u statuses to be against HEAD by default. */ if (opt_state->start_revision.kind == svn_opt_revision_unspecified) rev.kind = svn_opt_revision_head; else if (! opt_state->update) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("--revision (-r) option valid only with " "--show-updates (-u) option")); else rev = opt_state->start_revision; sb.had_print_error = FALSE; if (opt_state->xml) { /* If output is not incremental, output the XML header and wrap everything in a top-level element. This makes the output in its entirety a well-formed XML document. */ if (! opt_state->incremental) SVN_ERR(svn_cl__xml_print_header("status", scratch_pool)); } else { if (opt_state->incremental) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("'incremental' option only valid in XML " "mode")); } sb.suppress_externals_placeholders = (opt_state->quiet && (! opt_state->verbose)); sb.detailed = (opt_state->verbose || opt_state->update); sb.show_last_committed = opt_state->verbose; sb.skip_unrecognized = opt_state->quiet; sb.repos_locks = opt_state->update; sb.xml_mode = opt_state->xml; sb.cached_changelists = master_cl_hash; sb.cl_pool = scratch_pool; sb.text_conflicts = 0; sb.prop_conflicts = 0; sb.tree_conflicts = 0; sb.ctx = ctx; SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool)); iterpool = svn_pool_create(scratch_pool); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_revnum_t repos_rev = SVN_INVALID_REVNUM; svn_pool_clear(iterpool); SVN_ERR(svn_dirent_get_absolute(&(sb.target_abspath), target, scratch_pool)); sb.target_path = target; SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); if (opt_state->xml) SVN_ERR(print_start_target_xml(svn_dirent_local_style(target, iterpool), iterpool)); /* Retrieve a hash of status structures with the information requested by the user. */ SVN_ERR(svn_cl__try(svn_client_status6(&repos_rev, ctx, target, &rev, opt_state->depth, opt_state->verbose, opt_state->update, TRUE /* check_working_copy */, opt_state->no_ignore, opt_state->ignore_externals, FALSE /* depth_as_sticky */, opt_state->changelists, print_status, &sb, iterpool), NULL, opt_state->quiet, /* not versioned: */ SVN_ERR_WC_NOT_WORKING_COPY, SVN_ERR_WC_PATH_NOT_FOUND, 0)); if (opt_state->xml) SVN_ERR(print_finish_target_xml(repos_rev, iterpool)); } /* If any paths were cached because they were associated with changelists, we can now display them as grouped changelists. */ if (apr_hash_count(master_cl_hash) > 0) { apr_hash_index_t *hi; svn_stringbuf_t *buf; if (opt_state->xml) buf = svn_stringbuf_create_empty(scratch_pool); for (hi = apr_hash_first(scratch_pool, master_cl_hash); hi; hi = apr_hash_next(hi)) { const char *changelist_name = apr_hash_this_key(hi); apr_array_header_t *path_array = apr_hash_this_val(hi); int j; /* ### TODO: For non-XML output, we shouldn't print the ### leading \n on the first changelist if there were no ### non-changelist entries. */ if (opt_state->xml) { svn_stringbuf_setempty(buf); svn_xml_make_open_tag(&buf, scratch_pool, svn_xml_normal, "changelist", "name", changelist_name, SVN_VA_NULL); SVN_ERR(svn_cl__error_checked_fputs(buf->data, stdout)); } else SVN_ERR(svn_cmdline_printf(scratch_pool, _("\n--- Changelist '%s':\n"), changelist_name)); for (j = 0; j < path_array->nelts; j++) { struct status_cache *scache = APR_ARRAY_IDX(path_array, j, struct status_cache *); sb.target_abspath = scache->target_abspath; sb.target_path = scache->target_path; SVN_ERR(print_status_normal_or_xml(&sb, scache->path, scache->status, scratch_pool)); } if (opt_state->xml) { svn_stringbuf_setempty(buf); svn_xml_make_close_tag(&buf, scratch_pool, "changelist"); SVN_ERR(svn_cl__error_checked_fputs(buf->data, stdout)); } } }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__propdel(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; const char *pname, *pname_utf8; apr_array_header_t *args, *targets; int i; /* Get the property's name (and a UTF-8 version of that name). */ SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool)); pname = APR_ARRAY_IDX(args, 0, const char *); SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool)); /* No need to check svn_prop_name_is_valid for *deleting* properties, and it may even be useful to allow, in case invalid properties sneaked through somehow. */ SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, pool)); /* Add "." if user passed 0 file arguments */ svn_opt_push_implicit_dot_target(targets, pool); if (opt_state->revprop) /* operate on a revprop */ { svn_revnum_t rev; const char *URL; SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets, &URL, pool)); /* Let libsvn_client do the real work. */ SVN_ERR(svn_client_revprop_set(pname_utf8, NULL, URL, &(opt_state->start_revision), &rev, FALSE, ctx, pool)); if (! opt_state->quiet) { SVN_ERR(svn_cmdline_printf(pool, _("property '%s' deleted from" " repository revision %ld\n"), pname_utf8, rev)); } } else if (opt_state->start_revision.kind != svn_opt_revision_unspecified) { return svn_error_createf (SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("Cannot specify revision for deleting versioned property '%s'"), pname); } else /* operate on a normal, versioned property (not a revprop) */ { apr_pool_t *subpool = svn_pool_create(pool); if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_empty; /* For each target, remove the property PNAME. */ for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_commit_info_t *commit_info; svn_boolean_t success; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Pass FALSE for 'skip_checks' because it doesn't matter here, and opt_state->force doesn't apply to this command anyway. */ SVN_ERR(svn_cl__try(svn_client_propset3 (&commit_info, pname_utf8, NULL, target, opt_state->depth, FALSE, SVN_INVALID_REVNUM, opt_state->changelists, NULL, ctx, subpool), &success, opt_state->quiet, SVN_ERR_UNVERSIONED_RESOURCE, SVN_ERR_ENTRY_NOT_FOUND, SVN_NO_ERROR)); if (success && (! opt_state->quiet)) { SVN_ERR(svn_cmdline_printf (subpool, SVN_DEPTH_IS_RECURSIVE(opt_state->depth) ? _("property '%s' deleted (recursively) from '%s'.\n") : _("property '%s' deleted from '%s'.\n"), pname_utf8, svn_path_local_style(target, subpool))); } } svn_pool_destroy(subpool); } return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__status(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; apr_array_header_t *targets; apr_pool_t *subpool; apr_hash_t *master_cl_hash = apr_hash_make(pool); int i; svn_opt_revision_t rev; struct status_baton sb; SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, pool)); /* Add "." if user passed 0 arguments */ svn_opt_push_implicit_dot_target(targets, pool); /* We want our -u statuses to be against HEAD. */ rev.kind = svn_opt_revision_head; /* The notification callback, leave the notifier as NULL in XML mode */ if (! opt_state->xml) svn_cl__get_notifier(&ctx->notify_func2, &ctx->notify_baton2, FALSE, FALSE, FALSE, pool); subpool = svn_pool_create(pool); sb.had_print_error = FALSE; if (opt_state->xml) { /* If output is not incremental, output the XML header and wrap everything in a top-level element. This makes the output in its entirety a well-formed XML document. */ if (! opt_state->incremental) SVN_ERR(svn_cl__xml_print_header("status", pool)); } else { if (opt_state->incremental) return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("'incremental' option only valid in XML " "mode")); } sb.detailed = (opt_state->verbose || opt_state->update); sb.show_last_committed = opt_state->verbose; sb.skip_unrecognized = opt_state->quiet; sb.repos_locks = opt_state->update; sb.xml_mode = opt_state->xml; sb.cached_changelists = master_cl_hash; sb.cl_pool = pool; SVN_ERR(svn_opt__eat_peg_revisions(&targets, targets, pool)); for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_revnum_t repos_rev = SVN_INVALID_REVNUM; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); if (opt_state->xml) SVN_ERR(print_start_target_xml(svn_path_local_style(target, subpool), subpool)); /* Retrieve a hash of status structures with the information requested by the user. */ SVN_ERR(svn_cl__try(svn_client_status4(&repos_rev, target, &rev, print_status, &sb, opt_state->depth, opt_state->verbose, opt_state->update, opt_state->no_ignore, opt_state->ignore_externals, opt_state->changelists, ctx, subpool), NULL, opt_state->quiet, /* not versioned: */ SVN_ERR_WC_NOT_DIRECTORY, SVN_NO_ERROR)); if (opt_state->xml) SVN_ERR(print_finish_target_xml(repos_rev, subpool)); } /* If any paths were cached because they were associatied with changelists, we can now display them as grouped changelists. */ if (apr_hash_count(master_cl_hash) > 0) { apr_hash_index_t *hi; svn_stringbuf_t *buf; if (opt_state->xml) buf = svn_stringbuf_create("", pool); for (hi = apr_hash_first(pool, master_cl_hash); hi; hi = apr_hash_next(hi)) { const char *changelist_name; apr_array_header_t *path_array; const void *key; void *val; int j; apr_hash_this(hi, &key, NULL, &val); changelist_name = key; path_array = val; /* ### TODO: For non-XML output, we shouldn't print the ### leading \n on the first changelist if there were no ### non-changelist entries. */ if (opt_state->xml) { svn_stringbuf_set(buf, ""); svn_xml_make_open_tag(&buf, pool, svn_xml_normal, "changelist", "name", changelist_name, NULL); SVN_ERR(svn_cl__error_checked_fputs(buf->data, stdout)); } else SVN_ERR(svn_cmdline_printf(pool, _("\n--- Changelist '%s':\n"), changelist_name)); for (j = 0; j < path_array->nelts; j++) { struct status_cache *scache = APR_ARRAY_IDX(path_array, j, struct status_cache *); SVN_ERR(print_status_normal_or_xml(&sb, scache->path, scache->status, pool)); } if (opt_state->xml) { svn_stringbuf_set(buf, ""); svn_xml_make_close_tag(&buf, pool, "changelist"); SVN_ERR(svn_cl__error_checked_fputs(buf->data, stdout)); } } }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__propedit(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; const char *pname, *pname_utf8; apr_array_header_t *args, *targets; int i; /* Validate the input and get the property's name (and a UTF-8 version of that name). */ SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool)); pname = APR_ARRAY_IDX(args, 0, const char *); SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool)); if (! svn_prop_name_is_valid(pname_utf8)) return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL, _("'%s' is not a valid Subversion property name"), pname_utf8); if (opt_state->encoding && !svn_prop_needs_translation(pname_utf8)) return svn_error_create (SVN_ERR_UNSUPPORTED_FEATURE, NULL, _("--encoding option applies only to textual" " Subversion-controlled properties")); /* Suck up all the remaining arguments into a targets array */ SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, pool)); if (opt_state->revprop) /* operate on a revprop */ { svn_revnum_t rev; const char *URL; svn_string_t *propval; svn_string_t original_propval; const char *temp_dir; /* Implicit "." is okay for revision properties; it just helps us find the right repository. */ svn_opt_push_implicit_dot_target(targets, pool); SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets, &URL, pool)); /* Fetch the current property. */ SVN_ERR(svn_client_revprop_get(pname_utf8, &propval, URL, &(opt_state->start_revision), &rev, ctx, pool)); if (! propval) { propval = svn_string_create("", pool); /* This is how we signify to svn_client_revprop_set2() that we want it to check that the original value hasn't changed, but that that original value was non-existent: */ original_propval.data = NULL; /* and .len is ignored */ } else { original_propval = *propval; } /* Run the editor on a temporary file which contains the original property value... */ SVN_ERR(svn_io_temp_dir(&temp_dir, pool)); SVN_ERR(svn_cl__edit_string_externally (&propval, NULL, opt_state->editor_cmd, temp_dir, propval, "svn-prop", ctx->config, svn_prop_needs_translation(pname_utf8), opt_state->encoding, pool)); /* ...and re-set the property's value accordingly. */ if (propval) { SVN_ERR(svn_client_revprop_set2(pname_utf8, propval, &original_propval, URL, &(opt_state->start_revision), &rev, opt_state->force, ctx, pool)); SVN_ERR (svn_cmdline_printf (pool, _("Set new value for property '%s' on revision %ld\n"), pname_utf8, rev)); } else { SVN_ERR(svn_cmdline_printf (pool, _("No changes to property '%s' on revision %ld\n"), pname_utf8, rev)); } } else if (opt_state->start_revision.kind != svn_opt_revision_unspecified) { return svn_error_createf (SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("Cannot specify revision for editing versioned property '%s'"), pname_utf8); } else /* operate on a normal, versioned property (not a revprop) */ { apr_pool_t *subpool = svn_pool_create(pool); /* The customary implicit dot rule has been prone to user error * here. For example, Jon Trowbridge <*****@*****.**> did * * $ svn propedit HACKING * * and then when he closed his editor, he was surprised to see * * Set new value for property 'HACKING' on '' * * ...meaning that the property named 'HACKING' had been set on * the current working directory, with the value taken from the * editor. So we don't do the implicit dot thing anymore; an * explicit target is always required when editing a versioned * property. */ if (targets->nelts == 0) { return svn_error_create (SVN_ERR_CL_INSUFFICIENT_ARGS, NULL, _("Explicit target argument required")); } SVN_ERR(svn_opt__eat_peg_revisions(&targets, targets, pool)); /* For each target, edit the property PNAME. */ for (i = 0; i < targets->nelts; i++) { apr_hash_t *props; const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_string_t *propval, *edited_propval; const char *base_dir = target; const char *target_local; svn_wc_adm_access_t *adm_access; const svn_wc_entry_t *entry; svn_opt_revision_t peg_revision; svn_revnum_t base_rev = SVN_INVALID_REVNUM; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); /* Propedits can only happen on HEAD or the working copy, so the peg revision can be as unspecified. */ peg_revision.kind = svn_opt_revision_unspecified; /* Fetch the current property. */ SVN_ERR(svn_client_propget3(&props, pname_utf8, target, &peg_revision, &(opt_state->start_revision), &base_rev, svn_depth_empty, NULL, ctx, subpool)); /* Get the property value. */ propval = apr_hash_get(props, target, APR_HASH_KEY_STRING); if (! propval) propval = svn_string_create("", subpool); if (svn_path_is_url(target)) { /* For URLs, put the temporary file in the current directory. */ base_dir = "."; } else { if (opt_state->message || opt_state->filedata || opt_state->revprop_table) { return svn_error_create (SVN_ERR_CL_UNNECESSARY_LOG_MESSAGE, NULL, _("Local, non-commit operations do not take a log message " "or revision properties")); } /* Split the path if it is a file path. */ SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, target, FALSE, 0, ctx->cancel_func, ctx->cancel_baton, subpool)); SVN_ERR(svn_wc_entry(&entry, target, adm_access, FALSE, subpool)); if (! entry) return svn_error_createf (SVN_ERR_ENTRY_NOT_FOUND, NULL, _("'%s' does not appear to be a working copy path"), target); if (entry->kind == svn_node_file) svn_path_split(target, &base_dir, NULL, subpool); } /* Run the editor on a temporary file which contains the original property value... */ SVN_ERR(svn_cl__edit_string_externally(&edited_propval, NULL, opt_state->editor_cmd, base_dir, propval, "svn-prop", ctx->config, svn_prop_needs_translation (pname_utf8), opt_state->encoding, subpool)); target_local = svn_path_is_url(target) ? target : svn_path_local_style(target, subpool); /* ...and re-set the property's value accordingly. */ if (edited_propval && !svn_string_compare(propval, edited_propval)) { svn_commit_info_t *commit_info = NULL; svn_error_t *err = SVN_NO_ERROR; svn_cl__check_boolean_prop_val(pname_utf8, edited_propval->data, subpool); if (ctx->log_msg_func3) SVN_ERR(svn_cl__make_log_msg_baton(&(ctx->log_msg_baton3), opt_state, NULL, ctx->config, subpool)); err = svn_client_propset3(&commit_info, pname_utf8, edited_propval, target, svn_depth_empty, opt_state->force, base_rev, NULL, opt_state->revprop_table, ctx, subpool); if (ctx->log_msg_func3) SVN_ERR(svn_cl__cleanup_log_msg(ctx->log_msg_baton3, err, pool)); else if (err) return err; /* Print a message if we successfully committed or if it was just a wc propset (but not if the user aborted an URL propedit). */ if (commit_info || ! svn_path_is_url(target)) SVN_ERR (svn_cmdline_printf (subpool, _("Set new value for property '%s' on '%s'\n"), pname_utf8, target_local)); if (commit_info && ! opt_state->quiet) SVN_ERR(svn_cl__print_commit_info(commit_info, subpool)); } else { SVN_ERR (svn_cmdline_printf (subpool, _("No changes to property '%s' on '%s'\n"), pname_utf8, target_local)); } } svn_pool_destroy(subpool); } return SVN_NO_ERROR; }