int main(int argc, const char *argv[]) { apr_pool_t *pool; int exit_code = EXIT_SUCCESS; svn_error_t *err; /* Initialize the app. */ if (svn_cmdline_init("svnraisetreeconflict", stderr) != EXIT_SUCCESS) return EXIT_FAILURE; /* Create our top-level pool. Use a separate mutexless allocator, * given this application is single threaded. */ pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); err = sub_main(&exit_code, argc, argv, pool); /* Flush stdout and report if it fails. It would be flushed on exit anyway but this makes sure that output is not silently lost if it fails. */ err = svn_error_compose_create(err, svn_cmdline_fflush(stdout)); if (err) { exit_code = EXIT_FAILURE; svn_cmdline_handle_exit_error(err, NULL, "svnraisetreeconflict: "); } svn_pool_destroy(pool); return exit_code; }
int main(int argc, const char *argv[]) { apr_pool_t *pool; int exit_code = EXIT_SUCCESS; svn_error_t *err; const char *path; const char *cmd; if (argc < 2 || argc > 4) { fprintf(stderr, "USAGE: entries-dump [--entries|--subdirs|--tree-dump] DIR_PATH\n"); exit(1); } if (svn_cmdline_init("entries-dump", stderr) != EXIT_SUCCESS) { return EXIT_FAILURE; } /* Create our top-level pool. Use a separate mutexless allocator, * given this application is single threaded. */ pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); path = svn_dirent_internal_style(argv[argc-1], pool); if (argc > 2) cmd = argv[1]; else cmd = NULL; if (!cmd || !strcmp(cmd, "--entries")) err = entries_dump(path, NULL, pool); else if (!strcmp(cmd, "--subdirs")) err = directory_dump(path, pool); else if (!strcmp(cmd, "--tree-dump")) err = tree_dump(path, pool); else err = svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL, "Invalid command '%s'", cmd); if (err) { svn_handle_error2(err, stderr, FALSE, "entries-dump: "); svn_error_clear(err); exit_code = EXIT_FAILURE; } /* Clean up, and get outta here */ svn_pool_destroy(pool); apr_terminate(); return exit_code; }
/* Return a currently unused connection pool in *POOL. If no such pool * exists, create a new root pool and return that in *POOL. */ static svn_error_t * acquire_pool_internal(apr_pool_t **pool, svn_root_pools__t *pools) { SVN_ERR(svn_mutex__lock(pools->mutex)); *pool = pools->unused_pools->nelts ? *(apr_pool_t **)apr_array_pop(pools->unused_pools) : apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); SVN_ERR(svn_mutex__unlock(pools->mutex, SVN_NO_ERROR)); return SVN_NO_ERROR; }
apr_pool_t * svn_root_pools__acquire_pool(svn_root_pools__t *pools) { apr_pool_t *pool; svn_error_t *err = acquire_pool_internal(&pool, pools); if (err) { /* Mutex failure?! Well, try to continue with unrecycled data. */ svn_error_clear(err); pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); } return pool; }
svn_error_t * svn_root_pools__create(svn_root_pools__t **pools) { /* the collection of root pools must be managed independently from any other pool */ apr_pool_t *pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); /* construct result object */ svn_root_pools__t *result = apr_pcalloc(pool, sizeof(*result)); SVN_ERR(svn_mutex__init(&result->mutex, TRUE, pool)); result->unused_pools = apr_array_make(pool, 16, sizeof(apr_pool_t *)); /* done */ *pools = result; return SVN_NO_ERROR; }
int main(int argc, const char *argv[]) { apr_pool_t *pool; int exit_code = EXIT_SUCCESS; svn_error_t *err; /* Initialize the app. */ if (svn_cmdline_init("svnserve", stderr) != EXIT_SUCCESS) return EXIT_FAILURE; /* Create our top-level pool. */ pool = apr_allocator_owner_get(svn_pool_create_allocator(TRUE)); err = sub_main(&exit_code, argc, argv, pool); /* Flush stdout and report if it fails. It would be flushed on exit anyway but this makes sure that output is not silently lost if it fails. */ err = svn_error_compose_create(err, svn_cmdline_fflush(stdout)); if (err) { exit_code = EXIT_FAILURE; svn_cmdline_handle_exit_error(err, NULL, "svnserve: "); } #if APR_HAS_THREADS /* Explicitly wait for all threads to exit. As we found out with similar code in our C test framework, the memory pool cleanup below cannot be trusted to do the right thing. */ if (threads) apr_thread_pool_destroy(threads); #endif /* this will also close the server's socket */ svn_pool_destroy(pool); return exit_code; }
int main(int argc, char **argv) { apr_pool_t *pool; int exit_code = EXIT_SUCCESS; svn_error_t *err; const char *filename; if (argc == 2) filename = argv[1]; else filename = "-"; if (svn_cmdline_init("afl-x509", stderr) != EXIT_SUCCESS) return EXIT_FAILURE; pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); err = parse(filename, pool); if (err) exit_code = EXIT_FAILURE; svn_error_clear(err); svn_pool_destroy(pool); return exit_code; }
/* Standard svn test program */ int main(int argc, const char *argv[]) { const char *prog_name; int i; svn_boolean_t got_error = FALSE; apr_pool_t *pool, *test_pool; svn_boolean_t ran_a_test = FALSE; svn_boolean_t list_mode = FALSE; int opt_id; apr_status_t apr_err; apr_getopt_t *os; svn_error_t *err; char errmsg[200]; /* How many tests are there? */ int array_size = get_array_size(); svn_test_opts_t opts = { NULL }; opts.fs_type = DEFAULT_FS_TYPE; /* Initialize APR (Apache pools) */ if (apr_initialize() != APR_SUCCESS) { printf("apr_initialize() failed.\n"); exit(1); } /* set up the global pool. Use a separate allocator to limit memory * usage but make it thread-safe to allow for multi-threaded tests. */ pool = apr_allocator_owner_get(svn_pool_create_allocator(TRUE)); /* Remember the command line */ test_argc = argc; test_argv = argv; err = svn_cmdline__getopt_init(&os, argc, argv, pool); os->interleave = TRUE; /* Let options and arguments be interleaved */ /* Strip off any leading path components from the program name. */ prog_name = strrchr(argv[0], '/'); if (prog_name) prog_name++; else { /* Just check if this is that weird platform that uses \ instead of / for the path separator. */ prog_name = strrchr(argv[0], '\\'); if (prog_name) prog_name++; else prog_name = argv[0]; } if (err) return svn_cmdline_handle_exit_error(err, pool, prog_name); while (1) { const char *opt_arg; /* Parse the next option. */ apr_err = apr_getopt_long(os, cl_options, &opt_id, &opt_arg); if (APR_STATUS_IS_EOF(apr_err)) break; else if (apr_err && (apr_err != APR_BADCH)) { /* Ignore invalid option error to allow passing arbitary options */ fprintf(stderr, "apr_getopt_long failed : [%d] %s\n", apr_err, apr_strerror(apr_err, errmsg, sizeof(errmsg))); exit(1); } switch (opt_id) { case cleanup_opt: cleanup_mode = TRUE; break; case config_opt: opts.config_file = apr_pstrdup(pool, opt_arg); break; case fstype_opt: opts.fs_type = apr_pstrdup(pool, opt_arg); break; case list_opt: list_mode = TRUE; break; case mode_filter_opt: if (svn_cstring_casecmp(opt_arg, "PASS") == 0) mode_filter = svn_test_pass; else if (svn_cstring_casecmp(opt_arg, "XFAIL") == 0) mode_filter = svn_test_xfail; else if (svn_cstring_casecmp(opt_arg, "SKIP") == 0) mode_filter = svn_test_skip; else if (svn_cstring_casecmp(opt_arg, "ALL") == 0) mode_filter = svn_test_all; else { fprintf(stderr, "FAIL: Invalid --mode-filter option. Try "); fprintf(stderr, " PASS, XFAIL, SKIP or ALL.\n"); exit(1); } break; case verbose_opt: verbose_mode = TRUE; break; case quiet_opt: quiet_mode = TRUE; break; case allow_segfault_opt: allow_segfaults = TRUE; break; case server_minor_version_opt: { char *end; opts.server_minor_version = (int) strtol(opt_arg, &end, 10); if (end == opt_arg || *end != '\0') { fprintf(stderr, "FAIL: Non-numeric minor version given\n"); exit(1); } if ((opts.server_minor_version < 3) || (opts.server_minor_version > 6)) { fprintf(stderr, "FAIL: Invalid minor version given\n"); exit(1); } } } } /* Disable sleeping for timestamps, to speed up the tests. */ apr_env_set( "SVN_I_LOVE_CORRUPTED_WORKING_COPIES_SO_DISABLE_SLEEP_FOR_TIMESTAMPS", "yes", pool); /* You can't be both quiet and verbose. */ if (quiet_mode && verbose_mode) { fprintf(stderr, "FAIL: --verbose and --quiet are mutually exclusive\n"); exit(1); } /* Create an iteration pool for the tests */ cleanup_pool = svn_pool_create(pool); test_pool = svn_pool_create(pool); if (!allow_segfaults) svn_error_set_malfunction_handler(svn_error_raise_on_malfunction); if (argc >= 2) /* notice command-line arguments */ { if (! strcmp(argv[1], "list") || list_mode) { const char *header_msg; ran_a_test = TRUE; /* run all tests with MSG_ONLY set to TRUE */ header_msg = "Test # Mode Test Description\n" "------ ----- ----------------\n"; for (i = 1; i <= array_size; i++) { if (do_test_num(prog_name, i, TRUE, &opts, &header_msg, test_pool)) got_error = TRUE; /* Clear the per-function pool */ svn_pool_clear(test_pool); svn_pool_clear(cleanup_pool); } } else { for (i = 1; i < argc; i++) { if (svn_ctype_isdigit(argv[i][0]) || argv[i][0] == '-') { int test_num = atoi(argv[i]); if (test_num == 0) /* A --option argument, most likely. */ continue; ran_a_test = TRUE; if (do_test_num(prog_name, test_num, FALSE, &opts, NULL, test_pool)) got_error = TRUE; /* Clear the per-function pool */ svn_pool_clear(test_pool); svn_pool_clear(cleanup_pool); } } } } if (! ran_a_test) { /* just run all tests */ for (i = 1; i <= array_size; i++) { if (do_test_num(prog_name, i, FALSE, &opts, NULL, test_pool)) got_error = TRUE; /* Clear the per-function pool */ svn_pool_clear(test_pool); svn_pool_clear(cleanup_pool); } } /* Clean up APR */ svn_pool_destroy(pool); /* takes test_pool with it */ apr_terminate(); return got_error; }
int main(int argc, const char *argv[]) { const char *repos_path; apr_pool_t *pool; svn_boolean_t prop = FALSE, data = FALSE; svn_boolean_t quiet = FALSE; svn_error_t *err; apr_getopt_t *os; const apr_getopt_option_t options[] = { {"data", OPT_DATA, 0, N_("display data reps stats")}, {"prop", OPT_PROP, 0, N_("display prop reps stats")}, {"both", OPT_BOTH, 0, N_("display combined (data+prop) reps stats")}, {"quiet", 'q', 0, N_("no progress (only errors) to stderr")}, {"help", 'h', 0, N_("display this help")}, {"version", OPT_VERSION, 0, N_("show program version information")}, {0, 0, 0, 0} }; /* Initialize the app. */ if (svn_cmdline_init("svn-rep-sharing-stats", stderr) != EXIT_SUCCESS) return EXIT_FAILURE; /* Create our top-level pool. Use a separate mutexless allocator, * given this application is single threaded. */ pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); /* Check library versions */ err = check_lib_versions(); if (err) return svn_cmdline_handle_exit_error(err, pool, "svn-rep-sharing-stats: "); err = svn_cmdline__getopt_init(&os, argc, argv, pool); if (err) return svn_cmdline_handle_exit_error(err, pool, "svn-rep-sharing-stats: "); SVN_INT_ERR(check_experimental()); os->interleave = 1; while (1) { int opt; const char *arg; apr_status_t status = apr_getopt_long(os, options, &opt, &arg); if (APR_STATUS_IS_EOF(status)) break; if (status != APR_SUCCESS) { usage(pool); return EXIT_FAILURE; } switch (opt) { case OPT_DATA: data = TRUE; break; /* It seems we don't actually rep-share props yet. */ case OPT_PROP: prop = TRUE; break; case OPT_BOTH: data = TRUE; prop = TRUE; break; case 'q': quiet = TRUE; break; case 'h': help(options, pool); break; case OPT_VERSION: SVN_INT_ERR(version(pool)); exit(0); break; default: usage(pool); return EXIT_FAILURE; } } /* Exactly 1 non-option argument, * and at least one of "--data"/"--prop"/"--both". */ if (os->ind + 1 != argc || (!data && !prop)) { usage(pool); return EXIT_FAILURE; } /* Grab REPOS_PATH from argv. */ SVN_INT_ERR(svn_utf_cstring_to_utf8(&repos_path, os->argv[os->ind], pool)); repos_path = svn_dirent_internal_style(repos_path, pool); set_up_cancellation(); /* Do something. */ SVN_INT_ERR(process(repos_path, prop, data, quiet, pool)); /* We're done. */ svn_pool_destroy(pool); /* Flush stdout to make sure that the user will see any printing errors. */ SVN_INT_ERR(svn_cmdline_fflush(stdout)); return EXIT_SUCCESS; }
/* * Why is this not an svn subcommand? I have this vague idea that it could * be run as part of the build process, with the output embedded in the svn * program. Obviously we don't want to have to run svn when building svn. */ int main(int argc, const char *argv[]) { const char *wc_path, *trail_url; const char *local_abspath; apr_pool_t *pool; svn_wc_revision_status_t *res; svn_boolean_t no_newline = FALSE, committed = FALSE; svn_error_t *err; apr_getopt_t *os; svn_wc_context_t *wc_ctx; svn_boolean_t quiet = FALSE; svn_boolean_t is_version = FALSE; const apr_getopt_option_t options[] = { {"no-newline", 'n', 0, N_("do not output the trailing newline")}, {"committed", 'c', 0, N_("last changed rather than current revisions")}, {"help", 'h', 0, N_("display this help")}, {"version", SVNVERSION_OPT_VERSION, 0, N_("show program version information")}, {"quiet", 'q', 0, N_("no progress (only errors) to stderr")}, {0, 0, 0, 0} }; /* Initialize the app. */ if (svn_cmdline_init("svnversion", stderr) != EXIT_SUCCESS) return EXIT_FAILURE; /* Create our top-level pool. Use a separate mutexless allocator, * given this application is single threaded. */ pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE)); /* Check library versions */ err = check_lib_versions(); if (err) return svn_cmdline_handle_exit_error(err, pool, "svnversion: "); #if defined(WIN32) || defined(__CYGWIN__) /* Set the working copy administrative directory name. */ if (getenv("SVN_ASP_DOT_NET_HACK")) { err = svn_wc_set_adm_dir("_svn", pool); if (err) return svn_cmdline_handle_exit_error(err, pool, "svnversion: "); } #endif err = svn_cmdline__getopt_init(&os, argc, argv, pool); if (err) return svn_cmdline_handle_exit_error(err, pool, "svnversion: "); os->interleave = 1; while (1) { int opt; const char *arg; apr_status_t status = apr_getopt_long(os, options, &opt, &arg); if (APR_STATUS_IS_EOF(status)) break; if (status != APR_SUCCESS) usage(pool); /* this will exit() */ switch (opt) { case 'n': no_newline = TRUE; break; case 'c': committed = TRUE; break; case 'q': quiet = TRUE; break; case 'h': help(options, pool); break; case SVNVERSION_OPT_VERSION: is_version = TRUE; break; default: usage(pool); /* this will exit() */ } } if (is_version) { SVN_INT_ERR(version(quiet, pool)); exit(0); } if (os->ind > argc || os->ind < argc - 2) usage(pool); /* this will exit() */ SVN_INT_ERR(svn_utf_cstring_to_utf8(&wc_path, (os->ind < argc) ? os->argv[os->ind] : ".", pool)); SVN_INT_ERR(svn_opt__arg_canonicalize_path(&wc_path, wc_path, pool)); SVN_INT_ERR(svn_dirent_get_absolute(&local_abspath, wc_path, pool)); SVN_INT_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool)); if (os->ind+1 < argc) SVN_INT_ERR(svn_utf_cstring_to_utf8(&trail_url, os->argv[os->ind+1], pool)); else trail_url = NULL; err = svn_wc_revision_status2(&res, wc_ctx, local_abspath, trail_url, committed, NULL, NULL, pool, pool); if (err && (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND || err->apr_err == SVN_ERR_WC_NOT_WORKING_COPY)) { svn_node_kind_t kind; svn_boolean_t special; svn_error_clear(err); SVN_INT_ERR(svn_io_check_special_path(local_abspath, &kind, &special, pool)); if (special) SVN_INT_ERR(svn_cmdline_printf(pool, _("Unversioned symlink%s"), no_newline ? "" : "\n")); else if (kind == svn_node_dir) SVN_INT_ERR(svn_cmdline_printf(pool, _("Unversioned directory%s"), no_newline ? "" : "\n")); else if (kind == svn_node_file) SVN_INT_ERR(svn_cmdline_printf(pool, _("Unversioned file%s"), no_newline ? "" : "\n")); else { SVN_INT_ERR(svn_cmdline_fprintf(stderr, pool, kind == svn_node_none ? _("'%s' doesn't exist\n") : _("'%s' is of unknown type\n"), svn_dirent_local_style(local_abspath, pool))); svn_pool_destroy(pool); return EXIT_FAILURE; } svn_pool_destroy(pool); return EXIT_SUCCESS; } SVN_INT_ERR(err); if (! SVN_IS_VALID_REVNUM(res->min_rev)) { /* Local uncommitted modifications, no revision info was found. */ SVN_INT_ERR(svn_cmdline_printf(pool, _("Uncommitted local addition, " "copy or move%s"), no_newline ? "" : "\n")); svn_pool_destroy(pool); return EXIT_SUCCESS; } /* Build compact '123[:456]M?S?' string. */ SVN_INT_ERR(svn_cmdline_printf(pool, "%ld", res->min_rev)); if (res->min_rev != res->max_rev) SVN_INT_ERR(svn_cmdline_printf(pool, ":%ld", res->max_rev)); if (res->modified) SVN_INT_ERR(svn_cmdline_fputs("M", stdout, pool)); if (res->switched) SVN_INT_ERR(svn_cmdline_fputs("S", stdout, pool)); if (res->sparse_checkout) SVN_INT_ERR(svn_cmdline_fputs("P", stdout, pool)); if (! no_newline) SVN_INT_ERR(svn_cmdline_fputs("\n", stdout, pool)); svn_pool_destroy(pool); /* Flush stdout to make sure that the user will see any printing errors. */ SVN_INT_ERR(svn_cmdline_fflush(stdout)); return EXIT_SUCCESS; }