/*++ 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; }
int get_password(struct passwd_ctx *ctx) { char buf[MAX_STRING_LEN + 1]; if (ctx->passwd_src == PW_STDIN) { apr_file_t *file_stdin; apr_size_t nread; if (apr_file_open_stdin(&file_stdin, ctx->pool) != APR_SUCCESS) { ctx->errstr = "Unable to read from stdin."; return ERR_GENERAL; } if (apr_file_read_full(file_stdin, buf, sizeof(buf) - 1, &nread) != APR_EOF || nread == sizeof(buf) - 1) { goto err_too_long; } buf[nread] = '\0'; if (nread >= 1 && buf[nread-1] == '\n') { buf[nread-1] = '\0'; if (nread >= 2 && buf[nread-2] == '\r') buf[nread-2] = '\0'; } apr_file_close(file_stdin); ctx->passwd = apr_pstrdup(ctx->pool, buf); } else if (ctx->passwd_src == PW_PROMPT_VERIFY) { apr_size_t bufsize = sizeof(buf); if (apr_password_get("Enter password: "******"New password: "******"Re-type new password: "******"password verification error"; memset(ctx->passwd, '\0', strlen(ctx->passwd)); memset(buf, '\0', sizeof(buf)); return ERR_PWMISMATCH; } } memset(buf, '\0', sizeof(buf)); return 0; err_too_long: ctx->errstr = apr_psprintf(ctx->pool, "password too long (>%" APR_SIZE_T_FMT ")", ctx->out_len - 1); return ERR_OVERFLOW; }
svn_error_t * svn_stream_for_stdin(svn_stream_t **in, apr_pool_t *pool) { apr_file_t *stdin_file; apr_status_t apr_err; apr_err = apr_file_open_stdin(&stdin_file, pool); if (apr_err) return svn_error_wrap_apr(apr_err, "Can't open stdin"); *in = svn_stream_from_aprfile2(stdin_file, TRUE, pool); return SVN_NO_ERROR; }
/* Read a dumpstream from stdin, and use it to feed a loader capable * of transmitting that information to the repository located at URL * (to which SESSION has been opened). AUX_SESSION is a second RA * session opened to the same URL for performing auxiliary out-of-band * operations. */ static svn_error_t * load_revisions(svn_ra_session_t *session, svn_ra_session_t *aux_session, const char *url, svn_boolean_t quiet, apr_pool_t *pool) { apr_file_t *stdin_file; svn_stream_t *stdin_stream; apr_file_open_stdin(&stdin_file, pool); stdin_stream = svn_stream_from_aprfile2(stdin_file, FALSE, pool); SVN_ERR(svn_rdump__load_dumpstream(stdin_stream, session, aux_session, quiet, check_cancel, NULL, pool)); SVN_ERR(svn_stream_close(stdin_stream)); return SVN_NO_ERROR; }
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 * 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. */ }
double write_allocs(ibp_capset_t *caps, int qlen, int n, int asize, int block_size) { int count, i, j, nleft, nblocks, rem, len, err, block_start, alloc_start; int *slot; op_status_t status; int64_t nbytes, last_bytes, print_bytes, delta_bytes; apr_int32_t nfds, finished; double dbytes, r1, r2; apr_pool_t *pool; apr_file_t *fd_in; opque_t *q; op_generic_t *op; char *buffer = (char *)malloc(block_size); apr_interval_time_t dt = 10; apr_pollfd_t pfd; apr_time_t stime, dtime; int *tbuf_index; tbuffer_t *buf; Stack_t *tbuf_free; tbuf_free = new_stack(); type_malloc_clear(tbuf_index, int, qlen); type_malloc_clear(buf, tbuffer_t, qlen); for (i=0; i<qlen; i++) { tbuf_index[i] = i; push(tbuf_free, &(tbuf_index[i])); } //** Make the stuff to capture the kbd apr_pool_create(&pool, NULL); nfds = 1; apr_file_open_stdin(&fd_in, pool); pfd.p = pool; pfd.desc_type = APR_POLL_FILE; pfd.reqevents = APR_POLLIN|APR_POLLHUP; pfd.desc.f = fd_in; pfd.client_data = NULL; //** Init the ibp stuff init_buffer(buffer, 'W', block_size); q = new_opque(); opque_start_execution(q); nblocks = asize / block_size; rem = asize % block_size; if (rem > 0) nblocks++; block_start = 0; alloc_start = 0; finished = 0; apr_poll(&pfd, nfds, &finished, dt); count = 0; nbytes=0; last_bytes = 0; delta_bytes = 1024 * 1024 * 1024; print_bytes = delta_bytes; stime = apr_time_now(); while (finished == 0) { // nleft = qlen - opque_tasks_left(q); nleft = stack_size(tbuf_free); // printf("\nLOOP: nleft=%d qlen=%d\n", nleft, qlen); if (nleft > 0) { for (j=block_start; j < nblocks; j++) { for (i=alloc_start; i<n; i++) { nleft--; if (nleft <= 0) { block_start = j; alloc_start = i; goto skip_submit; } slot = (int *)pop(tbuf_free); if ((j==(nblocks-1)) && (rem > 0)) { len = rem; } else { len = block_size; } // printf("%d=(%d,%d) ", count, j, i); tbuffer_single(&(buf[*slot]), len, buffer); op = new_ibp_write_op(ic, get_ibp_cap(&(caps[i]), IBP_WRITECAP), j*block_size, &(buf[*slot]), 0, len, ibp_timeout); gop_set_id(op, *slot); ibp_op_set_cc(ibp_get_iop(op), cc); ibp_op_set_ncs(ibp_get_iop(op), ncs); opque_add(q, op); } alloc_start = 0; } block_start = 0; } skip_submit: finished = 1; apr_poll(&pfd, nfds, &finished, dt); do { //** Empty the finished queue. Always wait for for at least 1 to complete op = opque_waitany(q); status = gop_get_status(op); if (status.error_code != IBP_OK) { printf("ERROR: Aborting with error code %d\n", status.error_code); finished = 0; } count++; i = gop_get_id(op); nbytes = nbytes + tbuffer_size(&(buf[i])); if (nbytes > print_bytes) { dbytes = nbytes / (1.0*1024*1024*1024); dtime = apr_time_now() - stime; r2 = dtime / (1.0 * APR_USEC_PER_SEC); r1 = nbytes - last_bytes; r1 = r1 / (r2 * 1024.0 * 1024.0); printf("%.2lfGB written (%.2lfMB/s : %.2lf secs)\n", dbytes, r1, r2); print_bytes = print_bytes + delta_bytes; last_bytes = nbytes; stime = apr_time_now(); } push(tbuf_free, &(tbuf_index[i])); gop_free(op, OP_DESTROY); } while (opque_tasks_finished(q) > 0); } err = opque_waitall(q); if (err != OP_STATE_SUCCESS) { printf("write_allocs: At least 1 error occured! * ibp_errno=%d * nfailed=%d\n", err, opque_tasks_failed(q)); } opque_free(q, OP_DESTROY); free_stack(tbuf_free, 0); free(tbuf_index); free(buf); free(buffer); apr_pool_destroy(pool); dbytes = nbytes; return(dbytes); }
/* Drive EDITOR to affect the change represented by OPERATION. HEAD is the last-known youngest revision in the repository. */ static svn_error_t * drive(struct operation *operation, svn_revnum_t head, const svn_delta_editor_t *editor, apr_pool_t *pool) { apr_pool_t *subpool = svn_pool_create(pool); apr_hash_index_t *hi; struct driver_state state; for (hi = apr_hash_first(pool, operation->children); hi; hi = apr_hash_next(hi)) { const void *key; void *val; struct operation *child; void *file_baton = NULL; svn_pool_clear(subpool); apr_hash_this(hi, &key, NULL, &val); child = val; /* Deletes and replacements are simple -- delete something. */ if (child->operation == OP_DELETE || child->operation == OP_REPLACE) { SVN_ERR(editor->delete_entry(key, head, operation->baton, subpool)); } /* Opens could be for directories or files. */ if (child->operation == OP_OPEN) { if (child->kind == svn_node_dir) { SVN_ERR(editor->open_directory(key, operation->baton, head, subpool, &child->baton)); } else { SVN_ERR(editor->open_file(key, operation->baton, head, subpool, &file_baton)); } } /* Adds and replacements could also be for directories or files. */ if (child->operation == OP_ADD || child->operation == OP_REPLACE || child->operation == OP_PROPSET) { if (child->kind == svn_node_dir) { SVN_ERR(editor->add_directory(key, operation->baton, child->url, child->rev, subpool, &child->baton)); } else { SVN_ERR(editor->add_file(key, operation->baton, child->url, child->rev, subpool, &file_baton)); } } /* If there's a source file and an open file baton, we get to change textual contents. */ if ((child->src_file) && (file_baton)) { svn_txdelta_window_handler_t handler; void *handler_baton; svn_stream_t *contents; apr_file_t *f = NULL; SVN_ERR(editor->apply_textdelta(file_baton, NULL, subpool, &handler, &handler_baton)); if (strcmp(child->src_file, "-")) { SVN_ERR(svn_io_file_open(&f, child->src_file, APR_READ, APR_OS_DEFAULT, pool)); } else { apr_status_t apr_err = apr_file_open_stdin(&f, pool); if (apr_err) return svn_error_wrap_apr(apr_err, "Can't open stdin"); } contents = svn_stream_from_aprfile(f, pool); SVN_ERR(svn_txdelta_send_stream(contents, handler, handler_baton, NULL, pool)); SVN_ERR(svn_io_file_close(f, pool)); } /* If we opened a file, we need to apply outstanding propmods, then close it. */ if (file_baton) { if ((child->kind == svn_node_file) && (! apr_is_empty_table(child->props))) { state.baton = file_baton; state.pool = subpool; state.editor = editor; state.kind = child->kind; if (! apr_table_do(set_props, &state, child->props, NULL)) SVN_ERR(state.err); } SVN_ERR(editor->close_file(file_baton, NULL, subpool)); } /* If we opened, added, or replaced a directory, we need to recurse, apply outstanding propmods, and then close it. */ if ((child->kind == svn_node_dir) && (child->operation == OP_OPEN || child->operation == OP_ADD || child->operation == OP_REPLACE)) { SVN_ERR(drive(child, head, editor, subpool)); if ((child->kind == svn_node_dir) && (! apr_is_empty_table(child->props))) { state.baton = child->baton; state.pool = subpool; state.editor = editor; state.kind = child->kind; if (! apr_table_do(set_props, &state, child->props, NULL)) SVN_ERR(state.err); } SVN_ERR(editor->close_directory(child->baton, subpool)); } } svn_pool_destroy(subpool); return SVN_NO_ERROR; }