自学教程：C++ APR_BRIGADE_INSERT_TAIL函数代码示例

static intphp_apache_sapi_ub_write(const char *str, uint str_length TSRMLS_DC){	apr_bucket *b;	apr_bucket_brigade *bb;	apr_bucket_alloc_t *ba;	ap_filter_t *f; /* remaining output filters */	php_struct *ctx;	ctx = SG(server_context);	f = ctx->f;		if (str_length == 0) return 0;		ba = f->c->bucket_alloc;	bb = apr_brigade_create(ctx->r->pool, ba);	b = apr_bucket_transient_create(str, str_length, ba);	APR_BRIGADE_INSERT_TAIL(bb, b);	if (ap_pass_brigade(f->next, bb) != APR_SUCCESS || ctx->r->connection->aborted) {		php_handle_aborted_connection();	}		return str_length; /* we always consume all the data passed to us. */}

/* drain_available_output(): * * if any data is available from the filter, read it and append it * to the the bucket brigade */static apr_status_t drain_available_output(ap_filter_t *f,                                           apr_bucket_brigade *bb){    request_rec *r = f->r;    conn_rec *c = r->connection;    ef_ctx_t *ctx = f->ctx;    apr_size_t len;    char buf[4096];    apr_status_t rv;    apr_bucket *b;    while (1) {        int lvl = APLOG_TRACE5;        len = sizeof(buf);        rv = apr_file_read(ctx->proc->out, buf, &len);        if (rv && !APR_STATUS_IS_EAGAIN(rv))           lvl = APLOG_DEBUG;        ap_log_rerror(APLOG_MARK, lvl, rv, r, APLOGNO(01460)                      "apr_file_read(child output), len %" APR_SIZE_T_FMT,                      !rv ? len : -1);        if (rv != APR_SUCCESS) {            return rv;        }        b = apr_bucket_heap_create(buf, len, NULL, c->bucket_alloc);        APR_BRIGADE_INSERT_TAIL(bb, b);        return APR_SUCCESS;    }    /* we should never get here; if we do, a bogus error message would be     * the least of our problems     */    return APR_ANONYMOUS;}

static apr_status_t h2_conn_io_flush_int(h2_conn_io *io, int force){    if (io->unflushed || force) {        if (io->buflen > 0) {            /* something in the buffer, put it in the output brigade */            ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, io->connection,                          "h2_conn_io: flush, flushing %ld bytes", (long)io->buflen);            bucketeer_buffer(io);            io->buflen = 0;        }                if (force) {            APR_BRIGADE_INSERT_TAIL(io->output,                                    apr_bucket_flush_create(io->output->bucket_alloc));        }                ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, io->connection,                      "h2_conn_io: flush");        /* Send it out */        io->unflushed = 0;        return pass_out(io->output, io);        /* no more access after this, as we might have flushed an EOC bucket         * that de-allocated us all. */    }    return APR_SUCCESS;}

static int php_input_filter(ap_filter_t *f, apr_bucket_brigade *bb, 		ap_input_mode_t mode, apr_read_type_e block, apr_off_t readbytes){	php_struct *ctx;	apr_status_t rv;	if (f->r->proxyreq) {		return ap_get_brigade(f->next, bb, mode, block, readbytes);	}	ctx = SG(server_context);	if (ctx == NULL) {		ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, f->r,					 "php failed to get server context");		return HTTP_INTERNAL_SERVER_ERROR;	}	if ((rv = ap_get_brigade(f->next, bb, mode, block, readbytes)) != APR_SUCCESS) {		return rv;	}	if (!ctx->post_data) {		ctx->post_data = apr_brigade_create(f->r->pool, f->c->bucket_alloc);	}	if ((rv = ap_save_brigade(f, &ctx->post_data, &bb, f->r->pool)) != APR_SUCCESS) {		return rv;	}	apr_brigade_cleanup(bb);	APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_eos_create(bb->bucket_alloc));	return APR_SUCCESS;}

static apr_status_tread_complete_body(request_rec *r, apr_bucket_brigade *kept_body){    apr_bucket_brigade *tmp_bb;    apr_bucket *t_bucket1, *t_bucket2;    unsigned short eos_seen = 0;    apr_status_t status;    tmp_bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);    while (!eos_seen) {        status = ap_get_brigade(                        r->input_filters,                        tmp_bb,                        AP_MODE_READBYTES,                        APR_BLOCK_READ,                        HUGE_STRING_LEN);        /* This means the filter discovered an error.         * Furthermore input-filter already handeld the error and sends         * something to the output chain.         * For example ap_http_filter does this if LimitRequestBody is reached         */        if (status == AP_FILTER_ERROR) {            apr_brigade_destroy(tmp_bb);            return AP_FILTER_ERROR;        }        /* Cool no need to search for the eos bucket */        if (APR_STATUS_IS_EOF(status)) {            apr_brigade_destroy(tmp_bb);            return APR_SUCCESS;        }        if (status != APR_SUCCESS) {            apr_brigade_destroy(tmp_bb);            return status;        }        ITER_BRIGADE(t_bucket1, tmp_bb) {            apr_bucket_copy(t_bucket1, &t_bucket2);            /* If SSL is used TRANSIENT buckets are returned.             * However we need this bucket for a longer period than             * this function call, hence 'setaside' the bucket.             */            if APR_BUCKET_IS_TRANSIENT(t_bucket2) {                apr_bucket_setaside(t_bucket2, r->pool);            }            APR_BRIGADE_INSERT_TAIL(kept_body, t_bucket2);            if (!eos_seen && APR_BUCKET_IS_EOS(t_bucket1)) {                eos_seen = 1;            }        }        apr_brigade_cleanup(tmp_bb);    }

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);}

MP_INLINE static apr_status_t send_input_flush(modperl_filter_t *filter){    apr_bucket_alloc_t *ba = filter->f->c->bucket_alloc;    apr_bucket *b = apr_bucket_flush_create(ba);    APR_BRIGADE_INSERT_TAIL(filter->bb_out, b);    MP_TRACE_f(MP_FUNC, MP_FILTER_NAME_FORMAT               "write out: FLUSH bucket", MP_FILTER_NAME(filter->f));    return APR_SUCCESS;}

apr_status_t h2_io_in_close(h2_io *io){    if (io->bbin) {        APR_BRIGADE_INSERT_TAIL(io->bbin,                                 apr_bucket_eos_create(io->bbin->bucket_alloc));    }    io->eos_in = 1;    return APR_SUCCESS;}

static int process_fortune_connection(conn_rec *c){    apr_status_t rv;    apr_procattr_t *pattr;    apr_pool_t *p = c->pool;    apr_bucket *b;    apr_bucket_brigade *bb;    const char *err_msg = "200 OK/n";    fortune_conf_t *fconf =        ap_get_module_config(c->base_server->module_config,                             &fortune_module);    if (!fconf->enabled) {        return DECLINED;    }    bb = apr_brigade_create(p, c->bucket_alloc);    /* prepare process attribute */    if ((rv = apr_procattr_create(&pattr, c->pool)) != APR_SUCCESS) {        goto error;    }    if ((rv =         apr_procattr_io_set(pattr, APR_NO_PIPE, APR_FULL_BLOCK, APR_NO_PIPE))        != APR_SUCCESS) {        goto error;    }    /* default value: APR_PROGRAM */    if ((rv =         apr_procattr_cmdtype_set(pattr, APR_PROGRAM_ENV)) != APR_SUCCESS) {        goto error;    }    /* run the program and read the output from the pipe */    if ((rv = fortune_process(c, pattr, bb)) != APR_SUCCESS) {        apr_brigade_cleanup(bb);    }  error:    if (rv != APR_SUCCESS) {        err_msg = "500 ERROR/n";    }    b = apr_bucket_pool_create(err_msg, strlen(err_msg), p, c->bucket_alloc);    APR_BRIGADE_INSERT_HEAD(bb, b);    b = apr_bucket_flush_create(c->bucket_alloc);    APR_BRIGADE_INSERT_TAIL(bb, b);    rv = ap_pass_brigade(c->output_filters, bb);    return OK;}

MP_INLINE static apr_status_t send_input_eos(modperl_filter_t *filter){    apr_bucket_alloc_t *ba = filter->f->c->bucket_alloc;    apr_bucket *b = apr_bucket_eos_create(ba);    APR_BRIGADE_INSERT_TAIL(filter->bb_out, b);    ((modperl_filter_ctx_t *)filter->f->ctx)->sent_eos = 1;    MP_TRACE_f(MP_FUNC, MP_FILTER_NAME_FORMAT               "write out: EOS bucket", MP_FILTER_NAME(filter->f));    return APR_SUCCESS;}

static apr_status_t fortune_process(conn_rec *c,                                    apr_procattr_t *pattr,                                    apr_bucket_brigade *bb){    apr_status_t rv;    int argc = 0;    const char *argv[APP_MAX_ARGC];    apr_proc_t proc;    apr_bucket *b;    apr_pool_t *p = c->pool;    fortune_conf_t *fconf = ap_get_module_config(c->base_server->module_config,						 &fortune_module);    argv[argc++] = fconf->progname;    argv[argc++] = NULL;	/* @argvs should be null-terminated */    if ((rv = apr_proc_create(&proc, fconf->progname,                              (const char *const *) argv,                              NULL, (apr_procattr_t *) pattr,                              p)) != APR_SUCCESS) {        return rv;    }    while (TRUE) {        char buf[BUFSIZE] = { 0, };        /* read the command's output through the pipe */        rv = apr_file_gets(buf, sizeof(buf), proc.out);        if (APR_STATUS_IS_EOF(rv)) {            break;        }        b = apr_bucket_pool_create(apr_pstrdup(p, buf),                                   strlen(buf), p, c->bucket_alloc);        APR_BRIGADE_INSERT_TAIL(bb, b);    }    apr_file_close(proc.out);    {        int st;        apr_exit_why_e why;        rv = apr_proc_wait(&proc, &st, &why, APR_WAIT);        if (APR_STATUS_IS_CHILD_DONE(rv)) {            ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, c,                          "child done: why = %d, exit status = %d", why, st);        }        else {            ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, c, "child notdone");            return APR_EGENERAL;        }    }    return APR_SUCCESS;}

static apr_status_t amagent_post_filter(ap_filter_t *f, apr_bucket_brigade *bucket_out,        ap_input_mode_t emode, apr_read_type_e eblock, apr_off_t nbytes) {    request_rec *r = f->r;    conn_rec *c = r->connection;    apr_bucket *bucket;    apr_size_t sz;    char *clean;    const char *data = apr_table_get(r->notes, amagent_post_filter_name);    do {        if (data == NULL) break;        sz = strlen(data);        clean = base64_decode(data, &sz);        if (clean == NULL) break;        apr_table_unset(r->notes, amagent_post_filter_name);        LOG_R(APLOG_DEBUG, r, "amagent_post_filter(): reposting %ld bytes", sz);        bucket = apr_bucket_heap_create((const char *) clean, sz, NULL, c->bucket_alloc);        if (bucket == NULL) {            free(clean);            return APR_EGENERAL;        }        APR_BRIGADE_INSERT_TAIL(bucket_out, bucket);        free(clean);        bucket = apr_bucket_eos_create(c->bucket_alloc);        if (bucket == NULL) {            return APR_EGENERAL;        }        APR_BRIGADE_INSERT_TAIL(bucket_out, bucket);        ap_remove_input_filter(f);        return APR_SUCCESS;    } while (0);    apr_table_unset(r->notes, amagent_post_filter_name);    ap_remove_input_filter(f);    return ap_get_brigade(f->next, bucket_out, emode, eblock, nbytes);}

//------- void write_brigade(apr_bucket_brigade *bb_out,request_rec *r,char *data){  APR_BRIGADE_INSERT_TAIL(   bb_out,   apr_bucket_pool_create(    data,    strlen(data),    r->pool,    r->connection->bucket_alloc   )  ); } 

MP_INLINE static apr_status_t send_output_flush(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_flush_create(ba);    APR_BRIGADE_INSERT_TAIL(bb, b);    MP_TRACE_f(MP_FUNC, MP_FILTER_NAME_FORMAT               "write out: FLUSH bucket in separate bb", MP_FILTER_NAME(f));    return ap_pass_brigade(f, bb);}

apr_status_t h2_io_out_close(h2_io *io){    if (io->rst_error) {        return APR_ECONNABORTED;    }    if (!io->eos_out && !h2_util_has_eos(io->bbout, 0)) {        APR_BRIGADE_INSERT_TAIL(io->bbout,                                 apr_bucket_eos_create(io->bbout->bucket_alloc));    }    return APR_SUCCESS;}

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);}

/* Bring the current buffer content into the output brigade, appropriately * chunked. */static apr_status_t bucketeer_buffer(h2_conn_io *io) {    const char *data = io->buffer;    apr_size_t remaining = io->buflen;    apr_bucket *b;    int bcount, i;    if (io->write_size > WRITE_SIZE_INITIAL         && (io->cooldown_usecs > 0)        && (apr_time_now() - io->last_write) >= io->cooldown_usecs) {        /* long time not written, reset write size */        io->write_size = WRITE_SIZE_INITIAL;        io->bytes_written = 0;        ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, io->connection,                      "h2_conn_io(%ld): timeout write size reset to %ld",                       (long)io->connection->id, (long)io->write_size);    }    else if (io->write_size < WRITE_SIZE_MAX              && io->bytes_written >= io->warmup_size) {        /* connection is hot, use max size */        io->write_size = WRITE_SIZE_MAX;        ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, io->connection,                      "h2_conn_io(%ld): threshold reached, write size now %ld",                       (long)io->connection->id, (long)io->write_size);    }        bcount = (int)(remaining / io->write_size);    for (i = 0; i < bcount; ++i) {        b = apr_bucket_transient_create(data, io->write_size,                                         io->output->bucket_alloc);        APR_BRIGADE_INSERT_TAIL(io->output, b);        data += io->write_size;        remaining -= io->write_size;    }        if (remaining > 0) {        b = apr_bucket_transient_create(data, remaining,                                         io->output->bucket_alloc);        APR_BRIGADE_INSERT_TAIL(io->output, b);    }    return APR_SUCCESS;}

/*============================================================================ *============================================================================ * This is the beginning of the cgi filter code moved from mod_include. This *   is the code required to handle the "exec" SSI directive. *============================================================================ *============================================================================*/static apr_status_t include_cgi(include_ctx_t *ctx, ap_filter_t *f,                                apr_bucket_brigade *bb, char *s){    request_rec *r = f->r;    request_rec *rr = ap_sub_req_lookup_uri(s, r, f->next);    int rr_status;    if (rr->status != HTTP_OK) {        ap_destroy_sub_req(rr);        return APR_EGENERAL;    }    /* No hardwired path info or query allowed */    if ((rr->path_info && rr->path_info[0]) || rr->args) {        ap_destroy_sub_req(rr);        return APR_EGENERAL;    }    if (rr->finfo.filetype != APR_REG) {        ap_destroy_sub_req(rr);        return APR_EGENERAL;    }    /* Script gets parameters of the *document*, for back compatibility */    rr->path_info = r->path_info;       /* hard to get right; see mod_cgi.c */    rr->args = r->args;    /* Force sub_req to be treated as a CGI request, even if ordinary     * typing rules would have called it something else.     */    ap_set_content_type(rr, CGI_MAGIC_TYPE);    /* Run it. */    rr_status = ap_run_sub_req(rr);    if (ap_is_HTTP_REDIRECT(rr_status)) {        const char *location = apr_table_get(rr->headers_out, "Location");        if (location) {            char *buffer;            location = ap_escape_html(rr->pool, location);            buffer = apr_pstrcat(ctx->pool, "<a href=/"", location, "/">",                                 location, "</a>", NULL);            APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_pool_create(buffer,                                    strlen(buffer), ctx->pool,                                    f->c->bucket_alloc));        }    }    ap_destroy_sub_req(rr);    return APR_SUCCESS;}

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);}

static apr_status_t recall_body(cache_handle_t *h, apr_pool_t *p, apr_bucket_brigade *bb){    apr_bucket *b;    mem_cache_object_t *mobj = (mem_cache_object_t*) h->cache_obj->vobj;    if (mobj->type == CACHE_TYPE_FILE) {        /* CACHE_TYPE_FILE */        apr_file_t *file;        apr_os_file_put(&file, &mobj->fd, mobj->flags, p);        b = apr_bucket_file_create(file, 0, mobj->m_len, p, bb->bucket_alloc);    }    else {        /* CACHE_TYPE_HEAP */        b = apr_bucket_immortal_create(mobj->m, mobj->m_len, bb->bucket_alloc);    }    APR_BRIGADE_INSERT_TAIL(bb, b);    b = apr_bucket_eos_create(bb->bucket_alloc);    APR_BRIGADE_INSERT_TAIL(bb, b);    return APR_SUCCESS;}

static apr_status_t bucketeer_buffer(h2_conn_io *io) {    const char *data = io->buffer;    apr_size_t remaining = io->buflen;    int bcount = (int)(remaining / H2_CONN_IO_SSL_WRITE_SIZE);    apr_bucket *b;        for (int i = 0; i < bcount; ++i) {        b = apr_bucket_transient_create(data, H2_CONN_IO_SSL_WRITE_SIZE,                                         io->output->bucket_alloc);        APR_BRIGADE_INSERT_TAIL(io->output, b);        data += H2_CONN_IO_SSL_WRITE_SIZE;        remaining -= H2_CONN_IO_SSL_WRITE_SIZE;    }        if (remaining > 0) {        b = apr_bucket_transient_create(data, remaining,                                         io->output->bucket_alloc);        APR_BRIGADE_INSERT_TAIL(io->output, b);    }    return APR_SUCCESS;}

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;}

static apr_status_t recall_body(cache_handle_t *h, apr_pool_t *p, apr_bucket_brigade *bb){    apr_bucket *e;    disk_cache_object_t *dobj = (disk_cache_object_t*) h->cache_obj->vobj;    e = apr_bucket_file_create(dobj->fd, 0, (apr_size_t) dobj->file_size, p,                               bb->bucket_alloc);    APR_BRIGADE_INSERT_HEAD(bb, e);    e = apr_bucket_eos_create(bb->bucket_alloc);    APR_BRIGADE_INSERT_TAIL(bb, e);    return APR_SUCCESS;}

pstar_io::~pstar_io() {	apr_status_t rv;	apr_bucket *b;	static const char msg[] = "<h1>P* Error</h1><p>An error occured. More information can be found in the web server log files.</p>";	if (http_error_pending) {		apr_table_set (r->headers_out, "Content-Type", "text/html");//		apr_brigade_cleanup(bb);		b = apr_bucket_immortal_create(msg, sizeof(msg), ba);		APR_BRIGADE_INSERT_TAIL(bb, b);	}	b = apr_bucket_eos_create(ba);	APR_BRIGADE_INSERT_TAIL(bb, b);	rv = ap_pass_brigade(r->output_filters, bb);	if (rv != APR_SUCCESS) {		throw runtime_error("pstar_io::write(); Could not write to client");	}}

static apr_status_t send_bucket_downstream(ap_filter_t *f, apr_bucket *b){    charset_filter_ctx_t *ctx = f->ctx;    apr_status_t rv;    APR_BRIGADE_INSERT_TAIL(ctx->tmpbb, b);    rv = ap_pass_brigade(f->next, ctx->tmpbb);    if (rv != APR_SUCCESS) {        ctx->ees = EES_DOWNSTREAM;    }    apr_brigade_cleanup(ctx->tmpbb);    return rv;}

static PyObject * conn_write(connobject *self, PyObject *args){    char *buff;    int len;    apr_bucket_brigade *bb;    apr_bucket *b;    PyObject *s;    conn_rec *c = self->conn;    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;    }    /* PYTHON 2.5: 'PyString_Size' uses Py_ssize_t for return values (may need overflow check) */    len = PyString_Size(s);    if (len) {        buff = apr_pmemdup(c->pool, PyString_AS_STRING(s), len);        bb = apr_brigade_create(c->pool, c->bucket_alloc);        b = apr_bucket_pool_create(buff, len, c->pool, c->bucket_alloc);        APR_BRIGADE_INSERT_TAIL(bb, b);        /* Make sure the data is flushed to the client */        b = apr_bucket_flush_create(c->bucket_alloc);        APR_BRIGADE_INSERT_TAIL(bb, b);        ap_pass_brigade(c->output_filters, bb);    }    Py_INCREF(Py_None);    return Py_None;}

int output_finalize_bb (output_t* output, apr_table_t* out_headers){	apr_status_t rv;	apr_bucket* eos_bucket;	eos_bucket = apr_bucket_eos_create(output->bucket_allocator);	APR_BRIGADE_INSERT_TAIL(output->bucket_brigade, eos_bucket);	apr_table_overlap(out_headers, output->headers, APR_OVERLAP_TABLES_SET);	rv = apr_brigade_length(output->bucket_brigade,1,&(output->length));	return rv;}

static apr_status_t include_cmd(include_ctx_t *ctx, ap_filter_t *f,                                apr_bucket_brigade *bb, const char *command){    cgi_exec_info_t  e_info;    const char **argv;    apr_file_t *script_out = NULL, *script_in = NULL, *script_err = NULL;    apr_status_t rv;    request_rec *r = f->r;    add_ssi_vars(r);    e_info.process_cgi = 0;    e_info.cmd_type    = APR_SHELLCMD;    e_info.detached    = 0;    e_info.in_pipe     = APR_NO_PIPE;    e_info.out_pipe    = APR_FULL_BLOCK;    e_info.err_pipe    = APR_NO_PIPE;    e_info.prog_type   = RUN_AS_SSI;    e_info.bb          = &bb;    e_info.ctx         = ctx;    e_info.next        = f->next;    e_info.addrspace   = 0;    if ((rv = cgi_build_command(&command, &argv, r, r->pool,                                &e_info)) != APR_SUCCESS) {        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,                      "don't know how to spawn cmd child process: %s",                      r->filename);        return rv;    }    /* run the script in its own process */    if ((rv = run_cgi_child(&script_out, &script_in, &script_err,                            command, argv, r, r->pool,                            &e_info)) != APR_SUCCESS) {        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,                      "couldn't spawn child process: %s", r->filename);        return rv;    }    APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_pipe_create(script_in,                            f->c->bucket_alloc));    ctx->flush_now = 1;    /* We can't close the pipe here, because we may return before the     * full CGI has been sent to the network.  That's okay though,     * because we can rely on the pool to close the pipe for us.     */    return APR_SUCCESS;}

apr_status_t jxr_append_brigade(request_rec *r, apr_bucket_brigade *dest, apr_bucket_brigade *bb, int *eos_seen){	apr_size_t max_msglen = MAX_PACKET_SIZE - sizeof(Jaxer_Header);	apr_status_t rv;	while (!APR_BRIGADE_EMPTY(bb)) 	{		apr_size_t readlen;		const char *buffer;				apr_bucket *e = APR_BRIGADE_FIRST(bb);		if (APR_BUCKET_IS_EOS(e) )		{			apr_bucket_delete(e);			if (eos_seen)				*eos_seen = 1;			continue;		}		if (APR_BUCKET_IS_METADATA(e)) {			apr_bucket_delete(e);			continue;		}				/* Read the bucket now */		if ((rv = apr_bucket_read(e, &buffer, &readlen, APR_BLOCK_READ)) != APR_SUCCESS) 		{			ap_log_perror(APLOG_MARK, APLOG_INFO, rv, r->pool, "mod_jaxer: can't read data from handler");			return rv;		}				if (readlen > max_msglen)		{        	apr_bucket_split(e, max_msglen);		}else		{			APR_BUCKET_REMOVE(e);			APR_BRIGADE_INSERT_TAIL(dest, e);		}	}	if ((rv=apr_brigade_destroy(bb)) != APR_SUCCESS)	{		ap_log_perror(APLOG_MARK, APLOG_INFO, rv, r->pool, "mod_jaxer: failed to destroy brigade.");		return rv;	}	return APR_SUCCESS;}