/*++
StreamCreateBinaryConsole
Creates a binary console I/O stream.
Arguments:
console - Console type.
pool - Pointer to a memory pool.
Return Values:
If the function succeeds, the return value is a pointer to a STREAM structure.
If the function fails, the return value is null.
--*/
STREAM *
StreamCreateBinaryConsole(
int console,
apr_pool_t *pool
)
{
apr_file_t *file;
apr_status_t status;
ASSERT(pool != NULL);
switch (console) {
case CONSOLE_INPUT:
status = apr_file_open_stdin(&file, pool);
break;
case CONSOLE_OUTPUT:
status = apr_file_open_stdout(&file, pool);
break;
case CONSOLE_ERROR:
status = apr_file_open_stderr(&file, pool);
break;
default:
return NULL;
}
if (status != APR_SUCCESS) {
return NULL;
}
return StreamCreateFile(file, TRUE, pool);
}
/* Main driver.
Arguments (may be any combination):
-sstring - digests string
-t - runs time trial
-x - runs test script
filename - digests file
(none) - digests standard input
*/
int main (int argc, char **argv)
{
int i;
apr_initialize();
atexit(apr_terminate);
if (apr_pool_create(&local_pool, NULL) != APR_SUCCESS)
exit(-1);
apr_file_open_stdin(&in, local_pool);
apr_file_open_stdout(&out, local_pool);
apr_file_open_stderr(&err, local_pool);
if (argc > 1)
{
for (i = 1; i < argc; i++)
if (argv[i][0] == '-' && argv[i][1] == 's')
MDString(argv[i] + 2);
else if (strcmp(argv[i], "-t") == 0)
MDTimeTrial();
else if (strcmp (argv[i], "-x") == 0)
MDTestSuite();
else
MDFile(argv[i]);
}
else
MDFilter();
return 0;
}
/* return an OSHandle representing one of the standard streams */
static MVMObject * MVM_file_get_stdstream(MVMThreadContext *tc, MVMuint8 type) {
MVMOSHandle *result;
apr_file_t *handle;
apr_status_t rv;
MVMObject *type_object = tc->instance->boot_types->BOOTIO;
result = (MVMOSHandle *)REPR(type_object)->allocate(tc, STABLE(type_object));
/* need a temporary pool */
if ((rv = apr_pool_create(&result->body.mem_pool, NULL)) != APR_SUCCESS) {
MVM_exception_throw_apr_error(tc, rv, "get_stream failed to create pool: ");
}
switch(type) {
case 0:
apr_file_open_stdin(&handle, result->body.mem_pool);
break;
case 1:
apr_file_open_stdout(&handle, result->body.mem_pool);
break;
case 2:
apr_file_open_stderr(&handle, result->body.mem_pool);
break;
}
result->body.file_handle = handle;
result->body.handle_type = MVM_OSHANDLE_FILE;
result->body.encoding_type = MVM_encoding_type_utf8;
return (MVMObject *)result;
}
AP_DECLARE(apr_status_t) ap_replace_stderr_log(apr_pool_t *p,
const char *fname)
{
apr_file_t *stderr_file;
apr_status_t rc;
char *filename = ap_server_root_relative(p, fname);
if (!filename) {
ap_log_error(APLOG_MARK, APLOG_STARTUP|APLOG_CRIT,
APR_EBADPATH, NULL, "Invalid -E error log file %s",
fname);
return APR_EBADPATH;
}
if ((rc = apr_file_open(&stderr_file, filename,
APR_APPEND | APR_WRITE | APR_CREATE | APR_LARGEFILE,
APR_OS_DEFAULT, p)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_STARTUP, rc, NULL,
"%s: could not open error log file %s.",
ap_server_argv0, fname);
return rc;
}
if ((rc = apr_file_open_stderr(&stderr_log, p)) == APR_SUCCESS) {
apr_file_flush(stderr_log);
if ((rc = apr_file_dup2(stderr_log, stderr_file, p)) == APR_SUCCESS) {
apr_file_close(stderr_file);
}
}
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rc, NULL,
"unable to replace stderr with error_log");
}
return rc;
}
/* Spawn the piped logger process pl->program. */
static apr_status_t piped_log_spawn(piped_log *pl)
{
apr_procattr_t *procattr;
apr_proc_t *procnew = NULL;
apr_status_t status;
if (((status = apr_procattr_create(&procattr, pl->p)) != APR_SUCCESS) ||
((status = apr_procattr_cmdtype_set(procattr, pl->cmdtype))
!= APR_SUCCESS) ||
((status = apr_procattr_child_in_set(procattr,
ap_piped_log_read_fd(pl),
ap_piped_log_write_fd(pl)))
!= APR_SUCCESS) ||
((status = apr_procattr_child_errfn_set(procattr, log_child_errfn))
!= APR_SUCCESS) ||
((status = apr_procattr_error_check_set(procattr, 1)) != APR_SUCCESS)) {
char buf[120];
/* Something bad happened, give up and go away. */
ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
"piped_log_spawn: unable to setup child process '%s': %s",
pl->program, apr_strerror(status, buf, sizeof(buf)));
}
else {
char **args;
const char *pname;
apr_file_t *outfile, *errfile;
if ((status = apr_file_open_stdout(&outfile, pl->p)) == APR_SUCCESS)
status = apr_procattr_child_out_set(procattr, outfile, NULL);
if ((status = apr_file_open_stderr(&errfile, pl->p)) == APR_SUCCESS)
status = apr_procattr_child_err_set(procattr, errfile, NULL);
apr_tokenize_to_argv(pl->program, &args, pl->p);
pname = apr_pstrdup(pl->p, args[0]);
procnew = apr_pcalloc(pl->p, sizeof(apr_proc_t));
status = apr_proc_create(procnew, pname, (const char * const *) args,
NULL, procattr, pl->p);
if (status == APR_SUCCESS) {
pl->pid = procnew;
/* procnew->in was dup2'd from ap_piped_log_write_fd(pl);
* since the original fd is still valid, close the copy to
* avoid a leak. */
apr_file_close(procnew->in);
procnew->in = NULL;
apr_proc_other_child_register(procnew, piped_log_maintenance, pl,
ap_piped_log_write_fd(pl), pl->p);
close_handle_in_child(pl->p, ap_piped_log_read_fd(pl));
}
else {
char buf[120];
/* Something bad happened, give up and go away. */
ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
"unable to start piped log program '%s': %s",
pl->program, apr_strerror(status, buf, sizeof(buf)));
}
}
return status;
}
static void test_dup2(abts_case *tc, void *data)
{
apr_file_t *testfile = NULL;
apr_file_t *errfile = NULL;
apr_file_t *saveerr = NULL;
apr_status_t rv;
rv = apr_file_open(&testfile, FILEPATH "testdup2.file",
APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE |
APR_FOPEN_DELONCLOSE, APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, testfile);
rv = apr_file_open_stderr(&errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Set aside the real errfile */
rv = apr_file_dup(&saveerr, errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, saveerr);
rv = apr_file_dup2(errfile, testfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
apr_file_close(testfile);
rv = apr_file_dup2(errfile, saveerr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
apr_file_close(saveerr);
}
AP_DECLARE(void) ap_error_log2stderr(server_rec *s) {
apr_file_t *errfile = NULL;
apr_file_open_stderr(&errfile, s->process->pool);
if (s->error_log != NULL) {
apr_file_dup2(s->error_log, errfile, s->process->pool);
}
}
/* Called from apr_proc_create() if there are errors during launch of child
* process. Mostly just lifted from mod_cgi. */
static void extchilderr(apr_pool_t *p, apr_status_t err, const char *desc)
{
apr_file_t *stderr_log;
char errbuf[200];
apr_file_open_stderr(&stderr_log, p);
apr_file_printf(stderr_log,"%s: (%d) %s\n", ap_escape_logitem(p,desc),
err, apr_strerror(err,errbuf,sizeof(errbuf)));
}
AP_DECLARE(apr_status_t) ap_replace_stderr_log(apr_pool_t *p,
const char *fname)
{
apr_file_t *stderr_file;
apr_status_t rc;
char *filename = ap_server_root_relative(p, fname);
if (!filename) {
ap_log_error(APLOG_MARK, APLOG_STARTUP|APLOG_CRIT,
APR_EBADPATH, NULL, "Invalid -E error log file %s",
fname);
return APR_EBADPATH;
}
if ((rc = apr_file_open(&stderr_file, filename,
APR_APPEND | APR_WRITE | APR_CREATE | APR_LARGEFILE,
APR_OS_DEFAULT, p)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_STARTUP, rc, NULL,
"%s: could not open error log file %s.",
ap_server_argv0, fname);
return rc;
}
if (!stderr_pool) {
/* This is safe provided we revert it when we are finished.
* We don't manager the callers pool!
*/
stderr_pool = p;
}
if ((rc = apr_file_open_stderr(&stderr_log, stderr_pool))
== APR_SUCCESS) {
apr_file_flush(stderr_log);
if ((rc = apr_file_dup2(stderr_log, stderr_file, stderr_pool))
== APR_SUCCESS) {
apr_file_close(stderr_file);
/*
* You might ponder why stderr_pool should survive?
* The trouble is, stderr_pool may have s_main->error_log,
* so we aren't in a position to destory stderr_pool until
* the next recycle. There's also an apparent bug which
* is not; if some folk decided to call this function before
* the core open error logs hook, this pool won't survive.
* Neither does the stderr logger, so this isn't a problem.
*/
}
}
/* Revert, see above */
if (stderr_pool == p)
stderr_pool = NULL;
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rc, NULL,
"unable to replace stderr with error log file");
}
return rc;
}
/* Redirect stdout to stderr. ARG is the pool.
*
* In tunnel or inetd mode, we don't want hook scripts corrupting the
* data stream by sending data to stdout, so we need to redirect
* stdout somewhere else. Sending it to stderr is acceptable; sending
* it to /dev/null is another option, but apr doesn't provide a way to
* do that without also detaching from the controlling terminal.
*/
static apr_status_t redirect_stdout(void *arg)
{
apr_pool_t *pool = arg;
apr_file_t *out_file, *err_file;
apr_status_t apr_err;
if ((apr_err = apr_file_open_stdout(&out_file, pool)))
return apr_err;
if ((apr_err = apr_file_open_stderr(&err_file, pool)))
return apr_err;
return apr_file_dup2(out_file, err_file, pool);
}
/* Create a child process running PROGNAME with a pipe connected to
* the childs stdin. The write-end of the pipe will be placed in
* *FPIN on successful return. If dummy_stderr is non-zero, the
* stderr for the child will be the same as the stdout of the parent.
* Otherwise the child will inherit the stderr from the parent. */
static int log_child(apr_pool_t *p, const char *progname,
apr_file_t **fpin, apr_cmdtype_e cmdtype,
int dummy_stderr)
{
/* Child process code for 'ErrorLog "|..."';
* may want a common framework for this, since I expect it will
* be common for other foo-loggers to want this sort of thing...
*/
apr_status_t rc;
apr_procattr_t *procattr;
apr_proc_t *procnew;
apr_file_t *outfile, *errfile;
if (((rc = apr_procattr_create(&procattr, p)) == APR_SUCCESS)
&& ((rc = apr_procattr_cmdtype_set(procattr, cmdtype)) == APR_SUCCESS)
&& ((rc = apr_procattr_io_set(procattr,
APR_FULL_BLOCK,
APR_NO_PIPE,
APR_NO_PIPE)) == APR_SUCCESS)
&& ((rc = apr_procattr_error_check_set(procattr, 1)) == APR_SUCCESS)
&& ((rc = apr_procattr_child_errfn_set(procattr, log_child_errfn))
== APR_SUCCESS)) {
char **args;
const char *pname;
apr_tokenize_to_argv(progname, &args, p);
pname = apr_pstrdup(p, args[0]);
procnew = (apr_proc_t *)apr_pcalloc(p, sizeof(*procnew));
if ((rc = apr_file_open_stdout(&outfile, p)) == APR_SUCCESS) {
rc = apr_procattr_child_out_set(procattr, outfile, NULL);
if (dummy_stderr)
rc = apr_procattr_child_err_set(procattr, outfile, NULL);
else if ((rc = apr_file_open_stderr(&errfile, p)) == APR_SUCCESS)
rc = apr_procattr_child_err_set(procattr, errfile, NULL);
}
rc = apr_proc_create(procnew, pname, (const char * const *)args,
NULL, procattr, p);
if (rc == APR_SUCCESS) {
apr_pool_note_subprocess(p, procnew, APR_KILL_AFTER_TIMEOUT);
(*fpin) = procnew->in;
/* read handle to pipe not kept open, so no need to call
* close_handle_in_child()
*/
}
}
return rc;
}
static void test_dup2_readwrite(abts_case *tc, void *data)
{
apr_file_t *errfile = NULL;
apr_file_t *testfile = NULL;
apr_file_t *saveerr = NULL;
apr_status_t rv;
apr_size_t txtlen = sizeof(TEST);
char buff[50];
apr_off_t fpos;
rv = apr_file_open(&testfile, FILEPATH "testdup2.readwrite.file",
APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE |
APR_FOPEN_DELONCLOSE, APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, testfile);
rv = apr_file_open_stderr(&errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Set aside the real errfile */
rv = apr_file_dup(&saveerr, errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, saveerr);
rv = apr_file_dup2(errfile, testfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
txtlen = sizeof(TEST2);
rv = apr_file_write(errfile, TEST2, &txtlen);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, sizeof(TEST2), txtlen);
fpos = 0;
rv = apr_file_seek(testfile, APR_SET, &fpos);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File position mismatch, expected 0", fpos == 0);
txtlen = 50;
rv = apr_file_read(testfile, buff, &txtlen);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, TEST2, buff);
apr_file_close(testfile);
rv = apr_file_dup2(errfile, saveerr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
apr_file_close(saveerr);
}
svn_error_t *
svn_stream_for_stderr(svn_stream_t **err, apr_pool_t *pool)
{
apr_file_t *stderr_file;
apr_status_t apr_err;
apr_err = apr_file_open_stderr(&stderr_file, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, "Can't open stderr");
*err = svn_stream_from_aprfile2(stderr_file, TRUE, pool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_delta__get_debug_editor(const svn_delta_editor_t **editor,
void **edit_baton,
const svn_delta_editor_t *wrapped_editor,
void *wrapped_edit_baton,
apr_pool_t *pool)
{
svn_delta_editor_t *tree_editor = svn_delta_default_editor(pool);
struct edit_baton *eb = apr_palloc(pool, sizeof(*eb));
apr_file_t *errfp;
svn_stream_t *out;
apr_status_t apr_err = apr_file_open_stderr(&errfp, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, "Problem opening stderr");
out = svn_stream_from_aprfile2(errfp, TRUE, pool);
tree_editor->set_target_revision = set_target_revision;
tree_editor->open_root = open_root;
tree_editor->delete_entry = delete_entry;
tree_editor->add_directory = add_directory;
tree_editor->open_directory = open_directory;
tree_editor->change_dir_prop = change_dir_prop;
tree_editor->close_directory = close_directory;
tree_editor->absent_directory = absent_directory;
tree_editor->add_file = add_file;
tree_editor->open_file = open_file;
tree_editor->apply_textdelta = apply_textdelta;
tree_editor->change_file_prop = change_file_prop;
tree_editor->close_file = close_file;
tree_editor->absent_file = absent_file;
tree_editor->close_edit = close_edit;
eb->wrapped_editor = wrapped_editor;
eb->wrapped_edit_baton = wrapped_edit_baton;
eb->out = out;
eb->indent_level = 0;
*editor = tree_editor;
*edit_baton = eb;
return SVN_NO_ERROR;
}
void mpm_nt_eventlog_stderr_open(char *argv0, apr_pool_t *p)
{
SECURITY_ATTRIBUTES sa;
HANDLE hProc = GetCurrentProcess();
HANDLE hPipeRead = NULL;
HANDLE hPipeWrite = NULL;
HANDLE hDup = NULL;
DWORD threadid;
apr_file_t *eventlog_file;
apr_file_t *stderr_file;
display_name = argv0;
/* Create a pipe to send stderr messages to the system error log.
*
* _dup2() duplicates the write handle inheritable for us.
*/
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = FALSE;
CreatePipe(&hPipeRead, &hPipeWrite, NULL, 0);
ap_assert(hPipeRead && hPipeWrite);
stderr_ready = CreateEvent(NULL, FALSE, FALSE, NULL);
stderr_thread = CreateThread(NULL, 0, service_stderr_thread,
(LPVOID) hPipeRead, 0, &threadid);
ap_assert(stderr_ready && stderr_thread);
WaitForSingleObject(stderr_ready, INFINITE);
if ((apr_file_open_stderr(&stderr_file, p)
== APR_SUCCESS)
&& (apr_os_file_put(&eventlog_file, &hPipeWrite, APR_WRITE, p)
== APR_SUCCESS))
apr_file_dup2(stderr_file, eventlog_file, p);
/* The code above _will_ corrupt the StdHandle...
* and we must do so anyways. We set this up only
* after we initialized the posix stderr API.
*/
ap_open_stderr_log(p);
}
static void child_errfn(apr_pool_t *pool, apr_status_t err, const char *description)
{
request_rec *r;
void *vr;
apr_file_t *stderr_log;
char errbuf[200];
char time_str[APR_CTIME_LEN];
apr_pool_userdata_get(&vr, ERRFN_USERDATA_KEY, pool);
r = vr;
apr_file_open_stderr(&stderr_log, pool);
ap_recent_ctime(time_str, apr_time_now());
apr_file_printf(stderr_log,
"[%s] [client %s] mod_ext_filter (%d)%s: %s\n",
time_str,
r->connection->remote_ip,
err,
apr_strerror(err, errbuf, sizeof(errbuf)),
description);
}
static void cgi_child_errfn(apr_pool_t *pool, apr_status_t err,
const char *description)
{
apr_file_t *stderr_log;
apr_file_open_stderr(&stderr_log, pool);
/* Escape the logged string because it may be something that
* came in over the network.
*/
apr_file_printf(stderr_log,
"(%d)%pm: %s\n",
err,
&err,
#ifndef AP_UNSAFE_ERROR_LOG_UNESCAPED
ap_escape_logitem(pool,
#endif
description
#ifndef AP_UNSAFE_ERROR_LOG_UNESCAPED
)
#endif
);
}
static int JK_METHOD jk2_logger_file_init(jk_env_t *env, jk_logger_t *_this )
{
apr_status_t rv;
apr_file_t *oldF = (apr_file_t *)_this->logger_private;
apr_file_t *f = NULL;
jk_workerEnv_t *workerEnv = env->getByName(env, "workerEnv");
if (!_this->name) {
_this->name="${serverRoot}/logs/jk2.log";
}
_this->name = jk2_config_replaceProperties(env, workerEnv->initData,
_this->mbean->pool, _this->name);
if (!_this->name || !strcmp("stderr", _this->name)) {
if ((rv = apr_file_open_stderr(&f, env->globalPool->_private)) !=
APR_SUCCESS) {
_this->jkLog(env, _this,JK_LOG_ERROR,
"Can't open stderr file\n");
return JK_ERR;
}
_this->logger_private = f;
}
else {
if ((rv = apr_file_open(&f, _this->name,
APR_APPEND | APR_READ | APR_WRITE | APR_CREATE,
APR_OS_DEFAULT,
env->globalPool->_private)) != APR_SUCCESS) {
_this->jkLog(env, _this,JK_LOG_ERROR,
"Can't open log file %s\n", _this->name );
return JK_ERR;
}
_this->logger_private = f;
}
_this->jkLog(env, _this,JK_LOG_INFO,
"Initializing log file %s\n", _this->name );
if (oldF) {
apr_file_close(oldF);
}
return JK_OK;
}
zktool_display_options(const apr_getopt_option_t *options, apr_file_t *f, apr_pool_t *pool)
{
int self_created_pool = 0;
const apr_getopt_option_t *opt;
const char *optfmt;
if(pool == NULL) {
pool = zeke_root_subpool_create();
self_created_pool++;
}
if(f == NULL) {
apr_status_t st;
if((f = zstdout) == NULL && (f = zstderr) == NULL) {
st = apr_file_open_stderr(&f,pool);
if(st != APR_SUCCESS) {
st = apr_file_open_stdout(&f,pool);
if(st != APR_SUCCESS)
return;
}
apr_file_inherit_unset(f);
}
}
for(opt = options; opt->name != NULL || opt->optch != 0; opt++) {
optfmt = zktool_format_opt(opt,NULL,pool);
assert(optfmt != NULL);
#if 0
optfmt = apr_pstrcat(pool,optfmt,apr_psprintf(pool,"%%%ds%%s\n",(int)(30-strlen(optfmt))),NULL);
#endif
apr_file_printf(f,optfmt,opt->description);
apr_file_putc('\n',f);
}
if(self_created_pool)
apr_pool_destroy(pool);
}
static apr_status_t htdbm_init(apr_pool_t **pool, htdbm_t **hdbm)
{
#if APR_CHARSET_EBCDIC
apr_status_t rv;
#endif
apr_pool_create( pool, NULL);
apr_pool_abort_set(abort_on_oom, *pool);
apr_file_open_stderr(&errfile, *pool);
apr_signal(SIGINT, (void (*)(int)) htdbm_interrupted);
(*hdbm) = (htdbm_t *)apr_pcalloc(*pool, sizeof(htdbm_t));
(*hdbm)->ctx.pool = *pool;
#if APR_CHARSET_EBCDIC
rv = apr_xlate_open(&((*hdbm)->to_ascii), "ISO-8859-1", APR_DEFAULT_CHARSET, (*hdbm)->ctx.pool);
if (rv) {
fprintf(stderr, "apr_xlate_open(to ASCII)->%d\n", rv);
return APR_EGENERAL;
}
rv = apr_SHA1InitEBCDIC((*hdbm)->to_ascii);
if (rv) {
fprintf(stderr, "apr_SHA1InitEBCDIC()->%d\n", rv);
return APR_EGENERAL;
}
rv = apr_MD5InitEBCDIC((*hdbm)->to_ascii);
if (rv) {
fprintf(stderr, "apr_MD5InitEBCDIC()->%d\n", rv);
return APR_EGENERAL;
}
#endif /*APR_CHARSET_EBCDIC*/
/* Set MD5 as default */
(*hdbm)->ctx.alg = ALG_APMD5;
(*hdbm)->type = "default";
return APR_SUCCESS;
}
/*** Public interfaces. ***/
svn_error_t *
svn_ra__get_debug_reporter(const svn_ra_reporter3_t **reporter,
void **report_baton,
const svn_ra_reporter3_t *wrapped_reporter,
void *wrapped_report_baton,
apr_pool_t *pool)
{
svn_ra_reporter3_t *tree_reporter;
struct report_baton *rb;
apr_file_t *errfp;
svn_stream_t *out;
apr_status_t apr_err = apr_file_open_stderr(&errfp, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, "Problem opening stderr");
out = svn_stream_from_aprfile2(errfp, TRUE, pool);
/* ### svn_delta_default_editor() */
tree_reporter = apr_palloc(pool, sizeof(*tree_reporter));
rb = apr_palloc(pool, sizeof(*rb));
tree_reporter->set_path = set_path;
tree_reporter->delete_path = delete_path;
tree_reporter->link_path = link_path;
tree_reporter->finish_report = finish_report;
tree_reporter->abort_report = abort_report;
rb->wrapped_reporter = wrapped_reporter;
rb->wrapped_report_baton = wrapped_report_baton;
rb->out = out;
*reporter = tree_reporter;
*report_baton = rb;
return SVN_NO_ERROR;
}
static void dump_loaded_modules(apr_pool_t *p, server_rec *s)
{
ap_module_symbol_t *modie;
ap_module_symbol_t *modi;
so_server_conf *sconf;
int i;
apr_file_t *out = NULL;
if (!ap_exists_config_define("DUMP_MODULES")) {
return;
}
apr_file_open_stderr(&out, p);
apr_file_printf(out, "Loaded Modules:\n");
sconf = (so_server_conf *)ap_get_module_config(s->module_config,
&so_module);
for (i = 0; ; i++) {
modi = &ap_prelinked_module_symbols[i];
if (modi->name != NULL) {
apr_file_printf(out, " %s (static)\n", modi->name);
}
else {
break;
}
}
modie = (ap_module_symbol_t *)sconf->loaded_modules->elts;
for (i = 0; i < sconf->loaded_modules->nelts; i++) {
modi = &modie[i];
if (modi->name != NULL) {
apr_file_printf(out, " %s (shared)\n", modi->name);
}
}
}
static int
l_diff (lua_State *L) {
const char *path1 = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
svn_opt_revision_t rev1;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
rev1.kind = get_revision_kind (path1);
} else {
rev1.kind = svn_opt_revision_number;
rev1.value.number = lua_tointeger (L, 2);
}
const char *path2 = (lua_gettop (L) < 3 || lua_isnil (L, 3)) ? path1 : luaL_checkstring (L, 3);
svn_opt_revision_t rev2;
if (lua_gettop (L) < 4 || lua_isnil (L, 4)) {
if (svn_path_is_url (path2)) {
rev2.kind = svn_opt_revision_head;
} else {
rev2.kind = svn_opt_revision_working;
}
} else {
rev2.kind = svn_opt_revision_number;
rev2.value.number = lua_tointeger (L, 4);
}
const char *outfile = (lua_gettop (L) < 5 || lua_isnil (L, 5)) ? NULL : luaL_checkstring (L, 5);
const char *errfile = (lua_gettop (L) < 6 || lua_isnil (L, 6)) ? NULL : luaL_checkstring (L, 6);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path1 = svn_path_canonicalize (path1, pool);
path2 = svn_path_canonicalize (path2, pool);
apr_file_t *aprout;
apr_file_t *aprerr;
apr_status_t status;
if (outfile) {
status = apr_file_open (&aprout, outfile, APR_READ | APR_WRITE | APR_CREATE,
APR_OS_DEFAULT, pool);
} else {
status = apr_file_open_stdout(&aprout, pool);
}
if (status) {
IF_ERROR_RETURN (svn_error_wrap_apr(status, "Can't open output file"), pool, L);
}
if (errfile) {
status = apr_file_open (&aprerr, errfile, APR_READ | APR_WRITE | APR_CREATE,
APR_OS_DEFAULT, pool);
} else {
status = apr_file_open_stderr(&aprerr, pool);
}
if (status) {
IF_ERROR_RETURN (svn_error_wrap_apr(status, "Can't open error file"), pool , L);
}
apr_array_header_t *array;
array = apr_array_make (pool, 0, sizeof (const char *));
err = svn_client_diff3 (array, path1, &rev1, path2, &rev2,
TRUE, TRUE, FALSE, FALSE,
APR_LOCALE_CHARSET, aprout, aprerr,
ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
int main(int argc, const char * const argv[])
{
apr_file_t *f;
apr_status_t rv;
char tn[] = "htdigest.tmp.XXXXXX";
char *dirname;
char user[MAX_STRING_LEN];
char realm[MAX_STRING_LEN];
char line[MAX_STRING_LEN];
char l[MAX_STRING_LEN];
char w[MAX_STRING_LEN];
char x[MAX_STRING_LEN];
int found;
apr_app_initialize(&argc, &argv, NULL);
atexit(terminate);
apr_pool_create(&cntxt, NULL);
apr_file_open_stderr(&errfile, cntxt);
#if APR_CHARSET_EBCDIC
rv = apr_xlate_open(&to_ascii, "ISO8859-1", APR_DEFAULT_CHARSET, cntxt);
if (rv) {
apr_file_printf(errfile, "apr_xlate_open(): %s (%d)\n",
apr_strerror(rv, line, sizeof(line)), rv);
exit(1);
}
#endif
apr_signal(SIGINT, (void (*)(int)) interrupted);
if (argc == 5) {
if (strcmp(argv[1], "-c"))
usage();
rv = apr_file_open(&f, argv[2], APR_WRITE | APR_CREATE,
APR_OS_DEFAULT, cntxt);
if (rv != APR_SUCCESS) {
char errmsg[120];
apr_file_printf(errfile, "Could not open passwd file %s for writing: %s\n",
argv[2],
apr_strerror(rv, errmsg, sizeof errmsg));
exit(1);
}
apr_file_printf(errfile, "Adding password for %s in realm %s.\n",
argv[4], argv[3]);
add_password(argv[4], argv[3], f);
apr_file_close(f);
exit(0);
}
else if (argc != 4)
usage();
if (apr_temp_dir_get((const char**)&dirname, cntxt) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: could not determine temp dir\n",
argv[0]);
exit(1);
}
dirname = apr_psprintf(cntxt, "%s/%s", dirname, tn);
if (apr_file_mktemp(&tfp, dirname, 0, cntxt) != APR_SUCCESS) {
apr_file_printf(errfile, "Could not open temp file %s.\n", dirname);
exit(1);
}
if (apr_file_open(&f, argv[1], APR_READ, APR_OS_DEFAULT, cntxt) != APR_SUCCESS) {
apr_file_printf(errfile,
"Could not open passwd file %s for reading.\n", argv[1]);
apr_file_printf(errfile, "Use -c option to create new one.\n");
cleanup_tempfile_and_exit(1);
}
apr_cpystrn(user, argv[3], sizeof(user));
apr_cpystrn(realm, argv[2], sizeof(realm));
found = 0;
while (!(get_line(line, MAX_STRING_LEN, f))) {
if (found || (line[0] == '#') || (!line[0])) {
putline(tfp, line);
continue;
}
strcpy(l, line);
getword(w, l, ':');
getword(x, l, ':');
if (strcmp(user, w) || strcmp(realm, x)) {
putline(tfp, line);
continue;
}
else {
apr_file_printf(errfile, "Changing password for user %s in realm %s\n",
user, realm);
add_password(user, realm, tfp);
found = 1;
}
}
if (!found) {
apr_file_printf(errfile, "Adding user %s in realm %s\n", user, realm);
add_password(user, realm, tfp);
}
apr_file_close(f);
/* The temporary file has all the data, just copy it to the new location.
*/
if (apr_file_copy(dirname, argv[1], APR_FILE_SOURCE_PERMS, cntxt) !=
APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to update file %s\n",
argv[0], argv[1]);
}
apr_file_close(tfp);
return 0;
}
int ap_open_logs(apr_pool_t *pconf, apr_pool_t *p /* plog */,
apr_pool_t *ptemp, server_rec *s_main)
{
apr_status_t rc = APR_SUCCESS;
server_rec *virt, *q;
int replace_stderr;
apr_file_t *errfile = NULL;
apr_pool_cleanup_register(p, NULL, clear_handle_list,
apr_pool_cleanup_null);
if (open_error_log(s_main, 1, p) != OK) {
return DONE;
}
replace_stderr = 1;
if (s_main->error_log) {
/* replace stderr with this new log */
apr_file_flush(s_main->error_log);
if ((rc = apr_file_open_stderr(&errfile, p)) == APR_SUCCESS) {
rc = apr_file_dup2(errfile, s_main->error_log, p);
}
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rc, s_main,
"unable to replace stderr with error_log");
}
else {
replace_stderr = 0;
}
}
/* note that stderr may still need to be replaced with something
* because it points to the old error log, or back to the tty
* of the submitter.
* XXX: This is BS - /dev/null is non-portable
*/
if (replace_stderr && freopen("/dev/null", "w", stderr) == NULL) {
ap_log_error(APLOG_MARK, APLOG_CRIT, errno, s_main,
"unable to replace stderr with /dev/null");
}
for (virt = s_main->next; virt; virt = virt->next) {
if (virt->error_fname) {
for (q=s_main; q != virt; q = q->next) {
if (q->error_fname != NULL
&& strcmp(q->error_fname, virt->error_fname) == 0) {
break;
}
}
if (q == virt) {
if (open_error_log(virt, 0, p) != OK) {
return DONE;
}
}
else {
virt->error_log = q->error_log;
}
}
else {
virt->error_log = s_main->error_log;
}
}
return OK;
}
/*
* Let's do it. We end up doing a lot of file opening and closing,
* but what do we care? This application isn't run constantly.
*/
int main(int argc, const char * const argv[])
{
apr_file_t *fpw = NULL;
char record[MAX_STRING_LEN];
char line[MAX_STRING_LEN];
char *password = NULL;
char *pwfilename = NULL;
char *user = NULL;
char tn[] = "htpasswd.tmp.XXXXXX";
char *dirname;
char *scratch, cp[MAX_STRING_LEN];
int found = 0;
int i;
int alg = ALG_APMD5;
int mask = 0;
apr_pool_t *pool;
int existing_file = 0;
#if APR_CHARSET_EBCDIC
apr_status_t rv;
apr_xlate_t *to_ascii;
#endif
apr_app_initialize(&argc, &argv, NULL);
atexit(terminate);
apr_pool_create(&pool, NULL);
apr_file_open_stderr(&errfile, pool);
#if APR_CHARSET_EBCDIC
rv = apr_xlate_open(&to_ascii, "ISO-8859-1", APR_DEFAULT_CHARSET, pool);
if (rv) {
apr_file_printf(errfile, "apr_xlate_open(to ASCII)->%d" NL, rv);
exit(1);
}
rv = apr_SHA1InitEBCDIC(to_ascii);
if (rv) {
apr_file_printf(errfile, "apr_SHA1InitEBCDIC()->%d" NL, rv);
exit(1);
}
rv = apr_MD5InitEBCDIC(to_ascii);
if (rv) {
apr_file_printf(errfile, "apr_MD5InitEBCDIC()->%d" NL, rv);
exit(1);
}
#endif /*APR_CHARSET_EBCDIC*/
check_args(pool, argc, argv, &alg, &mask, &user, &pwfilename, &password);
#if defined(WIN32) || defined(NETWARE)
if (alg == ALG_CRYPT) {
alg = ALG_APMD5;
apr_file_printf(errfile, "Automatically using MD5 format." NL);
}
#endif
#if (!(defined(WIN32) || defined(TPF) || defined(NETWARE)))
if (alg == ALG_PLAIN) {
apr_file_printf(errfile,"Warning: storing passwords as plain text "
"might just not work on this platform." NL);
}
#endif
/*
* Only do the file checks if we're supposed to frob it.
*/
if (!(mask & APHTP_NOFILE)) {
existing_file = exists(pwfilename, pool);
if (existing_file) {
/*
* Check that this existing file is readable and writable.
*/
if (!accessible(pool, pwfilename, APR_READ | APR_APPEND)) {
apr_file_printf(errfile, "%s: cannot open file %s for "
"read/write access" NL, argv[0], pwfilename);
exit(ERR_FILEPERM);
}
}
else {
/*
* Error out if -c was omitted for this non-existant file.
*/
if (!(mask & APHTP_NEWFILE)) {
apr_file_printf(errfile,
"%s: cannot modify file %s; use '-c' to create it" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
/*
* As it doesn't exist yet, verify that we can create it.
*/
if (!accessible(pool, pwfilename, APR_CREATE | APR_WRITE)) {
apr_file_printf(errfile, "%s: cannot create file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
}
}
/*
* All the file access checks (if any) have been made. Time to go to work;
* try to create the record for the username in question. If that
* fails, there's no need to waste any time on file manipulations.
* Any error message text is returned in the record buffer, since
* the mkrecord() routine doesn't have access to argv[].
*/
if (!(mask & APHTP_DELUSER)) {
i = mkrecord(user, record, sizeof(record) - 1,
password, alg);
if (i != 0) {
apr_file_printf(errfile, "%s: %s" NL, argv[0], record);
exit(i);
}
if (mask & APHTP_NOFILE) {
printf("%s" NL, record);
exit(0);
}
}
/*
* We can access the files the right way, and we have a record
* to add or update. Let's do it..
*/
if (apr_temp_dir_get((const char**)&dirname, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: could not determine temp dir" NL,
argv[0]);
exit(ERR_FILEPERM);
}
dirname = apr_psprintf(pool, "%s/%s", dirname, tn);
if (apr_file_mktemp(&ftemp, dirname, 0, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to create temporary file %s" NL,
argv[0], dirname);
exit(ERR_FILEPERM);
}
/*
* If we're not creating a new file, copy records from the existing
* one to the temporary file until we find the specified user.
*/
if (existing_file && !(mask & APHTP_NEWFILE)) {
if (apr_file_open(&fpw, pwfilename, APR_READ | APR_BUFFERED,
APR_OS_DEFAULT, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to read file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
while (apr_file_gets(line, sizeof(line), fpw) == APR_SUCCESS) {
char *colon;
strcpy(cp, line);
scratch = cp;
while (apr_isspace(*scratch)) {
++scratch;
}
if (!*scratch || (*scratch == '#')) {
putline(ftemp, line);
continue;
}
/*
* See if this is our user.
*/
colon = strchr(scratch, ':');
if (colon != NULL) {
*colon = '\0';
}
else {
/*
* If we've not got a colon on the line, this could well
* not be a valid htpasswd file.
* We should bail at this point.
*/
apr_file_printf(errfile, "%s: The file %s does not appear "
"to be a valid htpasswd file." NL,
argv[0], pwfilename);
apr_file_close(fpw);
exit(ERR_INVALID);
}
if (strcmp(user, scratch) != 0) {
putline(ftemp, line);
continue;
}
else {
if (!(mask & APHTP_DELUSER)) {
/* We found the user we were looking for.
* Add him to the file.
*/
apr_file_printf(errfile, "Updating ");
putline(ftemp, record);
found++;
}
else {
/* We found the user we were looking for.
* Delete them from the file.
*/
apr_file_printf(errfile, "Deleting ");
found++;
}
}
}
apr_file_close(fpw);
}
if (!found && !(mask & APHTP_DELUSER)) {
apr_file_printf(errfile, "Adding ");
putline(ftemp, record);
}
else if (!found && (mask & APHTP_DELUSER)) {
apr_file_printf(errfile, "User %s not found" NL, user);
exit(0);
}
apr_file_printf(errfile, "password for user %s" NL, user);
/* The temporary file has all the data, just copy it to the new location.
*/
if (apr_file_copy(dirname, pwfilename, APR_FILE_SOURCE_PERMS, pool) !=
APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to update file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
apr_file_close(ftemp);
return 0;
}
AP_DECLARE(void) ap_open_stderr_log(apr_pool_t *p)
{
apr_file_open_stderr(&stderr_log, p);
}
/*
* 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;
}
void logging_preinit(config_t *cfg)
{
apr_pool_create(&cfg->errorlog_p, cfg->pool);
apr_file_open_stderr(&cfg->errorlog_fperr, cfg->pool);
}
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;
}
