static apr_status_t file_bucket_setaside(apr_bucket *data, apr_pool_t *reqpool)
{
apr_bucket_file *a = data->data;
apr_file_t *fd = NULL;
apr_file_t *f = a->fd;
apr_pool_t *curpool = apr_file_pool_get(f);
if (apr_pool_is_ancestor(curpool, reqpool)) {
return APR_SUCCESS;
}
if (!apr_pool_is_ancestor(a->readpool, reqpool)) {
a->readpool = reqpool;
}
apr_file_setaside(&fd, f, reqpool);
a->fd = fd;
return APR_SUCCESS;
}
apr_status_t h2_util_move(apr_bucket_brigade *to, apr_bucket_brigade *from,
apr_size_t maxlen, int *pfile_handles_allowed,
const char *msg)
{
apr_status_t status = APR_SUCCESS;
int same_alloc;
AP_DEBUG_ASSERT(to);
AP_DEBUG_ASSERT(from);
same_alloc = (to->bucket_alloc == from->bucket_alloc);
if (!FILE_MOVE) {
pfile_handles_allowed = NULL;
}
if (!APR_BRIGADE_EMPTY(from)) {
apr_bucket *b, *end;
status = last_not_included(from, maxlen, same_alloc,
pfile_handles_allowed, &end);
if (status != APR_SUCCESS) {
return status;
}
while (!APR_BRIGADE_EMPTY(from) && status == APR_SUCCESS) {
b = APR_BRIGADE_FIRST(from);
if (b == end) {
break;
}
if (same_alloc || (b->list == to->bucket_alloc)) {
/* both brigades use the same bucket_alloc and auto-cleanups
* have the same life time. It's therefore safe to just move
* directly. */
APR_BUCKET_REMOVE(b);
APR_BRIGADE_INSERT_TAIL(to, b);
#if LOG_BUCKETS
ap_log_perror(APLOG_MARK, LOG_LEVEL, 0, to->p,
"h2_util_move: %s, passed bucket(same bucket_alloc) "
"%ld-%ld, type=%s",
msg, (long)b->start, (long)b->length,
APR_BUCKET_IS_METADATA(b)?
(APR_BUCKET_IS_EOS(b)? "EOS":
(APR_BUCKET_IS_FLUSH(b)? "FLUSH" : "META")) :
(APR_BUCKET_IS_FILE(b)? "FILE" : "DATA"));
#endif
}
else if (DEEP_COPY) {
/* we have not managed the magic of passing buckets from
* one thread to another. Any attempts result in
* cleanup of pools scrambling memory.
*/
if (APR_BUCKET_IS_METADATA(b)) {
if (APR_BUCKET_IS_EOS(b)) {
APR_BRIGADE_INSERT_TAIL(to, apr_bucket_eos_create(to->bucket_alloc));
}
else if (APR_BUCKET_IS_FLUSH(b)) {
APR_BRIGADE_INSERT_TAIL(to, apr_bucket_flush_create(to->bucket_alloc));
}
else {
/* ignore */
}
}
else if (pfile_handles_allowed
&& *pfile_handles_allowed > 0
&& APR_BUCKET_IS_FILE(b)) {
/* We do not want to read files when passing buckets, if
* we can avoid it. However, what we've come up so far
* is not working corrently, resulting either in crashes or
* too many open file descriptors.
*/
apr_bucket_file *f = (apr_bucket_file *)b->data;
apr_file_t *fd = f->fd;
int setaside = (f->readpool != to->p);
#if LOG_BUCKETS
ap_log_perror(APLOG_MARK, LOG_LEVEL, 0, to->p,
"h2_util_move: %s, moving FILE bucket %ld-%ld "
"from=%lx(p=%lx) to=%lx(p=%lx), setaside=%d",
msg, (long)b->start, (long)b->length,
(long)from, (long)from->p,
(long)to, (long)to->p, setaside);
#endif
if (setaside) {
status = apr_file_setaside(&fd, fd, to->p);
if (status != APR_SUCCESS) {
ap_log_perror(APLOG_MARK, APLOG_ERR, status, to->p,
APLOGNO(02947) "h2_util: %s, setaside FILE",
msg);
return status;
}
}
apr_brigade_insert_file(to, fd, b->start, b->length,
to->p);
--(*pfile_handles_allowed);
}
else {
const char *data;
apr_size_t len;
status = apr_bucket_read(b, &data, &len, APR_BLOCK_READ);
if (status == APR_SUCCESS && len > 0) {
status = apr_brigade_write(to, NULL, NULL, data, len);
#if LOG_BUCKETS
ap_log_perror(APLOG_MARK, LOG_LEVEL, 0, to->p,
"h2_util_move: %s, copied bucket %ld-%ld "
"from=%lx(p=%lx) to=%lx(p=%lx)",
msg, (long)b->start, (long)b->length,
(long)from, (long)from->p,
(long)to, (long)to->p);
#endif
}
}
apr_bucket_delete(b);
}
else {
apr_bucket_setaside(b, to->p);
APR_BUCKET_REMOVE(b);
APR_BRIGADE_INSERT_TAIL(to, b);
#if LOG_BUCKETS
ap_log_perror(APLOG_MARK, LOG_LEVEL, 0, to->p,
"h2_util_move: %s, passed setaside bucket %ld-%ld "
"from=%lx(p=%lx) to=%lx(p=%lx)",
msg, (long)b->start, (long)b->length,
(long)from, (long)from->p,
(long)to, (long)to->p);
#endif
}
}
}
return status;
}
apr_status_t h2_beam_receive(h2_bucket_beam *beam,
apr_bucket_brigade *bb,
apr_read_type_e block,
apr_off_t readbytes)
{
h2_beam_lock bl;
apr_bucket *bred, *bgreen, *ng;
int transferred = 0;
apr_status_t status = APR_SUCCESS;
apr_off_t remain = readbytes;
/* Called from the green thread to take buckets from the beam */
if (enter_yellow(beam, &bl) == APR_SUCCESS) {
transfer:
if (beam->aborted) {
if (beam->green && !APR_BRIGADE_EMPTY(beam->green)) {
apr_brigade_cleanup(beam->green);
}
status = APR_ECONNABORTED;
goto leave;
}
/* transfer enough buckets from our green brigade, if we have one */
while (beam->green
&& !APR_BRIGADE_EMPTY(beam->green)
&& (readbytes <= 0 || remain >= 0)) {
bgreen = APR_BRIGADE_FIRST(beam->green);
if (readbytes > 0 && bgreen->length > 0 && remain <= 0) {
break;
}
APR_BUCKET_REMOVE(bgreen);
APR_BRIGADE_INSERT_TAIL(bb, bgreen);
remain -= bgreen->length;
++transferred;
}
/* transfer from our red brigade, transforming red buckets to
* green ones until we have enough */
while (!H2_BLIST_EMPTY(&beam->red) && (readbytes <= 0 || remain >= 0)) {
bred = H2_BLIST_FIRST(&beam->red);
bgreen = NULL;
if (readbytes > 0 && bred->length > 0 && remain <= 0) {
break;
}
if (APR_BUCKET_IS_METADATA(bred)) {
if (APR_BUCKET_IS_EOS(bred)) {
bgreen = apr_bucket_eos_create(bb->bucket_alloc);
beam->close_sent = 1;
}
else if (APR_BUCKET_IS_FLUSH(bred)) {
bgreen = apr_bucket_flush_create(bb->bucket_alloc);
}
else {
/* put red into hold, no green sent out */
}
}
else if (APR_BUCKET_IS_FILE(bred)) {
/* This is set aside into the target brigade pool so that
* any read operation messes with that pool and not
* the red one. */
apr_bucket_file *f = (apr_bucket_file *)bred->data;
apr_file_t *fd = f->fd;
int setaside = (f->readpool != bb->p);
if (setaside) {
status = apr_file_setaside(&fd, fd, bb->p);
if (status != APR_SUCCESS) {
goto leave;
}
++beam->files_beamed;
}
ng = apr_brigade_insert_file(bb, fd, bred->start, bred->length,
bb->p);
#if APR_HAS_MMAP
/* disable mmap handling as this leads to segfaults when
* the underlying file is changed while memory pointer has
* been handed out. See also PR 59348 */
apr_bucket_file_enable_mmap(ng, 0);
#endif
remain -= bred->length;
++transferred;
APR_BUCKET_REMOVE(bred);
H2_BLIST_INSERT_TAIL(&beam->hold, bred);
++transferred;
continue;
}
else {
/* create a "green" standin bucket. we took care about the
* underlying red bucket and its data when we placed it into
* the red brigade.
* the beam bucket will notify us on destruction that bred is
* no longer needed. */
bgreen = h2_beam_bucket_create(beam, bred, bb->bucket_alloc,
beam->buckets_sent++);
}
/* Place the red bucket into our hold, to be destroyed when no
* green bucket references it any more. */
APR_BUCKET_REMOVE(bred);
H2_BLIST_INSERT_TAIL(&beam->hold, bred);
beam->received_bytes += bred->length;
if (bgreen) {
APR_BRIGADE_INSERT_TAIL(bb, bgreen);
remain -= bgreen->length;
++transferred;
}
}
if (readbytes > 0 && remain < 0) {
/* too much, put some back */
remain = readbytes;
for (bgreen = APR_BRIGADE_FIRST(bb);
bgreen != APR_BRIGADE_SENTINEL(bb);
bgreen = APR_BUCKET_NEXT(bgreen)) {
remain -= bgreen->length;
if (remain < 0) {
apr_bucket_split(bgreen, bgreen->length+remain);
beam->green = apr_brigade_split_ex(bb,
APR_BUCKET_NEXT(bgreen),
beam->green);
break;
}
}
}
if (beam->closed
&& (!beam->green || APR_BRIGADE_EMPTY(beam->green))
&& H2_BLIST_EMPTY(&beam->red)) {
/* beam is closed and we have nothing more to receive */
if (!beam->close_sent) {
apr_bucket *b = apr_bucket_eos_create(bb->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
beam->close_sent = 1;
++transferred;
status = APR_SUCCESS;
}
}
if (transferred) {
status = APR_SUCCESS;
}
else if (beam->closed) {
status = APR_EOF;
}
else if (block == APR_BLOCK_READ && bl.mutex && beam->m_cond) {
status = wait_cond(beam, bl.mutex);
if (status != APR_SUCCESS) {
goto leave;
}
goto transfer;
}
else {
status = APR_EAGAIN;
}
leave:
leave_yellow(beam, &bl);
}
return status;
}
