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);
}
}
