S32 ll_apr_file_read(apr_file_t* apr_file, void *buf, S32 nbytes) { apr_size_t sz = nbytes; apr_status_t s = apr_file_read(apr_file, buf, &sz); if (s != APR_SUCCESS) { return 0; } else { llassert_always(sz <= 0x7fffffff); return (S32)sz; } }
APU_DECLARE(apr_status_t) apr_xml_parse_file(apr_pool_t *p, apr_xml_parser **parser, apr_xml_doc **ppdoc, apr_file_t *xmlfd, apr_size_t buffer_length) { apr_status_t rv; char *buffer; apr_size_t length; *parser = apr_xml_parser_create(p); if (*parser == NULL) { /* FIXME: returning an error code would be nice, * but we dont get one ;( */ return APR_EGENERAL; } buffer = apr_palloc(p, buffer_length); length = buffer_length; rv = apr_file_read(xmlfd, buffer, &length); while (rv == APR_SUCCESS) { rv = apr_xml_parser_feed(*parser, buffer, length); if (rv != APR_SUCCESS) { return rv; } length = buffer_length; rv = apr_file_read(xmlfd, buffer, &length); } if (rv != APR_EOF) { return rv; } rv = apr_xml_parser_done(*parser, ppdoc); *parser = NULL; return rv; }
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_READ | APR_WRITE | APR_CREATE | APR_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_INT_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); }
/* reads a line from a filehandle. */ MVMString * MVM_file_readline_fh(MVMThreadContext *tc, MVMObject *oshandle) { MVMString *result; apr_status_t rv; MVMOSHandle *handle; char ch; char *buf; apr_off_t offset = 0; apr_off_t fetched = 0; apr_off_t bytes_read = 0; verify_filehandle_type(tc, oshandle, &handle, "readline from filehandle"); if ((rv = apr_file_seek(handle->body.file_handle, APR_CUR, &offset)) != APR_SUCCESS) { MVM_exception_throw_apr_error(tc, rv, "Failed to tell position of filehandle in readline(1): "); } while (apr_file_getc(&ch, handle->body.file_handle) == APR_SUCCESS && ch != 10 && ch != 13) { bytes_read++; } /* have a look if it is a windows newline, and step back if not. */ if (ch == 13 && apr_file_getc(&ch, handle->body.file_handle) == APR_SUCCESS && ch != 10) { fetched--; } if ((rv = apr_file_seek(handle->body.file_handle, APR_CUR, &fetched)) != APR_SUCCESS) { MVM_exception_throw_apr_error(tc, rv, "Failed to tell position of filehandle in readline(2): "); } if ((rv = apr_file_seek(handle->body.file_handle, APR_SET, &offset)) != APR_SUCCESS) { MVM_exception_throw_apr_error(tc, rv, "Failed to tell position of filehandle in readline(3)"); } buf = malloc((int)(bytes_read + 1)); if ((rv = apr_file_read(handle->body.file_handle, buf, &bytes_read)) != APR_SUCCESS) { free(buf); MVM_exception_throw_apr_error(tc, rv, "readline from filehandle failed: "); } if ((rv = apr_file_seek(handle->body.file_handle, APR_SET, &fetched)) != APR_SUCCESS) { MVM_exception_throw_apr_error(tc, rv, "Failed to tell position of filehandle in readline(4)"); } /* XXX should this take a type object? */ result = MVM_decode_C_buffer_to_string(tc, tc->instance->VMString, buf, bytes_read, handle->body.encoding_type); free(buf); return result; }
/* Read and discard what's ever in the wakeup pipe. */ void apr_pollset_drain_wakeup_pipe(apr_pollset_t *pollset) { char rb[512]; apr_size_t nr = sizeof(rb); while (apr_file_read(pollset->wakeup_pipe[0], rb, &nr) == APR_SUCCESS) { /* Although we write just one byte to the other end of the pipe * during wakeup, multiple threads could call the wakeup. * So simply drain out from the input side of the pipe all * the data. */ if (nr != sizeof(rb)) break; } }
// File I/O S32 LLAPRFile::read(void *buf, S32 nbytes) { llassert_always(mFile) ; apr_size_t sz = nbytes; apr_status_t s = apr_file_read(mFile, buf, &sz); if (s != APR_SUCCESS) { return 0; } else { llassert_always(sz <= 0x7fffffff); return (S32)sz; } }
static void test_readzero(abts_case *tc, void *data) { apr_status_t rv; apr_size_t nbytes = 0; char *str = NULL; apr_file_t *filetest; rv = apr_file_open(&filetest, FILENAME, APR_READ, APR_OS_DEFAULT, p); APR_ASSERT_SUCCESS(tc, "Opening test file " FILENAME, rv); rv = apr_file_read(filetest, str, &nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_INT_EQUAL(tc, 0, nbytes); apr_file_close(filetest); }
MP_INLINE SV *modperl_slurp_filename(pTHX_ request_rec *r, int tainted) { SV *sv; apr_status_t rc; apr_size_t size; apr_file_t *file; size = r->finfo.size; sv = newSV(size); /* XXX: could have checked whether r->finfo.filehand is valid and * save the apr_file_open call, but apache gives us no API to * check whether filehand is valid. we can't test whether it's * NULL or not, as it may contain garbagea */ rc = apr_file_open(&file, r->filename, APR_READ|APR_BINARY, APR_OS_DEFAULT, r->pool); SLURP_SUCCESS("opening"); rc = apr_file_read(file, SvPVX(sv), &size); SLURP_SUCCESS("reading"); MP_TRACE_o(MP_FUNC, "read %d bytes from '%s'", size, r->filename); if (r->finfo.size != size) { SvREFCNT_dec(sv); Perl_croak(aTHX_ "Error: read %d bytes, expected %d ('%s')", size, (apr_size_t)r->finfo.size, r->filename); } rc = apr_file_close(file); SLURP_SUCCESS("closing"); SvPVX(sv)[size] = '\0'; SvCUR_set(sv, size); SvPOK_on(sv); if (tainted) { SvTAINTED_on(sv); } else { SvTAINTED_off(sv); } return newRV_noinc(sv); }
/* read all of a filehandle into a string. */ MVMString * MVM_file_readall_fh(MVMThreadContext *tc, MVMObject *oshandle) { MVMString *result; apr_status_t rv; MVMOSHandle *handle; apr_finfo_t finfo; apr_pool_t *tmp_pool; char *buf; MVMint64 bytes_read; /* XXX TODO length currently means bytes. alter it to mean graphemes. */ /* XXX TODO handle length == -1 to mean read to EOF */ verify_filehandle_type(tc, oshandle, &handle, "Readall from filehandle"); ENCODING_VALID(handle->body.encoding_type); /* need a temporary pool */ if ((rv = apr_pool_create(&tmp_pool, POOL(tc))) != APR_SUCCESS) { MVM_exception_throw_apr_error(tc, rv, "Readall failed to create pool: "); } if ((rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, handle->body.file_handle)) != APR_SUCCESS) { apr_pool_destroy(tmp_pool); MVM_exception_throw_apr_error(tc, rv, "Readall failed to get info about file: "); } apr_pool_destroy(tmp_pool); if (finfo.size > 0) { buf = malloc(finfo.size); bytes_read = finfo.size; if ((rv = apr_file_read(handle->body.file_handle, buf, (apr_size_t *)&bytes_read)) != APR_SUCCESS) { free(buf); MVM_exception_throw_apr_error(tc, rv, "Readall from filehandle failed: "); } /* XXX should this take a type object? */ result = MVM_decode_C_buffer_to_string(tc, tc->instance->VMString, buf, bytes_read, handle->body.encoding_type); free(buf); } else { result = (MVMString *)REPR(tc->instance->VMString)->allocate(tc, STABLE(tc->instance->VMString)); } return result; }
static void test_fileclose(CuTest *tc) { char str; apr_status_t rv; apr_size_t one = 1; apr_file_t *filetest = NULL; rv = apr_file_open(&filetest, FILENAME, APR_READ, APR_UREAD | APR_UWRITE | APR_GREAD, p); apr_assert_success(tc, "Opening test file " FILENAME, rv); rv = apr_file_close(filetest); CuAssertIntEquals(tc, APR_SUCCESS, rv); /* We just closed the file, so this should fail */ rv = apr_file_read(filetest, &str, &one); CuAssertIntEquals(tc, 1, APR_STATUS_IS_EBADF(rv)); }
AP_DECLARE(apr_status_t) ap_mpm_pod_check(ap_pod_t *pod) { char c; apr_size_t len = 1; apr_status_t rv; rv = apr_file_read(pod->pod_in, &c, &len); if ((rv == APR_SUCCESS) && (len == 1)) { return APR_SUCCESS; } if (rv != APR_SUCCESS) { return rv; } return AP_NORESTART; }
/* Digests the standard input and prints the result. */ static void MDFilter(void) { apr_md4_ctx_t context; apr_size_t len = 16; unsigned char buffer[16], digest[16]; apr_md4_init(&context); while (apr_file_read(in, buffer, &len) != APR_SUCCESS) { apr_md4_update(&context, buffer, len); len = 16; } apr_md4_update(&context, buffer, len); apr_md4_final(digest, &context); MDPrint(digest); apr_file_printf(out, "\n"); }
static void test_fileclose(abts_case *tc, void *data) { char str; apr_status_t rv; apr_size_t one = 1; apr_file_t *filetest = NULL; rv = apr_file_open(&filetest, FILENAME, APR_READ, APR_UREAD | APR_UWRITE | APR_GREAD, p); APR_ASSERT_SUCCESS(tc, "Opening test file " FILENAME, rv); rv = apr_file_close(filetest); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); /* We just closed the file, so this should fail */ rv = apr_file_read(filetest, &str, &one); ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EBADF(rv)); }
static void test_file_readwrite(abts_case *tc, void *data) { apr_file_t *file1 = NULL; apr_file_t *file3 = NULL; apr_status_t rv; apr_finfo_t finfo; apr_size_t txtlen = sizeof(TEST); char buff[50]; apr_off_t fpos; /* First, create a new file, empty... */ rv = apr_file_open(&file1, FILEPATH "testdup.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, file1); rv = apr_file_dup(&file3, file1, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_PTR_NOTNULL(tc, file3); rv = apr_file_write(file3, TEST, &txtlen); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_SIZE_EQUAL(tc, sizeof(TEST), txtlen); fpos = 0; rv = apr_file_seek(file1, 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(file1, buff, &txtlen); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_STR_EQUAL(tc, TEST, buff); /* cleanup after ourselves */ rv = apr_file_close(file1); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_file_close(file3); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_stat(&finfo, FILEPATH "testdup.readwrite.file", APR_FINFO_NORM, p); ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ENOENT(rv)); }
static void test_create_proc(CuTest *tc) { const char *args[2]; apr_procattr_t *attr; apr_file_t *testfile = NULL; apr_status_t rv; apr_size_t length; char *buf; rv = apr_procattr_create(&attr, p); CuAssertIntEquals(tc, APR_SUCCESS, rv); rv = apr_procattr_io_set(attr, APR_FULL_BLOCK, APR_FULL_BLOCK, APR_NO_PIPE); CuAssertIntEquals(tc, APR_SUCCESS, rv); rv = apr_procattr_dir_set(attr, "data"); CuAssertIntEquals(tc, APR_SUCCESS, rv); rv = apr_procattr_cmdtype_set(attr, APR_PROGRAM); CuAssertIntEquals(tc, APR_SUCCESS, rv); args[0] = "proc_child" EXTENSION; args[1] = NULL; rv = apr_proc_create(&newproc, "../proc_child" EXTENSION, args, NULL, attr, p); CuAssertIntEquals(tc, APR_SUCCESS, rv); testfile = newproc.in; length = strlen(TESTSTR); rv = apr_file_write(testfile, TESTSTR, &length); CuAssertIntEquals(tc, APR_SUCCESS, rv); CuAssertIntEquals(tc, strlen(TESTSTR), length); testfile = newproc.out; length = 256; buf = apr_pcalloc(p, length); rv = apr_file_read(testfile, buf, &length); CuAssertIntEquals(tc, APR_SUCCESS, rv); CuAssertStrEquals(tc, TESTSTR, buf); }
static void test_read(abts_case *tc, void *data) { apr_status_t rv; apr_size_t nbytes = 256; char *str = apr_pcalloc(p, nbytes + 1); apr_file_t *filetest = NULL; rv = apr_file_open(&filetest, FILENAME, APR_READ, APR_UREAD | APR_UWRITE | APR_GREAD, p); APR_ASSERT_SUCCESS(tc, "Opening test file " FILENAME, rv); rv = apr_file_read(filetest, str, &nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_INT_EQUAL(tc, strlen(TESTSTR), nbytes); ABTS_STR_EQUAL(tc, TESTSTR, str); apr_file_close(filetest); }
static void test_create_proc(abts_case *tc, void *data) { const char *args[2]; apr_procattr_t *attr; apr_file_t *testfile = NULL; apr_status_t rv; apr_size_t length; char *buf; rv = apr_procattr_create(&attr, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_procattr_io_set(attr, APR_FULL_BLOCK, APR_FULL_BLOCK, APR_NO_PIPE); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_procattr_dir_set(attr, "data"); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_procattr_cmdtype_set(attr, APR_PROGRAM); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); args[0] = "proc_child" EXTENSION; args[1] = NULL; rv = apr_proc_create(&newproc, "../" TESTBINPATH "proc_child" EXTENSION, args, NULL, attr, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); testfile = newproc.in; length = strlen(TESTSTR); rv = apr_file_write(testfile, TESTSTR, &length); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_SIZE_EQUAL(tc, strlen(TESTSTR), length); testfile = newproc.out; length = 256; buf = apr_pcalloc(p, length); rv = apr_file_read(testfile, buf, &length); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_STR_EQUAL(tc, TESTSTR, buf); }
static void test_read(CuTest *tc) { apr_status_t rv; apr_size_t nbytes = 256; char *str = apr_pcalloc(p, nbytes + 1); apr_file_t *filetest = NULL; rv = apr_file_open(&filetest, FILENAME, APR_READ, APR_UREAD | APR_UWRITE | APR_GREAD, p); apr_assert_success(tc, "Opening test file " FILENAME, rv); rv = apr_file_read(filetest, str, &nbytes); CuAssertIntEquals(tc, APR_SUCCESS, rv); CuAssertIntEquals(tc, strlen(TESTSTR), nbytes); CuAssertStrEquals(tc, TESTSTR, str); apr_file_close(filetest); }
//static S32 LLAPRFile::readEx(const std::string& filename, void *buf, S32 offset, S32 nbytes) { apr_file_t* file_handle; LLScopedVolatileAPRFilePool pool; apr_status_t s = apr_file_open(&file_handle, filename.c_str(), APR_READ|APR_BINARY, APR_OS_DEFAULT, pool); if (s != APR_SUCCESS || !file_handle) { ll_apr_warn_status(s); LL_WARNS("APR") << " while attempting to open file \"" << filename << '"' << LL_ENDL; return 0; } S32 off; if (offset < 0) off = LLAPRFile::seek(file_handle, APR_END, 0); else off = LLAPRFile::seek(file_handle, APR_SET, offset); apr_size_t bytes_read; if (off < 0) { bytes_read = 0; } else { bytes_read = nbytes ; apr_status_t s = apr_file_read(file_handle, buf, &bytes_read); if (s != APR_SUCCESS) { LL_WARNS("APR") << " Attempting to read filename: " << filename << LL_ENDL; ll_apr_warn_status(s); bytes_read = 0; } else { llassert_always(bytes_read <= 0x7fffffff); } } apr_file_close(file_handle); return (S32)bytes_read; }
int main(int argc,char **argv) { apr_initialize(); apr_pool_t *pool; apr_pool_create(&pool,NULL); apr_status_t st; char *filename; if(argc > 1) { filename=argv[1]; } else { filename="apr_md5.c"; } apr_md5_ctx_t md5; apr_md5_init(&md5); apr_file_t *file; st=apr_file_open(&file,filename,APR_READ,APR_REG,pool); if(st != APR_SUCCESS) { apr_err("apr_file_open()",st); return st; } apr_size_t n=1024; char *buf=apr_pcalloc(pool,n); while(APR_EOF != apr_file_eof(file)) { n=1024; st=apr_file_read(file,buf,&n); apr_md5_update(&md5,buf,n); } unsigned char result[APR_MD5_DIGESTSIZE]; apr_md5_final(result,&md5); for(int i=0;i<APR_MD5_DIGESTSIZE;i++) { printf("%02x",result[i]); } printf("\n"); apr_file_close(file); apr_pool_destroy(pool); apr_terminate(); return 0; }
//static S32 LLAPRFile::readEx(const std::string& filename, void *buf, S32 offset, S32 nbytes, LLVolatileAPRPool* pool) { //***************************************** apr_file_t* file_handle = open(filename, pool, APR_READ|APR_BINARY); //***************************************** if (!file_handle) { return 0; } llassert(offset >= 0); if (offset > 0) offset = LLAPRFile::seek(file_handle, APR_SET, offset); apr_size_t bytes_read; if (offset < 0) { bytes_read = 0; } else { bytes_read = nbytes ; apr_status_t s = apr_file_read(file_handle, buf, &bytes_read); if (s != APR_SUCCESS) { LL_WARNS("APR") << " Attempting to read filename: " << filename << LL_ENDL; ll_apr_warn_status(s); bytes_read = 0; } else { llassert_always(bytes_read <= 0x7fffffff); } } //***************************************** close(file_handle, pool) ; //***************************************** return (S32)bytes_read; }
apr_status_t kahanaUtilRand( void *rnd, size_t size ) { apr_pool_t *tp = NULL; apr_status_t rc; if( !( rc = apr_pool_create( &tp, NULL ) ) ) { apr_file_t *fdes = NULL; if( !( rc = apr_file_open( &fdes, "/dev/urandom", APR_READ, APR_UREAD|APR_OS_DEFAULT, tp ) ) ){ rc = apr_file_read( fdes, rnd, &size ); apr_file_close( fdes ); } else{ *((int*)rnd) = rand(); } apr_pool_destroy( tp ); } return rc; }
APR_DECLARE(apr_status_t) apr_file_read_full(apr_file_t *thefile, void *buf, apr_size_t nbytes, apr_size_t *bytes_read) { apr_status_t status; apr_size_t total_read = 0; do { apr_size_t amt = nbytes; status = apr_file_read(thefile, buf, &amt); buf = (char *)buf + amt; nbytes -= amt; total_read += amt; } while (status == APR_SUCCESS && nbytes > 0); if (bytes_read != NULL) *bytes_read = total_read; return status; }
// File I/O S32 LLAPRFile::read(void *buf, S32 nbytes) { if(!mFile) { llwarns << "apr mFile is removed by somebody else. Can not read." << llendl ; return 0; } apr_size_t sz = nbytes; apr_status_t s = apr_file_read(mFile, buf, &sz); if (s != APR_SUCCESS) { ll_apr_warn_status(s); return 0; } else { llassert_always(sz <= 0x7fffffff); return (S32)sz; } }
//static S32 LLAPRFile::readEx(const std::string& filename, void *buf, S32 offset, S32 nbytes, LLVolatileAPRPool* pool) { //***************************************** apr_file_t* file_handle = open(filename, pool, APR_READ|APR_BINARY); //***************************************** if (!file_handle) { return 0; } S32 off; if (offset < 0) off = LLAPRFile::seek(file_handle, APR_END, 0); else off = LLAPRFile::seek(file_handle, APR_SET, offset); apr_size_t bytes_read; if (off < 0) { bytes_read = 0; } else { bytes_read = nbytes ; apr_status_t s = apr_file_read(file_handle, buf, &bytes_read); if (s != APR_SUCCESS) { bytes_read = 0; } else { llassert_always(bytes_read <= 0x7fffffff); } } //***************************************** close(file_handle, pool) ; //***************************************** return (S32)bytes_read; }
apr_status_t procmgr_send_spawn_cmd(fcgid_command * command, request_rec * r) { apr_status_t rv; char notifybyte; apr_size_t nbytes = sizeof(*command); /* Get the global mutex before posting the request */ if ((rv = apr_global_mutex_lock(g_pipelock)) != APR_SUCCESS) { ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r, "mod_fcgid: can't get pipe mutex"); exit(0); } if ((rv = apr_file_write_full(g_ap_write_pipe, command, nbytes, NULL)) != APR_SUCCESS) { /* Just print some error log and fall through */ ap_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r, "mod_fcgid: can't write spawn command"); } else { /* Wait the finish notify while send the request successfully */ nbytes = sizeof(notifybyte); if ((rv = apr_file_read(g_ap_read_pipe, ¬ifybyte, &nbytes)) != APR_SUCCESS) { ap_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r, "mod_fcgid: can't get notify from process manager"); } } /* Release the lock */ if ((rv = apr_global_mutex_unlock(g_pipelock)) != APR_SUCCESS) { ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r, "mod_fcgid: can't release pipe mutex"); exit(0); } return APR_SUCCESS; }
static void test_writev_buffered_seek(CuTest *tc) { apr_file_t *f; apr_status_t rv; apr_off_t off = 0; struct iovec vec[3]; apr_size_t nbytes = strlen(TESTSTR); char *str = apr_pcalloc(p, nbytes+1); const char *fname = "data/testwritev_buffered.dat"; rv = apr_file_open(&f, fname, APR_WRITE | APR_READ | APR_BUFFERED, APR_OS_DEFAULT, p); rv = apr_file_read(f, str, &nbytes); CuAssertIntEquals(tc, APR_SUCCESS, rv); CuAssertStrEquals(tc, TESTSTR, str); rv = apr_file_seek(f, APR_SET, &off); CuAssertIntEquals(tc, APR_SUCCESS, rv); vec[0].iov_base = LINE1; vec[0].iov_len = strlen(LINE1); vec[1].iov_base = LINE2; vec[1].iov_len = strlen(LINE2); vec[2].iov_base = TESTSTR; vec[2].iov_len = strlen(TESTSTR); rv = apr_file_writev(f, vec, 3, &nbytes); CuAssertIntEquals(tc, APR_SUCCESS, rv); rv = apr_file_close(f); CuAssertIntEquals(tc, APR_SUCCESS, rv); file_contents_equal(tc, fname, LINE1 LINE2 TESTSTR, strlen(LINE1) + strlen(LINE2) + strlen(TESTSTR)); rv = apr_file_remove(fname, p); CuAssertIntEquals(tc, APR_SUCCESS, rv); }
/* drain_available_output(): * * if any data is available from the filter, read it and pass it * to the next filter */ static apr_status_t drain_available_output(ap_filter_t *f) { request_rec *r = f->r; conn_rec *c = r->connection; ef_ctx_t *ctx = f->ctx; ef_dir_t *dc = ctx->dc; apr_size_t len; char buf[4096]; apr_status_t rv; apr_bucket_brigade *bb; apr_bucket *b; while (1) { len = sizeof(buf); rv = apr_file_read(ctx->proc->out, buf, &len); if ((rv && !APR_STATUS_IS_EAGAIN(rv)) || dc->debug >= DBGLVL_GORY) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, rv, r, "apr_file_read(child output), len %" APR_SIZE_T_FMT, !rv ? len : -1); } if (rv != APR_SUCCESS) { return rv; } bb = apr_brigade_create(r->pool, c->bucket_alloc); b = apr_bucket_transient_create(buf, len, c->bucket_alloc); APR_BRIGADE_INSERT_TAIL(bb, b); if ((rv = ap_pass_brigade(f->next, bb)) != APR_SUCCESS) { ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "ap_pass_brigade()"); return rv; } } /* we should never get here; if we do, a bogus error message would be * the least of our problems */ return APR_ANONYMOUS; }
static void test_bigread(abts_case *tc, void *data) { apr_file_t *f = NULL; apr_status_t rv; char buf[APR_BUFFERSIZE * 2]; apr_size_t nbytes; /* Create a test file with known content. */ rv = apr_file_open(&f, "data/created_file", APR_CREATE | APR_WRITE | APR_TRUNCATE, APR_UREAD | APR_UWRITE, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); nbytes = APR_BUFFERSIZE; memset(buf, 0xFE, nbytes); rv = apr_file_write(f, buf, &nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_INT_EQUAL(tc, APR_BUFFERSIZE, nbytes); rv = apr_file_close(f); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); f = NULL; rv = apr_file_open(&f, "data/created_file", APR_READ, 0, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); nbytes = sizeof buf; rv = apr_file_read(f, buf, &nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_INT_EQUAL(tc, APR_BUFFERSIZE, nbytes); rv = apr_file_close(f); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_file_remove("data/created_file", p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); }
static void test_writev_buffered_seek(abts_case *tc, void *data) { apr_file_t *f; apr_status_t rv; apr_off_t off = 0; struct iovec vec[3]; apr_size_t nbytes = strlen(TESTSTR); char *str = apr_pcalloc(p, nbytes+1); const char *fname = "data/testwritev_buffered.dat"; APR_ASSERT_SUCCESS(tc, "open file for writing", apr_file_open(&f, fname, APR_FOPEN_WRITE | APR_FOPEN_READ | APR_FOPEN_BUFFERED, APR_OS_DEFAULT, p)); rv = apr_file_read(f, str, &nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_STR_EQUAL(tc, TESTSTR, str); APR_ASSERT_SUCCESS(tc, "buffered seek", apr_file_seek(f, APR_SET, &off)); vec[0].iov_base = LINE1; vec[0].iov_len = strlen(LINE1); vec[1].iov_base = LINE2; vec[1].iov_len = strlen(LINE2); vec[2].iov_base = TESTSTR; vec[2].iov_len = strlen(TESTSTR); APR_ASSERT_SUCCESS(tc, "writev of size 2 to file", apr_file_writev(f, vec, 3, &nbytes)); APR_ASSERT_SUCCESS(tc, "close for writing", apr_file_close(f)); file_contents_equal(tc, fname, LINE1 LINE2 TESTSTR, strlen(LINE1) + strlen(LINE2) + strlen(TESTSTR)); APR_ASSERT_SUCCESS(tc, "remove file", apr_file_remove(fname, p)); }