/* Handle stdout from CGI child. Duplicate of logic from the _read
* method of the real APR pipe bucket implementation. */
static apr_status_t aikido_read_stdout(apr_bucket *a, apr_file_t *out,
const char **str, apr_size_t *len)
{
char *buf;
apr_status_t rv;
*str = NULL;
*len = APR_BUCKET_BUFF_SIZE;
buf = apr_bucket_alloc(*len, a->list); /* XXX: check for failure? */
rv = apr_file_read(out, buf, len);
if (rv != APR_SUCCESS && rv != APR_EOF) {
apr_bucket_free(buf);
return rv;
}
if (*len > 0) {
struct aikido_bucket_data *data = a->data;
apr_bucket_heap *h;
/* Change the current bucket to refer to what we read */
a = apr_bucket_heap_make(a, buf, *len, apr_bucket_free);
h = a->data;
h->alloc_len = APR_BUCKET_BUFF_SIZE; /* note the real buffer size */
*str = buf;
APR_BUCKET_INSERT_AFTER(a, aikido_bucket_dup(data, a->list));
}
else {
apr_bucket_free(buf);
a = apr_bucket_immortal_make(a, "", 0);
*str = a->data;
}
return rv;
}
/*
* XXX: This function could do with some tweaking to reduce memory
* usage in various cases, e.g. share buffers in the heap between all
* the buckets that are set aside, or even spool set-aside data to
* disk if it gets too voluminous (but if it does then that's probably
* a bug elsewhere). There should probably be a apr_brigade_setaside()
* function that co-ordinates the action of all the bucket setaside
* functions to improve memory efficiency.
*/
static apr_status_t transient_bucket_setaside(apr_bucket *b, apr_pool_t *pool)
{
b = apr_bucket_heap_make(b, (char *)b->data + b->start, b->length, NULL);
if (b == NULL) {
return APR_ENOMEM;
}
return APR_SUCCESS;
}
static apr_status_t pipe_bucket_read(apr_bucket *a, const char **str,
apr_size_t *len, apr_read_type_e block)
{
apr_file_t *p = a->data;
char *buf;
apr_status_t rv;
apr_interval_time_t timeout;
if (block == APR_NONBLOCK_READ) {
apr_file_pipe_timeout_get(p, &timeout);
apr_file_pipe_timeout_set(p, 0);
}
*str = NULL;
*len = APR_BUCKET_BUFF_SIZE;
buf = apr_bucket_alloc(*len, a->list); /* XXX: check for failure? */
rv = apr_file_read(p, buf, len);
if (block == APR_NONBLOCK_READ) {
apr_file_pipe_timeout_set(p, timeout);
}
if (rv != APR_SUCCESS && rv != APR_EOF) {
apr_bucket_free(buf);
return rv;
}
/*
* If there's more to read we have to keep the rest of the pipe
* for later. Otherwise, we'll close the pipe.
* XXX: Note that more complicated bucket types that
* refer to data not in memory and must therefore have a read()
* function similar to this one should be wary of copying this
* code because if they have a destroy function they probably
* want to migrate the bucket's subordinate structure from the
* old bucket to a raw new one and adjust it as appropriate,
* rather than destroying the old one and creating a completely
* new bucket.
*/
if (*len > 0) {
apr_bucket_heap *h;
/* Change the current bucket to refer to what we read */
a = apr_bucket_heap_make(a, buf, *len, apr_bucket_free);
h = a->data;
h->alloc_len = APR_BUCKET_BUFF_SIZE; /* note the real buffer size */
*str = buf;
APR_BUCKET_INSERT_AFTER(a, apr_bucket_pipe_create(p, a->list));
}
else {
apr_bucket_free(buf);
a = apr_bucket_immortal_make(a, "", 0);
*str = a->data;
if (rv == APR_EOF) {
apr_file_close(p);
}
}
return APR_SUCCESS;
}
APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf,
apr_size_t length,
void (*free_func)(void *data),
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
APR_BUCKET_INIT(b);
b->free = apr_bucket_free;
b->list = list;
return apr_bucket_heap_make(b, buf, length, free_func);
}
static apr_status_t bucket_socket_ex_read(apr_bucket *a, const char **str,
apr_size_t *len,
apr_read_type_e block)
{
socket_ex_data *data = a->data;
apr_socket_t *p = data->sock;
char *buf;
apr_status_t rv;
apr_interval_time_t timeout;
if (block == APR_NONBLOCK_READ) {
apr_socket_timeout_get(p, &timeout);
apr_socket_timeout_set(p, 0);
}
*str = NULL;
*len = APR_BUCKET_BUFF_SIZE;
buf = apr_bucket_alloc(*len, a->list);
rv = apr_socket_recv(p, buf, len);
if (block == APR_NONBLOCK_READ) {
apr_socket_timeout_set(p, timeout);
}
if (rv != APR_SUCCESS && rv != APR_EOF) {
apr_bucket_free(buf);
return rv;
}
if (*len > 0) {
apr_bucket_heap *h;
/* count for stats */
*data->counter += *len;
/* Change the current bucket to refer to what we read */
a = apr_bucket_heap_make(a, buf, *len, apr_bucket_free);
h = a->data;
h->alloc_len = APR_BUCKET_BUFF_SIZE; /* note the real buffer size */
*str = buf;
APR_BUCKET_INSERT_AFTER(a, bucket_socket_ex_create(data, a->list));
}
else {
apr_bucket_free(buf);
a = apr_bucket_immortal_make(a, "", 0);
*str = a->data;
}
return APR_SUCCESS;
}
static apr_status_t
bucket_read(apr_bucket *bucket, const char **str, apr_size_t *len, apr_read_type_e block) {
char *buf;
ssize_t ret;
BucketData *data;
data = (BucketData *) bucket->data;
*str = NULL;
*len = 0;
if (!data->bufferResponse && block == APR_NONBLOCK_READ) {
/*
* The bucket brigade that Hooks::handleRequest() passes using
* ap_pass_brigade() is always passed through ap_content_length_filter,
* which is a filter which attempts to read all data from the
* bucket brigade and computes the Content-Length header from
* that. We don't want this to happen; because suppose that the
* Rails application sends back 1 GB of data, then
* ap_content_length_filter will buffer this entire 1 GB of data
* in memory before passing it to the HTTP client.
*
* ap_content_length_filter aborts and passes the bucket brigade
* down the filter chain when it encounters an APR_EAGAIN, except
* for the first read. So by returning APR_EAGAIN on every
* non-blocking read request, we can prevent ap_content_length_filter
* from buffering all data.
*/
//return APR_EAGAIN;
}
buf = (char *) apr_bucket_alloc(APR_BUCKET_BUFF_SIZE, bucket->list);
if (buf == NULL) {
return APR_ENOMEM;
}
do {
ret = read(data->state->connection, buf, APR_BUCKET_BUFF_SIZE);
} while (ret == -1 && errno == EINTR);
if (ret > 0) {
apr_bucket_heap *h;
data->state->bytesRead += ret;
*str = buf;
*len = ret;
bucket->data = NULL;
/* Change the current bucket (which is a Passenger Bucket) into a heap bucket
* that contains the data that we just read. This newly created heap bucket
* will be the first in the bucket list.
*/
bucket = apr_bucket_heap_make(bucket, buf, *len, apr_bucket_free);
h = (apr_bucket_heap *) bucket->data;
h->alloc_len = APR_BUCKET_BUFF_SIZE; /* note the real buffer size */
/* And after this newly created bucket we insert a new Passenger Bucket
* which can read the next chunk from the stream.
*/
APR_BUCKET_INSERT_AFTER(bucket, passenger_bucket_create(
data->state, bucket->list, data->bufferResponse));
/* The newly created Passenger Bucket has a reference to the session
* object, so we can delete data here.
*/
delete data;
return APR_SUCCESS;
} else if (ret == 0) {
data->state->completed = true;
delete data;
bucket->data = NULL;
apr_bucket_free(buf);
bucket = apr_bucket_immortal_make(bucket, "", 0);
*str = (const char *) bucket->data;
*len = 0;
return APR_SUCCESS;
} else /* ret == -1 */ {
int e = errno;
data->state->completed = true;
data->state->errorCode = e;
delete data;
bucket->data = NULL;
apr_bucket_free(buf);
return APR_FROM_OS_ERROR(e);
}
}
static apr_status_t file_bucket_read(apr_bucket *e, const char **str,
apr_size_t *len, apr_read_type_e block)
{
apr_bucket_file *a = e->data;
apr_file_t *f = a->fd;
apr_bucket *b = NULL;
char *buf;
apr_status_t rv;
apr_size_t filelength = e->length; /* bytes remaining in file past offset */
apr_off_t fileoffset = e->start;
#if APR_HAS_THREADS && !APR_HAS_XTHREAD_FILES
apr_int32_t flags;
#endif
#if APR_HAS_MMAP
if (file_make_mmap(e, filelength, fileoffset, a->readpool)) {
return apr_bucket_read(e, str, len, block);
}
#endif
#if APR_HAS_THREADS && !APR_HAS_XTHREAD_FILES
if ((flags = apr_file_flags_get(f)) & APR_FOPEN_XTHREAD) {
/* this file descriptor is shared across multiple threads and
* this OS doesn't support that natively, so as a workaround
* we must reopen the file into a->readpool */
const char *fname;
apr_file_name_get(&fname, f);
rv = apr_file_open(&f, fname, (flags & ~APR_FOPEN_XTHREAD), 0, a->readpool);
if (rv != APR_SUCCESS)
return rv;
a->fd = f;
}
#endif
*len = (filelength > APR_BUCKET_BUFF_SIZE)
? APR_BUCKET_BUFF_SIZE
: filelength;
*str = NULL; /* in case we die prematurely */
buf = apr_bucket_alloc(*len, e->list);
/* Handle offset ... */
rv = apr_file_seek(f, APR_SET, &fileoffset);
if (rv != APR_SUCCESS) {
apr_bucket_free(buf);
return rv;
}
rv = apr_file_read(f, buf, len);
if (rv != APR_SUCCESS && rv != APR_EOF) {
apr_bucket_free(buf);
return rv;
}
filelength -= *len;
/*
* Change the current bucket to refer to what we read,
* even if we read nothing because we hit EOF.
*/
apr_bucket_heap_make(e, buf, *len, apr_bucket_free);
/* If we have more to read from the file, then create another bucket */
if (filelength > 0 && rv != APR_EOF) {
/* for efficiency, we can just build a new apr_bucket struct
* to wrap around the existing file bucket */
b = apr_bucket_alloc(sizeof(*b), e->list);
b->start = fileoffset + (*len);
b->length = filelength;
b->data = a;
b->type = &apr_bucket_type_file;
b->free = apr_bucket_free;
b->list = e->list;
APR_BUCKET_INSERT_AFTER(e, b);
}
else {
file_bucket_destroy(a);
}
*str = buf;
return rv;
}
apr_status_t
chunk_bucket_read(apr_bucket *b, const char **str, apr_size_t *len, apr_read_type_e block)
{
apr_size_t written=0, length=0;
apr_size_t offset = 0;
apr_int64_t total64, remaining64, done64;
apr_int64_t bl64, w64;
ssize_t w;
dav_resource_private *ctx;
apr_status_t rc;
rc = APR_SUCCESS;
(void) block;
*str = NULL; /* in case we die prematurely */
*len = 0;
/*dummy bucket*/
if (b->length == (apr_size_t)(-1) || b->start == (apr_off_t)(-1))
return APR_SUCCESS;
ctx = b->data;
offset = b->start - ctx->cp_chunk.read;
DAV_DEBUG_REQ(ctx->request, 0, "Reading data for this bucket start at current position + %"APR_SIZE_T_FMT, offset);
DAV_DEBUG_REQ(ctx->request, 0, "Bucket length %"APR_SIZE_T_FMT, b->length);
total64 = g_ascii_strtoll(ctx->cp_chunk.uncompressed_size, NULL, 10);
done64 = b->start;
bl64 = b->length;
remaining64 = MIN(total64 - done64, bl64);
DAV_DEBUG_REQ(ctx->request, 0, "Data already returned=%"APR_INT64_T_FMT", remaining=%"APR_INT64_T_FMT, done64, remaining64);
if (remaining64 <= 0){
DAV_DEBUG_REQ(ctx->request, 0, "No remaining data, end of resource delivering.");
apr_bucket_heap_make(b, NULL, *len, apr_bucket_free);
return APR_SUCCESS;
}
else { /* determine the size of THIS bucket */
if (remaining64 > APR_BUCKET_BUFF_SIZE)
length = APR_BUCKET_BUFF_SIZE;
else
length = remaining64;
}
*len = length;
guint8 *buf = apr_bucket_alloc(length, b->list);
for (written=0; written < length ;) {
GError *gerror;
DAV_DEBUG_REQ(ctx->request, 0, "Trying to read at most %"APR_SSIZE_T_FMT" bytes (%"APR_SSIZE_T_FMT" received)",
length - written, written);
gerror = NULL;
w = ctx->comp_ctx.data_uncompressor(&ctx->cp_chunk, offset, buf+written, length-written, &gerror);
offset = 0;
DAV_DEBUG_REQ(ctx->request, 0 , "%"APR_SSIZE_T_FMT" bytes read from local resource", w);
if (w < 0) {
DAV_ERROR_REQ(ctx->request, 0, "Read from chunk failed : %s", gerror_get_message(gerror));
if (gerror)
g_error_free(gerror);
apr_bucket_free(buf);
return APR_INCOMPLETE;
}
if (gerror)
g_error_free(gerror);
if (w == 0) {
DAV_DEBUG_REQ(ctx->request, 0, "No bytes read from local resource whereas we"
" must read again, this should never happened");
apr_bucket_free(buf);
return APR_INCOMPLETE;
}
written += w;
}
*len = written;
DAV_DEBUG_REQ(ctx->request, 0, "Bucket done (%"APR_SSIZE_T_FMT" bytes, rc=%d)", written, rc);
w64 = written;
DAV_DEBUG_REQ(ctx->request, 0, "Status info : %"APR_INT64_T_FMT" written , %"APR_INT64_T_FMT" length total", w64, bl64);
apr_bucket_heap_make(b, (char*)buf, *len, apr_bucket_free);
if(w64 < bl64) {
apr_bucket *bkt;
DAV_DEBUG_REQ(ctx->request, 0, "Creating bucket info: bkt->length = %"APR_INT64_T_FMT", bkt->start ="
" %"APR_INT64_T_FMT", bkt->data = %p, bkt->list = %p\n", remaining64, done64 + w64,
&(ctx->cp_chunk), b->list);
bkt = apr_bucket_alloc(sizeof(*bkt), b->list);
bkt->type = &chunk_bucket_type;
bkt->length = remaining64 - w64;
bkt->start = done64 + w64;
bkt->data = ctx;
bkt->free = chunk_bucket_free_noop;
bkt->list = b->list;
APR_BUCKET_INSERT_AFTER(b, bkt);
DAV_DEBUG_REQ(ctx->request, 0, "Starting a new RAWX bucket (length=%"APR_SIZE_T_FMT" start=%"APR_INT64_T_FMT")", bkt->length, bkt->start);
}
*str = (char*)buf;
return rc;
}
//本函数只处理一次buf读取操作，loop在caller中执行
static apr_status_t socket_bucket_read(apr_bucket *a, const char **str,
apr_size_t *len, apr_read_type_e block)
{
//把数据从a->data中读入到a->list中的node空间中
apr_socket_t *p = a->data;
char *buf;
apr_status_t rv;
apr_interval_time_t timeout;
if (block == APR_NONBLOCK_READ) {
apr_socket_timeout_get(p, &timeout);
apr_socket_timeout_set(p, 0);
}
*str = NULL;
*len = APR_BUCKET_BUFF_SIZE;
buf = apr_bucket_alloc(*len, a->list); /* XXX: check for failure? */
rv = apr_socket_recv(p, buf, len);
if (block == APR_NONBLOCK_READ) {
apr_socket_timeout_set(p, timeout);
}
if (rv != APR_SUCCESS && rv != APR_EOF) {
apr_bucket_free(buf);
return rv;
}
/*
* If there's more to read we have to keep the rest of the socket
* for later. XXX: Note that more complicated bucket types that
* refer to data not in memory and must therefore have a read()
* function similar to this one should be wary of copying this
* code because if they have a destroy function they probably
* want to migrate the bucket's subordinate structure from the
* old bucket to a raw new one and adjust it as appropriate,
* rather than destroying the old one and creating a completely
* new bucket.
* 如果read后还有剩余，则需要保留socket剩余部分下次再读。
* 类似这样的需要一个read()操作的非内存bucket，请谨慎copy当前代码，
* 原因见上面解释
*
*
* Even if there is nothing more to read, don't close the socket here
* as we have to use it to send any response :) We could shut it
* down for reading, but there is no benefit to doing so.
* read完成后不需要close/shut down socket
*
*
*/
if (*len > 0) {
apr_bucket_heap *h;
/* Change the current bucket to refer to what we read */
//把当前读取的那部分数据组织成一个heap bucket,并返回起始地址
a = apr_bucket_heap_make(a, buf, *len, apr_bucket_free);
h = a->data;
h->alloc_len = APR_BUCKET_BUFF_SIZE; /* note the real buffer size */
*str = buf;
//剩下的p作为一个新的socket bucket
APR_BUCKET_INSERT_AFTER(a, apr_bucket_socket_create(p, a->list));
}
else {
apr_bucket_free(buf);
a = apr_bucket_immortal_make(a, "", 0);
*str = a->data;
}
return APR_SUCCESS;
}
static apr_status_t append_bucket(h2_bucket_beam *beam,
apr_bucket *bred,
apr_read_type_e block,
apr_pool_t *pool,
h2_beam_lock *pbl)
{
const char *data;
apr_size_t len;
apr_off_t space_left = 0;
apr_status_t status;
if (APR_BUCKET_IS_METADATA(bred)) {
if (APR_BUCKET_IS_EOS(bred)) {
beam->closed = 1;
}
APR_BUCKET_REMOVE(bred);
H2_BLIST_INSERT_TAIL(&beam->red, bred);
return APR_SUCCESS;
}
else if (APR_BUCKET_IS_FILE(bred)) {
/* file bucket lengths do not really count */
}
else {
space_left = calc_space_left(beam);
if (space_left > 0 && bred->length == ((apr_size_t)-1)) {
const char *data;
status = apr_bucket_read(bred, &data, &len, APR_BLOCK_READ);
if (status != APR_SUCCESS) {
return status;
}
}
if (space_left < bred->length) {
status = r_wait_space(beam, block, pbl, &space_left);
if (status != APR_SUCCESS) {
return status;
}
if (space_left <= 0) {
return APR_EAGAIN;
}
}
/* space available, maybe need bucket split */
}
/* The fundamental problem is that reading a red bucket from
* a green thread is a total NO GO, because the bucket might use
* its pool/bucket_alloc from a foreign thread and that will
* corrupt. */
status = APR_ENOTIMPL;
if (beam->closed && bred->length > 0) {
status = APR_EOF;
}
else if (APR_BUCKET_IS_TRANSIENT(bred)) {
/* this takes care of transient buckets and converts them
* into heap ones. Other bucket types might or might not be
* affected by this. */
status = apr_bucket_setaside(bred, pool);
}
else if (APR_BUCKET_IS_HEAP(bred)) {
/* For heap buckets read from a green thread is fine. The
* data will be there and live until the bucket itself is
* destroyed. */
status = APR_SUCCESS;
}
else if (APR_BUCKET_IS_POOL(bred)) {
/* pool buckets are bastards that register at pool cleanup
* to morph themselves into heap buckets. That may happen anytime,
* even after the bucket data pointer has been read. So at
* any time inside the green thread, the pool bucket memory
* may disappear. yikes. */
status = apr_bucket_read(bred, &data, &len, APR_BLOCK_READ);
if (status == APR_SUCCESS) {
apr_bucket_heap_make(bred, data, len, NULL);
}
}
else if (APR_BUCKET_IS_FILE(bred)) {
/* For file buckets the problem is their internal readpool that
* is used on the first read to allocate buffer/mmap.
* Since setting aside a file bucket will de-register the
* file cleanup function from the previous pool, we need to
* call that from a red thread.
* Additionally, we allow callbacks to prevent beaming file
* handles across. The use case for this is to limit the number
* of open file handles and rather use a less efficient beam
* transport. */
apr_file_t *fd = ((apr_bucket_file *)bred->data)->fd;
int can_beam = 1;
if (beam->last_beamed != fd && beam->can_beam_fn) {
can_beam = beam->can_beam_fn(beam->can_beam_ctx, beam, fd);
}
if (can_beam) {
beam->last_beamed = fd;
status = apr_bucket_setaside(bred, pool);
}
/* else: enter ENOTIMPL case below */
}
if (status == APR_ENOTIMPL) {
/* we have no knowledge about the internals of this bucket,
* but hope that after read, its data stays immutable for the
* lifetime of the bucket. (see pool bucket handling above for
* a counter example).
* We do the read while in a red thread, so that the bucket may
* use pools/allocators safely. */
if (space_left < APR_BUCKET_BUFF_SIZE) {
space_left = APR_BUCKET_BUFF_SIZE;
}
if (space_left < bred->length) {
apr_bucket_split(bred, space_left);
}
status = apr_bucket_read(bred, &data, &len, APR_BLOCK_READ);
if (status == APR_SUCCESS) {
status = apr_bucket_setaside(bred, pool);
}
}
if (status != APR_SUCCESS && status != APR_ENOTIMPL) {
return status;
}
APR_BUCKET_REMOVE(bred);
H2_BLIST_INSERT_TAIL(&beam->red, bred);
beam->sent_bytes += bred->length;
return APR_SUCCESS;
}