static void optional_option_notgiven(abts_case *tc, void *data)
{
int largc = 2;
const char * const largv[] = {"testprog", "-a"};
apr_getopt_t *opt;
apr_status_t rv;
char ch;
const char *optarg;
char str[8196];
str[0] = '\0';
rv = apr_getopt_init(&opt, p, largc, largv);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
opt->errfn = unknown_arg;
opt->errarg = str;
while (apr_getopt(opt, "a::", &ch, &optarg) == APR_SUCCESS) {
switch (ch) {
case 'a':
format_arg(str, ch, optarg);
break;
default:
break;
}
}
#if 0
/* Our version of getopt doesn't allow for optional arguments. */
ABTS_STR_EQUAL(tc, "option: a\n", str);
#endif
ABTS_STR_EQUAL(tc, "testprog: option requires an argument -- a\n", str);
}
int test(){
#ifdef APR_FILES_AS_SOCKETS
while ((rv = apr_getopt(opt, "lL:p:ftvec", &c, &opt_arg)) == APR_SUCCESS) {
#else
while ((rv = apr_getopt(opt, "lL:p:ftve", &c, &opt_arg)) == APR_SUCCESS) {
#endif
// code
}
}
static void no_options_found(abts_case *tc, void *data)
{
int largc = 5;
const char * const largv[] = {"testprog", "-a", "-b", "-c", "-d"};
apr_getopt_t *opt;
apr_status_t rv;
char ch;
const char *optarg;
char str[8196];
str[0] = '\0';
rv = apr_getopt_init(&opt, p, largc, largv);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
while (apr_getopt(opt, "abcd", &ch, &optarg) == APR_SUCCESS) {
switch (ch) {
case 'a':
case 'b':
case 'c':
case 'd':
default:
format_arg(str, ch, optarg);
}
}
ABTS_STR_EQUAL(tc, "option: a\n"
"option: b\n"
"option: c\n"
"option: d\n", str);
}
static void required_option(abts_case *tc, void *data)
{
int largc = 3;
const char * const largv[] = {"testprog", "-a", "foo"};
apr_getopt_t *opt;
apr_status_t rv;
char ch;
const char *optarg;
char str[8196];
str[0] = '\0';
rv = apr_getopt_init(&opt, p, largc, largv);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
opt->errfn = unknown_arg;
opt->errarg = str;
while (apr_getopt(opt, "a:", &ch, &optarg) == APR_SUCCESS) {
switch (ch) {
case 'a':
format_arg(str, ch, optarg);
break;
default:
break;
}
}
ABTS_STR_EQUAL(tc, "option: a with foo\n", str);
}
static void no_options(abts_case *tc, void *data)
{
int largc = 5;
const char * const largv[] = {"testprog", "-a", "-b", "-c", "-d"};
apr_getopt_t *opt;
apr_status_t rv;
char ch;
const char *optarg;
char str[8196];
str[0] = '\0';
rv = apr_getopt_init(&opt, p, largc, largv);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
opt->errfn = unknown_arg;
opt->errarg = str;
while (apr_getopt(opt, "efgh", &ch, &optarg) == APR_SUCCESS) {
switch (ch) {
case 'a':
case 'b':
case 'c':
case 'd':
format_arg(str, ch, optarg);
break;
default:
break;
}
}
ABTS_STR_EQUAL(tc, "testprog: illegal option -- a\n", str);
}
void ap_mpm_rewrite_args(process_rec *process)
{
apr_array_header_t *mpm_new_argv;
apr_status_t rv;
apr_getopt_t *opt;
char optbuf[3];
const char *optarg;
mpm_new_argv = apr_array_make(process->pool, process->argc,
sizeof(const char **));
*(const char **)apr_array_push(mpm_new_argv) = process->argv[0];
apr_getopt_init(&opt, process->pool, process->argc, process->argv);
opt->errfn = NULL;
optbuf[0] = '-';
/* option char returned by apr_getopt() will be stored in optbuf[1] */
optbuf[2] = '\0';
while ((rv = apr_getopt(opt, "k:" AP_SERVER_BASEARGS,
optbuf + 1, &optarg)) == APR_SUCCESS) {
switch(optbuf[1]) {
case 'k':
if (!dash_k_arg) {
if (!strcmp(optarg, "start") || !strcmp(optarg, "stop") ||
!strcmp(optarg, "restart") || !strcmp(optarg, "graceful") ||
!strcmp(optarg, "graceful-stop") ||
!strcmp(optarg, "reconfigure") || !strcmp(optarg, "SIGUSR2")) { //amiya 20140217
dash_k_arg = optarg;
break;
}
}
default:
*(const char **)apr_array_push(mpm_new_argv) =
apr_pstrdup(process->pool, optbuf);
if (optarg) {
*(const char **)apr_array_push(mpm_new_argv) = optarg;
}
}
}
/* back up to capture the bad argument */
if (rv == APR_BADCH || rv == APR_BADARG) {
opt->ind--;
}
while (opt->ind < opt->argc) {
*(const char **)apr_array_push(mpm_new_argv) =
apr_pstrdup(process->pool, opt->argv[opt->ind++]);
}
process->argc = mpm_new_argv->nelts;
process->argv = (const char * const *)mpm_new_argv->elts;
if (NULL == dash_k_arg) {
dash_k_arg = dash_k_arg_noarg;
}
APR_REGISTER_OPTIONAL_FN(ap_signal_server);
}
int main(int argc, const char * const *argv)
{
apr_status_t rv;
char errmsg[200];
const char *lockname = "multi.lock";
apr_getopt_t *opt;
char optchar;
const char *optarg;
printf("APR Lock Performance Test\n==============\n\n");
apr_initialize();
atexit(apr_terminate);
if (apr_pool_create(&pool, NULL) != APR_SUCCESS)
exit(-1);
if ((rv = apr_getopt_init(&opt, pool, argc, argv)) != APR_SUCCESS) {
fprintf(stderr, "Could not set up to parse options: [%d] %s\n",
rv, apr_strerror(rv, errmsg, sizeof errmsg));
exit(-1);
}
while ((rv = apr_getopt(opt, "f:", &optchar, &optarg)) == APR_SUCCESS) {
if (optchar == 'f') {
lockname = optarg;
}
}
if (rv != APR_SUCCESS && rv != APR_EOF) {
fprintf(stderr, "Could not parse options: [%d] %s\n",
rv, apr_strerror(rv, errmsg, sizeof errmsg));
exit(-1);
}
for (i = 1; i <= MAX_THREADS; ++i) {
if ((rv = test_thread_mutex(i)) != APR_SUCCESS) {
fprintf(stderr,"thread_mutex test failed : [%d] %s\n",
rv, apr_strerror(rv, (char*)errmsg, 200));
exit(-3);
}
if ((rv = test_thread_mutex_nested(i)) != APR_SUCCESS) {
fprintf(stderr,"thread_mutex (NESTED) test failed : [%d] %s\n",
rv, apr_strerror(rv, (char*)errmsg, 200));
exit(-4);
}
if ((rv = test_thread_rwlock(i)) != APR_SUCCESS) {
fprintf(stderr,"thread_rwlock test failed : [%d] %s\n",
rv, apr_strerror(rv, (char*)errmsg, 200));
exit(-6);
}
}
return 0;
}
int test(){
while ((status = apr_getopt(opt, "n:c:t:b:T:p:u:v:rkVhwix:y:z:C:H:P:A:g:X:de:SqB:"
#ifdef USE_SSL
"Z:f:"
#endif
,&c, &opt_arg)) == APR_SUCCESS) {
// code
}
}
static void init_params(apr_uint32_t *seed,
apr_uint32_t *maxlen, int *iterations,
int *dump_files, int *print_windows,
const char **random_bytes,
apr_uint32_t *bytes_range,
apr_pool_t *pool)
{
apr_getopt_t *opt;
char optch;
const char *opt_arg;
apr_status_t status;
*seed = (apr_uint32_t) apr_time_now();
*maxlen = DEFAULT_MAXLEN;
*iterations = DEFAULT_ITERATIONS;
*dump_files = DEFAULT_DUMP_FILES;
*print_windows = DEFAULT_PRINT_WINDOWS;
*random_bytes = NULL;
*bytes_range = 256;
apr_getopt_init(&opt, pool, test_argc, test_argv);
while (APR_SUCCESS
== (status = apr_getopt(opt, "s:l:n:r:FW", &optch, &opt_arg)))
{
switch (optch)
{
case 's':
*seed = atol(opt_arg);
break;
case 'l':
*maxlen = atoi(opt_arg);
break;
case 'n':
*iterations = atoi(opt_arg);
break;
case 'r':
*random_bytes = opt_arg + 1;
*bytes_range = strlen(*random_bytes);
break;
case 'F':
*dump_files = !*dump_files;
break;
case 'W':
*print_windows = !*print_windows;
break;
}
}
}
int main(int argc, const char * const *argv)
{
int reader = 0;
apr_status_t status;
char optchar;
const char *optarg;
apr_getopt_t *opt;
if (apr_initialize() != APR_SUCCESS)
errmsg("Could not initialize APR.\n");
atexit(apr_terminate);
if (apr_pool_create(&pool, NULL) != APR_SUCCESS)
errmsg("Could not create global pool.\n");
if (apr_getopt_init(&opt, pool, argc, argv) != APR_SUCCESS)
errmsg("Could not parse options.\n");
while ((status = apr_getopt(opt, "rf:", &optchar, &optarg)) == APR_SUCCESS) {
if (optchar == 'r')
++reader;
else if (optchar == 'f')
testfile = optarg;
}
if (status != APR_SUCCESS && status != APR_EOF) {
char msgbuf[80];
fprintf(stderr, "error: %s\n",
apr_strerror(status, msgbuf, sizeof msgbuf));
exit(1);
}
if (reader)
do_read();
else
do_write();
return 0;
}
int main(int argc, const char * const argv[])
{
apr_file_t *infd, *skwrapper;
apr_sockaddr_t *skaddr;
apr_getopt_t *gopt;
apr_socket_t *skt;
apr_pool_t *pool;
apr_status_t rv;
apr_proc_t proc;
/* Command line arguments */
int num_to_start = 1, port = 0;
const char *interface = NULL;
const char *command = NULL;
apr_app_initialize(&argc, &argv, NULL);
atexit(apr_terminate);
apr_pool_create(&pool, NULL);
rv = apr_getopt_init(&gopt, pool, argc, argv);
if (rv) {
return EXIT_FAILURE;
}
for (;;) {
const char *arg;
char opt;
rv = apr_getopt(gopt, "c:p:i:N:", &opt, &arg);
if (APR_STATUS_IS_EOF(rv)) {
break;
} else if (rv) {
usage();
} else {
switch (opt) {
case 'c':
command = arg;
break;
case 'p':
port = atoi(arg);
if (! port) {
usage();
}
break;
case 'i':
interface = arg;
break;
case 'N':
num_to_start = atoi(arg);
if (! num_to_start) {
usage();
}
break;
default:
break;
}
}
}
if (! command || ! port) {
usage();
}
rv = apr_sockaddr_info_get(&skaddr, interface, APR_UNSPEC, port, 0, pool);
if (rv) {
exit_error(rv, "apr_sockaddr_info_get");
}
rv = apr_socket_create(&skt, skaddr->family, SOCK_STREAM, APR_PROTO_TCP, pool);
if (rv) {
exit_error(rv, "apr_socket_create");
}
rv = apr_socket_bind(skt, skaddr);
if (rv) {
exit_error(rv, "apr_socket_bind");
}
rv = apr_socket_listen(skt, 1024);
if (rv) {
exit_error(rv, "apr_socket_listen");
}
rv = apr_proc_detach(APR_PROC_DETACH_DAEMONIZE);
if (rv) {
exit_error(rv, "apr_proc_detach");
}
#if defined(WIN32) || defined(OS2) || defined(NETWARE)
#error "Please implement me."
#else
while (--num_to_start >= 0) {
rv = apr_proc_fork(&proc, pool);
if (rv == APR_INCHILD) {
apr_os_file_t oft = 0;
apr_os_sock_t oskt;
/* Ok, so we need a file that has file descriptor 0 (which
* FastCGI wants), but points to our socket. This isn't really
* possible in APR, so we cheat a bit. I have no idea how to
* do this on a non-unix platform, so for now this is platform
* specific. Ick.
*
* Note that this has to happen post-detach, otherwise fd 0
* gets closed during apr_proc_detach and it's all for nothing.
*
* Unfortunately, doing this post detach means we have no way
* to let anyone know if there's a problem at this point :( */
rv = apr_os_file_put(&infd, &oft, APR_READ | APR_WRITE, pool);
if (rv) {
exit(EXIT_FAILURE);
}
rv = apr_os_sock_get(&oskt, skt);
if (rv) {
exit(EXIT_FAILURE);
}
rv = apr_os_file_put(&skwrapper, &oskt, APR_READ | APR_WRITE,
pool);
if (rv) {
exit(EXIT_FAILURE);
}
rv = apr_file_dup2(infd, skwrapper, pool);
if (rv) {
exit(EXIT_FAILURE);
}
/* XXX Can't use apr_proc_create because there's no way to get
* infd into the procattr without going through another dup2,
* which means by the time it gets to the fastcgi process it
* is no longer fd 0, so it doesn't work. Sigh. */
execl(command, command, NULL);
} else if (rv == APR_INPARENT) {
if (num_to_start == 0) {
apr_socket_close(skt);
}
} else {
exit_error(rv, "apr_proc_fork");
}
}
#endif
return EXIT_SUCCESS;
}
int main(int argc, const char * const argv[])
{
apr_pool_t *pool;
apr_status_t rv;
char errbuf[MAX_STRING_LEN];
int need_file = 1;
int need_user = 1;
int need_pwd = 1;
int need_cmnt = 0;
int changed = 0;
int cmd = HTDBM_MAKE;
int i, ret, args_left = 2;
apr_getopt_t *state;
char opt;
const char *opt_arg;
apr_app_initialize(&argc, &argv, NULL);
atexit(terminate);
if ((rv = htdbm_init(&pool, &h)) != APR_SUCCESS) {
fprintf(stderr, "Unable to initialize htdbm terminating!\n");
apr_strerror(rv, errbuf, sizeof(errbuf));
exit(1);
}
rv = apr_getopt_init(&state, pool, argc, argv);
if (rv != APR_SUCCESS)
exit(ERR_SYNTAX);
while ((rv = apr_getopt(state, "cnmspdBbDivxlC:T:", &opt, &opt_arg)) == APR_SUCCESS) {
switch (opt) {
case 'c':
h->create = 1;
break;
case 'n':
need_file = 0;
cmd = HTDBM_NOFILE;
args_left--;
break;
case 'l':
need_pwd = 0;
need_user = 0;
cmd = HTDBM_LIST;
h->rdonly = 1;
args_left--;
break;
case 't':
need_cmnt = 1;
args_left++;
break;
case 'T':
h->type = apr_pstrdup(h->ctx.pool, opt_arg);
break;
case 'v':
h->rdonly = 1;
cmd = HTDBM_VERIFY;
break;
case 'x':
need_pwd = 0;
cmd = HTDBM_DELETE;
break;
default:
ret = parse_common_options(&h->ctx, opt, opt_arg);
if (ret) {
fprintf(stderr, "Error: %s\n", h->ctx.errstr);
exit(ret);
}
}
}
if (h->ctx.passwd_src == PW_ARG) {
need_pwd = 0;
args_left++;
}
/*
* 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 (rv != APR_EOF || argc - i != args_left)
htdbm_usage();
if (need_file) {
h->filename = apr_pstrdup(h->ctx.pool, argv[i++]);
if ((rv = htdbm_open(h)) != APR_SUCCESS) {
fprintf(stderr, "Error opening database %s\n", h->filename);
apr_strerror(rv, errbuf, sizeof(errbuf));
fprintf(stderr,"%s\n",errbuf);
exit(ERR_FILEPERM);
}
}
if (need_user) {
h->username = apr_pstrdup(pool, argv[i++]);
if (htdbm_valid_username(h) != APR_SUCCESS)
exit(ERR_BADUSER);
}
if (h->ctx.passwd_src == PW_ARG)
h->ctx.passwd = apr_pstrdup(pool, argv[i++]);
if (need_pwd) {
ret = get_password(&h->ctx);
if (ret) {
fprintf(stderr, "Error: %s\n", h->ctx.errstr);
exit(ret);
}
}
if (need_cmnt)
h->comment = apr_pstrdup(pool, argv[i++]);
switch (cmd) {
case HTDBM_VERIFY:
if ((rv = htdbm_verify(h)) != APR_SUCCESS) {
if (APR_STATUS_IS_ENOENT(rv)) {
fprintf(stderr, "The user '%s' could not be found in database\n", h->username);
exit(ERR_BADUSER);
}
else {
fprintf(stderr, "Password mismatch for user '%s'\n", h->username);
exit(ERR_PWMISMATCH);
}
}
else
fprintf(stderr, "Password validated for user '%s'\n", h->username);
break;
case HTDBM_DELETE:
if (htdbm_del(h) != APR_SUCCESS) {
fprintf(stderr, "Cannot find user '%s' in database\n", h->username);
exit(ERR_BADUSER);
}
h->username = NULL;
changed = 1;
break;
case HTDBM_LIST:
htdbm_list(h);
break;
default:
ret = htdbm_make(h);
if (ret)
exit(ret);
break;
}
if (need_file && !h->rdonly) {
if ((rv = htdbm_save(h, &changed)) != APR_SUCCESS) {
apr_strerror(rv, errbuf, sizeof(errbuf));
exit(ERR_FILEPERM);
}
fprintf(stdout, "Database %s %s.\n", h->filename,
h->create ? "created" : (changed ? "modified" : "updated"));
}
if (cmd == HTDBM_NOFILE) {
if (!need_cmnt) {
fprintf(stderr, "%s:%s\n", h->username, h->ctx.passwd);
}
else {
fprintf(stderr, "%s:%s:%s\n", h->username, h->ctx.passwd,
h->comment);
}
}
htdbm_terminate(h);
return 0; /* Suppress compiler warning. */
}
int Main(int argc, char const * const argv[], char const * const envp[]) {
_aprcall(apr_initialize());
apr_pool_t *pool;
apr_pool_create(&pool, NULL);
bool tty(isatty(STDIN_FILENO));
bool compile(false);
CYOptions options;
append_history$ = (int (*)(int, const char *)) (dlsym(RTLD_DEFAULT, "append_history"));
#ifdef CY_ATTACH
pid_t pid(_not(pid_t));
#endif
const char *host(NULL);
const char *port(NULL);
apr_getopt_t *state;
_aprcall(apr_getopt_init(&state, pool, argc, argv));
for (;;) {
char opt;
const char *arg;
apr_status_t status(apr_getopt(state,
"cg:n:"
#ifdef CY_ATTACH
"p:"
#endif
"r:"
"s"
, &opt, &arg));
switch (status) {
case APR_EOF:
goto getopt;
case APR_BADCH:
case APR_BADARG:
fprintf(stderr,
"usage: cycript [-c]"
#ifdef CY_ATTACH
" [-p <pid|name>]"
#endif
" [-r <host:port>]"
" [<script> [<arg>...]]\n"
);
return 1;
default:
_aprcall(status);
}
switch (opt) {
case 'c':
compile = true;
break;
case 'g':
if (false);
else if (strcmp(arg, "rename") == 0)
options.verbose_ = true;
#if YYDEBUG
else if (strcmp(arg, "bison") == 0)
bison_ = true;
#endif
else {
fprintf(stderr, "invalid name for -g\n");
return 1;
}
break;
case 'n':
if (false);
else if (strcmp(arg, "minify") == 0)
pretty_ = true;
else {
fprintf(stderr, "invalid name for -n\n");
return 1;
}
break;
#ifdef CY_ATTACH
case 'p': {
size_t size(strlen(arg));
char *end;
pid = strtoul(arg, &end, 0);
if (arg + size != end) {
// XXX: arg needs to be escaped in some horrendous way of doom
const char *command(apr_pstrcat(pool, "ps axc|sed -e '/^ *[0-9]/{s/^ *\\([0-9]*\\)\\( *[^ ]*\\)\\{3\\} *-*\\([^ ]*\\)/\\3 \\1/;/^", arg, " /{s/^[^ ]* //;q;};};d'", NULL));
if (FILE *pids = popen(command, "r")) {
char value[32];
size = 0;
for (;;) {
size_t read(fread(value + size, 1, sizeof(value) - size, pids));
if (read == 0)
break;
else {
size += read;
if (size == sizeof(value)) {
pid = _not(pid_t);
goto fail;
}
}
}
size:
if (size == 0)
goto fail;
if (value[size - 1] == '\n') {
--size;
goto size;
}
value[size] = '\0';
size = strlen(value);
pid = strtoul(value, &end, 0);
if (value + size != end) fail:
pid = _not(pid_t);
_syscall(pclose(pids));
}
if (pid == _not(pid_t)) {
fprintf(stderr, "invalid pid for -p\n");
return 1;
}
}
} break;
#endif
case 'r': {
//size_t size(strlen(arg));
char *colon(strrchr(arg, ':'));
if (colon == NULL) {
fprintf(stderr, "missing colon in hostspec\n");
return 1;
}
/*char *end;
port = strtoul(colon + 1, &end, 10);
if (end != arg + size) {
fprintf(stderr, "invalid port in hostspec\n");
return 1;
}*/
host = arg;
*colon = '\0';
port = colon + 1;
} break;
case 's':
strict_ = true;
break;
}
} getopt:;
const char *script;
int ind(state->ind);
#ifdef CY_ATTACH
if (pid != _not(pid_t) && ind < argc - 1) {
fprintf(stderr, "-p cannot set argv\n");
return 1;
}
if (pid != _not(pid_t) && compile) {
fprintf(stderr, "-p conflicts with -c\n");
return 1;
}
#endif
if (ind == argc)
script = NULL;
else {
#ifdef CY_EXECUTE
// XXX: const_cast?! wtf gcc :(
CYSetArgs(argc - ind - 1, const_cast<const char **>(argv + ind + 1));
#endif
script = argv[ind];
if (strcmp(script, "-") == 0)
script = NULL;
}
#ifdef CY_ATTACH
if (pid != _not(pid_t) && script == NULL && !tty) {
fprintf(stderr, "non-terminal attaching to remote console\n");
return 1;
}
#endif
#ifdef CY_ATTACH
if (pid == _not(pid_t))
client_ = -1;
else {
int server(_syscall(socket(PF_UNIX, SOCK_STREAM, 0))); try {
struct sockaddr_un address;
memset(&address, 0, sizeof(address));
address.sun_family = AF_UNIX;
sprintf(address.sun_path, "/tmp/.s.cy.%u", getpid());
_syscall(bind(server, reinterpret_cast<sockaddr *>(&address), SUN_LEN(&address)));
_syscall(chmod(address.sun_path, 0777));
try {
_syscall(listen(server, 1));
InjectLibrary(pid);
client_ = _syscall(accept(server, NULL, NULL));
} catch (...) {
// XXX: exception?
unlink(address.sun_path);
throw;
}
} catch (...) {
_syscall(close(server));
throw;
}
}
#else
client_ = -1;
#endif
if (client_ == -1 && host != NULL && port != NULL) {
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = 0;
hints.ai_flags = 0;
struct addrinfo *infos;
_syscall(getaddrinfo(host, port, &hints, &infos));
_assert(infos != NULL); try {
for (struct addrinfo *info(infos); info != NULL; info = info->ai_next) {
int client(_syscall(socket(info->ai_family, info->ai_socktype, info->ai_protocol))); try {
_syscall(connect(client, info->ai_addr, info->ai_addrlen));
client_ = client;
break;
} catch (...) {
_syscall(close(client));
throw;
}
}
} catch (...) {
freeaddrinfo(infos);
throw;
}
}
if (script == NULL && tty)
Console(options);
else {
CYLocalPool pool;
char *start, *end;
std::istream *indirect;
if (script == NULL) {
start = NULL;
end = NULL;
indirect = &std::cin;
} else {
size_t size;
start = reinterpret_cast<char *>(Map(script, &size));
end = start + size;
if (size >= 2 && start[0] == '#' && start[1] == '!') {
start += 2;
if (void *line = memchr(start, '\n', end - start))
start = reinterpret_cast<char *>(line);
else
start = end;
}
indirect = NULL;
}
CYStream direct(start, end);
std::istream &stream(indirect == NULL ? direct : *indirect);
CYDriver driver(stream, script ?: "<stdin>");
cy::parser parser(driver);
Setup(driver, parser);
if (parser.parse() != 0 || !driver.errors_.empty()) {
for (CYDriver::Errors::const_iterator i(driver.errors_.begin()); i != driver.errors_.end(); ++i)
std::cerr << i->location_.begin << ": " << i->message_ << std::endl;
} else if (driver.program_ != NULL)
if (client_ != -1) {
// XXX: this code means that you can't pipe to another process
std::string code(start, end-start);
Run(client_, false, code, &std::cout);
} else {
std::ostringstream str;
CYOutput out(str, options);
Setup(out, driver, options);
out << *driver.program_;
std::string code(str.str());
if (compile)
std::cout << code;
else
Run(client_, false, code, &std::cout);
}
}
apr_pool_destroy(pool);
return 0;
}
int main(int argc, const char *const argv[])
{
apr_pool_t *pool;
apr_status_t rv = APR_SUCCESS;
apr_getopt_t *opt;
const char *opt_arg;
char ch;
apr_file_t *infile;
apr_dbm_t *outdbm;
apr_app_initialize(&argc, &argv, NULL);
atexit(apr_terminate);
verbose = 0;
format = NULL;
input = NULL;
output = NULL;
apr_pool_create(&pool, NULL);
if (argc) {
shortname = apr_filepath_name_get(argv[0]);
}
else {
shortname = "httxt2dbm";
}
apr_file_open_stderr(&errfile, pool);
rv = apr_getopt_init(&opt, pool, argc, argv);
if (rv != APR_SUCCESS) {
apr_file_printf(errfile, "Error: apr_getopt_init failed."NL NL);
return 1;
}
if (argc <= 1) {
usage();
return 1;
}
while ((rv = apr_getopt(opt, "vf::i::o::", &ch, &opt_arg)) == APR_SUCCESS) {
switch (ch) {
case 'v':
if (verbose) {
apr_file_printf(errfile, "Error: -v can only be passed once" NL NL);
usage();
return 1;
}
verbose = 1;
break;
case 'f':
if (format) {
apr_file_printf(errfile, "Error: -f can only be passed once" NL NL);
usage();
return 1;
}
format = apr_pstrdup(pool, opt_arg);
break;
case 'i':
if (input) {
apr_file_printf(errfile, "Error: -i can only be passed once" NL NL);
usage();
return 1;
}
input = apr_pstrdup(pool, opt_arg);
break;
case 'o':
if (output) {
apr_file_printf(errfile, "Error: -o can only be passed once" NL NL);
usage();
return 1;
}
output = apr_pstrdup(pool, opt_arg);
break;
}
}
if (rv != APR_EOF) {
apr_file_printf(errfile, "Error: Parsing Arguments Failed" NL NL);
usage();
return 1;
}
if (!input) {
apr_file_printf(errfile, "Error: No input file specified." NL NL);
usage();
return 1;
}
if (!output) {
apr_file_printf(errfile, "Error: No output DBM specified." NL NL);
usage();
return 1;
}
if (!format) {
format = "default";
}
if (verbose) {
apr_file_printf(errfile, "DBM Format: %s"NL, format);
}
if (!strcmp(input, "-")) {
rv = apr_file_open_stdin(&infile, pool);
}
else {
rv = apr_file_open(&infile, input, APR_READ|APR_BUFFERED,
APR_OS_DEFAULT, pool);
}
if (rv != APR_SUCCESS) {
apr_file_printf(errfile,
"Error: Cannot open input file '%s': (%d) %s" NL NL,
input, rv, apr_strerror(rv, errbuf, sizeof(errbuf)));
return 1;
}
if (verbose) {
apr_file_printf(errfile, "Input File: %s"NL, input);
}
rv = apr_dbm_open_ex(&outdbm, format, output, APR_DBM_RWCREATE,
APR_OS_DEFAULT, pool);
if (APR_STATUS_IS_ENOTIMPL(rv)) {
apr_file_printf(errfile,
"Error: The requested DBM Format '%s' is not available." NL NL,
format);
return 1;
}
if (rv != APR_SUCCESS) {
apr_file_printf(errfile,
"Error: Cannot open output DBM '%s': (%d) %s" NL NL,
output, rv, apr_strerror(rv, errbuf, sizeof(errbuf)));
return 1;
}
if (verbose) {
apr_file_printf(errfile, "DBM File: %s"NL, output);
}
rv = to_dbm(outdbm, infile, pool);
if (rv != APR_SUCCESS) {
apr_file_printf(errfile,
"Error: Converting to DBM: (%d) %s" NL NL,
rv, apr_strerror(rv, errbuf, sizeof(errbuf)));
return 1;
}
apr_dbm_close(outdbm);
if (verbose) {
apr_file_printf(errfile, "Conversion Complete." NL);
}
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;
}
int main(int argc, const char * const argv[])
{
char c;
const char *ap_confname = "httpd.conf";
const char *ngx_confname = "nginx.conf";
const char *def_server_root = NULL;
const char *temp_error_log = NULL;
const char *error;
process_rec *process;
server_rec *server_conf;
apr_pool_t *pglobal;
apr_pool_t *pconf;
apr_pool_t *plog; /* Pool of log streams, reset _after_ each read of conf */
apr_pool_t *ptemp; /* Pool for temporary config stuff, reset often */
apr_pool_t *pcommands; /* Pool for -D, -C and -c switches */
apr_getopt_t *opt;
apr_status_t rv;
const char *optarg;
AP_MONCONTROL(0); /* turn off profiling of startup */
process = init_process(&argc, &argv);
pglobal = process->pool;
pconf = process->pconf;
ap_server_argv0 = process->short_name;
#if APR_CHARSET_EBCDIC
if (ap_init_ebcdic(pglobal) != APR_SUCCESS) {
destroy_and_exit_process(process, 1);
}
#endif
apr_pool_create(&pcommands, pglobal);
apr_pool_tag(pcommands, "pcommands");
ap_server_pre_read_config = apr_array_make(pcommands, 1, sizeof(char *));
ap_server_post_read_config = apr_array_make(pcommands, 1, sizeof(char *));
ap_server_config_defines = apr_array_make(pcommands, 1, sizeof(char *));
error = ap_setup_prelinked_modules(process);
if (error) {
ap_log_error(APLOG_MARK, APLOG_STARTUP|APLOG_EMERG, 0, NULL, "%s: %s",
ap_server_argv0, error);
destroy_and_exit_process(process, 1);
}
ap_run_rewrite_args(process);
/* Maintain AP_SERVER_BASEARGS list in http_main.h to allow the MPM
* to safely pass on our args from its rewrite_args() handler.
*/
apr_getopt_init(&opt, pcommands, process->argc, process->argv);
while ((rv = apr_getopt(opt, APN_SERVER_BASEARGS, &c, &optarg))
== APR_SUCCESS) {
switch (c) {
case 'f':
ap_confname = optarg;
break;
case 'o':
ngx_confname = optarg;
break;
case 'd':
def_server_root = optarg;
break;
case 'l':
ap_show_modules();
destroy_and_exit_process(process, 0);
case 'L':
ap_show_directives();
destroy_and_exit_process(process, 0);
case 'h':
case '?':
usage(process);
destroy_and_exit_process(process, 0);
case 'H':
setconf = 1;
confname = optarg;
break;
case 'i':
defindex = 1;
break;
case 'G':
defgzip = 1;
break;
case 'D':
cleancfg = 1;
break;
case 'R':
forcerm = 1;
break;
}
}
if (rv != APR_EOF || argc < 3) {
if (c != 'h' && c != '?') {
usage(process);
}
destroy_and_exit_process(process, 1);
}
apr_pool_create(&plog, pglobal);
apr_pool_tag(plog, "plog");
apr_pool_create(&ptemp, pconf);
apr_pool_tag(ptemp, "ptemp");
/** we need the real path */
char* fullpath = NULL;
rv = apr_get_realpath(&fullpath, ap_confname, plog);
if (rv != APR_SUCCESS){
apn_error("Apache conf file is not found "
"or the given path is invalid! Exit.\n");
destroy_and_exit_process(process, 1);
}
ap_confname = apr_pstrdup(plog, fullpath);
/* Note that we preflight the config file once
* before reading it _again_ in the main loop.
* This allows things, log files configuration
* for example, to settle down.
*/
ap_server_root = def_server_root;
if (!ap_server_root){ // no specify serverroot by -d in commandline.
if (!ap_confname) {
apn_error("Apache conf file name is null!\n");
destroy_and_exit_process(process, 1);
}
/**
* if ap_confname is absolute path, get the prefix as serverroot.
* if it is not, set the current path as serverroot.
*/
char* basedir;
rv = apr_get_basedir(&basedir, ap_confname, process->pool);
if(rv!=APR_SUCCESS){
apn_error("Apache conf file is not found "
"or the given path is invalid! Exit.\n");
destroy_and_exit_process(process, 1);
}
ap_server_root = def_server_root = basedir;
/**
* Sometimes, ap_server_root should be set more intelligence.
* Because of apache conf depend on the ServerRoot.
* when not in localhost, maybe ServerRoot is not valid,
* and here need to guess the ap_server_root.
*/
apn_fixed_server_root(plog);
}
if (temp_error_log) {
ap_replace_stderr_log(process->pool, temp_error_log);
}
char *ngx_fullpath = NULL;
rv = apr_get_realpath(&ngx_fullpath, ngx_confname, plog);
if (rv == APR_SUCCESS && forcerm != 1) {
apn_error("Config file exists: %s. Exit.\n", ngx_fullpath);
destroy_and_exit_process(process, 1);
} else {
/* Create a empty nginx.conf, because mod_mime needs this file. */
apr_file_t *f;
rv = apr_file_open(&f, ngx_confname,
(forcerm == 1 ? APR_TRUNCATE : APR_CREATE ) |APR_APPEND|APR_WRITE,
APR_OS_DEFAULT, plog);
if (rv != APR_SUCCESS) {
apn_error("Create file error: %s\n", ngx_fullpath);
destroy_and_exit_process(process, 1);
}
apr_file_close(f);
}
/*
* here just create the main server, and the vhost is not created.
*/
server_conf = ap_read_config(process, ptemp, ap_confname, &ap_conftree);
if (!server_conf) {
destroy_and_exit_process(process, 1);
}
/* sort hooks here to make sure pre_config hooks are sorted properly */
apr_hook_sort_all();
if (ap_run_pre_config(pconf, plog, ptemp) != OK) {
ap_log_error(APLOG_MARK, APLOG_STARTUP |APLOG_ERR, 0,
NULL, "Pre-configuration failed");
destroy_and_exit_process(process, 1);
}
/* Lijinhu added : check the configuration validation */
if (ap_conftree == NULL) {
apn_error("The apache conf file is invalid! Please check it. Exit.\n");
destroy_and_exit_process(process, 1);
}
rv = ap_process_config_tree(server_conf, ap_conftree,
process->pconf, ptemp);
if (rv == OK) {
/*
* 1. merge server configs.
* 2. merge per dir configs for each server.
* 3. re-order the directorise.
*/
ap_fixup_virtual_hosts(pconf, server_conf);
/* compile the tables and such we need to do the run-time vhost lookups */
ap_fini_vhost_config(pconf, server_conf);
/*
* Sort hooks again because ap_process_config_tree may have added
* modules and hence hooks. This happens with mod_perl and modules
* written in perl.
*/
apr_hook_sort_all();
ap_run_test_config(pconf, server_conf);
ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, "Syntax OK");
if ( ap_run_post_config(pconf, plog, ptemp, server_conf) != OK) {
ap_log_error(APLOG_MARK, APLOG_STARTUP |APLOG_ERR, 0,
NULL, "Failed when merge some configurations");
destroy_and_exit_process(process, 1);
}
/*
* migrate the config to nginx conf format.
* generate the conf file of nginx.
*/
rv = apn_migrate_to_nginx(plog, server_conf, ngx_confname);
if (rv != OK) {
ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, "Migrate Error!");
}
destroy_and_exit_process(process, 0);
}
return 0; /* Termination 'ok' */
}
int main (int argc, const char * const argv[])
{
char buf[BUFSIZE];
apr_size_t nRead, nWrite;
apr_file_t *f_stdin;
apr_file_t *f_stdout;
apr_getopt_t *opt;
apr_status_t rv;
char c;
const char *opt_arg;
const char *err = NULL;
#if APR_FILES_AS_SOCKETS
apr_pollfd_t pollfd = { 0 };
apr_status_t pollret = APR_SUCCESS;
int polltimeout;
#endif
apr_app_initialize(&argc, &argv, NULL);
atexit(apr_terminate);
memset(&config, 0, sizeof config);
memset(&status, 0, sizeof status);
status.rotateReason = ROTATE_NONE;
apr_pool_create(&status.pool, NULL);
apr_getopt_init(&opt, status.pool, argc, argv);
#if APR_FILES_AS_SOCKETS
while ((rv = apr_getopt(opt, "lL:p:ftvecn:", &c, &opt_arg)) == APR_SUCCESS) {
#else
while ((rv = apr_getopt(opt, "lL:p:ftven:", &c, &opt_arg)) == APR_SUCCESS) {
#endif
switch (c) {
case 'l':
config.use_localtime = 1;
break;
case 'L':
config.linkfile = opt_arg;
break;
case 'p':
config.postrotate_prog = opt_arg;
break;
case 'f':
config.force_open = 1;
break;
case 't':
config.truncate = 1;
break;
case 'v':
config.verbose = 1;
break;
case 'e':
config.echo = 1;
break;
#if APR_FILES_AS_SOCKETS
case 'c':
config.create_empty = 1;
break;
#endif
case 'n':
config.num_files = atoi(opt_arg);
status.fileNum = -1;
break;
}
}
if (rv != APR_EOF) {
usage(argv[0], NULL /* specific error message already issued */ );
}
/*
* After the initial flags we need 2 to 4 arguments,
* the file name, either the rotation interval time or size
* or both of them, and optionally the UTC offset.
*/
if ((argc - opt->ind < 2) || (argc - opt->ind > 4) ) {
usage(argv[0], "Incorrect number of arguments");
}
config.szLogRoot = argv[opt->ind++];
/* Read in the remaining flags, namely time, size and UTC offset. */
for(; opt->ind < argc; opt->ind++) {
if ((err = get_time_or_size(&config, argv[opt->ind],
opt->ind < argc - 1 ? 0 : 1)) != NULL) {
usage(argv[0], err);
}
}
config.use_strftime = (strchr(config.szLogRoot, '%') != NULL);
if (config.use_strftime && config.num_files > 0) {
fprintf(stderr, "Cannot use -n with %% in filename\n");
exit(1);
}
if (status.fileNum == -1 && config.num_files < 1) {
fprintf(stderr, "Invalid -n argument\n");
exit(1);
}
if (apr_file_open_stdin(&f_stdin, status.pool) != APR_SUCCESS) {
fprintf(stderr, "Unable to open stdin\n");
exit(1);
}
if (apr_file_open_stdout(&f_stdout, status.pool) != APR_SUCCESS) {
fprintf(stderr, "Unable to open stdout\n");
exit(1);
}
/*
* Write out result of config parsing if verbose is set.
*/
if (config.verbose) {
dumpConfig(&config);
}
#if APR_FILES_AS_SOCKETS
if (config.create_empty && config.tRotation) {
pollfd.p = status.pool;
pollfd.desc_type = APR_POLL_FILE;
pollfd.reqevents = APR_POLLIN;
pollfd.desc.f = f_stdin;
}
#endif
/*
* Immediately open the logfile as we start, if we were forced
* to do so via '-f'.
*/
if (config.force_open) {
doRotate(&config, &status);
}
for (;;) {
nRead = sizeof(buf);
#if APR_FILES_AS_SOCKETS
if (config.create_empty && config.tRotation) {
polltimeout = status.tLogEnd ? status.tLogEnd - get_now(&config) : config.tRotation;
if (polltimeout <= 0) {
pollret = APR_TIMEUP;
}
else {
pollret = apr_poll(&pollfd, 1, &pollret, apr_time_from_sec(polltimeout));
}
}
if (pollret == APR_SUCCESS) {
rv = apr_file_read(f_stdin, buf, &nRead);
if (APR_STATUS_IS_EOF(rv)) {
break;
}
else if (rv != APR_SUCCESS) {
exit(3);
}
}
else if (pollret == APR_TIMEUP) {
*buf = 0;
nRead = 0;
}
else {
fprintf(stderr, "Unable to poll stdin\n");
exit(5);
}
#else /* APR_FILES_AS_SOCKETS */
rv = apr_file_read(f_stdin, buf, &nRead);
if (APR_STATUS_IS_EOF(rv)) {
break;
}
else if (rv != APR_SUCCESS) {
exit(3);
}
#endif /* APR_FILES_AS_SOCKETS */
checkRotate(&config, &status);
if (status.rotateReason != ROTATE_NONE) {
doRotate(&config, &status);
}
nWrite = nRead;
rv = apr_file_write_full(status.current.fd, buf, nWrite, &nWrite);
if (nWrite != nRead) {
apr_off_t cur_offset;
cur_offset = 0;
if (apr_file_seek(status.current.fd, APR_CUR, &cur_offset) != APR_SUCCESS) {
cur_offset = -1;
}
status.nMessCount++;
apr_snprintf(status.errbuf, sizeof status.errbuf,
"Error %d writing to log file at offset %" APR_OFF_T_FMT ". "
"%10d messages lost (%pm)\n",
rv, cur_offset, status.nMessCount, &rv);
truncate_and_write_error(&status);
}
else {
status.nMessCount++;
}
if (config.echo) {
if (apr_file_write_full(f_stdout, buf, nRead, &nWrite)) {
fprintf(stderr, "Unable to write to stdout\n");
exit(4);
}
}
}
return 0; /* reached only at stdin EOF. */
}
static void netware_rewrite_args(process_rec *process)
{
char *def_server_root;
char optbuf[3];
const char *opt_arg;
apr_getopt_t *opt;
apr_array_header_t *mpm_new_argv;
atexit (mpm_term);
InstallConsoleHandler();
/* Make sure to hold the Apache screen open if exit() is called */
hold_screen_on_exit = 1;
/* Rewrite process->argv[];
*
* add default -d serverroot from the path of this executable
*
* The end result will look like:
* The -d serverroot default from the running executable
*/
if (process->argc > 0) {
char *s = apr_pstrdup (process->pconf, process->argv[0]);
if (s) {
int i, len = strlen(s);
for (i=len; i; i--) {
if (s[i] == '\\' || s[i] == '/') {
s[i] = '\0';
apr_filepath_merge(&def_server_root, NULL, s,
APR_FILEPATH_TRUENAME, process->pool);
break;
}
}
/* Use process->pool so that the rewritten argv
* lasts for the lifetime of the server process,
* because pconf will be destroyed after the
* initial pre-flight of the config parser.
*/
mpm_new_argv = apr_array_make(process->pool, process->argc + 2,
sizeof(const char *));
*(const char **)apr_array_push(mpm_new_argv) = process->argv[0];
*(const char **)apr_array_push(mpm_new_argv) = "-d";
*(const char **)apr_array_push(mpm_new_argv) = def_server_root;
optbuf[0] = '-';
optbuf[2] = '\0';
apr_getopt_init(&opt, process->pool, process->argc, process->argv);
while (apr_getopt(opt, AP_SERVER_BASEARGS"n:", optbuf + 1, &opt_arg) == APR_SUCCESS) {
switch (optbuf[1]) {
case 'n':
if (opt_arg) {
renamescreen(opt_arg);
}
break;
case 'E':
/* Don't need to hold the screen open if the output is going to a file */
hold_screen_on_exit = -1;
default:
*(const char **)apr_array_push(mpm_new_argv) =
apr_pstrdup(process->pool, optbuf);
if (opt_arg) {
*(const char **)apr_array_push(mpm_new_argv) = opt_arg;
}
break;
}
}
process->argc = mpm_new_argv->nelts;
process->argv = (const char * const *) mpm_new_argv->elts;
}
}
}
int main(int argc, const char **argv)
{
apr_status_t status;
apr_pool_t *pool;
apr_sockaddr_t *address;
serf_context_t *context;
serf_connection_t *connection;
app_baton_t app_ctx;
handler_baton_t *handler_ctx;
apr_uri_t url;
const char *raw_url, *method;
int count;
apr_getopt_t *opt;
char opt_c;
char *authn = NULL;
const char *opt_arg;
/* For the parser threads */
apr_thread_t *thread[3];
apr_threadattr_t *tattr;
apr_status_t parser_status;
parser_baton_t *parser_ctx;
apr_initialize();
atexit(apr_terminate);
apr_pool_create(&pool, NULL);
apr_atomic_init(pool);
/* serf_initialize(); */
/* Default to one round of fetching. */
count = 1;
/* Default to GET. */
method = "GET";
apr_getopt_init(&opt, pool, argc, argv);
while ((status = apr_getopt(opt, "a:hv", &opt_c, &opt_arg)) ==
APR_SUCCESS) {
int srclen, enclen;
switch (opt_c) {
case 'a':
srclen = strlen(opt_arg);
enclen = apr_base64_encode_len(srclen);
authn = apr_palloc(pool, enclen + 6);
strcpy(authn, "Basic ");
(void) apr_base64_encode(&authn[6], opt_arg, srclen);
break;
case 'h':
print_usage(pool);
exit(0);
break;
case 'v':
puts("Serf version: " SERF_VERSION_STRING);
exit(0);
default:
break;
}
}
if (opt->ind != opt->argc - 1) {
print_usage(pool);
exit(-1);
}
raw_url = argv[opt->ind];
apr_uri_parse(pool, raw_url, &url);
if (!url.port) {
url.port = apr_uri_port_of_scheme(url.scheme);
}
if (!url.path) {
url.path = "/";
}
if (strcasecmp(url.scheme, "https") == 0) {
app_ctx.using_ssl = 1;
}
else {
app_ctx.using_ssl = 0;
}
status = apr_sockaddr_info_get(&address,
url.hostname, APR_UNSPEC, url.port, 0,
pool);
if (status) {
printf("Error creating address: %d\n", status);
exit(1);
}
context = serf_context_create(pool);
/* ### Connection or Context should have an allocator? */
app_ctx.bkt_alloc = serf_bucket_allocator_create(pool, NULL, NULL);
app_ctx.ssl_ctx = NULL;
app_ctx.authn = authn;
connection = serf_connection_create(context, address,
conn_setup, &app_ctx,
closed_connection, &app_ctx,
pool);
handler_ctx = (handler_baton_t*)serf_bucket_mem_alloc(app_ctx.bkt_alloc,
sizeof(handler_baton_t));
handler_ctx->allocator = app_ctx.bkt_alloc;
handler_ctx->doc_queue = apr_array_make(pool, 1, sizeof(doc_path_t*));
handler_ctx->doc_queue_alloc = app_ctx.bkt_alloc;
handler_ctx->requests_outstanding =
(apr_uint32_t*)serf_bucket_mem_alloc(app_ctx.bkt_alloc,
sizeof(apr_uint32_t));
apr_atomic_set32(handler_ctx->requests_outstanding, 0);
handler_ctx->hdr_read = 0;
parser_ctx = (void*)serf_bucket_mem_alloc(app_ctx.bkt_alloc,
sizeof(parser_baton_t));
parser_ctx->requests_outstanding = handler_ctx->requests_outstanding;
parser_ctx->connection = connection;
parser_ctx->app_ctx = &app_ctx;
parser_ctx->doc_queue = handler_ctx->doc_queue;
parser_ctx->doc_queue_alloc = handler_ctx->doc_queue_alloc;
/* Restrict ourselves to this host. */
parser_ctx->hostinfo = url.hostinfo;
status = apr_thread_mutex_create(&parser_ctx->mutex,
APR_THREAD_MUTEX_DEFAULT, pool);
if (status) {
printf("Couldn't create mutex %d\n", status);
return status;
}
status = apr_thread_cond_create(&parser_ctx->condvar, pool);
if (status) {
printf("Couldn't create condvar: %d\n", status);
return status;
}
/* Let the handler now which condvar to use. */
handler_ctx->doc_queue_condvar = parser_ctx->condvar;
apr_threadattr_create(&tattr, pool);
/* Start the parser thread. */
apr_thread_create(&thread[0], tattr, parser_thread, parser_ctx, pool);
/* Deliver the first request. */
create_request(url.hostinfo, url.path, NULL, NULL, parser_ctx, pool);
/* Go run our normal thread. */
while (1) {
int tries = 0;
status = serf_context_run(context, SERF_DURATION_FOREVER, pool);
if (APR_STATUS_IS_TIMEUP(status))
continue;
if (status) {
char buf[200];
printf("Error running context: (%d) %s\n", status,
apr_strerror(status, buf, sizeof(buf)));
exit(1);
}
/* We run this check to allow our parser threads to add more
* requests to our queue.
*/
for (tries = 0; tries < 3; tries++) {
if (!apr_atomic_read32(handler_ctx->requests_outstanding)) {
#ifdef SERF_VERBOSE
printf("Waiting...");
#endif
apr_sleep(100000);
#ifdef SERF_VERBOSE
printf("Done\n");
#endif
}
else {
break;
}
}
if (tries >= 3) {
break;
}
/* Debugging purposes only! */
serf_debug__closed_conn(app_ctx.bkt_alloc);
}
printf("Quitting...\n");
serf_connection_close(connection);
/* wake up the parser via condvar signal */
apr_thread_cond_signal(parser_ctx->condvar);
status = apr_thread_join(&parser_status, thread[0]);
if (status) {
printf("Error joining thread: %d\n", status);
return status;
}
serf_bucket_mem_free(app_ctx.bkt_alloc, handler_ctx->requests_outstanding);
serf_bucket_mem_free(app_ctx.bkt_alloc, parser_ctx);
apr_pool_destroy(pool);
return 0;
}
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]);
}
}
int main(int argc, const char const *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_inf("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;
}
/*
* main
*/
int main(int argc, const char * const argv[])
{
apr_off_t max;
apr_time_t current, repeat, delay, previous;
apr_status_t status;
apr_pool_t *pool, *instance;
apr_getopt_t *o;
apr_finfo_t info;
int retries, isdaemon, limit_found, intelligent, dowork;
char opt;
const char *arg;
char *proxypath, *path;
interrupted = 0;
repeat = 0;
isdaemon = 0;
dryrun = 0;
limit_found = 0;
max = 0;
verbose = 0;
realclean = 0;
benice = 0;
deldirs = 0;
intelligent = 0;
previous = 0; /* avoid compiler warning */
proxypath = NULL;
if (apr_app_initialize(&argc, &argv, NULL) != APR_SUCCESS) {
return 1;
}
atexit(apr_terminate);
if (argc) {
shortname = apr_filepath_name_get(argv[0]);
}
if (apr_pool_create(&pool, NULL) != APR_SUCCESS) {
return 1;
}
apr_pool_abort_set(oom, pool);
apr_file_open_stderr(&errfile, pool);
apr_signal(SIGINT, setterm);
apr_signal(SIGTERM, setterm);
apr_getopt_init(&o, pool, argc, argv);
while (1) {
status = apr_getopt(o, "iDnvrtd:l:L:p:", &opt, &arg);
if (status == APR_EOF) {
break;
}
else if (status != APR_SUCCESS) {
usage();
}
else {
switch (opt) {
case 'i':
if (intelligent) {
usage();
}
intelligent = 1;
break;
case 'D':
if (dryrun) {
usage();
}
dryrun = 1;
break;
case 'n':
if (benice) {
usage();
}
benice = 1;
break;
case 't':
if (deldirs) {
usage();
}
deldirs = 1;
break;
case 'v':
if (verbose) {
usage();
}
verbose = 1;
break;
case 'r':
if (realclean) {
usage();
}
realclean = 1;
deldirs = 1;
break;
case 'd':
if (isdaemon) {
usage();
}
isdaemon = 1;
repeat = apr_atoi64(arg);
repeat *= SECS_PER_MIN;
repeat *= APR_USEC_PER_SEC;
break;
case 'l':
if (limit_found) {
usage();
}
limit_found = 1;
do {
apr_status_t rv;
char *end;
rv = apr_strtoff(&max, arg, &end, 10);
if (rv == APR_SUCCESS) {
if ((*end == 'K' || *end == 'k') && !end[1]) {
max *= KBYTE;
}
else if ((*end == 'M' || *end == 'm') && !end[1]) {
max *= MBYTE;
}
else if ((*end == 'G' || *end == 'g') && !end[1]) {
max *= GBYTE;
}
else if (*end && /* neither empty nor [Bb] */
((*end != 'B' && *end != 'b') || end[1])) {
rv = APR_EGENERAL;
}
}
if (rv != APR_SUCCESS) {
apr_file_printf(errfile, "Invalid limit: %s"
APR_EOL_STR APR_EOL_STR, arg);
usage();
}
} while(0);
break;
case 'p':
if (proxypath) {
usage();
}
proxypath = apr_pstrdup(pool, arg);
if (apr_filepath_set(proxypath, pool) != APR_SUCCESS) {
usage();
}
break;
} /* switch */
} /* else */
} /* while */
if (o->ind != argc) {
usage();
}
if (isdaemon && (repeat <= 0 || verbose || realclean || dryrun)) {
usage();
}
if (!isdaemon && intelligent) {
usage();
}
if (!proxypath || max <= 0) {
usage();
}
if (apr_filepath_get(&path, 0, pool) != APR_SUCCESS) {
usage();
}
baselen = strlen(path);
#ifndef DEBUG
if (isdaemon) {
apr_file_close(errfile);
apr_proc_detach(APR_PROC_DETACH_DAEMONIZE);
}
#endif
do {
apr_pool_create(&instance, pool);
now = apr_time_now();
APR_RING_INIT(&root, _entry, link);
delcount = 0;
unsolicited = 0;
dowork = 0;
switch (intelligent) {
case 0:
dowork = 1;
break;
case 1:
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
previous = info.mtime;
intelligent = 2;
}
dowork = 1;
break;
case 2:
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
if (previous != info.mtime) {
dowork = 1;
}
previous = info.mtime;
break;
}
intelligent = 1;
dowork = 1;
break;
}
if (dowork && !interrupted) {
if (!process_dir(path, instance) && !interrupted) {
purge(path, instance, max);
}
else if (!isdaemon && !interrupted) {
apr_file_printf(errfile, "An error occurred, cache cleaning "
"aborted." APR_EOL_STR);
return 1;
}
if (intelligent && !interrupted) {
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
previous = info.mtime;
intelligent = 2;
}
else {
intelligent = 1;
}
}
}
apr_pool_destroy(instance);
current = apr_time_now();
if (current < now) {
delay = repeat;
}
else if (current - now >= repeat) {
delay = repeat;
}
else {
delay = now + repeat - current;
}
/* we can't sleep the whole delay time here apiece as this is racy
* with respect to interrupt delivery - think about what happens
* if we have tested for an interrupt, then get scheduled
* before the apr_sleep() call and while waiting for the cpu
* we do get an interrupt
*/
if (isdaemon) {
while (delay && !interrupted) {
if (delay > APR_USEC_PER_SEC) {
apr_sleep(APR_USEC_PER_SEC);
delay -= APR_USEC_PER_SEC;
}
else {
apr_sleep(delay);
delay = 0;
}
}
}
} while (isdaemon && !interrupted);
if (!isdaemon && interrupted) {
apr_file_printf(errfile, "Cache cleaning aborted due to user "
"request." APR_EOL_STR);
return 1;
}
return 0;
}
int main(int argc, const char const* argv[]) {
apr_pool_t* p = NULL;
apr_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;
Command request = 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 = Install;
url = optarg;
break;
case 'L':
request = List;
break;
case 'c':
config_opts = optarg;
break;
case 'm':
make_opts = optarg;
break;
case 'i':
install_opts = optarg;
break;
case 'S':
request = Init;
break;
case 'F':
request = Fetch;
url = optarg;
break;
case 'B':
request = Build;
url = optarg;
break;
}
}
switch(request) {
case Install:
check(url, "You must give a url.");
Command_install(p, url, config_opts, make_opts, install_opts);
break;
case List:
DB_list();
break;
case Fetch:
check(url, "You must give a url.");
Command_fetch(p, url, true);
log_info("Downloaded to %s and in /tmp", BUILD_DIR);
break;
case Build:
check(url, "You must give a url.");
Command_build(p, url, config_opts, make_opts, install_opts);
break;
case Init:
rv = DB_init();
check(rv == 0, "Failed to make the database.");
break;
default:
sentinel("Invalid command given.");
}
return EXIT_SUCCESS;
error:
return EXIT_FAILURE;
}
int main(int argc, const char const *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;
default:
log_info("Unknown command");}}
switch (request) {
case COMMAND_INSTALL:
check(url != NULL, "You must specify an 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 specify an URL.");
Command_fetch(p, url, 1);
log_info("Downloaded target to %s",BUILD_DIR);
break;
case COMMAND_BUILD:
check(url != NULL, "You must specify an URL.");
Command_install(p, url, config_opts, make_opts, install_opts);
break;
case COMMAND_INIT:
rv = DB_init();
check(rv == 0, "Failed to create database.");
break;
case COMMAND_NONE:
printf("Usage: give one of the flags -S -I -L -F -B with apropriate arguments\n");
break;
default:
sentinel("Invalid command given");}
apr_pool_terminate();
return 0;
error:
apr_pool_terminate();
return 1;
}
int main(int argc, const char* const argv[])
{
apr_thread_t **t;
apr_queue_t *queue;
int i;
apr_status_t rv;
apr_getopt_t *opt;
const char *optarg;
char c;
int numconsumers=3;
int numproducers=4;
int queuesize=100;
int sleeptime=30;
char errorbuf[200];
apr_initialize();
srand((unsigned int)apr_time_now());
printf("APR Queue Test\n======================\n\n");
printf("%-60s", "Initializing the context");
if (apr_pool_create(&context, NULL) != APR_SUCCESS) {
fflush(stdout);
fprintf(stderr, "Failed.\nCould not initialize\n");
exit(-1);
}
printf("OK\n");
apr_getopt_init(&opt, context, argc, argv);
while ((rv = apr_getopt(opt, "p:c:P:C:q:s:v", &c, &optarg))
== APR_SUCCESS) {
switch (c) {
case 'c':
numconsumers = atoi( optarg);
break;
case 'p':
numproducers = atoi( optarg);
break;
case 'C':
consumer_activity = atoi( optarg);
break;
case 'P':
producer_activity = atoi( optarg);
break;
case 's':
sleeptime= atoi(optarg);
break;
case 'q':
queuesize = atoi(optarg);
break;
case 'v':
verbose= 1;
break;
default:
usage();
exit(-1);
}
}
/* bad cmdline option? then we die */
if (rv != APR_EOF || opt->ind < opt->argc) {
usage();
exit(-1);
}
printf("test stats %d consumers (rate %d/sec) %d producers (rate %d/sec) queue size %d sleep %d\n",
numconsumers,consumer_activity, numproducers, producer_activity, queuesize,sleeptime);
printf("%-60s", "Initializing the queue");
rv = apr_queue_create(&queue, queuesize, context);
if (rv != APR_SUCCESS) {
fflush(stdout);
fprintf(stderr, "Failed\nCould not create queue %d\n",rv);
apr_strerror(rv, errorbuf,200);
fprintf(stderr,"%s\n",errorbuf);
exit(-1);
}
printf("OK\n");
t = apr_palloc( context, sizeof(apr_thread_t*) * (numconsumers+numproducers));
printf("%-60s", "Starting consumers");
for (i=0;i<numconsumers;i++) {
rv = apr_thread_create(&t[i], NULL, consumer, queue, context);
if (rv != APR_SUCCESS) {
apr_strerror(rv, errorbuf,200);
fprintf(stderr, "Failed\nError starting consumer thread (%d) rv=%d:%s\n",i, rv,errorbuf);
exit(-1);
}
}
for (i=numconsumers;i<(numconsumers+numproducers);i++) {
rv = apr_thread_create(&t[i], NULL, producer, queue, context);
if (rv != APR_SUCCESS) {
apr_strerror(rv, errorbuf,200);
fprintf(stderr, "Failed\nError starting producer thread (%d) rv=%d:%s\n",i, rv,errorbuf);
exit(-1);
}
}
printf("OK\n");
printf("%-60s", "Sleeping\n");
apr_sleep( sleeptime * 1000000 ); /* sleep 10 seconds */
printf("OK\n");
printf("%-60s", "Terminating queue");
rv = apr_queue_term(queue);
if (rv != APR_SUCCESS) {
apr_strerror(rv, errorbuf,200);
fprintf( stderr, "apr_queue_term failed %d:%s\n",rv,errorbuf);
}
printf("OK\n");
printf("%-60s", "Waiting for threads to exit\n");
fflush(stdout);
for (i=0;i<numconsumers+numproducers;i++) {
apr_thread_join(&rv, t[i]);
if (rv != 0 ) {
apr_strerror(rv, errorbuf,200);
if (i<numconsumers)
fprintf( stderr, "consumer thread %d failed rv %d:%s\n",i,rv,errorbuf);
else
fprintf( stderr, "producer thread %d failed rv %d:%s\n",i,rv,errorbuf);
}
}
printf("OK\n");
apr_terminate();
return 0;
}
