MP_INLINE static apr_status_t send_output_eos(ap_filter_t *f)
{
apr_bucket_alloc_t *ba = f->c->bucket_alloc;
apr_bucket_brigade *bb = apr_brigade_create(MP_FILTER_POOL(f),
ba);
apr_bucket *b = apr_bucket_eos_create(ba);
APR_BRIGADE_INSERT_TAIL(bb, b);
((modperl_filter_ctx_t *)f->ctx)->sent_eos = 1;
MP_TRACE_f(MP_FUNC, MP_FILTER_NAME_FORMAT
"write out: EOS bucket in separate bb", MP_FILTER_NAME(f));
return ap_pass_brigade(f->next, bb);
}
h2_stream *h2_stream_open(int id, apr_pool_t *pool, h2_session *session)
{
h2_stream *stream = h2_stream_create(id, pool, session);
set_state(stream, H2_STREAM_ST_OPEN);
stream->request = h2_request_create(id, pool, session->config);
stream->bbout = apr_brigade_create(stream->pool,
stream->session->c->bucket_alloc);
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_stream(%ld-%d): opened", session->id, stream->id);
return stream;
}
h2_io *h2_io_create(int id, apr_pool_t *pool, apr_bucket_alloc_t *bucket_alloc)
{
h2_io *io = apr_pcalloc(pool, sizeof(*io));
if (io) {
io->id = id;
io->pool = pool;
io->bbin = NULL;
io->bbout = apr_brigade_create(pool, bucket_alloc);
io->response = apr_pcalloc(pool, sizeof(h2_response));
}
return io;
}
h2_task_input *h2_task_input_create(h2_task_env *env, apr_pool_t *pool,
apr_bucket_alloc_t *bucket_alloc)
{
h2_task_input *input = apr_pcalloc(pool, sizeof(h2_task_input));
if (input) {
input->env = env;
input->bb = NULL;
if (env->serialize_headers) {
input->bb = apr_brigade_create(pool, bucket_alloc);
apr_brigade_printf(input->bb, NULL, NULL, "%s %s HTTP/1.1\r\n",
env->method, env->path);
apr_table_do(ser_header, input, env->headers, NULL);
apr_brigade_puts(input->bb, NULL, NULL, "\r\n");
if (input->env->input_eos) {
APR_BRIGADE_INSERT_TAIL(input->bb, apr_bucket_eos_create(bucket_alloc));
}
}
else if (!input->env->input_eos) {
input->bb = apr_brigade_create(pool, bucket_alloc);
}
else {
/* We do not serialize and have eos already, no need to
* create a bucket brigade. */
}
if (APLOGcdebug(&env->c)) {
char buffer[1024];
apr_size_t len = sizeof(buffer)-1;
if (input->bb) {
apr_brigade_flatten(input->bb, buffer, &len);
}
buffer[len] = 0;
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, &env->c,
"h2_task_input(%s): request is: %s",
env->id, buffer);
}
}
return input;
}
h2_from_h1 *h2_from_h1_create(int stream_id, apr_pool_t *pool,
apr_bucket_alloc_t *bucket_alloc)
{
h2_from_h1 *from_h1 = apr_pcalloc(pool, sizeof(h2_from_h1));
if (from_h1) {
from_h1->stream_id = stream_id;
from_h1->pool = pool;
from_h1->tmp = apr_brigade_create(pool, bucket_alloc);
from_h1->state = H2_RESP_ST_STATUS_LINE;
from_h1->hlines = apr_array_make(pool, 10, sizeof(char *));
}
return from_h1;
}
static apr_status_t CaseFilterOutFilter(ap_filter_t *f,
apr_bucket_brigade *pbbIn)
{
request_rec *r = f->r;
conn_rec *c = r->connection;
apr_bucket *pbktIn;
apr_bucket_brigade *pbbOut;
pbbOut=apr_brigade_create(r->pool, c->bucket_alloc);
for (pbktIn = APR_BRIGADE_FIRST(pbbIn);
pbktIn != APR_BRIGADE_SENTINEL(pbbIn);
pbktIn = APR_BUCKET_NEXT(pbktIn))
{
const char *data;
apr_size_t len;
char *buf;
apr_size_t n;
apr_bucket *pbktOut;
if(APR_BUCKET_IS_EOS(pbktIn))
{
apr_bucket *pbktEOS=apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(pbbOut,pbktEOS);
continue;
}
/* read */
apr_bucket_read(pbktIn,&data,&len,APR_BLOCK_READ);
/* write */
buf = apr_bucket_alloc(len, c->bucket_alloc);
for(n=0 ; n < len ; ++n)
buf[n] = apr_toupper(data[n]);
pbktOut = apr_bucket_heap_create(buf, len, apr_bucket_free,
c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(pbbOut,pbktOut);
}
/* Q: is there any advantage to passing a brigade for each bucket?
* A: obviously, it can cut down server resource consumption, if this
* experimental module was fed a file of 4MB, it would be using 8MB for
* the 'read' buckets and the 'write' buckets.
*
* Note it is more efficient to consume (destroy) each bucket as it's
* processed above than to do a single cleanup down here. In any case,
* don't let our caller pass the same buckets to us, twice;
*/
apr_brigade_cleanup(pbbIn);
return ap_pass_brigade(f->next,pbbOut);
}
apr_status_t h2_stream_set_response(h2_stream *stream, h2_response *response,
apr_bucket_brigade *bb)
{
stream->response = response;
if (bb && !APR_BRIGADE_EMPTY(bb)) {
if (!stream->bbout) {
stream->bbout = apr_brigade_create(stream->pool,
stream->m->c->bucket_alloc);
}
return h2_util_move(stream->bbout, bb, 16 * 1024, NULL,
"h2_stream_set_response");
}
return APR_SUCCESS;
}
static void test_create(abts_case *tc, void *data)
{
apr_bucket_alloc_t *ba;
apr_bucket_brigade *bb;
ba = apr_bucket_alloc_create(p);
bb = apr_brigade_create(p, ba);
ABTS_ASSERT(tc, "new brigade not NULL", bb != NULL);
ABTS_ASSERT(tc, "new brigade is empty", APR_BRIGADE_EMPTY(bb));
apr_brigade_destroy(bb);
apr_bucket_alloc_destroy(ba);
}
static apr_bucket_brigade* get_bb(request_rec* r)
{
apr_bucket_brigade *bb = NULL;
int s = apr_pool_userdata_get((void**)&bb, "bb", r->pool);
if (s == 0)
{
if (bb == NULL)
{
bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
apr_pool_userdata_set(bb, "bb", NULL, r->pool);
}
}
return bb;
}
apr_status_t h2_stream_schedule(h2_stream *stream, int eos,
h2_stream_pri_cmp *cmp, void *ctx)
{
apr_status_t status;
AP_DEBUG_ASSERT(stream);
AP_DEBUG_ASSERT(stream->session);
AP_DEBUG_ASSERT(stream->session->mplx);
if (!output_open(stream)) {
return APR_ECONNRESET;
}
if (stream->scheduled) {
return APR_EINVAL;
}
if (eos) {
close_input(stream);
}
/* Seeing the end-of-headers, we have everything we need to
* start processing it.
*/
status = h2_request_end_headers(stream->request, stream->pool, eos);
if (status == APR_SUCCESS) {
if (!eos) {
stream->bbin = apr_brigade_create(stream->pool,
stream->session->c->bucket_alloc);
}
stream->input_remaining = stream->request->content_length;
status = h2_mplx_process(stream->session->mplx, stream->id,
stream->request, eos, cmp, ctx);
stream->scheduled = 1;
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, stream->session->c,
"h2_stream(%ld-%d): scheduled %s %s://%s%s",
stream->session->id, stream->id,
stream->request->method, stream->request->scheme,
stream->request->authority, stream->request->path);
}
else {
h2_stream_rst(stream, H2_ERR_INTERNAL_ERROR);
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, stream->session->c,
"h2_stream(%ld-%d): RST=2 (internal err) %s %s://%s%s",
stream->session->id, stream->id,
stream->request->method, stream->request->scheme,
stream->request->authority, stream->request->path);
}
return status;
}
static apr_bucket_brigade *make_simple_brigade(apr_bucket_alloc_t *ba,
const char *first,
const char *second)
{
apr_bucket_brigade *bb = apr_brigade_create(p, ba);
apr_bucket *e;
e = apr_bucket_transient_create(first, strlen(first), ba);
APR_BRIGADE_INSERT_TAIL(bb, e);
e = apr_bucket_transient_create(second, strlen(second), ba);
APR_BRIGADE_INSERT_TAIL(bb, e);
return bb;
}
apr_status_t h2_io_in_write(h2_io *io, apr_bucket_brigade *bb)
{
if (io->eos_in) {
return APR_EOF;
}
io->eos_in = h2_util_has_eos(bb, 0);
if (!APR_BRIGADE_EMPTY(bb)) {
if (!io->bbin) {
io->bbin = apr_brigade_create(io->bbout->p,
io->bbout->bucket_alloc);
}
return h2_util_move(io->bbin, bb, 0, 0, "h2_io_in_write");
}
return APR_SUCCESS;
}
porter_upload_request_t* porter_create_request(apreq_handle_t *req,
request_rec *raw_request,
porter_server_conf *config)
{
porter_upload_request_t *upload_request = apr_palloc(req->pool, sizeof(*upload_request));
upload_request->raw_request = raw_request;
upload_request->request = req;
upload_request->pool = req->pool;
upload_request->param_names = apr_array_make(req->pool, 1, sizeof(const char*));
upload_request->status = APR_SUCCESS;
upload_request->bucket_brigade = apr_brigade_create(req->pool, req->bucket_alloc);
upload_request->secret = config->secret;
return upload_request;
}
static int sendfile_handler(request_rec *r, a_file *file)
{
#if APR_HAS_SENDFILE
conn_rec *c = r->connection;
apr_bucket *b;
apr_bucket_brigade *bb = apr_brigade_create(r->pool, c->bucket_alloc);
apr_brigade_insert_file(bb, file->file, 0, file->finfo.size, r->pool);
b = apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
if (ap_pass_brigade(r->output_filters, bb) != APR_SUCCESS)
return AP_FILTER_ERROR;
#endif
return OK;
}
h2_stream *h2_stream_create(int id, apr_pool_t *pool, h2_session *session)
{
h2_stream *stream = apr_pcalloc(pool, sizeof(h2_stream));
if (stream != NULL) {
stream->id = id;
stream->state = H2_STREAM_ST_IDLE;
stream->pool = pool;
stream->session = session;
stream->bbout = apr_brigade_create(stream->pool,
stream->session->c->bucket_alloc);
stream->request = h2_request_create(id, pool, session->c->bucket_alloc);
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_stream(%ld-%d): created", session->id, stream->id);
}
return stream;
}
AP_CORE_DECLARE(void) ap_flush_conn(conn_rec *c)
{
apr_bucket_brigade *bb;
apr_bucket *b;
bb = apr_brigade_create(c->pool, c->bucket_alloc);
/* FLUSH bucket */
b = apr_bucket_flush_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
/* End Of Connection bucket */
b = ap_bucket_eoc_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
ap_pass_brigade(c->output_filters, bb);
}
static PyObject *filter_write(filterobject *self, PyObject *args)
{
char *buff;
int len;
apr_bucket *b;
PyObject *s;
conn_rec *c = self->request_obj->request_rec->connection;
if (! PyArg_ParseTuple(args, "O", &s))
return NULL;
if (! PyString_Check(s)) {
PyErr_SetString(PyExc_TypeError, "Argument to write() must be a string");
return NULL;
}
if (self->closed) {
PyErr_SetString(PyExc_ValueError, "I/O operation on closed filter");
return NULL;
}
/* PYTHON 2.5: 'PyString_Size' uses Py_ssize_t for return values (may need overflow check) */
len = PyString_Size(s);
if (len) {
/* does the output brigade exist? */
if (!self->bb_out) {
self->bb_out = apr_brigade_create(self->f->r->pool,
c->bucket_alloc);
}
buff = apr_bucket_alloc(len, c->bucket_alloc);
memcpy(buff, PyString_AS_STRING(s), len);
b = apr_bucket_heap_create(buff, len, apr_bucket_free,
c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(self->bb_out, b);
}
Py_INCREF(Py_None);
return Py_None;
}
AP_DECLARE(apr_status_t) ap_save_brigade(ap_filter_t *f,
apr_bucket_brigade **saveto,
apr_bucket_brigade **b, apr_pool_t *p)
{
apr_bucket *e;
apr_status_t rv, srv = APR_SUCCESS;
/* If have never stored any data in the filter, then we had better
* create an empty bucket brigade so that we can concat.
*/
if (!(*saveto)) {
*saveto = apr_brigade_create(p, f->c->bucket_alloc);
}
for (e = APR_BRIGADE_FIRST(*b);
e != APR_BRIGADE_SENTINEL(*b);
e = APR_BUCKET_NEXT(e))
{
rv = apr_bucket_setaside(e, p);
/* If the bucket type does not implement setaside, then
* (hopefully) morph it into a bucket type which does, and set
* *that* aside... */
if (rv == APR_ENOTIMPL) {
const char *s;
apr_size_t n;
rv = apr_bucket_read(e, &s, &n, APR_BLOCK_READ);
if (rv == APR_SUCCESS) {
rv = apr_bucket_setaside(e, p);
}
}
if (rv != APR_SUCCESS) {
srv = rv;
/* Return an error but still save the brigade if
* ->setaside() is really not implemented. */
if (rv != APR_ENOTIMPL) {
return rv;
}
}
}
APR_BRIGADE_CONCAT(*saveto, *b);
return srv;
}
static apr_status_t send_eos(ap_filter_t *f)
{
request_rec *r = f->r;
conn_rec *c = r->connection;
apr_bucket_brigade *bb;
apr_bucket *b;
charset_filter_ctx_t *ctx = f->ctx;
apr_status_t rv;
bb = apr_brigade_create(r->pool, c->bucket_alloc);
b = apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
rv = ap_pass_brigade(f->next, bb);
if (rv != APR_SUCCESS) {
ctx->ees = EES_DOWNSTREAM;
}
return rv;
}
int output_init_bb (apr_pool_t* pool, output_t** output_ptr){
output_t* output = *output_ptr = apr_pcalloc(pool, sizeof(output_t));
//Prepare Output
output->pool = pool;
output->headers = apr_table_make(pool, 10);
output->content_type = apr_pcalloc(pool, sizeof(char) * 255);
output->bucket_allocator = apr_bucket_alloc_create(pool);
output->error_messages = apr_pcalloc(pool, sizeof(error_messages_t));
output->error_messages->num_errors = 0;
output->bucket_brigade = apr_brigade_create(pool, output->bucket_allocator);
output->length = 0;
return 0;
}
static void
read_post_data(sl_vm_t* vm, sl_request_opts_t* opts, request_rec* r)
{
apr_bucket_brigade* brigade = apr_brigade_create(r->pool, r->connection->bucket_alloc);
size_t len = 1024;
opts->post_length = 0;
opts->post_data = NULL;
while(ap_get_brigade(r->input_filters, brigade, AP_MODE_READBYTES, APR_BLOCK_READ, len) == APR_SUCCESS) {
opts->post_data = sl_realloc(vm->arena, opts->post_data, opts->post_length + len);
apr_brigade_flatten(brigade, opts->post_data + opts->post_length, &len);
apr_brigade_cleanup(brigade);
opts->post_length += len;
if(!len) {
break;
}
len = 1024;
}
}
static int ssl_hook_process_connection(conn_rec* c)
{
SSLConnRec *sslconn = myConnConfig(c);
if (sslconn && !sslconn->disabled) {
/* On an active SSL connection, let the input filters initialize
* themselves which triggers the handshake, which again triggers
* all kinds of useful things such as SNI and ALPN.
*/
apr_bucket_brigade* temp;
temp = apr_brigade_create(c->pool, c->bucket_alloc);
ap_get_brigade(c->input_filters, temp,
AP_MODE_INIT, APR_BLOCK_READ, 0);
apr_brigade_destroy(temp);
}
return DECLINED;
}
static
int fcgi_server_send_stdout_data(fcgi_request_t *fr, uint16_t request_id,
void *data, uint16_t payload_len)
{
apr_bucket_alloc_t *bkt_alloc = fr->r->connection->bucket_alloc;
apr_bucket_brigade *bde = apr_brigade_create(fr->r->pool, bkt_alloc);
apr_bucket *bkt = apr_bucket_transient_create(data, payload_len, bkt_alloc);
APR_BRIGADE_INSERT_TAIL(bde, bkt);
int rv = ap_pass_brigade(fr->r->output_filters, bde);
if (rv || fr->r->connection->aborted) {
ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, fr->r,
"FastCGI: client stopped connection before send body completed");
return HTTP_INTERNAL_SERVER_ERROR;
}
return OK;
}
static void test_splitline(abts_case *tc, void *data)
{
apr_bucket_alloc_t *ba = apr_bucket_alloc_create(p);
apr_bucket_brigade *bin, *bout;
bin = make_simple_brigade(ba, "blah blah blah-",
"end of line.\nfoo foo foo");
bout = apr_brigade_create(p, ba);
apr_assert_success(tc, "split line",
apr_brigade_split_line(bout, bin,
APR_BLOCK_READ, 100));
flatten_match(tc, "split line", bout, "blah blah blah-end of line.\n");
flatten_match(tc, "remainder", bin, "foo foo foo");
apr_brigade_destroy(bout);
apr_brigade_destroy(bin);
apr_bucket_alloc_destroy(ba);
}
static int mmap_handler(request_rec *r, a_file *file)
{
#if APR_HAS_MMAP
conn_rec *c = r->connection;
apr_bucket *b;
apr_mmap_t *mm;
apr_bucket_brigade *bb = apr_brigade_create(r->pool, c->bucket_alloc);
apr_mmap_dup(&mm, file->mm, r->pool);
b = apr_bucket_mmap_create(mm, 0, (apr_size_t)file->finfo.size,
c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
b = apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
if (ap_pass_brigade(r->output_filters, bb) != APR_SUCCESS)
return AP_FILTER_ERROR;
#endif
return OK;
}
static apr_status_t urlReplaceFilterOutFilter(ap_filter_t *f,
apr_bucket_brigade *pbbIn)
{
request_rec *r = f->r;
conn_rec *c = r->connection;
apr_bucket *pbktIn;
apr_bucket_brigade *pbbOut;
pbbOut=apr_brigade_create(r->pool, c->bucket_alloc);
for (pbktIn = APR_BRIGADE_FIRST(pbbIn);
pbktIn != APR_BRIGADE_SENTINEL(pbbIn);
pbktIn = APR_BUCKET_NEXT(pbktIn))
{
const char *data;
apr_size_t len;
char *buf;
apr_size_t n;
apr_bucket *pbktOut;
if (APR_BUCKET_IS_EOS(pbktIn))
{
apr_bucket *pbktEOS=apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(pbbOut,pbktEOS);
continue;
}
/* read */
apr_bucket_read(pbktIn,&data,&len,APR_BLOCK_READ);
/* write */
buf = apr_bucket_alloc(len, c->bucket_alloc);
for (n=0 ; n < len ; ++n)
buf[n] = apr_toupper(data[n]);
pbktOut = apr_bucket_heap_create(buf, len, apr_bucket_free,
c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(pbbOut,pbktOut);
}
apr_brigade_cleanup(pbbIn);
return ap_pass_brigade(f->next,pbbOut);
}
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;
}
/* 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_simple(abts_case *tc, void *data)
{
apr_bucket_alloc_t *ba;
apr_bucket_brigade *bb;
apr_bucket *fb, *tb;
ba = apr_bucket_alloc_create(p);
bb = apr_brigade_create(p, ba);
fb = APR_BRIGADE_FIRST(bb);
ABTS_ASSERT(tc, "first bucket of empty brigade is sentinel",
fb == APR_BRIGADE_SENTINEL(bb));
fb = apr_bucket_flush_create(ba);
APR_BRIGADE_INSERT_HEAD(bb, fb);
ABTS_ASSERT(tc, "first bucket of brigade is flush",
APR_BRIGADE_FIRST(bb) == fb);
ABTS_ASSERT(tc, "bucket after flush is sentinel",
APR_BUCKET_NEXT(fb) == APR_BRIGADE_SENTINEL(bb));
tb = apr_bucket_transient_create("aaa", 3, ba);
APR_BUCKET_INSERT_BEFORE(fb, tb);
ABTS_ASSERT(tc, "bucket before flush now transient",
APR_BUCKET_PREV(fb) == tb);
ABTS_ASSERT(tc, "bucket after transient is flush",
APR_BUCKET_NEXT(tb) == fb);
ABTS_ASSERT(tc, "bucket before transient is sentinel",
APR_BUCKET_PREV(tb) == APR_BRIGADE_SENTINEL(bb));
apr_brigade_cleanup(bb);
ABTS_ASSERT(tc, "cleaned up brigade was empty", APR_BRIGADE_EMPTY(bb));
apr_brigade_destroy(bb);
apr_bucket_alloc_destroy(ba);
}
static void test_bwrite(abts_case *tc, void *data)
{
apr_bucket_alloc_t *ba = apr_bucket_alloc_create(p);
apr_bucket_brigade *bb = apr_brigade_create(p, ba);
apr_off_t length;
int n;
for (n = 0; n < COUNT; n++) {
apr_assert_success(tc, "brigade_write",
apr_brigade_write(bb, NULL, NULL,
THESTR, sizeof THESTR));
}
apr_assert_success(tc, "determine brigade length",
apr_brigade_length(bb, 1, &length));
ABTS_ASSERT(tc, "brigade has correct length",
length == (COUNT * sizeof THESTR));
apr_brigade_destroy(bb);
apr_bucket_alloc_destroy(ba);
}
