int main(int argc, char **argv) { LLError::initForApplication("."); LLError::setFatalFunction(wouldHaveCrashed); LLError::setDefaultLevel(LLError::LEVEL_ERROR); //< *TODO: should come from error config file. Note that we // have a command line option that sets this to debug. #ifdef CTYPE_WORKAROUND ctype_workaround(); #endif ll_init_apr(); apr_pool_t* pool = NULL; if(APR_SUCCESS != apr_pool_create(&pool, NULL)) { std::cerr << "Unable to initialize pool" << std::endl; return 1; } apr_getopt_t* os = NULL; if(APR_SUCCESS != apr_getopt_init(&os, pool, argc, argv)) { std::cerr << "Unable to pool" << std::endl; return 1; } // values used for controlling application bool verbose_mode = false; bool wait_at_exit = false; std::string test_group; // values use for options parsing apr_status_t apr_err; const char* opt_arg = NULL; int opt_id = 0; std::ofstream *output = NULL; const char *touch = NULL; while(true) { apr_err = apr_getopt_long(os, TEST_CL_OPTIONS, &opt_id, &opt_arg); if(APR_STATUS_IS_EOF(apr_err)) break; if(apr_err) { char buf[255]; /* Flawfinder: ignore */ std::cerr << "Error parsing options: " << apr_strerror(apr_err, buf, 255) << std::endl; return 1; } switch (opt_id) { case 'g': test_group.assign(opt_arg); break; case 'h': stream_usage(std::cout, argv[0]); return 0; break; case 'l': stream_groups(std::cout, argv[0]); return 0; case 'v': verbose_mode = true; break; case 'o': output = new std::ofstream; output->open(opt_arg); break; case 's': // --sourcedir tut::sSourceDir = opt_arg; // For convenience, so you can use tut::sSourceDir + "myfile" tut::sSourceDir += '/'; break; case 't': touch = opt_arg; break; case 'w': wait_at_exit = true; break; case 'd': // *TODO: should come from error config file. We set it to // ERROR by default, so this allows full debug levels. LLError::setDefaultLevel(LLError::LEVEL_DEBUG); break; default: stream_usage(std::cerr, argv[0]); return 1; break; } } // run the tests LLTestCallback callback(verbose_mode, output); tut::runner.get().set_callback(&callback); if(test_group.empty()) { tut::runner.get().run_tests(); } else { tut::runner.get().run_tests(test_group); } if (wait_at_exit) { std::cerr << "Waiting for input before exiting..." << std::endl; std::cin.get(); } if (output) { output->close(); delete output; } if (touch) { std::ofstream s; s.open(touch); s << "ok" << std::endl; s.close(); } apr_terminate(); return 0; }
int main(int argc, const char **argv) { apr_iconv_t cd; iconv_stream *is; const char *from = NULL, *to = NULL, *input = NULL; char opt; apr_pool_t *ctx; apr_status_t status; apr_getopt_t *options; const char *opt_arg; /* Initialize APR */ apr_initialize(); atexit(closeapr); if (apr_pool_create(&ctx, NULL) != APR_SUCCESS) { fprintf(stderr, "Couldn't allocate context.\n"); exit(-1); } apr_getopt_init(&options, ctx, argc, argv); status = apr_getopt(options, "f:s:t:v", &opt, &opt_arg); while (status == APR_SUCCESS) { switch (opt) { case 'f': from = opt_arg; break; case 't': to = opt_arg; break; case 's': input = opt_arg; break; case 'v': fprintf(stderr, "APR-iconv version " API_VERSION_STRING "\n"); exit(0); default: fprintf(stderr, "Usage: iconv -f <name> -t <name> [-s <input>]\n"); exit(3); } status = apr_getopt(options, "f:s:t:v",&opt, &opt_arg); } if (status == APR_BADCH || status == APR_BADARG) { fprintf(stderr, "Usage: iconv -f <name> -t <name> [-s <input>]\n"); exit(3); } if (from == NULL) { fprintf(stderr, "missing source charset (-f <name>)\n"); exit(4); } if (to == NULL) { fprintf(stderr, "missing destination charset (-t <name>)\n"); exit(5); } /* Use it */ status = apr_iconv_open(to, from, ctx, &cd); if (status) { fprintf(stderr, "unable to open specified converter\n"); exit(6); } if (!(is = iconv_ostream_fopen(cd, stdout))) { apr_iconv_close(cd,ctx); exit(7); } if (input) { if (iconv_bwrite(is, input, strlen(input)) <= 0) exit(8); } else if (optind < argc) { for (opt = optind; opt < argc; opt ++) convert_file(argv[opt], is); } else convert_file("-", is); if (iconv_write(is, NULL, 0) < 0) exit(9); iconv_stream_close(is); apr_iconv_close(cd,ctx); return 0; }
static apt_bool_t options_load(server_options_t *options, int argc, const char * const *argv, apr_pool_t *pool) { apr_status_t rv; apr_getopt_t *opt = NULL; int optch; const char *optarg; const apr_getopt_option_t opt_option[] = { /* long-option, short-option, has-arg flag, description */ { "root-dir", 'r', TRUE, "path to root dir" }, /* -r arg or --root-dir arg */ { "log-prio", 'l', TRUE, "log priority" }, /* -l arg or --log-prio arg */ { "log-output", 'o', TRUE, "log output mode" }, /* -o arg or --log-output arg */ #ifdef WIN32 { "service", 's', FALSE, "run as service" }, /* -s or --service */ { "name", 'n', TRUE, "service name" }, /* -n or --name arg */ #else { "daemon", 'd', FALSE, "start as daemon" }, /* -d or --daemon */ #endif { "version", 'v', FALSE, "show version" }, /* -v or --version */ { "help", 'h', FALSE, "show help" }, /* -h or --help */ { NULL, 0, 0, NULL }, /* end */ }; rv = apr_getopt_init(&opt, pool , argc, argv); if(rv != APR_SUCCESS) { return FALSE; } while((rv = apr_getopt_long(opt, opt_option, &optch, &optarg)) == APR_SUCCESS) { switch(optch) { case 'r': options->root_dir_path = optarg; break; case 'l': options->log_priority = optarg; break; case 'o': options->log_output = optarg; break; #ifdef WIN32 case 's': options->foreground = FALSE; break; case 'n': options->svcname = optarg; break; #else case 'd': options->foreground = FALSE; break; #endif case 'v': printf(UNI_VERSION_STRING); return FALSE; case 'h': usage(); return FALSE; } } if(rv != APR_EOF) { usage(); return FALSE; } return TRUE; }
int main(int argc, const char *argv[]) { apr_pool_t *p = NULL; apr_pool_initialize(); apr_pool_create(&p, NULL); apr_getopt_t *opt; apr_status_t rv; char ch = '\0'; const char *optarg = NULL; const char *config_opts = NULL; const char *install_opts = NULL; const char *make_opts = NULL; const char *url = NULL; enum CommandType request = COMMAND_NONE; rv = apr_getopt_init(&opt, p, argc, argv); while(apr_getopt(opt, "I:Lc:m:i:d:SF:B:", &ch, &optarg) == APR_SUCCESS) { switch (ch) { case 'I': request = COMMAND_INSTALL; url = optarg; break; case 'L': request = COMMAND_LIST; break; case 'c': config_opts = optarg; break; case 'm': make_opts = optarg; break; case 'i': install_opts = optarg; break; case 'S': request = COMMAND_INIT; break; case 'F': request = COMMAND_FETCH; url = optarg; break; case 'B': request = COMMAND_BUILD; url = optarg; break; } } switch(request) { case COMMAND_INSTALL: check(url, "You must at least give a URL."); Command_install(p, url, config_opts, make_opts, install_opts); break; case COMMAND_LIST: DB_list(); break; case COMMAND_FETCH: check(url != NULL, "You must give a URL."); Command_fetch(p, url, 1); log_info("Downloaded to %s and in /tmp/", BUILD_DIR); break; case COMMAND_BUILD: check(url, "You must at least give a URL."); Command_build(p, url, config_opts, make_opts, install_opts); break; case COMMAND_INIT: rv = DB_init(); check(rv == 0, "Failed to make the database."); break; default: sentinel("Invalid command given."); } return 0; error: return 1; }
static void check_args(int argc, const char *const argv[], struct passwd_ctx *ctx, int *mask, char **user, char **pwfilename) { const char *arg; int args_left = 2; int i, ret; apr_getopt_t *state; apr_status_t rv; char opt; const char *opt_arg; apr_pool_t *pool = ctx->pool; rv = apr_getopt_init(&state, pool, argc, argv); if (rv != APR_SUCCESS) exit(ERR_SYNTAX); while ((rv = apr_getopt(state, "cnmspdBbDiC:", &opt, &opt_arg)) == APR_SUCCESS) { switch (opt) { case 'c': *mask |= APHTP_NEWFILE; break; case 'n': args_left--; *mask |= APHTP_NOFILE; break; case 'D': *mask |= APHTP_DELUSER; break; default: ret = parse_common_options(ctx, opt, opt_arg); if (ret) { apr_file_printf(errfile, "%s: %s" NL, argv[0], ctx->errstr); exit(ret); } } } if (ctx->passwd_src == PW_ARG) args_left++; if (rv != APR_EOF) usage(); if ((*mask & APHTP_NEWFILE) && (*mask & APHTP_NOFILE)) { apr_file_printf(errfile, "%s: -c and -n options conflict" NL, argv[0]); exit(ERR_SYNTAX); } if ((*mask & APHTP_NEWFILE) && (*mask & APHTP_DELUSER)) { apr_file_printf(errfile, "%s: -c and -D options conflict" NL, argv[0]); exit(ERR_SYNTAX); } if ((*mask & APHTP_NOFILE) && (*mask & APHTP_DELUSER)) { apr_file_printf(errfile, "%s: -n and -D options conflict" NL, argv[0]); exit(ERR_SYNTAX); } /* * Make sure we still have exactly the right number of arguments left * (the filename, the username, and possibly the password if -b was * specified). */ i = state->ind; if ((argc - i) != args_left) { usage(); } if (!(*mask & APHTP_NOFILE)) { if (strlen(argv[i]) > (APR_PATH_MAX - 1)) { apr_file_printf(errfile, "%s: filename too long" NL, argv[0]); exit(ERR_OVERFLOW); } *pwfilename = apr_pstrdup(pool, argv[i++]); } if (strlen(argv[i]) > (MAX_STRING_LEN - 1)) { apr_file_printf(errfile, "%s: username too long (> %d)" NL, argv[0], MAX_STRING_LEN - 1); exit(ERR_OVERFLOW); } *user = apr_pstrdup(pool, argv[i++]); if ((arg = strchr(*user, ':')) != NULL) { apr_file_printf(errfile, "%s: username contains illegal " "character '%c'" NL, argv[0], *arg); exit(ERR_BADUSER); } if (ctx->passwd_src == PW_ARG) { if (strlen(argv[i]) > (MAX_STRING_LEN - 1)) { apr_file_printf(errfile, "%s: password too long (> %d)" NL, argv[0], MAX_STRING_LEN); exit(ERR_OVERFLOW); } ctx->passwd = apr_pstrdup(pool, argv[i]); } }
static svn_error_t * test_svn_opt_args_to_target_array2(const char **msg, svn_boolean_t msg_only, svn_test_opts_t *opts, apr_pool_t *pool) { apr_size_t i; static struct { const char *input; const char *output; /* NULL means an error is expected. */ } const tests[] = { { ".", "" }, { ".@BASE", "@BASE" }, { "foo///bar", "foo/bar" }, { "foo///bar@13", "foo/bar@13" }, { "foo///bar@HEAD", "foo/bar@HEAD" }, { "foo///bar@{1999-12-31}", "foo/bar@{1999-12-31}" }, { "http://a//b////", "http://a/b" }, { "http://a///b@27", "http://a/b@27" }, { "http://a/b//@COMMITTED", "http://a/b@COMMITTED" }, { "foo///bar@1:2", "foo/bar@1:2" }, { "foo///bar@baz", "foo/bar@baz" }, { "foo///bar@", "foo/bar@" }, { "foo///bar///@13", "foo/bar@13" }, { "foo///bar@@13", "foo/bar@@13" }, { "foo///@bar@HEAD", "foo/@bar@HEAD" }, { "foo@///bar", "foo@/bar" }, { "foo@HEAD///bar", "foo@HEAD/bar" }, }; *msg = "test svn_opt_args_to_target_array2"; if (msg_only) return SVN_NO_ERROR; for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) { const char *input = tests[i].input; const char *expected_output = tests[i].output; apr_array_header_t *targets; apr_getopt_t *os; const int argc = 2; const char *argv[3] = { 0 }; apr_status_t apr_err; svn_error_t *err; argv[0] = "opt-test"; argv[1] = input; argv[2] = NULL; apr_err = apr_getopt_init(&os, pool, argc, argv); if (apr_err) return svn_error_wrap_apr(apr_err, "Error initializing command line arguments"); err = svn_opt_args_to_target_array2(&targets, os, NULL, pool); if (expected_output) { const char *actual_output; if (err) return err; if (argc - 1 != targets->nelts) return svn_error_createf(SVN_ERR_TEST_FAILED, NULL, "Passed %d target(s) to " "svn_opt_args_to_target_array2() but " "got %d back.", argc - 1, targets->nelts); actual_output = APR_ARRAY_IDX(targets, 0, const char *); if (! svn_path_is_canonical(actual_output, pool)) return svn_error_createf(SVN_ERR_TEST_FAILED, NULL, "Input '%s' to " "svn_opt_args_to_target_array2() should " "have returned a canonical path but " "'%s' is not.", input, actual_output); if (strcmp(expected_output, actual_output) != 0) return svn_error_createf(SVN_ERR_TEST_FAILED, NULL, "Input '%s' to " "svn_opt_args_to_target_array2() should " "have returned '%s' but returned '%s'.", input, expected_output, actual_output); } else { if (! err) return svn_error_createf(SVN_ERR_TEST_FAILED, NULL, "Unexpected success in passing '%s' " "to svn_opt_args_to_target_array2().", input); } }