static void test_file_trunc(abts_case *tc, void *data) { apr_status_t rv; apr_file_t *f; const char *fname = "data/testtruncate.dat"; const char *s; apr_size_t nbytes; apr_finfo_t finfo; apr_file_remove(fname, p); /* Test unbuffered */ rv = apr_file_open(&f, fname, APR_FOPEN_CREATE | APR_FOPEN_READ | APR_FOPEN_WRITE, APR_FPROT_UREAD | APR_FPROT_UWRITE, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); s = "some data"; nbytes = strlen(s); rv = apr_file_write(f, s, &nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_SIZE_EQUAL(tc, strlen(s), nbytes); rv = apr_file_trunc(f, 4); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_file_close(f); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_stat(&finfo, fname, APR_FINFO_SIZE, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_ASSERT(tc, "File size mismatch, expected 4", finfo.size == 4); rv = apr_file_remove(fname, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); /* Test buffered */ rv = apr_file_open(&f, fname, APR_FOPEN_CREATE | APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_BUFFERED, APR_FPROT_UREAD | APR_FPROT_UWRITE, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); nbytes = strlen(s); rv = apr_file_write(f, s, &nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_SIZE_EQUAL(tc, strlen(s), nbytes); rv = apr_file_trunc(f, 4); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_file_close(f); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); rv = apr_stat(&finfo, fname, APR_FINFO_SIZE, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_ASSERT(tc, "File size mismatch, expected 4", finfo.size == 4); rv = apr_file_remove(fname, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); }
APR_DECLARE(apr_status_t) apr_file_puts(const char *str, apr_file_t *thefile) { apr_size_t len; len = strlen(str); return apr_file_write(thefile, str, &len); }
static void read_write_notimeout(abts_case *tc, void *data) { apr_status_t rv; char *buf = "this is a test"; char *input; apr_size_t nbytes; nbytes = strlen("this is a test"); rv = apr_file_pipe_create(&readp, &writep, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_PTR_NOTNULL(tc, readp); ABTS_PTR_NOTNULL(tc, writep); rv = apr_file_write(writep, buf, &nbytes); ABTS_INT_EQUAL(tc, strlen("this is a test"), nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); nbytes = 256; input = apr_pcalloc(p, nbytes + 1); rv = apr_file_read(readp, input, &nbytes); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_INT_EQUAL(tc, strlen("this is a test"), nbytes); ABTS_STR_EQUAL(tc, "this is a test", input); }
mapcache_lock_result mapcache_locker_disk_aquire_lock(mapcache_context *ctx, mapcache_locker *self, char *resource, void **lock) { char *lockname, errmsg[120]; mapcache_locker_disk *ldisk; apr_file_t *lockfile; apr_status_t rv; assert(self->type == MAPCACHE_LOCKER_DISK); ldisk = (mapcache_locker_disk*)self; *lock = NULL; /*unused*/ lockname = lock_filename_for_resource(ctx,ldisk,resource); /* create the lockfile */ rv = apr_file_open(&lockfile,lockname,APR_WRITE|APR_CREATE|APR_EXCL|APR_XTHREAD,APR_OS_DEFAULT,ctx->pool); /* if the file already exists, wait for it to disappear */ /* TODO: check the lock isn't stale (i.e. too old) */ if( rv != APR_SUCCESS ) { if( !APR_STATUS_IS_EEXIST(rv) ) { ctx->set_error(ctx, 500, "failed to create lockfile %s: %s", lockname, apr_strerror(rv,errmsg,120)); return MAPCACHE_LOCK_NOENT; } return MAPCACHE_LOCK_LOCKED; } else { /* we acquired the lock */ char *pid_s; pid_t pid; apr_size_t pid_s_len; pid = getpid(); pid_s = apr_psprintf(ctx->pool,"%"APR_PID_T_FMT,pid); pid_s_len = strlen(pid_s); apr_file_write(lockfile,pid_s,&pid_s_len); apr_file_close(lockfile); return MAPCACHE_LOCK_AQUIRED; } }
static void test_fail_write_flush(abts_case *tc, void *data) { apr_file_t *f; const char *fname = "data/testflush.dat"; apr_status_t rv; char buf[APR_BUFFERSIZE]; int n; apr_file_remove(fname, p); APR_ASSERT_SUCCESS(tc, "open test file", apr_file_open(&f, fname, APR_CREATE|APR_READ|APR_BUFFERED, APR_UREAD|APR_UWRITE, p)); memset(buf, 'A', sizeof buf); /* Try three writes. One of these should fail when it exceeds the * internal buffer and actually tries to write to the file, which * was opened read-only and hence should be unwritable. */ for (n = 0, rv = APR_SUCCESS; n < 4 && rv == APR_SUCCESS; n++) { apr_size_t bytes = sizeof buf; rv = apr_file_write(f, buf, &bytes); } ABTS_ASSERT(tc, "failed to write to read-only buffered fd", rv != APR_SUCCESS); apr_file_close(f); }
/* write a color bar with (roughly) logarithmic scale as BMP image to FILE. */ static void write_scale(apr_file_t *file) { int x; word value = 0, inc = 1; /* write header to file */ write_bitmap_header(file, 64, 1); for (x = 0; x < 64; ++x) { apr_size_t written; byte color[3] = { 128, 128, 128 }; select_color(color, value); if (value + (int)inc < 0x10000) { value += inc; if (value >= 8 * inc) inc *= 2; } written = sizeof(color); apr_file_write(file, color, &written); } }
/* output css file */ static void sass_output_file(request_rec *r, char *filename, char *data) { apr_status_t rc; apr_size_t bytes; apr_file_t *file = NULL; if (!data) { return; } rc = apr_file_open(&file, filename, APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE, APR_FPROT_OS_DEFAULT, r->pool); if (rc == APR_SUCCESS) { bytes = strlen(data); rc = apr_file_write(file, data, &bytes); if (rc != APR_SUCCESS) { _RERR(r, "Can't create/write to file: %s", filename); } apr_file_close(file); } else { _RERR(r, "Can't create/write to file: %s", filename); } }
static void test_buffered_write_size(abts_case *tc, void *data) { const apr_size_t data_len = strlen(NEWFILEDATA); apr_file_t *thefile; apr_finfo_t finfo; apr_status_t rv; apr_size_t bytes; rv = apr_file_open(&thefile, NEWFILENAME, APR_READ | APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BUFFERED | APR_DELONCLOSE, APR_OS_DEFAULT, p); APR_ASSERT_SUCCESS(tc, "open file", rv); /* A funny thing happened to me the other day: I wrote something * into a buffered file, then asked for its size using * apr_file_info_get; and guess what? The size was 0! That's not a * nice way to behave. */ bytes = data_len; rv = apr_file_write(thefile, NEWFILEDATA, &bytes); APR_ASSERT_SUCCESS(tc, "write file contents", rv); ABTS_TRUE(tc, data_len == bytes); rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, thefile); APR_ASSERT_SUCCESS(tc, "get file size", rv); ABTS_TRUE(tc, bytes == (apr_size_t) finfo.size); apr_file_close(thefile); }
static void read_write_notimeout(CuTest *tc) { apr_status_t rv; char *buf = "this is a test"; char *input; apr_size_t nbytes; nbytes = strlen("this is a test"); rv = apr_file_pipe_create(&readp, &writep, p); CuAssertIntEquals(tc, APR_SUCCESS, rv); CuAssertPtrNotNull(tc, readp); CuAssertPtrNotNull(tc, writep); rv = apr_file_write(writep, buf, &nbytes); CuAssertIntEquals(tc, strlen("this is a test"), nbytes); CuAssertIntEquals(tc, APR_SUCCESS, rv); nbytes = 256; input = apr_pcalloc(p, nbytes + 1); rv = apr_file_read(readp, input, &nbytes); CuAssertIntEquals(tc, APR_SUCCESS, rv); CuAssertIntEquals(tc, strlen("this is a test"), nbytes); CuAssertStrEquals(tc, "this is a test", input); }
APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile, const struct iovec *vec, apr_size_t nvec, apr_size_t *nbytes) { #ifdef HAVE_WRITEV int bytes; if ((bytes = writev(thefile->filedes, vec, nvec)) < 0) { *nbytes = 0; return errno; } else { *nbytes = bytes; return APR_SUCCESS; } #else /** * The problem with trying to output the entire iovec is that we cannot * maintain the behavoir that a real writev would have. If we iterate * over the iovec one at a time, we loose the atomic properties of * writev(). The other option is to combine the entire iovec into one * buffer that we could then send in one call to write(). This is not * reasonable since we do not know how much data an iovec could contain. * * The only reasonable option, that maintains the semantics of a real * writev(), is to only write the first iovec. Callers of file_writev() * must deal with partial writes as they normally would. If you want to * ensure an entire iovec is written, use apr_file_writev_full(). */ *nbytes = vec[0].iov_len; return apr_file_write(thefile, vec[0].iov_base, nbytes); #endif }
static void test_writev_buffered(CuTest *tc) { apr_status_t rv; apr_file_t *f; apr_size_t nbytes; struct iovec vec[2]; const char *fname = "data/testwritev_buffered.dat"; rv = apr_file_open(&f, fname, APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BUFFERED, APR_OS_DEFAULT, p); CuAssertIntEquals(tc, APR_SUCCESS, rv); nbytes = strlen(TESTSTR); rv = apr_file_write(f, TESTSTR, &nbytes); 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); rv = apr_file_writev(f, vec, 2, &nbytes); CuAssertIntEquals(tc, APR_SUCCESS, rv); rv = apr_file_close(f); CuAssertIntEquals(tc, APR_SUCCESS, rv); file_contents_equal(tc, fname, TESTSTR LINE1 LINE2, strlen(TESTSTR) + strlen(LINE1) + strlen(LINE2)); }
static apr_status_t pass_data_to_filter(ap_filter_t *f, const char *data, apr_size_t len, apr_bucket_brigade *bb) { ef_ctx_t *ctx = f->ctx; ef_dir_t *dc = ctx->dc; apr_status_t rv; apr_size_t bytes_written = 0; apr_size_t tmplen; do { tmplen = len - bytes_written; rv = apr_file_write(ctx->proc->in, (const char *)data + bytes_written, &tmplen); bytes_written += tmplen; if (rv != APR_SUCCESS && !APR_STATUS_IS_EAGAIN(rv)) { ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, f->r, "apr_file_write(child input), len %" APR_SIZE_T_FMT, tmplen); return rv; } if (APR_STATUS_IS_EAGAIN(rv)) { /* XXX handle blocking conditions here... if we block, we need * to read data from the child process and pass it down to the * next filter! */ rv = drain_available_output(f, bb); if (APR_STATUS_IS_EAGAIN(rv)) { #if APR_FILES_AS_SOCKETS int num_events; const apr_pollfd_t *pdesc; rv = apr_pollset_poll(ctx->pollset, f->r->server->timeout, &num_events, &pdesc); if (rv || dc->debug >= DBGLVL_GORY) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, rv, f->r, "apr_pollset_poll()"); } if (rv != APR_SUCCESS && !APR_STATUS_IS_EINTR(rv)) { /* some error such as APR_TIMEUP */ return rv; } #else /* APR_FILES_AS_SOCKETS */ /* Yuck... I'd really like to wait until I can read * or write, but instead I have to sleep and try again */ apr_sleep(100000); /* 100 milliseconds */ if (dc->debug >= DBGLVL_GORY) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, f->r, "apr_sleep()"); } #endif /* APR_FILES_AS_SOCKETS */ } else if (rv != APR_SUCCESS) { return rv; } } } while (bytes_written < len); return rv; }
// this callback fucntion is used to write all the data from a CURL request to a file static int write_data(void *ptr, size_t size, size_t nmemb, void *stream) { int len = size * nmemb; int written = apr_file_write((apr_file_t*)stream, ptr, &len); apr_off_t offset = 0; apr_file_seek((apr_file_t*)stream, APR_SET, &offset); return size * nmemb; }
static void flush_log(buffered_log *buf) { if (buf->outcnt && buf->handle != NULL) { apr_file_write(buf->handle, buf->outbuf, &buf->outcnt); buf->outcnt = 0; } }
static int rand_check_kat(rnd_fn *f, apr_random_t *r, const unsigned char expected[RANDOM_BUF_SZ], apr_file_t *readp, apr_file_t *writep) { apr_size_t nbytes = RANDOM_BUF_SZ; apr_size_t cmd_size = 1; unsigned char c[RANDOM_BUF_SZ]; char ack; apr_status_t rv; rv = f(r, c, RANDOM_BUF_SZ); if (rv) return 2; rv = 0; if (memcmp(c, expected, RANDOM_BUF_SZ)) { rv = 1; } else { hexdump("Generated: ", c, RANDOM_BUF_SZ); hexdump("Previous: ", expected, RANDOM_BUF_SZ); } /* Report back our random values for comparison in another child */ apr_file_write(writep, c, &nbytes); /* Wait for our parent ack the data */ apr_file_read(readp, &ack, &cmd_size); return rv; }
static void test_writev_buffered(abts_case *tc, void *data) { apr_file_t *f; apr_size_t nbytes; struct iovec vec[2]; const char *fname = "data/testwritev_buffered.dat"; APR_ASSERT_SUCCESS(tc, "open file for writing", apr_file_open(&f, fname, APR_WRITE | APR_CREATE | APR_TRUNCATE | APR_BUFFERED, APR_OS_DEFAULT, p)); nbytes = strlen(TESTSTR); APR_ASSERT_SUCCESS(tc, "buffered write", apr_file_write(f, TESTSTR, &nbytes)); vec[0].iov_base = LINE1; vec[0].iov_len = strlen(LINE1); vec[1].iov_base = LINE2; vec[1].iov_len = strlen(LINE2); APR_ASSERT_SUCCESS(tc, "writev of size 2 to file", apr_file_writev(f, vec, 2, &nbytes)); APR_ASSERT_SUCCESS(tc, "close for writing", apr_file_close(f)); file_contents_equal(tc, fname, TESTSTR LINE1 LINE2, strlen(TESTSTR) + strlen(LINE1) + strlen(LINE2)); }
/* Write the cluster read map for all files in INFO as BMP image to FILE. * If MAX_X is not 0, scale all lines to MAX_X pixels. Use POOL for * allocations. */ static void write_bitmap(apr_array_header_t *info, int max_x, apr_file_t *file, apr_pool_t *pool) { int ysize = info->nelts; int xsize = 0; int x, y; apr_size_t row_size; apr_size_t written; color_t *line, *scaled_line; svn_boolean_t do_scale = max_x > 0; /* xsize = max cluster number */ for (y = 0; y < ysize; ++y) if (xsize < APR_ARRAY_IDX(info, y, file_stats_t *)->read_map->nelts) xsize = APR_ARRAY_IDX(info, y, file_stats_t *)->read_map->nelts; /* limit picture dimensions (16k pixels in each direction) */ if (xsize >= 0x4000) xsize = 0x3fff; if (ysize >= 0x4000) ysize = 0x3fff; if (max_x == 0) max_x = xsize; /* rows in BMP files must be aligned to 4 bytes */ row_size = APR_ALIGN(max_x * sizeof(color_t), 4); /**/ line = apr_pcalloc(pool, xsize * sizeof(color_t)); scaled_line = apr_pcalloc(pool, row_size); /* write header to file */ write_bitmap_header(file, max_x, ysize); /* write all rows */ for (y = 0; y < ysize; ++y) { file_stats_t *file_info = APR_ARRAY_IDX(info, y, file_stats_t *); int block_count = file_info->read_map->nelts; for (x = 0; x < xsize; ++x) { color_t color = { 128, 128, 128 }; if (x < block_count) { word count = APR_ARRAY_IDX(file_info->read_map, x, word); select_color(color, count); } memcpy(line[x], color, sizeof(color)); } scale_line(scaled_line, max_x, line, block_count ? block_count : 1); written = row_size; apr_file_write(file, do_scale ? scaled_line : line, &written); } }
// write SQInteger file_put_contents(HSQUIRRELVM v) { // function parameters const SQChar* filename; const SQChar* contents; // internal structures apr_file_t* file; apr_size_t nbytes; apr_status_t status; request_rec* r = get_request_rec(v); // for error messages char error[120]; char errorMessage[120]; ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "file_put_contents()"); // grab filename param if( sq_gettype(v, 2) != OT_STRING ) { return SQ_ERROR; } else if( SQ_FAILED(sq_getstring(v, 2, &filename)) ) { return SQ_ERROR; } // grab contents param if( sq_gettype(v, 3) != OT_STRING ) { return SQ_ERROR; } else if( SQ_FAILED(sq_getstring(v, 3, &contents)) ) { return SQ_ERROR; } nbytes = strlen(contents); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, " file_put_contents('%s', '%s') %d", filename, contents, (int)nbytes); if( (status = apr_file_open(&file, filename, APR_WRITE|APR_CREATE, APR_OS_DEFAULT, r->pool)) != APR_SUCCESS ) { apr_strerror(status, error, sizeof error); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, " file_put_contents() failed: %s", error); sprintf(errorMessage, "file_put_contents() failed: %s", error); errorfunc(v, errorMessage); sq_pushbool(v, SQFalse); } else if( (status = apr_file_write(file, contents, &nbytes)) != APR_SUCCESS ) { apr_strerror(status, error, sizeof error); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, " file_put_contents() failed: %s", error); sprintf(errorMessage, "file_put_contents() failed: %s", error); errorfunc(v, errorMessage); sq_pushbool(v, SQFalse); } else { sq_pushinteger(v, nbytes); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, " file_put_contents() wrote %d bytes", (int)nbytes); } ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "file_put_contents() returning 1"); return 1; }
void aos_log_print_default(const char *message, int len) { if (aos_stderr_file == NULL) { fprintf(stderr, "%s", message); } else { apr_size_t bnytes = len; apr_file_write(aos_stderr_file, message, &bnytes); } }
APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile, const struct iovec *vec, apr_size_t nvec, apr_size_t *nbytes) { #ifdef HAVE_WRITEV apr_status_t rv; int bytes; if (thefile->buffered) { file_lock(thefile); rv = apr_file_flush_locked(thefile); if (rv != APR_SUCCESS) { file_unlock(thefile); return rv; } if (thefile->direction == 0) { /* Position file pointer for writing at the offset we are * logically reading from */ apr_int64_t offset = thefile->filePtr - thefile->dataRead + thefile->bufpos; if (offset != thefile->filePtr) lseek(thefile->filedes, offset, SEEK_SET); thefile->bufpos = thefile->dataRead = 0; } file_unlock(thefile); } if ((bytes = writev(thefile->filedes, vec, nvec)) < 0) { *nbytes = 0; rv = errno; } else { *nbytes = bytes; rv = APR_SUCCESS; } return rv; #else /** * The problem with trying to output the entire iovec is that we cannot * maintain the behavoir that a real writev would have. If we iterate * over the iovec one at a time, we loose the atomic properties of * writev(). The other option is to combine the entire iovec into one * buffer that we could then send in one call to write(). This is not * reasonable since we do not know how much data an iovec could contain. * * The only reasonable option, that maintains the semantics of a real * writev(), is to only write the first iovec. Callers of file_writev() * must deal with partial writes as they normally would. If you want to * ensure an entire iovec is written, use apr_file_writev_full(). */ *nbytes = vec[0].iov_len; return apr_file_write(thefile, vec[0].iov_base, nbytes); #endif }
int slayer_server_log_message(slayer_server_log_manager_t *manager, const char *message) { if (message && manager->fhandle) { apr_thread_mutex_lock(manager->file_mutex); apr_size_t nbytes = strlen(message); apr_file_write(manager->fhandle,message,&nbytes); apr_thread_mutex_unlock(manager->file_mutex); } return 0; }
/* Implements svn_write_fn_t */ static svn_error_t * file_write_cb(void *baton, const char *buffer, apr_size_t *len) { file_baton_t *b = baton; apr_status_t status = apr_file_write(b->out_file, buffer, len); if (status) return svn_error_wrap_apr(status, _("Can't write to connection")); return SVN_NO_ERROR; }
static apr_status_t lcn_fs_index_output_flush_buffer ( lcn_index_output_t *os, char *buf, size_t len ) { apr_status_t s; apr_size_t l = len; LCNCR( apr_file_write( ( ( lcn_fs_index_output_t* ) os )->_apr_file, buf, &l ) ); return s; }
// write_name_data is a call back function used by libcurl to deal with the body // data from http requests to websites. it modifies a file/stream with information // about a place's coordinates static int write_name_data(void *ptr, size_t size, size_t nmemb, void *stream) { char * result = match_and_process_expression( NULL, ptr, LATLON_NUM_GROUPS, REGEXP_GROUP_SIZE, LATLON_REG_EXP, get_lat_and_lon); if(result==NULL) { return OK; } int result_len = strlen(result); apr_file_write((apr_file_t*)stream, result, &result_len); free(result); return result_len; }
static apr_status_t tmpfile_filter(ap_filter_t *f, apr_bucket_brigade *bbout, ap_input_mode_t mode, apr_read_type_e block, apr_off_t nbytes) { apr_bucket_brigade* bbin = apr_brigade_create(f->r->pool, f->r->connection->bucket_alloc); apr_file_t* tmpfile ; char* tmpname = apr_pstrdup(f->r->pool, "/tmp/mod-upload.XXXXXX") ; if ( f->ctx ) { APR_BRIGADE_INSERT_TAIL(bbout, apr_bucket_eos_create(bbout->bucket_alloc)) ; return APR_SUCCESS ; } if ( apr_file_mktemp(&tmpfile, tmpname, KEEPONCLOSE, f->r->pool) != APR_SUCCESS ) { // error ap_remove_input_filter(f) ; } apr_pool_cleanup_register(f->r->pool, tmpfile, (void*)apr_file_close, apr_pool_cleanup_null) ; for ( ; ; ) { apr_bucket* b ; const char* ptr = 0 ; apr_size_t bytes ; #ifdef DEBUG ap_log_rerror(APLOG_MARK,APLOG_DEBUG,0, f->r, "get_brigade") ; #endif ap_get_brigade(f->next, bbin, AP_MODE_READBYTES, APR_BLOCK_READ, BUFLEN) ; for ( b = APR_BRIGADE_FIRST(bbin) ; b != APR_BRIGADE_SENTINEL(bbin) && ! f->ctx ; b = APR_BUCKET_NEXT(b) ) { if ( APR_BUCKET_IS_EOS(b) ) { f->ctx = f ; // just using it as a flag; any nonzero will do apr_file_flush(tmpfile) ; apr_brigade_puts(bbout, ap_filter_flush, f, tmpname) ; APR_BRIGADE_INSERT_TAIL(bbout, apr_bucket_eos_create(bbout->bucket_alloc) ) ; } else if ( apr_bucket_read(b, &ptr, &bytes, APR_BLOCK_READ) == APR_SUCCESS ) { #ifdef DEBUG ap_log_rerror(APLOG_MARK,APLOG_DEBUG,0, f->r, " %d bytes in bucket", bytes) ; #endif apr_file_write(tmpfile, ptr, &bytes) ; } } if ( f->ctx ) break ; else apr_brigade_cleanup(bbin) ; } apr_brigade_destroy(bbin) ; return APR_SUCCESS ; }
/* Returns the amount written. */ static int bio_file_write(BIO *bio, const char *in, int inl) { apr_file_t *file = bio->ptr; apr_size_t nbytes; BIO_clear_retry_flags(bio); nbytes = inl; apr_file_write(file, in, &nbytes); return nbytes; }
static int write_to_log_array(request_rec* r, apr_array_header_t* logs, const char* buf, size_t buflen) { int i; protolog_file* log_array = (protolog_file*) logs->elts; for (i = 0; i < logs->nelts; ++i) { protolog_file* log = &log_array[i]; apr_file_write(log->log_handle, buf, &buflen); } return OK; }
static void test_dup2_readwrite(abts_case *tc, void *data) { apr_file_t *errfile = NULL; apr_file_t *testfile = NULL; apr_file_t *saveerr = NULL; apr_status_t rv; apr_size_t txtlen = sizeof(TEST); char buff[50]; apr_off_t fpos; rv = apr_file_open(&testfile, FILEPATH "testdup2.readwrite.file", APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_DELONCLOSE, APR_OS_DEFAULT, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_PTR_NOTNULL(tc, testfile); rv = apr_file_open_stderr(&errfile, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); /* Set aside the real errfile */ rv = apr_file_dup(&saveerr, errfile, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_PTR_NOTNULL(tc, saveerr); rv = apr_file_dup2(errfile, testfile, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_PTR_NOTNULL(tc, errfile); txtlen = sizeof(TEST2); rv = apr_file_write(errfile, TEST2, &txtlen); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_SIZE_EQUAL(tc, sizeof(TEST2), txtlen); fpos = 0; rv = apr_file_seek(testfile, APR_SET, &fpos); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_ASSERT(tc, "File position mismatch, expected 0", fpos == 0); txtlen = 50; rv = apr_file_read(testfile, buff, &txtlen); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_STR_EQUAL(tc, TEST2, buff); apr_file_close(testfile); rv = apr_file_dup2(errfile, saveerr, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); ABTS_PTR_NOTNULL(tc, errfile); apr_file_close(saveerr); }
static apr_status_t pod_signal_internal(ap_pod_t *pod) { apr_status_t rv; char char_of_death = '!'; apr_size_t one = 1; rv = apr_file_write(pod->pod_out, &char_of_death, &one); if (rv != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00053) "write pipe_of_death"); } return rv; }
S32 ll_apr_file_write(apr_file_t* apr_file, const void *buf, S32 nbytes) { apr_size_t sz = nbytes; apr_status_t s = apr_file_write(apr_file, buf, &sz); if (s != APR_SUCCESS) { return 0; } else { llassert_always(sz <= 0x7fffffff); return (S32)sz; } }