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