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