1251881Speter/* 2251881Speter * deprecated.c: holding file for all deprecated APIs. 3251881Speter * "we can't lose 'em, but we can shun 'em!" 4251881Speter * 5251881Speter * ==================================================================== 6251881Speter * Licensed to the Apache Software Foundation (ASF) under one 7251881Speter * or more contributor license agreements. See the NOTICE file 8251881Speter * distributed with this work for additional information 9251881Speter * regarding copyright ownership. The ASF licenses this file 10251881Speter * to you under the Apache License, Version 2.0 (the 11251881Speter * "License"); you may not use this file except in compliance 12251881Speter * with the License. You may obtain a copy of the License at 13251881Speter * 14251881Speter * http://www.apache.org/licenses/LICENSE-2.0 15251881Speter * 16251881Speter * Unless required by applicable law or agreed to in writing, 17251881Speter * software distributed under the License is distributed on an 18251881Speter * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 19251881Speter * KIND, either express or implied. See the License for the 20251881Speter * specific language governing permissions and limitations 21251881Speter * under the License. 22251881Speter * ==================================================================== 23251881Speter */ 24251881Speter 25251881Speter/* ==================================================================== */ 26251881Speter 27251881Speter 28251881Speter 29251881Speter#include <assert.h> 30251881Speter 31289180Speter#include <apr_md5.h> 32289180Speter 33251881Speter/* We define this here to remove any further warnings about the usage of 34251881Speter deprecated functions in this file. */ 35251881Speter#define SVN_DEPRECATED 36251881Speter 37251881Speter#include "svn_hash.h" 38251881Speter#include "svn_subst.h" 39251881Speter#include "svn_path.h" 40251881Speter#include "svn_opt.h" 41251881Speter#include "svn_cmdline.h" 42251881Speter#include "svn_version.h" 43251881Speter#include "svn_pools.h" 44251881Speter#include "svn_dso.h" 45251881Speter#include "svn_mergeinfo.h" 46251881Speter#include "svn_utf.h" 47251881Speter#include "svn_xml.h" 48289180Speter#include "svn_auth.h" 49362181Sdim#include "svn_base64.h" 50251881Speter 51251881Speter#include "opt.h" 52289180Speter#include "auth.h" 53251881Speter#include "private/svn_opt_private.h" 54251881Speter#include "private/svn_mergeinfo_private.h" 55251881Speter 56251881Speter#include "svn_private_config.h" 57251881Speter 58251881Speter 59251881Speter 60251881Speter 61251881Speter/*** Code. ***/ 62251881Speter 63251881Speter/*** From subst.c ***/ 64251881Speter/* Convert an old-style svn_subst_keywords_t struct * into a new-style 65251881Speter * keywords hash. Keyword values are shallow copies, so the produced 66251881Speter * hash must not be assumed to have lifetime longer than the struct it 67251881Speter * is based on. A NULL input causes a NULL output. */ 68251881Speterstatic apr_hash_t * 69251881Speterkwstruct_to_kwhash(const svn_subst_keywords_t *kwstruct, 70251881Speter apr_pool_t *pool) 71251881Speter{ 72251881Speter apr_hash_t *kwhash; 73251881Speter 74251881Speter if (kwstruct == NULL) 75251881Speter return NULL; 76251881Speter 77251881Speter kwhash = apr_hash_make(pool); 78251881Speter 79251881Speter if (kwstruct->revision) 80251881Speter { 81251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_REVISION_LONG, kwstruct->revision); 82251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_REVISION_MEDIUM, kwstruct->revision); 83251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_REVISION_SHORT, kwstruct->revision); 84251881Speter } 85251881Speter if (kwstruct->date) 86251881Speter { 87251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_DATE_LONG, kwstruct->date); 88251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_DATE_SHORT, kwstruct->date); 89251881Speter } 90251881Speter if (kwstruct->author) 91251881Speter { 92251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_AUTHOR_LONG, kwstruct->author); 93251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_AUTHOR_SHORT, kwstruct->author); 94251881Speter } 95251881Speter if (kwstruct->url) 96251881Speter { 97251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_URL_LONG, kwstruct->url); 98251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_URL_SHORT, kwstruct->url); 99251881Speter } 100251881Speter if (kwstruct->id) 101251881Speter { 102251881Speter svn_hash_sets(kwhash, SVN_KEYWORD_ID, kwstruct->id); 103251881Speter } 104251881Speter 105251881Speter return kwhash; 106251881Speter} 107251881Speter 108251881Speter 109251881Spetersvn_error_t * 110251881Spetersvn_subst_translate_stream3(svn_stream_t *src_stream, 111251881Speter svn_stream_t *dst_stream, 112251881Speter const char *eol_str, 113251881Speter svn_boolean_t repair, 114251881Speter apr_hash_t *keywords, 115251881Speter svn_boolean_t expand, 116251881Speter apr_pool_t *pool) 117251881Speter{ 118251881Speter /* The docstring requires that *some* translation be requested. */ 119251881Speter SVN_ERR_ASSERT(eol_str || keywords); 120251881Speter 121251881Speter /* We don't want the copy3 to close the provided streams. */ 122251881Speter src_stream = svn_stream_disown(src_stream, pool); 123251881Speter dst_stream = svn_stream_disown(dst_stream, pool); 124251881Speter 125251881Speter /* Wrap the destination stream with our translation stream. It is more 126251881Speter efficient than wrapping the source stream. */ 127251881Speter dst_stream = svn_subst_stream_translated(dst_stream, eol_str, repair, 128251881Speter keywords, expand, pool); 129251881Speter 130251881Speter return svn_error_trace(svn_stream_copy3(src_stream, dst_stream, 131251881Speter NULL, NULL, pool)); 132251881Speter} 133251881Speter 134251881Spetersvn_error_t * 135251881Spetersvn_subst_translate_stream2(svn_stream_t *s, /* src stream */ 136251881Speter svn_stream_t *d, /* dst stream */ 137251881Speter const char *eol_str, 138251881Speter svn_boolean_t repair, 139251881Speter const svn_subst_keywords_t *keywords, 140251881Speter svn_boolean_t expand, 141251881Speter apr_pool_t *pool) 142251881Speter{ 143251881Speter apr_hash_t *kh = kwstruct_to_kwhash(keywords, pool); 144251881Speter 145251881Speter return svn_error_trace(svn_subst_translate_stream3(s, d, eol_str, repair, 146251881Speter kh, expand, pool)); 147251881Speter} 148251881Speter 149251881Spetersvn_error_t * 150251881Spetersvn_subst_translate_stream(svn_stream_t *s, /* src stream */ 151251881Speter svn_stream_t *d, /* dst stream */ 152251881Speter const char *eol_str, 153251881Speter svn_boolean_t repair, 154251881Speter const svn_subst_keywords_t *keywords, 155251881Speter svn_boolean_t expand) 156251881Speter{ 157251881Speter apr_pool_t *pool = svn_pool_create(NULL); 158251881Speter svn_error_t *err = svn_subst_translate_stream2(s, d, eol_str, repair, 159251881Speter keywords, expand, pool); 160251881Speter svn_pool_destroy(pool); 161251881Speter return svn_error_trace(err); 162251881Speter} 163251881Speter 164251881Spetersvn_error_t * 165251881Spetersvn_subst_translate_cstring(const char *src, 166251881Speter const char **dst, 167251881Speter const char *eol_str, 168251881Speter svn_boolean_t repair, 169251881Speter const svn_subst_keywords_t *keywords, 170251881Speter svn_boolean_t expand, 171251881Speter apr_pool_t *pool) 172251881Speter{ 173251881Speter apr_hash_t *kh = kwstruct_to_kwhash(keywords, pool); 174251881Speter 175251881Speter return svn_error_trace(svn_subst_translate_cstring2(src, dst, eol_str, 176251881Speter repair, kh, expand, 177251881Speter pool)); 178251881Speter} 179251881Speter 180251881Spetersvn_error_t * 181251881Spetersvn_subst_copy_and_translate(const char *src, 182251881Speter const char *dst, 183251881Speter const char *eol_str, 184251881Speter svn_boolean_t repair, 185251881Speter const svn_subst_keywords_t *keywords, 186251881Speter svn_boolean_t expand, 187251881Speter apr_pool_t *pool) 188251881Speter{ 189251881Speter return svn_error_trace(svn_subst_copy_and_translate2(src, dst, eol_str, 190251881Speter repair, keywords, 191251881Speter expand, FALSE, pool)); 192251881Speter} 193251881Speter 194251881Spetersvn_error_t * 195251881Spetersvn_subst_copy_and_translate2(const char *src, 196251881Speter const char *dst, 197251881Speter const char *eol_str, 198251881Speter svn_boolean_t repair, 199251881Speter const svn_subst_keywords_t *keywords, 200251881Speter svn_boolean_t expand, 201251881Speter svn_boolean_t special, 202251881Speter apr_pool_t *pool) 203251881Speter{ 204251881Speter apr_hash_t *kh = kwstruct_to_kwhash(keywords, pool); 205251881Speter 206251881Speter return svn_error_trace(svn_subst_copy_and_translate3(src, dst, eol_str, 207251881Speter repair, kh, expand, 208251881Speter special, pool)); 209251881Speter} 210251881Speter 211251881Spetersvn_error_t * 212251881Spetersvn_subst_copy_and_translate3(const char *src, 213251881Speter const char *dst, 214251881Speter const char *eol_str, 215251881Speter svn_boolean_t repair, 216251881Speter apr_hash_t *keywords, 217251881Speter svn_boolean_t expand, 218251881Speter svn_boolean_t special, 219251881Speter apr_pool_t *pool) 220251881Speter{ 221251881Speter return svn_error_trace(svn_subst_copy_and_translate4(src, dst, eol_str, 222251881Speter repair, keywords, 223251881Speter expand, special, 224251881Speter NULL, NULL, 225251881Speter pool)); 226251881Speter} 227251881Speter 228251881Speter 229251881Spetersvn_error_t * 230251881Spetersvn_subst_stream_translated_to_normal_form(svn_stream_t **stream, 231251881Speter svn_stream_t *source, 232251881Speter svn_subst_eol_style_t eol_style, 233251881Speter const char *eol_str, 234251881Speter svn_boolean_t always_repair_eols, 235251881Speter apr_hash_t *keywords, 236251881Speter apr_pool_t *pool) 237251881Speter{ 238251881Speter if (eol_style == svn_subst_eol_style_native) 239251881Speter eol_str = SVN_SUBST_NATIVE_EOL_STR; 240251881Speter else if (! (eol_style == svn_subst_eol_style_fixed 241251881Speter || eol_style == svn_subst_eol_style_none)) 242251881Speter return svn_error_create(SVN_ERR_IO_UNKNOWN_EOL, NULL, NULL); 243251881Speter 244251881Speter *stream = svn_subst_stream_translated(source, eol_str, 245251881Speter eol_style == svn_subst_eol_style_fixed 246251881Speter || always_repair_eols, 247251881Speter keywords, FALSE, pool); 248251881Speter 249251881Speter return SVN_NO_ERROR; 250251881Speter} 251251881Speter 252251881Spetersvn_error_t * 253251881Spetersvn_subst_translate_string(svn_string_t **new_value, 254251881Speter const svn_string_t *value, 255251881Speter const char *encoding, 256251881Speter apr_pool_t *pool) 257251881Speter{ 258251881Speter return svn_subst_translate_string2(new_value, NULL, NULL, value, 259251881Speter encoding, FALSE, pool, pool); 260251881Speter} 261251881Speter 262251881Spetersvn_error_t * 263251881Spetersvn_subst_stream_detranslated(svn_stream_t **stream_p, 264251881Speter const char *src, 265251881Speter svn_subst_eol_style_t eol_style, 266251881Speter const char *eol_str, 267251881Speter svn_boolean_t always_repair_eols, 268251881Speter apr_hash_t *keywords, 269251881Speter svn_boolean_t special, 270251881Speter apr_pool_t *pool) 271251881Speter{ 272251881Speter svn_stream_t *src_stream; 273251881Speter 274251881Speter if (special) 275251881Speter return svn_subst_read_specialfile(stream_p, src, pool, pool); 276251881Speter 277251881Speter /* This will be closed by svn_subst_stream_translated_to_normal_form 278251881Speter when the returned stream is closed. */ 279251881Speter SVN_ERR(svn_stream_open_readonly(&src_stream, src, pool, pool)); 280251881Speter 281251881Speter return svn_error_trace(svn_subst_stream_translated_to_normal_form( 282251881Speter stream_p, src_stream, 283251881Speter eol_style, eol_str, 284251881Speter always_repair_eols, 285251881Speter keywords, pool)); 286251881Speter} 287251881Speter 288251881Spetersvn_error_t * 289251881Spetersvn_subst_translate_to_normal_form(const char *src, 290251881Speter const char *dst, 291251881Speter svn_subst_eol_style_t eol_style, 292251881Speter const char *eol_str, 293251881Speter svn_boolean_t always_repair_eols, 294251881Speter apr_hash_t *keywords, 295251881Speter svn_boolean_t special, 296251881Speter apr_pool_t *pool) 297251881Speter{ 298251881Speter 299251881Speter if (eol_style == svn_subst_eol_style_native) 300251881Speter eol_str = SVN_SUBST_NATIVE_EOL_STR; 301251881Speter else if (! (eol_style == svn_subst_eol_style_fixed 302251881Speter || eol_style == svn_subst_eol_style_none)) 303251881Speter return svn_error_create(SVN_ERR_IO_UNKNOWN_EOL, NULL, NULL); 304251881Speter 305251881Speter return svn_error_trace(svn_subst_copy_and_translate3( 306251881Speter src, dst, eol_str, 307251881Speter eol_style == svn_subst_eol_style_fixed 308251881Speter || always_repair_eols, 309251881Speter keywords, 310251881Speter FALSE /* contract keywords */, 311251881Speter special, 312251881Speter pool)); 313251881Speter} 314251881Speter 315251881Speter 316251881Speter/*** From opt.c ***/ 317251881Speter/* Same as print_command_info2(), but with deprecated struct revision. */ 318251881Speterstatic svn_error_t * 319251881Speterprint_command_info(const svn_opt_subcommand_desc_t *cmd, 320251881Speter const apr_getopt_option_t *options_table, 321251881Speter svn_boolean_t help, 322251881Speter apr_pool_t *pool, 323251881Speter FILE *stream) 324251881Speter{ 325251881Speter svn_boolean_t first_time; 326251881Speter apr_size_t i; 327251881Speter 328251881Speter /* Print the canonical command name. */ 329251881Speter SVN_ERR(svn_cmdline_fputs(cmd->name, stream, pool)); 330251881Speter 331251881Speter /* Print the list of aliases. */ 332251881Speter first_time = TRUE; 333251881Speter for (i = 0; i < SVN_OPT_MAX_ALIASES; i++) 334251881Speter { 335251881Speter if (cmd->aliases[i] == NULL) 336251881Speter break; 337251881Speter 338251881Speter if (first_time) { 339251881Speter SVN_ERR(svn_cmdline_fputs(" (", stream, pool)); 340251881Speter first_time = FALSE; 341251881Speter } 342251881Speter else 343251881Speter SVN_ERR(svn_cmdline_fputs(", ", stream, pool)); 344251881Speter 345251881Speter SVN_ERR(svn_cmdline_fputs(cmd->aliases[i], stream, pool)); 346251881Speter } 347251881Speter 348251881Speter if (! first_time) 349251881Speter SVN_ERR(svn_cmdline_fputs(")", stream, pool)); 350251881Speter 351251881Speter if (help) 352251881Speter { 353251881Speter const apr_getopt_option_t *option; 354251881Speter svn_boolean_t have_options = FALSE; 355251881Speter 356251881Speter SVN_ERR(svn_cmdline_fprintf(stream, pool, ": %s", _(cmd->help))); 357251881Speter 358251881Speter /* Loop over all valid option codes attached to the subcommand */ 359251881Speter for (i = 0; i < SVN_OPT_MAX_OPTIONS; i++) 360251881Speter { 361251881Speter if (cmd->valid_options[i]) 362251881Speter { 363251881Speter if (!have_options) 364251881Speter { 365251881Speter SVN_ERR(svn_cmdline_fputs(_("\nValid options:\n"), 366251881Speter stream, pool)); 367251881Speter have_options = TRUE; 368251881Speter } 369251881Speter 370251881Speter /* convert each option code into an option */ 371251881Speter option = 372251881Speter svn_opt_get_option_from_code2(cmd->valid_options[i], 373251881Speter options_table, NULL, pool); 374251881Speter 375251881Speter /* print the option's docstring */ 376251881Speter if (option && option->description) 377251881Speter { 378251881Speter const char *optstr; 379251881Speter svn_opt_format_option(&optstr, option, TRUE, pool); 380251881Speter SVN_ERR(svn_cmdline_fprintf(stream, pool, " %s\n", 381251881Speter optstr)); 382251881Speter } 383251881Speter } 384251881Speter } 385251881Speter 386251881Speter if (have_options) 387251881Speter SVN_ERR(svn_cmdline_fprintf(stream, pool, "\n")); 388251881Speter } 389251881Speter 390251881Speter return SVN_NO_ERROR; 391251881Speter} 392251881Speter 393362181Sdimconst svn_opt_subcommand_desc2_t * 394362181Sdimsvn_opt_get_canonical_subcommand2(const svn_opt_subcommand_desc2_t *table, 395362181Sdim const char *cmd_name) 396362181Sdim{ 397362181Sdim int i = 0; 398362181Sdim 399362181Sdim if (cmd_name == NULL) 400362181Sdim return NULL; 401362181Sdim 402362181Sdim while (table[i].name) { 403362181Sdim int j; 404362181Sdim if (strcmp(cmd_name, table[i].name) == 0) 405362181Sdim return table + i; 406362181Sdim for (j = 0; (j < SVN_OPT_MAX_ALIASES) && table[i].aliases[j]; j++) 407362181Sdim if (strcmp(cmd_name, table[i].aliases[j]) == 0) 408362181Sdim return table + i; 409362181Sdim 410362181Sdim i++; 411362181Sdim } 412362181Sdim 413362181Sdim /* If we get here, there was no matching subcommand name or alias. */ 414362181Sdim return NULL; 415362181Sdim} 416362181Sdim 417251881Speterconst svn_opt_subcommand_desc_t * 418251881Spetersvn_opt_get_canonical_subcommand(const svn_opt_subcommand_desc_t *table, 419251881Speter const char *cmd_name) 420251881Speter{ 421251881Speter int i = 0; 422251881Speter 423251881Speter if (cmd_name == NULL) 424251881Speter return NULL; 425251881Speter 426251881Speter while (table[i].name) { 427251881Speter int j; 428251881Speter if (strcmp(cmd_name, table[i].name) == 0) 429251881Speter return table + i; 430251881Speter for (j = 0; (j < SVN_OPT_MAX_ALIASES) && table[i].aliases[j]; j++) 431251881Speter if (strcmp(cmd_name, table[i].aliases[j]) == 0) 432251881Speter return table + i; 433251881Speter 434251881Speter i++; 435251881Speter } 436251881Speter 437251881Speter /* If we get here, there was no matching subcommand name or alias. */ 438251881Speter return NULL; 439251881Speter} 440251881Speter 441362181Sdimconst apr_getopt_option_t * 442362181Sdimsvn_opt_get_option_from_code2(int code, 443362181Sdim const apr_getopt_option_t *option_table, 444362181Sdim const svn_opt_subcommand_desc2_t *command, 445362181Sdim apr_pool_t *pool) 446362181Sdim{ 447362181Sdim apr_size_t i; 448362181Sdim 449362181Sdim for (i = 0; option_table[i].optch; i++) 450362181Sdim if (option_table[i].optch == code) 451362181Sdim { 452362181Sdim if (command) 453362181Sdim { 454362181Sdim int j; 455362181Sdim 456362181Sdim for (j = 0; ((j < SVN_OPT_MAX_OPTIONS) && 457362181Sdim command->desc_overrides[j].optch); j++) 458362181Sdim if (command->desc_overrides[j].optch == code) 459362181Sdim { 460362181Sdim apr_getopt_option_t *tmpopt = 461362181Sdim apr_palloc(pool, sizeof(*tmpopt)); 462362181Sdim *tmpopt = option_table[i]; 463362181Sdim tmpopt->description = command->desc_overrides[j].desc; 464362181Sdim return tmpopt; 465362181Sdim } 466362181Sdim } 467362181Sdim return &(option_table[i]); 468362181Sdim } 469362181Sdim 470362181Sdim return NULL; 471362181Sdim} 472362181Sdim 473362181Sdimconst apr_getopt_option_t * 474362181Sdimsvn_opt_get_option_from_code(int code, 475362181Sdim const apr_getopt_option_t *option_table) 476362181Sdim{ 477362181Sdim apr_size_t i; 478362181Sdim 479362181Sdim for (i = 0; option_table[i].optch; i++) 480362181Sdim if (option_table[i].optch == code) 481362181Sdim return &(option_table[i]); 482362181Sdim 483362181Sdim return NULL; 484362181Sdim} 485362181Sdim 486362181Sdim/* Like svn_opt_get_option_from_code2(), but also, if CODE appears a second 487362181Sdim * time in OPTION_TABLE with a different name, then set *LONG_ALIAS to that 488362181Sdim * second name, else set it to NULL. */ 489362181Sdimstatic const apr_getopt_option_t * 490362181Sdimget_option_from_code(const char **long_alias, 491362181Sdim int code, 492362181Sdim const apr_getopt_option_t *option_table, 493362181Sdim const svn_opt_subcommand_desc2_t *command, 494362181Sdim apr_pool_t *pool) 495362181Sdim{ 496362181Sdim const apr_getopt_option_t *i; 497362181Sdim const apr_getopt_option_t *opt 498362181Sdim = svn_opt_get_option_from_code2(code, option_table, command, pool); 499362181Sdim 500362181Sdim /* Find a long alias in the table, if there is one. */ 501362181Sdim *long_alias = NULL; 502362181Sdim for (i = option_table; i->optch; i++) 503362181Sdim { 504362181Sdim if (i->optch == code && i->name != opt->name) 505362181Sdim { 506362181Sdim *long_alias = i->name; 507362181Sdim break; 508362181Sdim } 509362181Sdim } 510362181Sdim 511362181Sdim return opt; 512362181Sdim} 513362181Sdim 514362181Sdim/* Print an option OPT nicely into a STRING allocated in POOL. 515362181Sdim * If OPT has a single-character short form, then print OPT->name (if not 516362181Sdim * NULL) as an alias, else print LONG_ALIAS (if not NULL) as an alias. 517362181Sdim * If DOC is set, include the generic documentation string of OPT, 518362181Sdim * localized to the current locale if a translation is available. 519362181Sdim */ 520362181Sdimstatic void 521362181Sdimformat_option(const char **string, 522362181Sdim const apr_getopt_option_t *opt, 523362181Sdim const char *long_alias, 524362181Sdim svn_boolean_t doc, 525362181Sdim apr_pool_t *pool) 526362181Sdim{ 527362181Sdim char *opts; 528362181Sdim 529362181Sdim if (opt == NULL) 530362181Sdim { 531362181Sdim *string = "?"; 532362181Sdim return; 533362181Sdim } 534362181Sdim 535362181Sdim /* We have a valid option which may or may not have a "short 536362181Sdim name" (a single-character alias for the long option). */ 537362181Sdim if (opt->optch <= 255) 538362181Sdim opts = apr_psprintf(pool, "-%c [--%s]", opt->optch, opt->name); 539362181Sdim else if (long_alias) 540362181Sdim opts = apr_psprintf(pool, "--%s [--%s]", opt->name, long_alias); 541362181Sdim else 542362181Sdim opts = apr_psprintf(pool, "--%s", opt->name); 543362181Sdim 544362181Sdim if (opt->has_arg) 545362181Sdim opts = apr_pstrcat(pool, opts, _(" ARG"), SVN_VA_NULL); 546362181Sdim 547362181Sdim if (doc) 548362181Sdim opts = apr_psprintf(pool, "%-24s : %s", opts, _(opt->description)); 549362181Sdim 550362181Sdim *string = opts; 551362181Sdim} 552362181Sdim 553362181Sdim/* Print the canonical command name for CMD, and all its aliases, to 554362181Sdim STREAM. If HELP is set, print CMD's help string too, in which case 555362181Sdim obtain option usage from OPTIONS_TABLE. */ 556362181Sdimstatic svn_error_t * 557362181Sdimprint_command_info2(const svn_opt_subcommand_desc2_t *cmd, 558362181Sdim const apr_getopt_option_t *options_table, 559362181Sdim const int *global_options, 560362181Sdim svn_boolean_t help, 561362181Sdim apr_pool_t *pool, 562362181Sdim FILE *stream) 563362181Sdim{ 564362181Sdim svn_boolean_t first_time; 565362181Sdim apr_size_t i; 566362181Sdim 567362181Sdim /* Print the canonical command name. */ 568362181Sdim SVN_ERR(svn_cmdline_fputs(cmd->name, stream, pool)); 569362181Sdim 570362181Sdim /* Print the list of aliases. */ 571362181Sdim first_time = TRUE; 572362181Sdim for (i = 0; i < SVN_OPT_MAX_ALIASES; i++) 573362181Sdim { 574362181Sdim if (cmd->aliases[i] == NULL) 575362181Sdim break; 576362181Sdim 577362181Sdim if (first_time) { 578362181Sdim SVN_ERR(svn_cmdline_fputs(" (", stream, pool)); 579362181Sdim first_time = FALSE; 580362181Sdim } 581362181Sdim else 582362181Sdim SVN_ERR(svn_cmdline_fputs(", ", stream, pool)); 583362181Sdim 584362181Sdim SVN_ERR(svn_cmdline_fputs(cmd->aliases[i], stream, pool)); 585362181Sdim } 586362181Sdim 587362181Sdim if (! first_time) 588362181Sdim SVN_ERR(svn_cmdline_fputs(")", stream, pool)); 589362181Sdim 590362181Sdim if (help) 591362181Sdim { 592362181Sdim const apr_getopt_option_t *option; 593362181Sdim const char *long_alias; 594362181Sdim svn_boolean_t have_options = FALSE; 595362181Sdim 596362181Sdim SVN_ERR(svn_cmdline_fprintf(stream, pool, ": %s", _(cmd->help))); 597362181Sdim 598362181Sdim /* Loop over all valid option codes attached to the subcommand */ 599362181Sdim for (i = 0; i < SVN_OPT_MAX_OPTIONS; i++) 600362181Sdim { 601362181Sdim if (cmd->valid_options[i]) 602362181Sdim { 603362181Sdim if (!have_options) 604362181Sdim { 605362181Sdim SVN_ERR(svn_cmdline_fputs(_("\nValid options:\n"), 606362181Sdim stream, pool)); 607362181Sdim have_options = TRUE; 608362181Sdim } 609362181Sdim 610362181Sdim /* convert each option code into an option */ 611362181Sdim option = get_option_from_code(&long_alias, cmd->valid_options[i], 612362181Sdim options_table, cmd, pool); 613362181Sdim 614362181Sdim /* print the option's docstring */ 615362181Sdim if (option && option->description) 616362181Sdim { 617362181Sdim const char *optstr; 618362181Sdim format_option(&optstr, option, long_alias, TRUE, pool); 619362181Sdim SVN_ERR(svn_cmdline_fprintf(stream, pool, " %s\n", 620362181Sdim optstr)); 621362181Sdim } 622362181Sdim } 623362181Sdim } 624362181Sdim /* And global options too */ 625362181Sdim if (global_options && *global_options) 626362181Sdim { 627362181Sdim SVN_ERR(svn_cmdline_fputs(_("\nGlobal options:\n"), 628362181Sdim stream, pool)); 629362181Sdim have_options = TRUE; 630362181Sdim 631362181Sdim for (i = 0; global_options[i]; i++) 632362181Sdim { 633362181Sdim 634362181Sdim /* convert each option code into an option */ 635362181Sdim option = get_option_from_code(&long_alias, global_options[i], 636362181Sdim options_table, cmd, pool); 637362181Sdim 638362181Sdim /* print the option's docstring */ 639362181Sdim if (option && option->description) 640362181Sdim { 641362181Sdim const char *optstr; 642362181Sdim format_option(&optstr, option, long_alias, TRUE, pool); 643362181Sdim SVN_ERR(svn_cmdline_fprintf(stream, pool, " %s\n", 644362181Sdim optstr)); 645362181Sdim } 646362181Sdim } 647362181Sdim } 648362181Sdim 649362181Sdim if (have_options) 650362181Sdim SVN_ERR(svn_cmdline_fprintf(stream, pool, "\n")); 651362181Sdim } 652362181Sdim 653362181Sdim return SVN_NO_ERROR; 654362181Sdim} 655362181Sdim 656362181Sdim/* The body for svn_opt_print_generic_help2() function with standard error 657362181Sdim * handling semantic. Handling of errors implemented at caller side. */ 658362181Sdimstatic svn_error_t * 659362181Sdimprint_generic_help_body(const char *header, 660362181Sdim const svn_opt_subcommand_desc2_t *cmd_table, 661362181Sdim const apr_getopt_option_t *opt_table, 662362181Sdim const char *footer, 663362181Sdim apr_pool_t *pool, FILE *stream) 664362181Sdim{ 665362181Sdim int i = 0; 666362181Sdim 667362181Sdim if (header) 668362181Sdim SVN_ERR(svn_cmdline_fputs(header, stream, pool)); 669362181Sdim 670362181Sdim while (cmd_table[i].name) 671362181Sdim { 672362181Sdim SVN_ERR(svn_cmdline_fputs(" ", stream, pool)); 673362181Sdim SVN_ERR(print_command_info2(cmd_table + i, opt_table, 674362181Sdim NULL, FALSE, 675362181Sdim pool, stream)); 676362181Sdim SVN_ERR(svn_cmdline_fputs("\n", stream, pool)); 677362181Sdim i++; 678362181Sdim } 679362181Sdim 680362181Sdim SVN_ERR(svn_cmdline_fputs("\n", stream, pool)); 681362181Sdim 682362181Sdim if (footer) 683362181Sdim SVN_ERR(svn_cmdline_fputs(footer, stream, pool)); 684362181Sdim 685362181Sdim return SVN_NO_ERROR; 686362181Sdim} 687362181Sdim 688251881Spetervoid 689362181Sdimsvn_opt_print_generic_help2(const char *header, 690362181Sdim const svn_opt_subcommand_desc2_t *cmd_table, 691362181Sdim const apr_getopt_option_t *opt_table, 692362181Sdim const char *footer, 693362181Sdim apr_pool_t *pool, FILE *stream) 694362181Sdim{ 695362181Sdim svn_error_t *err; 696362181Sdim 697362181Sdim err = print_generic_help_body(header, cmd_table, opt_table, footer, pool, 698362181Sdim stream); 699362181Sdim 700362181Sdim /* Issue #3014: 701362181Sdim * Don't print anything on broken pipes. The pipe was likely 702362181Sdim * closed by the process at the other end. We expect that 703362181Sdim * process to perform error reporting as necessary. 704362181Sdim * 705362181Sdim * ### This assumes that there is only one error in a chain for 706362181Sdim * ### SVN_ERR_IO_PIPE_WRITE_ERROR. See svn_cmdline_fputs(). */ 707362181Sdim if (err && err->apr_err != SVN_ERR_IO_PIPE_WRITE_ERROR) 708362181Sdim svn_handle_error2(err, stderr, FALSE, "svn: "); 709362181Sdim svn_error_clear(err); 710362181Sdim} 711362181Sdim 712362181Sdimsvn_boolean_t 713362181Sdimsvn_opt_subcommand_takes_option3(const svn_opt_subcommand_desc2_t *command, 714362181Sdim int option_code, 715362181Sdim const int *global_options) 716362181Sdim{ 717362181Sdim apr_size_t i; 718362181Sdim 719362181Sdim for (i = 0; i < SVN_OPT_MAX_OPTIONS; i++) 720362181Sdim if (command->valid_options[i] == option_code) 721362181Sdim return TRUE; 722362181Sdim 723362181Sdim if (global_options) 724362181Sdim for (i = 0; global_options[i]; i++) 725362181Sdim if (global_options[i] == option_code) 726362181Sdim return TRUE; 727362181Sdim 728362181Sdim return FALSE; 729362181Sdim} 730362181Sdim 731362181Sdimsvn_boolean_t 732362181Sdimsvn_opt_subcommand_takes_option2(const svn_opt_subcommand_desc2_t *command, 733362181Sdim int option_code) 734362181Sdim{ 735362181Sdim return svn_opt_subcommand_takes_option3(command, 736362181Sdim option_code, 737362181Sdim NULL); 738362181Sdim} 739362181Sdim 740362181Sdimsvn_boolean_t 741362181Sdimsvn_opt_subcommand_takes_option(const svn_opt_subcommand_desc_t *command, 742362181Sdim int option_code) 743362181Sdim{ 744362181Sdim apr_size_t i; 745362181Sdim 746362181Sdim for (i = 0; i < SVN_OPT_MAX_OPTIONS; i++) 747362181Sdim if (command->valid_options[i] == option_code) 748362181Sdim return TRUE; 749362181Sdim 750362181Sdim return FALSE; 751362181Sdim} 752362181Sdim 753362181Sdimvoid 754362181Sdimsvn_opt_subcommand_help3(const char *subcommand, 755362181Sdim const svn_opt_subcommand_desc2_t *table, 756362181Sdim const apr_getopt_option_t *options_table, 757362181Sdim const int *global_options, 758362181Sdim apr_pool_t *pool) 759362181Sdim{ 760362181Sdim const svn_opt_subcommand_desc2_t *cmd = 761362181Sdim svn_opt_get_canonical_subcommand2(table, subcommand); 762362181Sdim svn_error_t *err; 763362181Sdim 764362181Sdim if (cmd) 765362181Sdim err = print_command_info2(cmd, options_table, global_options, 766362181Sdim TRUE, pool, stdout); 767362181Sdim else 768362181Sdim err = svn_cmdline_fprintf(stderr, pool, 769362181Sdim _("\"%s\": unknown command.\n\n"), subcommand); 770362181Sdim 771362181Sdim if (err) { 772362181Sdim /* Issue #3014: Don't print anything on broken pipes. */ 773362181Sdim if (err->apr_err != SVN_ERR_IO_PIPE_WRITE_ERROR) 774362181Sdim svn_handle_error2(err, stderr, FALSE, "svn: "); 775362181Sdim svn_error_clear(err); 776362181Sdim } 777362181Sdim} 778362181Sdim 779362181Sdimvoid 780251881Spetersvn_opt_subcommand_help2(const char *subcommand, 781251881Speter const svn_opt_subcommand_desc2_t *table, 782251881Speter const apr_getopt_option_t *options_table, 783251881Speter apr_pool_t *pool) 784251881Speter{ 785251881Speter svn_opt_subcommand_help3(subcommand, table, options_table, 786251881Speter NULL, pool); 787251881Speter} 788251881Speter 789251881Spetervoid 790251881Spetersvn_opt_subcommand_help(const char *subcommand, 791251881Speter const svn_opt_subcommand_desc_t *table, 792251881Speter const apr_getopt_option_t *options_table, 793251881Speter apr_pool_t *pool) 794251881Speter{ 795251881Speter const svn_opt_subcommand_desc_t *cmd = 796251881Speter svn_opt_get_canonical_subcommand(table, subcommand); 797251881Speter svn_error_t *err; 798251881Speter 799251881Speter if (cmd) 800251881Speter err = print_command_info(cmd, options_table, TRUE, pool, stdout); 801251881Speter else 802251881Speter err = svn_cmdline_fprintf(stderr, pool, 803251881Speter _("\"%s\": unknown command.\n\n"), subcommand); 804251881Speter 805251881Speter if (err) { 806251881Speter svn_handle_error2(err, stderr, FALSE, "svn: "); 807251881Speter svn_error_clear(err); 808251881Speter } 809251881Speter} 810251881Speter 811251881Spetersvn_error_t * 812251881Spetersvn_opt_args_to_target_array3(apr_array_header_t **targets_p, 813251881Speter apr_getopt_t *os, 814251881Speter const apr_array_header_t *known_targets, 815251881Speter apr_pool_t *pool) 816251881Speter{ 817251881Speter return svn_error_trace(svn_opt__args_to_target_array(targets_p, os, 818251881Speter known_targets, pool)); 819251881Speter} 820251881Speter 821251881Spetersvn_error_t * 822251881Spetersvn_opt_args_to_target_array2(apr_array_header_t **targets_p, 823251881Speter apr_getopt_t *os, 824251881Speter const apr_array_header_t *known_targets, 825251881Speter apr_pool_t *pool) 826251881Speter{ 827251881Speter svn_error_t *err = svn_opt_args_to_target_array3(targets_p, os, 828251881Speter known_targets, pool); 829251881Speter 830251881Speter if (err && err->apr_err == SVN_ERR_RESERVED_FILENAME_SPECIFIED) 831251881Speter { 832251881Speter svn_error_clear(err); 833251881Speter return SVN_NO_ERROR; 834251881Speter } 835251881Speter 836251881Speter return err; 837251881Speter} 838251881Speter 839251881Spetersvn_error_t * 840251881Spetersvn_opt_args_to_target_array(apr_array_header_t **targets_p, 841251881Speter apr_getopt_t *os, 842251881Speter const apr_array_header_t *known_targets, 843251881Speter svn_opt_revision_t *start_revision, 844251881Speter svn_opt_revision_t *end_revision, 845251881Speter svn_boolean_t extract_revisions, 846251881Speter apr_pool_t *pool) 847251881Speter{ 848251881Speter apr_array_header_t *output_targets; 849251881Speter 850251881Speter SVN_ERR(svn_opt_args_to_target_array2(&output_targets, os, 851251881Speter known_targets, pool)); 852251881Speter 853251881Speter if (extract_revisions) 854251881Speter { 855251881Speter svn_opt_revision_t temprev; 856251881Speter const char *path; 857251881Speter 858251881Speter if (output_targets->nelts > 0) 859251881Speter { 860251881Speter path = APR_ARRAY_IDX(output_targets, 0, const char *); 861251881Speter SVN_ERR(svn_opt_parse_path(&temprev, &path, path, pool)); 862251881Speter if (temprev.kind != svn_opt_revision_unspecified) 863251881Speter { 864251881Speter APR_ARRAY_IDX(output_targets, 0, const char *) = path; 865251881Speter start_revision->kind = temprev.kind; 866251881Speter start_revision->value = temprev.value; 867251881Speter } 868251881Speter } 869251881Speter if (output_targets->nelts > 1) 870251881Speter { 871251881Speter path = APR_ARRAY_IDX(output_targets, 1, const char *); 872251881Speter SVN_ERR(svn_opt_parse_path(&temprev, &path, path, pool)); 873251881Speter if (temprev.kind != svn_opt_revision_unspecified) 874251881Speter { 875251881Speter APR_ARRAY_IDX(output_targets, 1, const char *) = path; 876251881Speter end_revision->kind = temprev.kind; 877251881Speter end_revision->value = temprev.value; 878251881Speter } 879251881Speter } 880251881Speter } 881251881Speter 882251881Speter *targets_p = output_targets; 883251881Speter return SVN_NO_ERROR; 884251881Speter} 885251881Speter 886251881Spetersvn_error_t * 887362181Sdimsvn_opt_print_help4(apr_getopt_t *os, 888362181Sdim const char *pgm_name, 889362181Sdim svn_boolean_t print_version, 890362181Sdim svn_boolean_t quiet, 891362181Sdim svn_boolean_t verbose, 892362181Sdim const char *version_footer, 893362181Sdim const char *header, 894362181Sdim const svn_opt_subcommand_desc2_t *cmd_table, 895362181Sdim const apr_getopt_option_t *option_table, 896362181Sdim const int *global_options, 897362181Sdim const char *footer, 898362181Sdim apr_pool_t *pool) 899362181Sdim{ 900362181Sdim apr_array_header_t *targets = NULL; 901362181Sdim 902362181Sdim if (os) 903362181Sdim SVN_ERR(svn_opt_parse_all_args(&targets, os, pool)); 904362181Sdim 905362181Sdim if (os && targets->nelts) /* help on subcommand(s) requested */ 906362181Sdim { 907362181Sdim int i; 908362181Sdim 909362181Sdim for (i = 0; i < targets->nelts; i++) 910362181Sdim { 911362181Sdim svn_opt_subcommand_help3(APR_ARRAY_IDX(targets, i, const char *), 912362181Sdim cmd_table, option_table, 913362181Sdim global_options, pool); 914362181Sdim } 915362181Sdim } 916362181Sdim else if (print_version) /* just --version */ 917362181Sdim { 918362181Sdim SVN_ERR(svn_opt__print_version_info(pgm_name, version_footer, 919362181Sdim svn_version_extended(verbose, pool), 920362181Sdim quiet, verbose, pool)); 921362181Sdim } 922362181Sdim else if (os && !targets->nelts) /* `-h', `--help', or `help' */ 923362181Sdim svn_opt_print_generic_help2(header, 924362181Sdim cmd_table, 925362181Sdim option_table, 926362181Sdim footer, 927362181Sdim pool, 928362181Sdim stdout); 929362181Sdim else /* unknown option or cmd */ 930362181Sdim SVN_ERR(svn_cmdline_fprintf(stderr, pool, 931362181Sdim _("Type '%s help' for usage.\n"), pgm_name)); 932362181Sdim 933362181Sdim return SVN_NO_ERROR; 934362181Sdim} 935362181Sdim 936362181Sdimsvn_error_t * 937251881Spetersvn_opt_print_help3(apr_getopt_t *os, 938251881Speter const char *pgm_name, 939251881Speter svn_boolean_t print_version, 940251881Speter svn_boolean_t quiet, 941251881Speter const char *version_footer, 942251881Speter const char *header, 943251881Speter const svn_opt_subcommand_desc2_t *cmd_table, 944251881Speter const apr_getopt_option_t *option_table, 945251881Speter const int *global_options, 946251881Speter const char *footer, 947251881Speter apr_pool_t *pool) 948251881Speter{ 949251881Speter return svn_error_trace(svn_opt_print_help4(os, 950251881Speter pgm_name, 951251881Speter print_version, 952251881Speter quiet, 953251881Speter FALSE, 954251881Speter version_footer, 955251881Speter header, 956251881Speter cmd_table, 957251881Speter option_table, 958251881Speter global_options, 959251881Speter footer, 960251881Speter pool)); 961251881Speter} 962251881Speter 963251881Spetersvn_error_t * 964251881Spetersvn_opt_print_help2(apr_getopt_t *os, 965251881Speter const char *pgm_name, 966251881Speter svn_boolean_t print_version, 967251881Speter svn_boolean_t quiet, 968251881Speter const char *version_footer, 969251881Speter const char *header, 970251881Speter const svn_opt_subcommand_desc2_t *cmd_table, 971251881Speter const apr_getopt_option_t *option_table, 972251881Speter const char *footer, 973251881Speter apr_pool_t *pool) 974251881Speter{ 975251881Speter return svn_error_trace(svn_opt_print_help4(os, 976251881Speter pgm_name, 977251881Speter print_version, 978251881Speter quiet, 979251881Speter FALSE, 980251881Speter version_footer, 981251881Speter header, 982251881Speter cmd_table, 983251881Speter option_table, 984251881Speter NULL, 985251881Speter footer, 986251881Speter pool)); 987251881Speter} 988251881Speter 989251881Spetersvn_error_t * 990251881Spetersvn_opt_print_help(apr_getopt_t *os, 991251881Speter const char *pgm_name, 992251881Speter svn_boolean_t print_version, 993251881Speter svn_boolean_t quiet, 994251881Speter const char *version_footer, 995251881Speter const char *header, 996251881Speter const svn_opt_subcommand_desc_t *cmd_table, 997251881Speter const apr_getopt_option_t *option_table, 998251881Speter const char *footer, 999251881Speter apr_pool_t *pool) 1000251881Speter{ 1001251881Speter apr_array_header_t *targets = NULL; 1002251881Speter 1003251881Speter if (os) 1004251881Speter SVN_ERR(svn_opt_parse_all_args(&targets, os, pool)); 1005251881Speter 1006251881Speter if (os && targets->nelts) /* help on subcommand(s) requested */ 1007251881Speter { 1008251881Speter int i; 1009251881Speter 1010251881Speter for (i = 0; i < targets->nelts; i++) 1011251881Speter { 1012251881Speter svn_opt_subcommand_help(APR_ARRAY_IDX(targets, i, const char *), 1013251881Speter cmd_table, option_table, pool); 1014251881Speter } 1015251881Speter } 1016251881Speter else if (print_version) /* just --version */ 1017251881Speter { 1018251881Speter SVN_ERR(svn_opt__print_version_info(pgm_name, version_footer, 1019251881Speter svn_version_extended(FALSE, pool), 1020251881Speter quiet, FALSE, pool)); 1021251881Speter } 1022251881Speter else if (os && !targets->nelts) /* `-h', `--help', or `help' */ 1023251881Speter svn_opt_print_generic_help(header, 1024251881Speter cmd_table, 1025251881Speter option_table, 1026251881Speter footer, 1027251881Speter pool, 1028251881Speter stdout); 1029251881Speter else /* unknown option or cmd */ 1030251881Speter SVN_ERR(svn_cmdline_fprintf(stderr, pool, 1031251881Speter _("Type '%s help' for usage.\n"), pgm_name)); 1032251881Speter 1033251881Speter return SVN_NO_ERROR; 1034251881Speter} 1035251881Speter 1036251881Spetervoid 1037251881Spetersvn_opt_print_generic_help(const char *header, 1038251881Speter const svn_opt_subcommand_desc_t *cmd_table, 1039251881Speter const apr_getopt_option_t *opt_table, 1040251881Speter const char *footer, 1041251881Speter apr_pool_t *pool, FILE *stream) 1042251881Speter{ 1043251881Speter int i = 0; 1044251881Speter svn_error_t *err; 1045251881Speter 1046251881Speter if (header) 1047251881Speter if ((err = svn_cmdline_fputs(header, stream, pool))) 1048251881Speter goto print_error; 1049251881Speter 1050251881Speter while (cmd_table[i].name) 1051251881Speter { 1052251881Speter if ((err = svn_cmdline_fputs(" ", stream, pool)) 1053251881Speter || (err = print_command_info(cmd_table + i, opt_table, FALSE, 1054251881Speter pool, stream)) 1055251881Speter || (err = svn_cmdline_fputs("\n", stream, pool))) 1056251881Speter goto print_error; 1057251881Speter i++; 1058251881Speter } 1059251881Speter 1060251881Speter if ((err = svn_cmdline_fputs("\n", stream, pool))) 1061251881Speter goto print_error; 1062251881Speter 1063251881Speter if (footer) 1064251881Speter if ((err = svn_cmdline_fputs(footer, stream, pool))) 1065251881Speter goto print_error; 1066251881Speter 1067251881Speter return; 1068251881Speter 1069251881Speter print_error: 1070251881Speter svn_handle_error2(err, stderr, FALSE, "svn: "); 1071251881Speter svn_error_clear(err); 1072251881Speter} 1073251881Speter 1074251881Speter/*** From io.c ***/ 1075251881Spetersvn_error_t * 1076251881Spetersvn_io_open_unique_file2(apr_file_t **file, 1077251881Speter const char **temp_path, 1078251881Speter const char *path, 1079251881Speter const char *suffix, 1080251881Speter svn_io_file_del_t delete_when, 1081251881Speter apr_pool_t *pool) 1082251881Speter{ 1083251881Speter const char *dirpath; 1084251881Speter const char *filename; 1085251881Speter 1086251881Speter svn_path_split(path, &dirpath, &filename, pool); 1087251881Speter return svn_error_trace(svn_io_open_uniquely_named(file, temp_path, 1088251881Speter dirpath, filename, suffix, 1089251881Speter delete_when, 1090251881Speter pool, pool)); 1091251881Speter} 1092251881Speter 1093251881Spetersvn_error_t * 1094251881Spetersvn_io_open_unique_file(apr_file_t **file, 1095251881Speter const char **temp_path, 1096251881Speter const char *path, 1097251881Speter const char *suffix, 1098251881Speter svn_boolean_t delete_on_close, 1099251881Speter apr_pool_t *pool) 1100251881Speter{ 1101251881Speter return svn_error_trace(svn_io_open_unique_file2(file, temp_path, 1102251881Speter path, suffix, 1103251881Speter delete_on_close 1104251881Speter ? svn_io_file_del_on_close 1105251881Speter : svn_io_file_del_none, 1106251881Speter pool)); 1107251881Speter} 1108251881Speter 1109251881Spetersvn_error_t * 1110251881Spetersvn_io_run_diff(const char *dir, 1111251881Speter const char *const *user_args, 1112251881Speter int num_user_args, 1113251881Speter const char *label1, 1114251881Speter const char *label2, 1115251881Speter const char *from, 1116251881Speter const char *to, 1117251881Speter int *pexitcode, 1118251881Speter apr_file_t *outfile, 1119251881Speter apr_file_t *errfile, 1120251881Speter const char *diff_cmd, 1121251881Speter apr_pool_t *pool) 1122251881Speter{ 1123251881Speter SVN_ERR(svn_path_cstring_to_utf8(&diff_cmd, diff_cmd, pool)); 1124251881Speter 1125251881Speter return svn_error_trace(svn_io_run_diff2(dir, user_args, num_user_args, 1126251881Speter label1, label2, 1127251881Speter from, to, pexitcode, 1128251881Speter outfile, errfile, diff_cmd, 1129251881Speter pool)); 1130251881Speter} 1131251881Speter 1132251881Spetersvn_error_t * 1133251881Spetersvn_io_run_diff3_2(int *exitcode, 1134251881Speter const char *dir, 1135251881Speter const char *mine, 1136251881Speter const char *older, 1137251881Speter const char *yours, 1138251881Speter const char *mine_label, 1139251881Speter const char *older_label, 1140251881Speter const char *yours_label, 1141251881Speter apr_file_t *merged, 1142251881Speter const char *diff3_cmd, 1143251881Speter const apr_array_header_t *user_args, 1144251881Speter apr_pool_t *pool) 1145251881Speter{ 1146251881Speter SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool)); 1147251881Speter 1148251881Speter return svn_error_trace(svn_io_run_diff3_3(exitcode, dir, 1149251881Speter mine, older, yours, 1150251881Speter mine_label, older_label, 1151251881Speter yours_label, merged, 1152251881Speter diff3_cmd, user_args, pool)); 1153251881Speter} 1154251881Speter 1155251881Spetersvn_error_t * 1156251881Spetersvn_io_run_diff3(const char *dir, 1157251881Speter const char *mine, 1158251881Speter const char *older, 1159251881Speter const char *yours, 1160251881Speter const char *mine_label, 1161251881Speter const char *older_label, 1162251881Speter const char *yours_label, 1163251881Speter apr_file_t *merged, 1164251881Speter int *exitcode, 1165251881Speter const char *diff3_cmd, 1166251881Speter apr_pool_t *pool) 1167251881Speter{ 1168251881Speter return svn_error_trace(svn_io_run_diff3_2(exitcode, dir, mine, older, yours, 1169251881Speter mine_label, older_label, 1170251881Speter yours_label, 1171251881Speter merged, diff3_cmd, NULL, pool)); 1172251881Speter} 1173251881Speter 1174251881Spetersvn_error_t * 1175251881Spetersvn_io_remove_file(const char *path, 1176251881Speter apr_pool_t *scratch_pool) 1177251881Speter{ 1178251881Speter return svn_error_trace(svn_io_remove_file2(path, FALSE, scratch_pool)); 1179251881Speter} 1180251881Speter 1181251881Spetersvn_error_t *svn_io_file_lock(const char *lock_file, 1182251881Speter svn_boolean_t exclusive, 1183251881Speter apr_pool_t *pool) 1184251881Speter{ 1185251881Speter return svn_io_file_lock2(lock_file, exclusive, FALSE, pool); 1186251881Speter} 1187251881Speter 1188251881Spetersvn_error_t * 1189251881Spetersvn_io_get_dirents2(apr_hash_t **dirents, 1190251881Speter const char *path, 1191251881Speter apr_pool_t *pool) 1192251881Speter{ 1193251881Speter /* Note that the first part of svn_io_dirent2_t is identical 1194251881Speter to svn_io_dirent_t to allow this construct */ 1195251881Speter return svn_error_trace( 1196251881Speter svn_io_get_dirents3(dirents, path, FALSE, pool, pool)); 1197251881Speter} 1198251881Speter 1199251881Spetersvn_error_t * 1200251881Spetersvn_io_get_dirents(apr_hash_t **dirents, 1201251881Speter const char *path, 1202251881Speter apr_pool_t *pool) 1203251881Speter{ 1204251881Speter /* Note that in C, padding is not allowed at the beginning of structs, 1205251881Speter so this is actually portable, since the kind field of svn_io_dirent_t 1206251881Speter is first in that struct. */ 1207251881Speter return svn_io_get_dirents2(dirents, path, pool); 1208251881Speter} 1209251881Speter 1210251881Spetersvn_error_t * 1211251881Spetersvn_io_start_cmd2(apr_proc_t *cmd_proc, 1212251881Speter const char *path, 1213251881Speter const char *cmd, 1214251881Speter const char *const *args, 1215251881Speter svn_boolean_t inherit, 1216251881Speter svn_boolean_t infile_pipe, 1217251881Speter apr_file_t *infile, 1218251881Speter svn_boolean_t outfile_pipe, 1219251881Speter apr_file_t *outfile, 1220251881Speter svn_boolean_t errfile_pipe, 1221251881Speter apr_file_t *errfile, 1222251881Speter apr_pool_t *pool) 1223251881Speter{ 1224251881Speter return svn_io_start_cmd3(cmd_proc, path, cmd, args, NULL, inherit, 1225251881Speter infile_pipe, infile, outfile_pipe, outfile, 1226251881Speter errfile_pipe, errfile, pool); 1227251881Speter} 1228251881Speter 1229251881Spetersvn_error_t * 1230251881Spetersvn_io_start_cmd(apr_proc_t *cmd_proc, 1231251881Speter const char *path, 1232251881Speter const char *cmd, 1233251881Speter const char *const *args, 1234251881Speter svn_boolean_t inherit, 1235251881Speter apr_file_t *infile, 1236251881Speter apr_file_t *outfile, 1237251881Speter apr_file_t *errfile, 1238251881Speter apr_pool_t *pool) 1239251881Speter{ 1240251881Speter return svn_io_start_cmd2(cmd_proc, path, cmd, args, inherit, FALSE, 1241251881Speter infile, FALSE, outfile, FALSE, errfile, pool); 1242251881Speter} 1243251881Speter 1244251881Spetersvn_error_t * 1245251881Spetersvn_io_file_read_full(apr_file_t *file, void *buf, 1246251881Speter apr_size_t nbytes, apr_size_t *bytes_read, 1247251881Speter apr_pool_t *pool) 1248251881Speter{ 1249251881Speter return svn_io_file_read_full2(file, buf, nbytes, bytes_read, NULL, pool); 1250251881Speter} 1251251881Speter 1252251881Speterstruct walk_func_filter_baton_t 1253251881Speter{ 1254251881Speter svn_io_walk_func_t walk_func; 1255251881Speter void *walk_baton; 1256251881Speter}; 1257251881Speter 1258251881Speter/* Implements svn_io_walk_func_t, but only allows APR_DIR and APR_REG 1259251881Speter finfo types through to the wrapped function/baton. */ 1260251881Speterstatic svn_error_t * 1261251881Speterwalk_func_filter_func(void *baton, 1262251881Speter const char *path, 1263251881Speter const apr_finfo_t *finfo, 1264251881Speter apr_pool_t *pool) 1265251881Speter{ 1266251881Speter struct walk_func_filter_baton_t *b = baton; 1267251881Speter 1268251881Speter if (finfo->filetype == APR_DIR || finfo->filetype == APR_REG) 1269251881Speter SVN_ERR(b->walk_func(b->walk_baton, path, finfo, pool)); 1270251881Speter 1271251881Speter return SVN_NO_ERROR; 1272251881Speter} 1273251881Speter 1274251881Spetersvn_error_t * 1275251881Spetersvn_io_dir_walk(const char *dirname, 1276251881Speter apr_int32_t wanted, 1277251881Speter svn_io_walk_func_t walk_func, 1278251881Speter void *walk_baton, 1279251881Speter apr_pool_t *pool) 1280251881Speter{ 1281251881Speter struct walk_func_filter_baton_t baton; 1282251881Speter baton.walk_func = walk_func; 1283251881Speter baton.walk_baton = walk_baton; 1284251881Speter return svn_error_trace(svn_io_dir_walk2(dirname, wanted, 1285251881Speter walk_func_filter_func, 1286251881Speter &baton, pool)); 1287251881Speter} 1288251881Speter 1289251881Spetersvn_error_t * 1290251881Spetersvn_io_stat_dirent(const svn_io_dirent2_t **dirent_p, 1291251881Speter const char *path, 1292251881Speter svn_boolean_t ignore_enoent, 1293251881Speter apr_pool_t *result_pool, 1294251881Speter apr_pool_t *scratch_pool) 1295251881Speter{ 1296251881Speter return svn_error_trace( 1297251881Speter svn_io_stat_dirent2(dirent_p, 1298251881Speter path, 1299251881Speter FALSE, 1300251881Speter ignore_enoent, 1301251881Speter result_pool, 1302251881Speter scratch_pool)); 1303251881Speter} 1304251881Speter 1305362181Sdimsvn_error_t * 1306362181Sdimsvn_io_file_rename(const char *from_path, const char *to_path, 1307362181Sdim apr_pool_t *pool) 1308362181Sdim{ 1309362181Sdim return svn_error_trace(svn_io_file_rename2(from_path, to_path, 1310362181Sdim FALSE, pool)); 1311362181Sdim} 1312362181Sdim 1313362181Sdimsvn_error_t * 1314362181Sdimsvn_io_write_atomic(const char *final_path, 1315362181Sdim const void *buf, 1316362181Sdim apr_size_t nbytes, 1317362181Sdim const char *copy_perms_path, 1318362181Sdim apr_pool_t *scratch_pool) 1319362181Sdim{ 1320362181Sdim return svn_error_trace(svn_io_write_atomic2(final_path, buf, nbytes, 1321362181Sdim copy_perms_path, TRUE, 1322362181Sdim scratch_pool)); 1323362181Sdim} 1324362181Sdim 1325251881Speter/*** From constructors.c ***/ 1326251881Spetersvn_log_changed_path_t * 1327251881Spetersvn_log_changed_path_dup(const svn_log_changed_path_t *changed_path, 1328251881Speter apr_pool_t *pool) 1329251881Speter{ 1330251881Speter svn_log_changed_path_t *new_changed_path 1331251881Speter = apr_palloc(pool, sizeof(*new_changed_path)); 1332251881Speter 1333251881Speter *new_changed_path = *changed_path; 1334251881Speter 1335251881Speter if (new_changed_path->copyfrom_path) 1336251881Speter new_changed_path->copyfrom_path = 1337251881Speter apr_pstrdup(pool, new_changed_path->copyfrom_path); 1338251881Speter 1339251881Speter return new_changed_path; 1340251881Speter} 1341251881Speter 1342251881Speter/*** From cmdline.c ***/ 1343251881Spetersvn_error_t * 1344251881Spetersvn_cmdline_prompt_user(const char **result, 1345251881Speter const char *prompt_str, 1346251881Speter apr_pool_t *pool) 1347251881Speter{ 1348251881Speter return svn_error_trace(svn_cmdline_prompt_user2(result, prompt_str, NULL, 1349251881Speter pool)); 1350251881Speter} 1351251881Speter 1352251881Spetersvn_error_t * 1353251881Spetersvn_cmdline_setup_auth_baton(svn_auth_baton_t **ab, 1354251881Speter svn_boolean_t non_interactive, 1355251881Speter const char *auth_username, 1356251881Speter const char *auth_password, 1357251881Speter const char *config_dir, 1358251881Speter svn_boolean_t no_auth_cache, 1359251881Speter svn_config_t *cfg, 1360251881Speter svn_cancel_func_t cancel_func, 1361251881Speter void *cancel_baton, 1362251881Speter apr_pool_t *pool) 1363251881Speter{ 1364251881Speter return svn_error_trace(svn_cmdline_create_auth_baton( 1365251881Speter ab, non_interactive, 1366251881Speter auth_username, auth_password, 1367251881Speter config_dir, no_auth_cache, FALSE, 1368251881Speter cfg, cancel_func, cancel_baton, pool)); 1369251881Speter} 1370251881Speter 1371251881Speter/*** From dso.c ***/ 1372251881Spetervoid 1373251881Spetersvn_dso_initialize(void) 1374251881Speter{ 1375251881Speter svn_error_t *err = svn_dso_initialize2(); 1376251881Speter if (err) 1377251881Speter { 1378251881Speter svn_error_clear(err); 1379251881Speter abort(); 1380251881Speter } 1381251881Speter} 1382251881Speter 1383251881Speter/*** From simple_providers.c ***/ 1384251881Spetervoid 1385251881Spetersvn_auth_get_simple_provider(svn_auth_provider_object_t **provider, 1386251881Speter apr_pool_t *pool) 1387251881Speter{ 1388251881Speter svn_auth_get_simple_provider2(provider, NULL, NULL, pool); 1389251881Speter} 1390251881Speter 1391251881Speter/*** From ssl_client_cert_pw_providers.c ***/ 1392251881Spetervoid 1393251881Spetersvn_auth_get_ssl_client_cert_pw_file_provider 1394251881Speter (svn_auth_provider_object_t **provider, 1395251881Speter apr_pool_t *pool) 1396251881Speter{ 1397251881Speter svn_auth_get_ssl_client_cert_pw_file_provider2(provider, NULL, NULL, pool); 1398251881Speter} 1399251881Speter 1400251881Speter/*** From path.c ***/ 1401251881Speter 1402251881Speter#define SVN_EMPTY_PATH "" 1403251881Speter 1404251881Speterconst char * 1405251881Spetersvn_path_url_add_component(const char *url, 1406251881Speter const char *component, 1407251881Speter apr_pool_t *pool) 1408251881Speter{ 1409251881Speter /* URL can have trailing '/' */ 1410251881Speter url = svn_path_canonicalize(url, pool); 1411251881Speter 1412251881Speter return svn_path_url_add_component2(url, component, pool); 1413251881Speter} 1414251881Speter 1415251881Spetervoid 1416251881Spetersvn_path_split(const char *path, 1417251881Speter const char **dirpath, 1418251881Speter const char **base_name, 1419251881Speter apr_pool_t *pool) 1420251881Speter{ 1421251881Speter assert(dirpath != base_name); 1422251881Speter 1423251881Speter if (dirpath) 1424251881Speter *dirpath = svn_path_dirname(path, pool); 1425251881Speter 1426251881Speter if (base_name) 1427251881Speter *base_name = svn_path_basename(path, pool); 1428251881Speter} 1429251881Speter 1430251881Speter 1431251881Spetersvn_error_t * 1432251881Spetersvn_path_split_if_file(const char *path, 1433251881Speter const char **pdirectory, 1434251881Speter const char **pfile, 1435251881Speter apr_pool_t *pool) 1436251881Speter{ 1437251881Speter apr_finfo_t finfo; 1438251881Speter svn_error_t *err; 1439251881Speter 1440251881Speter SVN_ERR_ASSERT(svn_path_is_canonical(path, pool)); 1441251881Speter 1442251881Speter err = svn_io_stat(&finfo, path, APR_FINFO_TYPE, pool); 1443251881Speter if (err && ! APR_STATUS_IS_ENOENT(err->apr_err)) 1444251881Speter return err; 1445251881Speter 1446251881Speter if (err || finfo.filetype == APR_REG) 1447251881Speter { 1448251881Speter svn_error_clear(err); 1449251881Speter svn_path_split(path, pdirectory, pfile, pool); 1450251881Speter } 1451251881Speter else if (finfo.filetype == APR_DIR) 1452251881Speter { 1453251881Speter *pdirectory = path; 1454251881Speter *pfile = SVN_EMPTY_PATH; 1455251881Speter } 1456251881Speter else 1457251881Speter { 1458251881Speter return svn_error_createf(SVN_ERR_BAD_FILENAME, NULL, 1459251881Speter _("'%s' is neither a file nor a directory name"), 1460251881Speter svn_path_local_style(path, pool)); 1461251881Speter } 1462251881Speter 1463251881Speter return SVN_NO_ERROR; 1464251881Speter} 1465251881Speter 1466251881Speter/*** From stream.c ***/ 1467251881Spetersvn_error_t *svn_stream_copy2(svn_stream_t *from, svn_stream_t *to, 1468251881Speter svn_cancel_func_t cancel_func, 1469251881Speter void *cancel_baton, 1470251881Speter apr_pool_t *scratch_pool) 1471251881Speter{ 1472251881Speter return svn_error_trace(svn_stream_copy3( 1473251881Speter svn_stream_disown(from, scratch_pool), 1474251881Speter svn_stream_disown(to, scratch_pool), 1475251881Speter cancel_func, cancel_baton, scratch_pool)); 1476251881Speter} 1477251881Speter 1478251881Spetersvn_error_t *svn_stream_copy(svn_stream_t *from, svn_stream_t *to, 1479251881Speter apr_pool_t *scratch_pool) 1480251881Speter{ 1481251881Speter return svn_error_trace(svn_stream_copy3( 1482251881Speter svn_stream_disown(from, scratch_pool), 1483251881Speter svn_stream_disown(to, scratch_pool), 1484251881Speter NULL, NULL, scratch_pool)); 1485251881Speter} 1486251881Speter 1487251881Spetersvn_stream_t * 1488251881Spetersvn_stream_from_aprfile(apr_file_t *file, apr_pool_t *pool) 1489251881Speter{ 1490251881Speter return svn_stream_from_aprfile2(file, TRUE, pool); 1491251881Speter} 1492251881Speter 1493251881Spetersvn_error_t * 1494362181Sdimsvn_stream_for_stdin(svn_stream_t **in, apr_pool_t *pool) 1495362181Sdim{ 1496362181Sdim return svn_error_trace(svn_stream_for_stdin2(in, FALSE, pool)); 1497362181Sdim} 1498362181Sdim 1499362181Sdimsvn_error_t * 1500251881Spetersvn_stream_contents_same(svn_boolean_t *same, 1501251881Speter svn_stream_t *stream1, 1502251881Speter svn_stream_t *stream2, 1503251881Speter apr_pool_t *pool) 1504251881Speter{ 1505251881Speter return svn_error_trace(svn_stream_contents_same2( 1506251881Speter same, 1507251881Speter svn_stream_disown(stream1, pool), 1508251881Speter svn_stream_disown(stream2, pool), 1509251881Speter pool)); 1510251881Speter} 1511251881Speter 1512289180Spetervoid 1513289180Spetersvn_stream_set_read(svn_stream_t *stream, 1514289180Speter svn_read_fn_t read_fn) 1515289180Speter{ 1516289180Speter svn_stream_set_read2(stream, NULL /* only full read support */, 1517289180Speter read_fn); 1518289180Speter} 1519289180Speter 1520289180Spetersvn_error_t * 1521289180Spetersvn_stream_read(svn_stream_t *stream, 1522289180Speter char *buffer, 1523289180Speter apr_size_t *len) 1524289180Speter{ 1525289180Speter return svn_error_trace(svn_stream_read_full(stream, buffer, len)); 1526289180Speter} 1527289180Speter 1528289180Speterstruct md5_stream_baton 1529289180Speter{ 1530289180Speter const unsigned char **read_digest; 1531289180Speter const unsigned char **write_digest; 1532289180Speter svn_checksum_t *read_checksum; 1533289180Speter svn_checksum_t *write_checksum; 1534289180Speter svn_stream_t *proxy; 1535289180Speter apr_pool_t *pool; 1536289180Speter}; 1537289180Speter 1538289180Speterstatic svn_error_t * 1539289180Speterread_handler_md5(void *baton, char *buffer, apr_size_t *len) 1540289180Speter{ 1541289180Speter struct md5_stream_baton *btn = baton; 1542289180Speter return svn_error_trace(svn_stream_read2(btn->proxy, buffer, len)); 1543289180Speter} 1544289180Speter 1545289180Speterstatic svn_error_t * 1546289180Speterread_full_handler_md5(void *baton, char *buffer, apr_size_t *len) 1547289180Speter{ 1548289180Speter struct md5_stream_baton *btn = baton; 1549289180Speter return svn_error_trace(svn_stream_read_full(btn->proxy, buffer, len)); 1550289180Speter} 1551289180Speter 1552289180Speterstatic svn_error_t * 1553289180Speterskip_handler_md5(void *baton, apr_size_t len) 1554289180Speter{ 1555289180Speter struct md5_stream_baton *btn = baton; 1556289180Speter return svn_error_trace(svn_stream_skip(btn->proxy, len)); 1557289180Speter} 1558289180Speter 1559289180Speterstatic svn_error_t * 1560289180Speterwrite_handler_md5(void *baton, const char *buffer, apr_size_t *len) 1561289180Speter{ 1562289180Speter struct md5_stream_baton *btn = baton; 1563289180Speter return svn_error_trace(svn_stream_write(btn->proxy, buffer, len)); 1564289180Speter} 1565289180Speter 1566289180Speterstatic svn_error_t * 1567289180Speterclose_handler_md5(void *baton) 1568289180Speter{ 1569289180Speter struct md5_stream_baton *btn = baton; 1570289180Speter 1571289180Speter SVN_ERR(svn_stream_close(btn->proxy)); 1572289180Speter 1573289180Speter if (btn->read_digest) 1574289180Speter *btn->read_digest 1575289180Speter = apr_pmemdup(btn->pool, btn->read_checksum->digest, 1576289180Speter APR_MD5_DIGESTSIZE); 1577289180Speter 1578289180Speter if (btn->write_digest) 1579289180Speter *btn->write_digest 1580289180Speter = apr_pmemdup(btn->pool, btn->write_checksum->digest, 1581289180Speter APR_MD5_DIGESTSIZE); 1582289180Speter 1583289180Speter return SVN_NO_ERROR; 1584289180Speter} 1585289180Speter 1586289180Speter 1587289180Spetersvn_stream_t * 1588289180Spetersvn_stream_checksummed(svn_stream_t *stream, 1589289180Speter const unsigned char **read_digest, 1590289180Speter const unsigned char **write_digest, 1591289180Speter svn_boolean_t read_all, 1592289180Speter apr_pool_t *pool) 1593289180Speter{ 1594289180Speter svn_stream_t *s; 1595289180Speter struct md5_stream_baton *baton; 1596289180Speter 1597289180Speter if (! read_digest && ! write_digest) 1598289180Speter return stream; 1599289180Speter 1600289180Speter baton = apr_palloc(pool, sizeof(*baton)); 1601289180Speter baton->read_digest = read_digest; 1602289180Speter baton->write_digest = write_digest; 1603289180Speter baton->pool = pool; 1604289180Speter 1605289180Speter /* Set BATON->proxy to a stream that will fill in BATON->read_checksum 1606289180Speter * and BATON->write_checksum (if we want them) when it is closed. */ 1607289180Speter baton->proxy 1608289180Speter = svn_stream_checksummed2(stream, 1609289180Speter read_digest ? &baton->read_checksum : NULL, 1610289180Speter write_digest ? &baton->write_checksum : NULL, 1611289180Speter svn_checksum_md5, 1612289180Speter read_all, pool); 1613289180Speter 1614289180Speter /* Create a stream that will forward its read/write/close operations to 1615289180Speter * BATON->proxy and will fill in *READ_DIGEST and *WRITE_DIGEST (if we 1616289180Speter * want them) after it closes BATON->proxy. */ 1617289180Speter s = svn_stream_create(baton, pool); 1618289180Speter svn_stream_set_read2(s, read_handler_md5, read_full_handler_md5); 1619289180Speter svn_stream_set_skip(s, skip_handler_md5); 1620289180Speter svn_stream_set_write(s, write_handler_md5); 1621289180Speter svn_stream_set_close(s, close_handler_md5); 1622289180Speter return s; 1623289180Speter} 1624289180Speter 1625362181Sdimsvn_error_t * 1626362181Sdimsvn_string_from_stream(svn_string_t **result, 1627362181Sdim svn_stream_t *stream, 1628362181Sdim apr_pool_t *result_pool, 1629362181Sdim apr_pool_t *scratch_pool) 1630362181Sdim{ 1631362181Sdim return svn_error_trace(svn_string_from_stream2(result, stream, 0, 1632362181Sdim result_pool)); 1633362181Sdim} 1634362181Sdim 1635251881Speter/*** From path.c ***/ 1636251881Speter 1637251881Speterconst char * 1638251881Spetersvn_path_internal_style(const char *path, apr_pool_t *pool) 1639251881Speter{ 1640251881Speter if (svn_path_is_url(path)) 1641251881Speter return svn_uri_canonicalize(path, pool); 1642251881Speter else 1643251881Speter return svn_dirent_internal_style(path, pool); 1644251881Speter} 1645251881Speter 1646251881Speter 1647251881Speterconst char * 1648251881Spetersvn_path_local_style(const char *path, apr_pool_t *pool) 1649251881Speter{ 1650251881Speter if (svn_path_is_url(path)) 1651251881Speter return apr_pstrdup(pool, path); 1652251881Speter else 1653251881Speter return svn_dirent_local_style(path, pool); 1654251881Speter} 1655251881Speter 1656251881Speterconst char * 1657251881Spetersvn_path_canonicalize(const char *path, apr_pool_t *pool) 1658251881Speter{ 1659251881Speter if (svn_path_is_url(path)) 1660251881Speter return svn_uri_canonicalize(path, pool); 1661251881Speter else 1662251881Speter return svn_dirent_canonicalize(path, pool); 1663251881Speter} 1664251881Speter 1665251881Speter 1666251881Speter/*** From mergeinfo.c ***/ 1667251881Speter 1668251881Spetersvn_error_t * 1669251881Spetersvn_mergeinfo_inheritable(svn_mergeinfo_t *output, 1670251881Speter svn_mergeinfo_t mergeinfo, 1671251881Speter const char *path, 1672251881Speter svn_revnum_t start, 1673251881Speter svn_revnum_t end, 1674251881Speter apr_pool_t *pool) 1675251881Speter{ 1676251881Speter return svn_error_trace(svn_mergeinfo_inheritable2(output, mergeinfo, path, 1677251881Speter start, end, 1678251881Speter TRUE, pool, pool)); 1679251881Speter} 1680251881Speter 1681251881Spetersvn_error_t * 1682251881Spetersvn_rangelist_inheritable(svn_rangelist_t **inheritable_rangelist, 1683251881Speter const svn_rangelist_t *rangelist, 1684251881Speter svn_revnum_t start, 1685251881Speter svn_revnum_t end, 1686251881Speter apr_pool_t *pool) 1687251881Speter{ 1688251881Speter return svn_error_trace(svn_rangelist_inheritable2(inheritable_rangelist, 1689251881Speter rangelist, 1690251881Speter start, end, TRUE, 1691251881Speter pool, pool)); 1692251881Speter} 1693251881Speter 1694251881Spetersvn_error_t * 1695251881Spetersvn_rangelist_merge(svn_rangelist_t **rangelist, 1696251881Speter const svn_rangelist_t *changes, 1697251881Speter apr_pool_t *pool) 1698251881Speter{ 1699251881Speter SVN_ERR(svn_rangelist_merge2(*rangelist, changes, 1700251881Speter pool, pool)); 1701251881Speter 1702251881Speter return svn_error_trace( 1703362181Sdim svn_rangelist__canonicalize(*rangelist, pool)); 1704251881Speter} 1705251881Speter 1706251881Spetersvn_error_t * 1707251881Spetersvn_mergeinfo_diff(svn_mergeinfo_t *deleted, svn_mergeinfo_t *added, 1708251881Speter svn_mergeinfo_t from, svn_mergeinfo_t to, 1709251881Speter svn_boolean_t consider_inheritance, 1710251881Speter apr_pool_t *pool) 1711251881Speter{ 1712251881Speter return svn_error_trace(svn_mergeinfo_diff2(deleted, added, from, to, 1713251881Speter consider_inheritance, pool, 1714251881Speter pool)); 1715251881Speter} 1716251881Speter 1717251881Spetersvn_error_t * 1718251881Spetersvn_mergeinfo_merge(svn_mergeinfo_t mergeinfo, 1719251881Speter svn_mergeinfo_t changes, 1720251881Speter apr_pool_t *pool) 1721251881Speter{ 1722251881Speter return svn_error_trace(svn_mergeinfo_merge2(mergeinfo, changes, pool, 1723251881Speter pool)); 1724251881Speter} 1725251881Speter 1726251881Spetersvn_error_t * 1727251881Spetersvn_mergeinfo_remove(svn_mergeinfo_t *mergeinfo, svn_mergeinfo_t eraser, 1728251881Speter svn_mergeinfo_t whiteboard, apr_pool_t *pool) 1729251881Speter{ 1730251881Speter return svn_mergeinfo_remove2(mergeinfo, eraser, whiteboard, TRUE, pool, 1731251881Speter pool); 1732251881Speter} 1733251881Speter 1734251881Spetersvn_error_t * 1735251881Spetersvn_mergeinfo_intersect(svn_mergeinfo_t *mergeinfo, 1736251881Speter svn_mergeinfo_t mergeinfo1, 1737251881Speter svn_mergeinfo_t mergeinfo2, 1738251881Speter apr_pool_t *pool) 1739251881Speter{ 1740251881Speter return svn_mergeinfo_intersect2(mergeinfo, mergeinfo1, mergeinfo2, 1741251881Speter TRUE, pool, pool); 1742251881Speter} 1743251881Speter 1744251881Speter/*** From config.c ***/ 1745251881Spetersvn_error_t * 1746251881Spetersvn_config_create(svn_config_t **cfgp, 1747251881Speter svn_boolean_t section_names_case_sensitive, 1748251881Speter apr_pool_t *result_pool) 1749251881Speter{ 1750251881Speter return svn_error_trace(svn_config_create2(cfgp, 1751251881Speter section_names_case_sensitive, 1752251881Speter FALSE, 1753251881Speter result_pool)); 1754251881Speter} 1755251881Speter 1756251881Spetersvn_error_t * 1757251881Spetersvn_config_read2(svn_config_t **cfgp, const char *file, 1758251881Speter svn_boolean_t must_exist, 1759251881Speter svn_boolean_t section_names_case_sensitive, 1760251881Speter apr_pool_t *result_pool) 1761251881Speter{ 1762251881Speter return svn_error_trace(svn_config_read3(cfgp, file, 1763251881Speter must_exist, 1764251881Speter section_names_case_sensitive, 1765251881Speter FALSE, 1766251881Speter result_pool)); 1767251881Speter} 1768251881Speter 1769251881Spetersvn_error_t * 1770251881Spetersvn_config_read(svn_config_t **cfgp, const char *file, 1771251881Speter svn_boolean_t must_exist, 1772251881Speter apr_pool_t *result_pool) 1773251881Speter{ 1774251881Speter return svn_error_trace(svn_config_read3(cfgp, file, 1775251881Speter must_exist, 1776251881Speter FALSE, FALSE, 1777251881Speter result_pool)); 1778251881Speter} 1779251881Speter 1780251881Speter#ifdef SVN_DISABLE_FULL_VERSION_MATCH 1781251881Speter/* This double underscore name is used by the 1.6 command line client. 1782251881Speter Keeping this name is sufficient for the 1.6 client to use the 1.7 1783251881Speter libraries at runtime. */ 1784251881Spetersvn_error_t * 1785251881Spetersvn_opt__eat_peg_revisions(apr_array_header_t **true_targets_p, 1786251881Speter apr_array_header_t *targets, 1787251881Speter apr_pool_t *pool); 1788251881Spetersvn_error_t * 1789251881Spetersvn_opt__eat_peg_revisions(apr_array_header_t **true_targets_p, 1790251881Speter apr_array_header_t *targets, 1791251881Speter apr_pool_t *pool) 1792251881Speter{ 1793251881Speter unsigned int i; 1794251881Speter apr_array_header_t *true_targets; 1795251881Speter 1796251881Speter true_targets = apr_array_make(pool, 5, sizeof(const char *)); 1797251881Speter 1798251881Speter for (i = 0; i < targets->nelts; i++) 1799251881Speter { 1800251881Speter const char *target = APR_ARRAY_IDX(targets, i, const char *); 1801251881Speter const char *true_target; 1802251881Speter 1803251881Speter SVN_ERR(svn_opt__split_arg_at_peg_revision(&true_target, NULL, 1804251881Speter target, pool)); 1805251881Speter APR_ARRAY_PUSH(true_targets, const char *) = true_target; 1806251881Speter } 1807251881Speter 1808251881Speter SVN_ERR_ASSERT(true_targets_p); 1809251881Speter *true_targets_p = true_targets; 1810251881Speter 1811251881Speter return SVN_NO_ERROR; 1812251881Speter} 1813251881Speter#endif 1814251881Speter 1815251881Spetervoid 1816251881Spetersvn_xml_make_header(svn_stringbuf_t **str, apr_pool_t *pool) 1817251881Speter{ 1818251881Speter svn_xml_make_header2(str, NULL, pool); 1819251881Speter} 1820251881Speter 1821289180Speter 1822289180Speter/*** From utf.c ***/ 1823251881Spetervoid 1824251881Spetersvn_utf_initialize(apr_pool_t *pool) 1825251881Speter{ 1826251881Speter svn_utf_initialize2(FALSE, pool); 1827251881Speter} 1828251881Speter 1829251881Spetersvn_error_t * 1830289180Spetersvn_utf_cstring_from_utf8_ex(const char **dest, 1831289180Speter const char *src, 1832289180Speter const char *topage, 1833289180Speter const char *convset_key, 1834289180Speter apr_pool_t *pool) 1835289180Speter{ 1836289180Speter return svn_utf_cstring_from_utf8_ex2(dest, src, topage, pool); 1837289180Speter} 1838289180Speter 1839289180Speter/*** From error.c ***/ 1840289180Spetervoid 1841289180Spetersvn_handle_error(svn_error_t *err, FILE *stream, svn_boolean_t fatal) 1842289180Speter{ 1843289180Speter svn_handle_error2(err, stream, fatal, "svn: "); 1844289180Speter} 1845289180Speter 1846289180Spetervoid 1847289180Spetersvn_handle_warning(FILE *stream, svn_error_t *err) 1848289180Speter{ 1849289180Speter svn_handle_warning2(stream, err, "svn: "); 1850289180Speter} 1851289180Speter 1852289180Speter 1853289180Speter/*** From subst.c ***/ 1854289180Spetersvn_error_t * 1855251881Spetersvn_subst_build_keywords(svn_subst_keywords_t *kw, 1856251881Speter const char *keywords_val, 1857251881Speter const char *rev, 1858251881Speter const char *url, 1859251881Speter apr_time_t date, 1860251881Speter const char *author, 1861251881Speter apr_pool_t *pool) 1862251881Speter{ 1863251881Speter apr_hash_t *kwhash; 1864251881Speter const svn_string_t *val; 1865251881Speter 1866251881Speter SVN_ERR(svn_subst_build_keywords2(&kwhash, keywords_val, rev, 1867251881Speter url, date, author, pool)); 1868251881Speter 1869251881Speter /* The behaviour of pre-1.3 svn_subst_build_keywords, which we are 1870251881Speter * replicating here, is to write to a slot in the svn_subst_keywords_t 1871251881Speter * only if the relevant keyword was present in keywords_val, otherwise 1872251881Speter * leaving that slot untouched. */ 1873251881Speter 1874251881Speter val = svn_hash_gets(kwhash, SVN_KEYWORD_REVISION_LONG); 1875251881Speter if (val) 1876251881Speter kw->revision = val; 1877251881Speter 1878251881Speter val = svn_hash_gets(kwhash, SVN_KEYWORD_DATE_LONG); 1879251881Speter if (val) 1880251881Speter kw->date = val; 1881251881Speter 1882251881Speter val = svn_hash_gets(kwhash, SVN_KEYWORD_AUTHOR_LONG); 1883251881Speter if (val) 1884251881Speter kw->author = val; 1885251881Speter 1886251881Speter val = svn_hash_gets(kwhash, SVN_KEYWORD_URL_LONG); 1887251881Speter if (val) 1888251881Speter kw->url = val; 1889251881Speter 1890251881Speter val = svn_hash_gets(kwhash, SVN_KEYWORD_ID); 1891251881Speter if (val) 1892251881Speter kw->id = val; 1893251881Speter 1894251881Speter return SVN_NO_ERROR; 1895251881Speter} 1896251881Speter 1897257936Speter/*** From version.c ***/ 1898257936Spetersvn_error_t * 1899257936Spetersvn_ver_check_list(const svn_version_t *my_version, 1900257936Speter const svn_version_checklist_t *checklist) 1901257936Speter{ 1902257936Speter return svn_ver_check_list2(my_version, checklist, svn_ver_compatible); 1903257936Speter} 1904289180Speter 1905289180Speter/*** From win32_crypto.c ***/ 1906289180Speter#if defined(WIN32) && !defined(__MINGW32__) 1907289180Spetervoid 1908289180Spetersvn_auth_get_windows_simple_provider(svn_auth_provider_object_t **provider, 1909289180Speter apr_pool_t *pool) 1910289180Speter{ 1911289180Speter svn_auth__get_windows_simple_provider(provider, pool); 1912289180Speter} 1913289180Speter 1914289180Spetervoid 1915289180Spetersvn_auth_get_windows_ssl_client_cert_pw_provider 1916289180Speter (svn_auth_provider_object_t **provider, 1917289180Speter apr_pool_t *pool) 1918289180Speter{ 1919289180Speter svn_auth__get_windows_ssl_client_cert_pw_provider(provider, pool); 1920289180Speter} 1921289180Speter 1922289180Spetervoid 1923289180Spetersvn_auth_get_windows_ssl_server_trust_provider 1924289180Speter (svn_auth_provider_object_t **provider, apr_pool_t *pool) 1925289180Speter{ 1926289180Speter svn_auth__get_windows_ssl_server_trust_provider(provider, pool); 1927289180Speter} 1928289180Speter#endif /* WIN32 && !__MINGW32__ */ 1929289180Speter 1930289180Speter/*** From macos_keychain.c ***/ 1931289180Speter#if defined(DARWIN) 1932289180Spetervoid 1933289180Spetersvn_auth_get_keychain_simple_provider(svn_auth_provider_object_t **provider, 1934289180Speter apr_pool_t *pool) 1935289180Speter{ 1936309511Speter#ifdef SVN_HAVE_KEYCHAIN_SERVICES 1937289180Speter svn_auth__get_keychain_simple_provider(provider, pool); 1938309511Speter#else 1939309511Speter svn_auth__get_dummmy_simple_provider(provider, pool); 1940309511Speter#endif 1941289180Speter} 1942289180Speter 1943289180Spetervoid 1944289180Spetersvn_auth_get_keychain_ssl_client_cert_pw_provider 1945289180Speter (svn_auth_provider_object_t **provider, 1946289180Speter apr_pool_t *pool) 1947289180Speter{ 1948309511Speter#ifdef SVN_HAVE_KEYCHAIN_SERVICES 1949289180Speter svn_auth__get_keychain_ssl_client_cert_pw_provider(provider, pool); 1950309511Speter#else 1951309511Speter /* Not really the right type of dummy provider, but doesn't throw NULL 1952309511Speter errors as just returning NULL would */ 1953309511Speter svn_auth__get_dummmy_simple_provider(provider, pool); 1954309511Speter#endif 1955289180Speter} 1956289180Speter#endif /* DARWIN */ 1957289180Speter 1958289180Speter#if !defined(WIN32) 1959289180Spetervoid 1960289180Spetersvn_auth_get_gpg_agent_simple_provider(svn_auth_provider_object_t **provider, 1961289180Speter apr_pool_t *pool) 1962289180Speter{ 1963289180Speter#ifdef SVN_HAVE_GPG_AGENT 1964289180Speter svn_auth__get_gpg_agent_simple_provider(provider, pool); 1965289180Speter#else 1966289180Speter svn_auth__get_dummmy_simple_provider(provider, pool); 1967289180Speter#endif /* SVN_HAVE_GPG_AGENT */ 1968289180Speter} 1969289180Speter#endif /* !WIN32 */ 1970289180Speter 1971289180Spetersvn_error_t * 1972289180Spetersvn_cmdline_create_auth_baton(svn_auth_baton_t **ab, 1973289180Speter svn_boolean_t non_interactive, 1974289180Speter const char *auth_username, 1975289180Speter const char *auth_password, 1976289180Speter const char *config_dir, 1977289180Speter svn_boolean_t no_auth_cache, 1978289180Speter svn_boolean_t trust_server_cert, 1979289180Speter svn_config_t *cfg, 1980289180Speter svn_cancel_func_t cancel_func, 1981289180Speter void *cancel_baton, 1982289180Speter apr_pool_t *pool) 1983289180Speter{ 1984289180Speter return svn_error_trace(svn_cmdline_create_auth_baton2(ab, 1985289180Speter non_interactive, 1986289180Speter auth_username, 1987289180Speter auth_password, 1988289180Speter config_dir, 1989289180Speter no_auth_cache, 1990289180Speter trust_server_cert, 1991289180Speter FALSE, 1992289180Speter FALSE, 1993289180Speter FALSE, 1994289180Speter FALSE, 1995289180Speter cfg, 1996289180Speter cancel_func, 1997289180Speter cancel_baton, 1998289180Speter pool)); 1999289180Speter} 2000362181Sdim 2001362181Sdim/*** From base64.c ***/ 2002362181Sdimsvn_stream_t * 2003362181Sdimsvn_base64_encode(svn_stream_t *output, apr_pool_t *pool) 2004362181Sdim{ 2005362181Sdim return svn_base64_encode2(output, TRUE, pool); 2006362181Sdim} 2007362181Sdim 2008362181Sdim/*** From string.c ***/ 2009362181Sdimchar * 2010362181Sdimsvn_cstring_join(const apr_array_header_t *strings, 2011362181Sdim const char *separator, 2012362181Sdim apr_pool_t *pool) 2013362181Sdim{ 2014362181Sdim return svn_cstring_join2(strings, separator, TRUE, pool); 2015362181Sdim} 2016