/*++
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;
}
/* 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;
}
/* 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;
}
/* 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, 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 *errfile;
if (((rc = apr_procattr_create(&procattr, p)) == APR_SUCCESS)
&& ((rc = apr_procattr_cmdtype_set(procattr,
APR_SHELLCMD_ENV)) == 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)
&& (!dummy_stderr
|| ((rc = apr_file_open_stdout(&errfile, p)) == APR_SUCCESS
&& (rc = apr_procattr_child_err_set(procattr,
errfile,
errfile)) == 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));
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()
*/
}
/* apr_procattr_child_err_set dups errfile twice: close the
* remaining "parent-side" copy (apr_proc_create closes the
* other). */
if (dummy_stderr) {
apr_file_close(procnew->err);
}
}
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);
}
svn_error_t *
svn_stream_for_stdout(svn_stream_t **out, apr_pool_t *pool)
{
apr_file_t *stdout_file;
apr_status_t apr_err;
apr_err = apr_file_open_stdout(&stdout_file, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, "Can't open stdout");
*out = svn_stream_from_aprfile2(stdout_file, TRUE, pool);
return SVN_NO_ERROR;
}
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 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_stdout(&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);
}
}
}
int main(int argc, const char **argv)
{
apr_status_t status;
apr_pool_t *pool;
serf_bucket_alloc_t *bkt_alloc;
serf_context_t *context;
serf_connection_t **connections;
app_baton_t app_ctx;
handler_baton_t handler_ctx;
serf_bucket_t *req_hdrs = NULL;
apr_uri_t url;
const char *proxy = NULL;
const char *raw_url, *method, *req_body_path = NULL;
int count, inflight, conn_count;
int i;
int print_headers, debug;
const char *username = NULL;
const char *password = "";
const char *pem_path = NULL, *pem_pwd = NULL;
apr_getopt_t *opt;
int opt_c;
const char *opt_arg;
apr_initialize();
atexit(apr_terminate);
apr_pool_create(&pool, NULL);
/* serf_initialize(); */
bkt_alloc = serf_bucket_allocator_create(pool, NULL, NULL);
/* Default to one round of fetching with no limit to max inflight reqs. */
count = 1;
inflight = 0;
conn_count = 1;
/* Default to GET. */
method = "GET";
/* Do not print headers by default. */
print_headers = 0;
/* Do not debug by default. */
debug = 0;
apr_getopt_init(&opt, pool, argc, argv);
while ((status = apr_getopt_long(opt, options, &opt_c, &opt_arg)) ==
APR_SUCCESS) {
switch (opt_c) {
case 'U':
username = opt_arg;
break;
case 'P':
password = opt_arg;
break;
case 'd':
debug = 1;
break;
case 'f':
req_body_path = opt_arg;
break;
case 'h':
print_usage(pool);
exit(0);
break;
case 'H':
print_headers = 1;
break;
case 'm':
method = opt_arg;
break;
case 'n':
errno = 0;
count = apr_strtoi64(opt_arg, NULL, 10);
if (errno) {
printf("Problem converting number of times to fetch URL (%d)\n",
errno);
return errno;
}
break;
case 'c':
errno = 0;
conn_count = apr_strtoi64(opt_arg, NULL, 10);
if (errno) {
printf("Problem converting number of concurrent connections to use (%d)\n",
errno);
return errno;
}
if (conn_count <= 0) {
printf("Invalid number of concurrent connections to use (%d)\n",
conn_count);
return 1;
}
break;
case 'x':
errno = 0;
inflight = apr_strtoi64(opt_arg, NULL, 10);
if (errno) {
printf("Problem converting number of requests to have outstanding (%d)\n",
errno);
return errno;
}
break;
case 'p':
proxy = opt_arg;
break;
case 'r':
{
char *sep;
char *hdr_val;
if (req_hdrs == NULL) {
/* first request header, allocate bucket */
req_hdrs = serf_bucket_headers_create(bkt_alloc);
}
sep = strchr(opt_arg, ':');
if ((sep == NULL) || (sep == opt_arg) || (strlen(sep) <= 1)) {
printf("Invalid request header string (%s)\n", opt_arg);
return EINVAL;
}
hdr_val = sep + 1;
while (*hdr_val == ' ') {
hdr_val++;
}
serf_bucket_headers_setx(req_hdrs, opt_arg, (sep - opt_arg), 1,
hdr_val, strlen(hdr_val), 1);
}
break;
case CERTFILE:
pem_path = opt_arg;
break;
case CERTPWD:
pem_pwd = opt_arg;
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;
}
if (strcasecmp(method, "HEAD") == 0) {
app_ctx.head_request = 1;
}
else {
app_ctx.head_request = 0;
}
app_ctx.hostinfo = url.hostinfo;
app_ctx.pem_path = pem_path;
app_ctx.pem_pwd = pem_pwd;
context = serf_context_create(pool);
app_ctx.serf_ctx = context;
if (proxy)
{
apr_sockaddr_t *proxy_address = NULL;
apr_port_t proxy_port;
char *proxy_host;
char *proxy_scope;
status = apr_parse_addr_port(&proxy_host, &proxy_scope, &proxy_port, proxy, pool);
if (status)
{
printf("Cannot parse proxy hostname/port: %d\n", status);
apr_pool_destroy(pool);
exit(1);
}
if (!proxy_host)
{
printf("Proxy hostname must be specified\n");
apr_pool_destroy(pool);
exit(1);
}
if (!proxy_port)
{
printf("Proxy port must be specified\n");
apr_pool_destroy(pool);
exit(1);
}
status = apr_sockaddr_info_get(&proxy_address, proxy_host, APR_UNSPEC,
proxy_port, 0, pool);
if (status)
{
printf("Cannot resolve proxy address '%s': %d\n", proxy_host, status);
apr_pool_destroy(pool);
exit(1);
}
serf_config_proxy(context, proxy_address);
}
if (username)
{
serf_config_authn_types(context, SERF_AUTHN_ALL);
}
else
{
serf_config_authn_types(context, SERF_AUTHN_NTLM | SERF_AUTHN_NEGOTIATE);
}
serf_config_credentials_callback(context, credentials_callback);
/* Setup debug logging */
if (debug)
{
serf_log_output_t *output;
apr_status_t status;
status = serf_logging_create_stream_output(&output,
context,
SERF_LOG_DEBUG,
SERF_LOGCOMP_ALL_MSG,
SERF_LOG_DEFAULT_LAYOUT,
stderr,
pool);
if (!status)
serf_logging_add_output(context, output);
}
/* ### Connection or Context should have an allocator? */
app_ctx.bkt_alloc = bkt_alloc;
connections = apr_pcalloc(pool, conn_count * sizeof(serf_connection_t*));
for (i = 0; i < conn_count; i++)
{
conn_baton_t *conn_ctx = apr_pcalloc(pool, sizeof(*conn_ctx));
conn_ctx->app = &app_ctx;
conn_ctx->ssl_ctx = NULL;
status = serf_connection_create2(&connections[i], context, url,
conn_setup, conn_ctx,
closed_connection, conn_ctx,
pool);
if (status) {
printf("Error creating connection: %d\n", status);
apr_pool_destroy(pool);
exit(1);
}
serf_connection_set_max_outstanding_requests(connections[i], inflight);
}
handler_ctx.completed_requests = 0;
handler_ctx.print_headers = print_headers;
#if APR_VERSION_AT_LEAST(1, 3, 0)
apr_file_open_flags_stdout(&handler_ctx.output_file, APR_BUFFERED, pool);
#else
apr_file_open_stdout(&handler_ctx.output_file, pool);
#endif
handler_ctx.host = url.hostinfo;
handler_ctx.method = method;
handler_ctx.path = apr_pstrcat(pool,
url.path,
url.query ? "?" : "",
url.query ? url.query : "",
NULL);
handler_ctx.username = username;
handler_ctx.password = password;
handler_ctx.auth_attempts = 0;
handler_ctx.req_body_path = req_body_path;
handler_ctx.acceptor = accept_response;
handler_ctx.acceptor_baton = &app_ctx;
handler_ctx.handler = handle_response;
handler_ctx.req_hdrs = req_hdrs;
for (i = 0; i < count; i++) {
/* We don't need the returned request here. */
serf_connection_request_create(connections[i % conn_count],
setup_request, &handler_ctx);
}
while (1) {
status = serf_context_run(context, SERF_DURATION_FOREVER, pool);
if (APR_STATUS_IS_TIMEUP(status))
continue;
if (status) {
char buf[200];
const char *err_string;
err_string = serf_error_string(status);
if (!err_string) {
err_string = apr_strerror(status, buf, sizeof(buf));
}
printf("Error running context: (%d) %s\n", status, err_string);
apr_pool_destroy(pool);
exit(1);
}
if (apr_atomic_read32(&handler_ctx.completed_requests) >= count) {
break;
}
/* Debugging purposes only! */
serf_debug__closed_conn(app_ctx.bkt_alloc);
}
apr_file_close(handler_ctx.output_file);
for (i = 0; i < conn_count; i++)
{
serf_connection_close(connections[i]);
}
apr_pool_destroy(pool);
return 0;
}
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[])
{
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. */
}
/* Compile with
* $> export APR_LIBS="`apr-1-config --cflags --cppflags --includes --ldflags --link-ld --libs`"
* $> export APU_LIBS="`apu-1-config --includes --ldflags --link-ld --libs`"
* $> gcc aprGetoptLong.c -o aprGetoptLong $APR_LIBS $APU_LIBS
*/
int main(int argc, const char * const *argv)
{
apr_pool_t *p = NULL;
apr_getopt_t *cmdLineArgs = NULL;
apr_status_t rv;
int optChar = 0;
const char *optArg = NULL;
/* Will hold the position for the non optional
* args in the APR parsed argv
*/
int processedOptions = 0;
/* cleanly handle fileIO this time */
apr_file_t *out = NULL;
apr_file_t *err = NULL;
/* Let's handle long opts too */
const apr_getopt_option_t longOpts[] = {{"help", 'h', 0, "Show help"}, {"choose", 'c', 1, "Choose something"}};
/* init APR, create memory pool */
apr_app_initialize(&argc, &argv, NULL);
atexit(apr_terminate);
apr_pool_create(&p, NULL);
/* Open stdin, stderr */
apr_file_open_stdout(&out, p);
apr_file_open_stderr(&err, p);
/* init APRs getopt */
apr_getopt_init(&cmdLineArgs, p, argc, argv);
/* Allow options to be added after arguments */
cmdLineArgs->interleave = 1;
/* Now step through the options given */
while ((rv = apr_getopt_long(cmdLineArgs, longOpts, &optChar, &optArg)) == APR_SUCCESS) {
switch(optChar) {
case 'h':
apr_file_printf(out, "Read option h ...\n");
break;
case 'c':
apr_file_printf(out, "Read option c with argument %s \n", optArg);
break;
default:
apr_file_printf(out, "Default reached ...\n");
}
}
if (APR_STATUS_IS_BADCH(rv)) {
apr_file_printf(err, "Read bad option ...\n");
}
processedOptions = cmdLineArgs->ind;
/* Now spit out non options */
while (processedOptions < argc) {
apr_file_printf(out, "Non opt arg: %s\n", cmdLineArgs->argv[processedOptions++]);
}
apr_pool_destroy(p);
return 0;
}
/* fonction simulant la commande svn diff */
apr_array_header_t *svn_support_diff_call(char *rep_path,
char *filename,
int revision1,
int revision2,
apr_pool_t* subpool)
{
svn_error_t *err;
apr_file_t *outfile;
apr_file_t *errfile;
apr_status_t rv;
svn_opt_revision_t rev1;
svn_opt_revision_t rev2;
// -- Initialisation du tableau et du buffer de résultats --
apr_array_header_t *list_result = apr_array_make(subpool, 1, sizeof (const char *));
svn_stringbuf_t *res = svn_stringbuf_create("",subpool);
// -- Initialisation des chemins des fichiers --
const svn_stringbuf_t *slash = svn_stringbuf_create("/",subpool);
const svn_stringbuf_t *filepath = svn_stringbuf_create(filename,subpool);
svn_stringbuf_t *path = svn_stringbuf_create(rep_path,subpool);
if (strcmp(filename,"") != 0) {
svn_stringbuf_appendstr(path,slash);
svn_stringbuf_appendstr(path,filepath);
}
// -- Initialisation des revisions --
rev1.kind = rev2.kind = svn_opt_revision_number;
rev1.value.number=revision1;
rev2.value.number=revision2;
// -- Initialisation des fichiers d'output --
if ((rv = apr_file_open_stdout(&outfile,subpool)) != APR_SUCCESS) {
svn_pool_destroy(subpool);
return NULL;
}
if ((rv = apr_file_open_stdout(&errfile,subpool)) != APR_SUCCESS) {
svn_pool_destroy(subpool);
return NULL;
}
const apr_array_header_t *diff_options = apr_array_make(subpool, 1, sizeof (const char *));
//apr_file_t *write_end;
//apr_file_t *read_end;
//apr_file_pipe_create(&write_end,&read_end,subpool);
int tube[2];
pipe(tube);
switch(fork()){
case -1:
perror("fork");
svn_pool_destroy(subpool);
return NULL;
case 0:
//apr_file_close(read_end);
//apr_file_dup2(outfile,write_end,subpool);
close(tube[0]);
dup2(tube[1],STDOUT_FILENO);
err = svn_client_diff4(diff_options,
path->data,
&rev1,
path->data,
&rev2,
NULL,
svn_depth_infinity,
TRUE,// ignore_ancestry
TRUE,// no_diff_deleted
FALSE, // ignore_content_type
SVN_APR_LOCALE_CHARSET,
outfile,
errfile,
NULL,
ctx,
subpool);
if (err) {
svn_handle_error2 (err, stderr, FALSE, "svn_support_diff: ");
svn_pool_destroy(subpool);
return NULL;
}
exit(0);
}
//apr_file_close(write_end);
close(tube[1]);
int buf_size = 4096;
char buf[buf_size];
int rc;
const svn_stringbuf_t *tmp;
while((rc=read(tube[0],buf,buf_size))>0){//(rv=apr_file_gets(buf,buf_size,read_end))){
//if(APR_STATUS_IS_EOF(rv))
//break;
buf[rc]='\0';
tmp = svn_stringbuf_create(buf,subpool);
svn_stringbuf_appendstr(res,tmp);
//*(char **)apr_array_push(list_result) = buf;
}
wait(NULL);
svn_cstring_split_endline_append(list_result,res->data,subpool);
svn_pool_destroy(subpool);
return list_result;
}
static int
l_diff (lua_State *L) {
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
apr_file_t *aprout;
apr_file_t *aprerr;
apr_status_t status;
apr_array_header_t *array;
svn_opt_revision_t rev1;
svn_opt_revision_t rev2;
const char *path1 = NULL;
const char *path2 = NULL;
const char *outfile = NULL;
const char *errfile = NULL;
int itable = 7;
svn_boolean_t recursive = TRUE;
svn_boolean_t ignore_ancestry = TRUE;
svn_boolean_t no_diff_deleted = FALSE;
svn_boolean_t force = FALSE;
path1 = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
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);
}
path2 = (lua_gettop (L) < 3 || lua_isnil (L, 3)) ? path1 : luaL_checkstring (L, 3);
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);
}
outfile = (lua_gettop (L) < 5 || lua_isnil (L, 5)) ? NULL : luaL_checkstring (L, 5);
errfile = (lua_gettop (L) < 6 || lua_isnil (L, 6)) ? NULL : luaL_checkstring (L, 6);
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "ignore_ancestry");
if (lua_isboolean (L, -1)) {
ignore_ancestry = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "no_diff_deleted");
if (lua_isboolean (L, -1)) {
no_diff_deleted = lua_toboolean (L, -1);
}
lua_getfield (L, itable, "force");
if (lua_isboolean (L, -1)) {
force = lua_toboolean (L, -1);
}
}
init_function (&ctx, &pool, L);
path1 = svn_path_canonicalize (path1, pool);
path2 = svn_path_canonicalize (path2, pool);
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);
}
array = apr_array_make (pool, 0, sizeof (const char *));
err = svn_client_diff3 (array, path1, &rev1, path2, &rev2,
recursive, ignore_ancestry, no_diff_deleted, force,
APR_LOCALE_CHARSET, aprout, aprerr,
ctx, pool);
IF_ERROR_RETURN (err, pool, L);
svn_pool_destroy (pool);
return 0;
}
