■
apr_buckets.hで宣言されていたbrigadeの操作関数郡
APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data) { apr_bucket_brigade *b = data; apr_bucket *e; while (!APR_BRIGADE_EMPTY(b)) { e = APR_BRIGADE_FIRST(b); apr_bucket_delete(e); } /* We don't need to free(bb) because it's allocated from a pool. */ return APR_SUCCESS; }
brigadeの要素eがなくなるまでapr_buckdet_deleteを呼び出している。
apr_bucket_deleteはそのbucketをbrigadeから除去し、メモリを開放している
APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
apr_bucket_alloc_t *list)
{
apr_bucket_brigade *b;
b = apr_palloc(p, sizeof(*b));
b->p = p;
b->bucket_alloc = list;
APR_RING_INIT(&b->list, apr_bucket, link);
apr_pool_cleanup_register(b->p, b, brigade_cleanup, apr_pool_cleanup_null);
return b;
}
brigadeのメモリ確保とbucket用ringの初期化。
apr_pool_cleanup_registerは/src/lib/apr/memory/unix/apr_pool.cに定義されていて
メモリのcleanup用にこのbrigadeをpoolに登録する
APR_DECLARE(void) apr_pool_cleanup_register(apr_pool_t *p, const void *data, apr_status_t (*plain_cleanup_fn)(void *data), apr_status_t (*child_cleanup_fn)(void *data)) { cleanup_t *c; #if APR_POOL_DEBUG apr_pool_check_integrity(p); #endif /* APR_POOL_DEBUG */ if (p != NULL) { if (p->free_cleanups) { /* reuse a cleanup structure */ c = p->free_cleanups; p->free_cleanups = c->next; } else { c = apr_palloc(p, sizeof(cleanup_t)); } c->data = data; c->plain_cleanup_fn = plain_cleanup_fn; c->child_cleanup_fn = child_cleanup_fn; c->next = p->cleanups; p->cleanups = c; } }
APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
apr_bucket *e)
{
apr_bucket_brigade *a;
apr_bucket *f;
a = apr_brigade_create(b->p, b->bucket_alloc);
/* Return an empty brigade if there is nothing left in
* the first brigade to split off
*/
if (e != APR_BRIGADE_SENTINEL(b)) {
f = APR_RING_LAST(&b->list);
APR_RING_UNSPLICE(e, f, link);
APR_RING_SPLICE_HEAD(&a->list, e, f, apr_bucket, link);
}
APR_BRIGADE_CHECK_CONSISTENCY(a);
APR_BRIGADE_CHECK_CONSISTENCY(b);
return a;
}
splitはbrigadeを新しく作成し、bucket eがbrigade bの番兵じゃなければeからf(brigade bの最後のbucket)を新しいbrigade aとして設定し返す。APR_RING_UNSPLICEによりbrigade bからはe〜fのbucketは外される。
APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
apr_off_t point,
apr_bucket **after_point)
{
apr_bucket *e;
const char *s;
apr_size_t len;
apr_status_t rv;
if (point < 0) {
/* this could cause weird (not necessarily SEGV) things to happen */
return APR_EINVAL;
}
if (point == 0) {
*after_point = APR_BRIGADE_FIRST(b);
return APR_SUCCESS;
}
APR_BRIGADE_CHECK_CONSISTENCY(b);
for (e = APR_BRIGADE_FIRST(b);
e != APR_BRIGADE_SENTINEL(b);
e = APR_BUCKET_NEXT(e))
{
if ((e->length == (apr_size_t)(-1)) && (point > (apr_size_t)(-1))) {
/* point is too far out to simply split this bucket,
* we must fix this bucket's size and keep going... */
rv = apr_bucket_read(e, &s, &len, APR_BLOCK_READ);
if (rv != APR_SUCCESS) {
*after_point = e;
return rv;
}
}
if ((point < e->length) || (e->length == (apr_size_t)(-1))) {
/* We already checked e->length -1 above, so we now
* trust e->length < MAX_APR_SIZE_T.
* First try to split the bucket natively... */
if ((rv = apr_bucket_split(e, (apr_size_t)point))
!= APR_ENOTIMPL) {
*after_point = APR_BUCKET_NEXT(e);
return rv;
}
/* if the bucket cannot be split, we must read from it,
* changing its type to one that can be split */
rv = apr_bucket_read(e, &s, &len, APR_BLOCK_READ);
if (rv != APR_SUCCESS) {
*after_point = e;
return rv;
}
/* this assumes that len == e->length, which is okay because e
* might have been morphed by the apr_bucket_read() above, but
* if it was, the length would have been adjusted appropriately */
if (point < e->length) {
rv = apr_bucket_split(e, (apr_size_t)point);
*after_point = APR_BUCKET_NEXT(e);
return rv;
}
}
if (point == e->length) {
*after_point = APR_BUCKET_NEXT(e);
return APR_SUCCESS;
}
point -= e->length;
}
*after_point = APR_BRIGADE_SENTINEL(b);
return APR_INCOMPLETE;
}
splitとは違い新しいbrigadeを作らずにoffset値pointにより場合分けし、分けられるようであればそれを*after_pointとして返している。
APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
int read_all, apr_off_t *length)
{
apr_off_t total = 0;
apr_bucket *bkt;
for (bkt = APR_BRIGADE_FIRST(bb);
bkt != APR_BRIGADE_SENTINEL(bb);
bkt = APR_BUCKET_NEXT(bkt))
{
if (bkt->length == (apr_size_t)(-1)) {
const char *ignore;
apr_size_t len;
apr_status_t status;
if (!read_all) {
*length = -1;
return APR_SUCCESS;
}
if ((status = apr_bucket_read(bkt, &ignore, &len,
APR_BLOCK_READ)) != APR_SUCCESS) {
return status;
}
}
total += bkt->length;
}
*length = total;
return APR_SUCCESS;
}
brigadeにリンクされてる各bucketのlengthを足して*lengthで返している。
APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
char *c, apr_size_t *len)
{
apr_size_t actual = 0;
apr_bucket *b;
for (b = APR_BRIGADE_FIRST(bb);
b != APR_BRIGADE_SENTINEL(bb);
b = APR_BUCKET_NEXT(b))
{
const char *str;
apr_size_t str_len;
apr_status_t status;
status = apr_bucket_read(b, &str, &str_len, APR_BLOCK_READ);
if (status != APR_SUCCESS) {
return status;
}
/* If we would overflow. */
if (str_len + actual > *len) {
str_len = *len - actual;
}
/* XXX: It appears that overflow of the final bucket
* is DISCARDED without any warning to the caller.
*
* No, we only copy the data up to their requested size. -- jre
*/
memcpy(c, str, str_len);
c += str_len;
actual += str_len;
/* This could probably be actual == *len, but be safe from stray
* photons. */
if (actual >= *len) {
break;
}
}
*len = actual;
return APR_SUCCESS;
}
brigade bbの各bucket bからデータをreadで読み取って(str)それをc(char*)にmemcpyしている。
最終的に全てのデータがcに連結されて返される。
APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb,
char **c,
apr_size_t *len,
apr_pool_t *pool)
{
apr_off_t actual;
apr_size_t total;
apr_status_t rv;
apr_brigade_length(bb, 1, &actual);
total = (apr_size_t)actual;
*c = apr_palloc(pool, total);
rv = apr_brigade_flatten(bb, *c, &total);
if (rv != APR_SUCCESS) {
return rv;
}
*len = total;
return APR_SUCCESS;
}
brigadeの長さをapr_brigade_lengthで計ってからapr_brigade_flattenを呼出し、cに全データを格納している。cはapr_pallocによりpoolで確保される。
APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
apr_bucket_brigade *bbIn,
apr_read_type_e block,
apr_off_t maxbytes)
{
apr_off_t readbytes = 0;
while (!APR_BRIGADE_EMPTY(bbIn)) {
const char *pos;
const char *str;
apr_size_t len;
apr_status_t rv;
apr_bucket *e;
e = APR_BRIGADE_FIRST(bbIn);
rv = apr_bucket_read(e, &str, &len, block);
if (rv != APR_SUCCESS) {
return rv;
}
pos = memchr(str, APR_ASCII_LF, len);
/* We found a match. */
if (pos != NULL) {
apr_bucket_split(e, pos - str + 1);
APR_BUCKET_REMOVE(e);
APR_BRIGADE_INSERT_TAIL(bbOut, e);
return APR_SUCCESS;
}
APR_BUCKET_REMOVE(e);
APR_BRIGADE_INSERT_TAIL(bbOut, e);
readbytes += len;
/* We didn't find an APR_ASCII_LF within the maximum line length. */
if (readbytes >= maxbytes) {
break;
}
}
return APR_SUCCESS;
}
brigade bbInからbucketを読み取っていき、その中のデータにLF(\n)があった場合、そこでbrigadeを分割する。（そのbucket以前のリンクbucketはbbOutでそれより後のものがbbInとして残る）
APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b,
struct iovec *vec, int *nvec)
{
int left = *nvec;
apr_bucket *e;
struct iovec *orig;
apr_size_t iov_len;
apr_status_t rv;
orig = vec;
for (e = APR_BRIGADE_FIRST(b);
e != APR_BRIGADE_SENTINEL(b);
e = APR_BUCKET_NEXT(e))
{
if (left-- == 0)
break;
rv = apr_bucket_read(e, (const char **)&vec->iov_base, &iov_len,
APR_NONBLOCK_READ);
if (rv != APR_SUCCESS)
return rv;
vec->iov_len = iov_len; /* set indirectly in case size differs */
++vec;
}
*nvec = vec - orig;
return APR_SUCCESS;
}
struct iovecのvecにbrigade bの全bucketデータを読み込ませている
- write関連
APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
apr_brigade_flush flush,
void *ctx,
const char *str, apr_size_t nbyte)
{
~~~
if (!APR_BRIGADE_EMPTY(b) && APR_BUCKET_IS_HEAP(e)) {
apr_bucket_heap *h = e->data;
/* HEAP bucket start offsets are always in-memory, safe to cast */
remaining = h->alloc_len - (e->length + (apr_size_t)e->start);
buf = h->base + e->start + e->length;
}
if (nbyte > remaining) {
if (flush) {
e = apr_bucket_transient_create(str, nbyte, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
return flush(b, ctx);
}
else {
e = apr_bucket_heap_create(str, nbyte, NULL, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
return APR_SUCCESS;
}
}
else if (!buf) {
/* we don't have a buffer, but the data is small enough
* that we don't mind making a new buffer */
buf = apr_bucket_alloc(APR_BUCKET_BUFF_SIZE, b->bucket_alloc);
e = apr_bucket_heap_create(buf, APR_BUCKET_BUFF_SIZE,
apr_bucket_free, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
e->length = 0; /* We are writing into the brigade, and
* allocating more memory than we need. This
* ensures that the bucket thinks it is empty just
* after we create it. We'll fix the length
* once we put data in it below.
*/
}
/* there is a sufficiently big buffer bucket available now */
memcpy(buf, str, nbyte);
e->length += nbyte;
return APR_SUCCESS;
}
brigadeの最後の要素eに十分な空きがあればそこにデータ(str)をnbytes分コピーする。十分な空きがない場合はbucketを新く作り、そこにstrをコピーする。
