ngx_int_t move_chain_to_brigade(ngx_chain_t *chain_orig,
apr_bucket_brigade *bb, ngx_pool_t *pool, ngx_int_t last_buf)
{
apr_bucket *e;
ngx_chain_t *cl;
ngx_chain_t *chain = chain_orig;
while (chain) {
e = ngx_buf_to_apr_bucket(chain->buf, bb->p, bb->bucket_alloc);
if (e == NULL) {
return NGX_ERROR;
}
APR_BRIGADE_INSERT_TAIL(bb, e);
if (chain->buf->last_buf) {
e = apr_bucket_eos_create(bb->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, e);
return NGX_OK;
}
cl = chain;
chain = chain->next;
ngx_free_chain(pool, cl);
}
if (last_buf) {
e = apr_bucket_eos_create(bb->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, e);
return NGX_OK;
}
return NGX_AGAIN;
}
static apr_status_t tmpfile_filter(ap_filter_t *f, apr_bucket_brigade *bbout,
ap_input_mode_t mode, apr_read_type_e block, apr_off_t nbytes) {
apr_bucket_brigade* bbin = apr_brigade_create(f->r->pool,
f->r->connection->bucket_alloc);
apr_file_t* tmpfile ;
char* tmpname = apr_pstrdup(f->r->pool, "/tmp/mod-upload.XXXXXX") ;
if ( f->ctx ) {
APR_BRIGADE_INSERT_TAIL(bbout, apr_bucket_eos_create(bbout->bucket_alloc)) ;
return APR_SUCCESS ;
}
if ( apr_file_mktemp(&tmpfile, tmpname, KEEPONCLOSE, f->r->pool) != APR_SUCCESS ) {
// error
ap_remove_input_filter(f) ;
}
apr_pool_cleanup_register(f->r->pool, tmpfile,
(void*)apr_file_close, apr_pool_cleanup_null) ;
for ( ; ; ) {
apr_bucket* b ;
const char* ptr = 0 ;
apr_size_t bytes ;
#ifdef DEBUG
ap_log_rerror(APLOG_MARK,APLOG_DEBUG,0, f->r, "get_brigade") ;
#endif
ap_get_brigade(f->next, bbin, AP_MODE_READBYTES, APR_BLOCK_READ, BUFLEN) ;
for ( b = APR_BRIGADE_FIRST(bbin) ;
b != APR_BRIGADE_SENTINEL(bbin) && ! f->ctx ;
b = APR_BUCKET_NEXT(b) ) {
if ( APR_BUCKET_IS_EOS(b) ) {
f->ctx = f ; // just using it as a flag; any nonzero will do
apr_file_flush(tmpfile) ;
apr_brigade_puts(bbout, ap_filter_flush, f, tmpname) ;
APR_BRIGADE_INSERT_TAIL(bbout,
apr_bucket_eos_create(bbout->bucket_alloc) ) ;
} else if ( apr_bucket_read(b, &ptr, &bytes, APR_BLOCK_READ)
== APR_SUCCESS ) {
#ifdef DEBUG
ap_log_rerror(APLOG_MARK,APLOG_DEBUG,0, f->r, " %d bytes in bucket", bytes) ;
#endif
apr_file_write(tmpfile, ptr, &bytes) ;
}
}
if ( f->ctx )
break ;
else
apr_brigade_cleanup(bbin) ;
}
apr_brigade_destroy(bbin) ;
return APR_SUCCESS ;
}
/**
* Sends a brigade with an error bucket down the filter chain.
*/
apr_status_t send_error_bucket(modsec_rec *msr, ap_filter_t *f, int status) {
apr_bucket_brigade *brigade = NULL;
apr_bucket *bucket = NULL;
/* Set the status line explicitly for the error document */
f->r->status_line = ap_get_status_line(status);
brigade = apr_brigade_create(f->r->pool, f->r->connection->bucket_alloc);
if (brigade == NULL) return APR_EGENERAL;
bucket = ap_bucket_error_create(status, NULL, f->r->pool, f->r->connection->bucket_alloc);
if (bucket == NULL) return APR_EGENERAL;
APR_BRIGADE_INSERT_TAIL(brigade, bucket);
bucket = apr_bucket_eos_create(f->r->connection->bucket_alloc);
if (bucket == NULL) return APR_EGENERAL;
APR_BRIGADE_INSERT_TAIL(brigade, bucket);
ap_pass_brigade(f->next, brigade);
/* NOTE:
* It may not matter what we do from the filter as it may be too
* late to even generate an error (already sent to client). Nick Kew
* recommends to return APR_EGENERAL in hopes that the handler in control
* will notice and do The Right Thing. So, that is what we do now.
*/
return APR_EGENERAL;
}
static PyObject *filter_close(filterobject *self, PyObject *args)
{
conn_rec *c = self->request_obj->request_rec->connection;
if (! self->closed) {
/* does the output brigade exist? */
if (!self->bb_out) {
self->bb_out = apr_brigade_create(self->f->r->pool,
c->bucket_alloc);
}
APR_BRIGADE_INSERT_TAIL(self->bb_out,
apr_bucket_eos_create(c->bucket_alloc));
if (! self->is_input) {
Py_BEGIN_ALLOW_THREADS;
self->rc = ap_pass_brigade(self->f->next, self->bb_out);
apr_brigade_destroy(self->bb_out);
Py_END_ALLOW_THREADS;
self->bb_out = NULL;
}
self->closed = 1;
}
Py_INCREF(Py_None);
return Py_None;
}
h2_task_input *h2_task_input_create(h2_task *task, apr_pool_t *pool,
apr_bucket_alloc_t *bucket_alloc)
{
h2_task_input *input = apr_pcalloc(pool, sizeof(h2_task_input));
if (input) {
input->task = task;
input->bb = NULL;
if (task->serialize_headers) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, task->c,
"h2_task_input(%s): serialize request %s %s",
task->id, task->request->method, task->request->path);
input->bb = apr_brigade_create(pool, bucket_alloc);
apr_brigade_printf(input->bb, NULL, NULL, "%s %s HTTP/1.1\r\n",
task->request->method, task->request->path);
apr_table_do(ser_header, input, task->request->headers, NULL);
apr_brigade_puts(input->bb, NULL, NULL, "\r\n");
if (input->task->input_eos) {
APR_BRIGADE_INSERT_TAIL(input->bb, apr_bucket_eos_create(bucket_alloc));
}
}
else if (!input->task->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. */
}
}
return input;
}
static apr_status_t gnutls_io_filter_error(ap_filter_t * f,
apr_bucket_brigade * bb,
apr_status_t status) {
mgs_handle_t *ctxt = (mgs_handle_t *) f->ctx;
apr_bucket *bucket;
switch (status) {
case HTTP_BAD_REQUEST:
/* log the situation */
ap_log_error(APLOG_MARK, APLOG_INFO, 0,
f->c->base_server,
"GnuTLS handshake failed: HTTP spoken on HTTPS port; "
"trying to send HTML error page");
mgs_srvconf_rec *sc = (mgs_srvconf_rec *) ap_get_module_config(
f->c->base_server->module_config,
&gnutls_module
);
ctxt->status = -1;
sc->non_ssl_request = 1;
/* fake the request line */
bucket = HTTP_ON_HTTPS_PORT_BUCKET(f->c->bucket_alloc);
break;
default:
return status;
}
APR_BRIGADE_INSERT_TAIL(bb, bucket);
bucket = apr_bucket_eos_create(f->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, bucket);
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;
}
/**
* This works right now because all timers are invoked in the single listener
* thread in the Event MPM -- the same thread that serf callbacks are made
* from, so we don't technically need a mutex yet, but with the Simple MPM,
* invocations are made from worker threads, and we need to figure out locking
*/
static void timed_cleanup_callback(void *baton)
{
s_baton_t *ctx = baton;
/* Causes all serf connections to unregister from the event mpm */
if (ctx->rstatus) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, ctx->rstatus, ctx->r, APLOGNO(01119)
"serf: request returned: %d", ctx->rstatus);
ctx->r->status = HTTP_OK;
apr_pool_destroy(ctx->serf_pool);
ap_die(ctx->rstatus, ctx->r);
}
else {
apr_bucket *e;
apr_brigade_cleanup(ctx->tmpbb);
e = apr_bucket_flush_create(ctx->r->connection->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(ctx->tmpbb, e);
e = apr_bucket_eos_create(ctx->r->connection->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(ctx->tmpbb, e);
/* TODO: return code? bleh */
ap_pass_brigade(ctx->r->output_filters, ctx->tmpbb);
apr_pool_destroy(ctx->serf_pool);
ap_finalize_request_protocol(ctx->r);
ap_process_request_after_handler(ctx->r);
return;
}
}
/**
* This is the second most important function, as it delivers the content of the
* file (or the directory if not DAV)
* @param resource The resource generated previously
* @param output Here is where the output must be written
* @return NULL on success
*/
static dav_error *dav_ns_deliver(const dav_resource *resource,
ap_filter_t *output)
{
apr_bucket_brigade *bb;
apr_bucket *bkt;
dav_error *err;
bb = apr_brigade_create(resource->pool, output->c->bucket_alloc);
if (resource->collection)
err = dav_ns_deliver_collection(resource, resource->info->request->output_filters, bb);
else if (resource->info->metalink) {
err = dav_ns_deliver_metalink(resource, resource->info->request->output_filters, bb);
}
else
err = dav_new_error(resource->pool, HTTP_INTERNAL_SERVER_ERROR, 0,
"NS should not be trying to deliver files!");
if (err != NULL)
return err;
/* Close and flush the output */
bkt = apr_bucket_eos_create(output->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, bkt);
if (ap_pass_brigade(resource->info->request->output_filters, bb) != APR_SUCCESS)
return dav_shared_new_error(resource->info->request, NULL, HTTP_INTERNAL_SERVER_ERROR,
"Could not write EOS to filter.");
/* All OK */
return NULL;
}
static dav_error *
dav_rainx_deliver_SPECIAL(const dav_resource *resource, ap_filter_t *output)
{
const char *result;
int result_len;
apr_status_t status;
apr_pool_t *pool;
apr_bucket_brigade *bb;
apr_bucket *bkt;
DAV_XDEBUG_RES(resource, 0, "%s()", __FUNCTION__);
pool = resource->info->request->pool;
/* Check resource type */
if (resource->type != DAV_RESOURCE_TYPE_PRIVATE)
return server_create_and_stat_error(resource_get_server_config(resource), pool,
HTTP_CONFLICT, 0, apr_pstrdup(pool, "Cannot GET this type of resource."));
if (resource->collection)
return server_create_and_stat_error(resource_get_server_config(resource), pool,
HTTP_CONFLICT, 0, apr_pstrdup(pool,"No GET on collections"));
/* Generate the output */
result = resource->info->generator(resource, pool);
result_len = strlen(result);
/* We must reply a buffer */
bkt = apr_bucket_heap_create(result, result_len, NULL, output->c->bucket_alloc);
bb = apr_brigade_create(pool, output->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, bkt);
/* Nothing more to reply */
bkt = apr_bucket_eos_create(output->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, bkt);
DAV_XDEBUG_RES(resource, 0, "%s : ready to deliver", __FUNCTION__);
if ((status = ap_pass_brigade(output, bb)) != APR_SUCCESS)
return server_create_and_stat_error(resource_get_server_config(resource), pool,
HTTP_FORBIDDEN, 0, apr_pstrdup(pool,"Could not write contents to filter."));
server_inc_stat(resource_get_server_config(resource), RAWX_STATNAME_REP_2XX, 0);
/* HERE ADD request counter */
switch(resource->info->type) {
case STAT:
server_inc_request_stat(resource_get_server_config(resource), RAWX_STATNAME_REQ_STAT,
request_get_duration(resource->info->request));
break;
case INFO:
server_inc_request_stat(resource_get_server_config(resource), RAWX_STATNAME_REQ_INFO,
request_get_duration(resource->info->request));
break;
default:
break;
}
return NULL;
}
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;
}
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;
}
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;
}
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 *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;
}
static apr_status_t send_416(ap_filter_t *f, apr_bucket_brigade *tmpbb)
{
apr_bucket *e;
conn_rec *c = f->r->connection;
ap_remove_output_filter(f);
f->r->status = HTTP_OK;
e = ap_bucket_error_create(HTTP_RANGE_NOT_SATISFIABLE, NULL,
f->r->pool, c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(tmpbb, e);
e = apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(tmpbb, e);
return ap_pass_brigade(f->next, tmpbb);
}
static apr_status_t ef_output_filter(ap_filter_t *f, apr_bucket_brigade *bb)
{
request_rec *r = f->r;
ef_ctx_t *ctx = f->ctx;
apr_status_t rv;
if (!ctx) {
if ((rv = init_filter_instance(f)) != APR_SUCCESS) {
ctx = f->ctx;
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"can't initialise output filter %s: %s",
f->frec->name,
(ctx->dc->onfail == 1) ? "removing" : "aborting");
ap_remove_output_filter(f);
if (ctx->dc->onfail == 1) {
return ap_pass_brigade(f->next, bb);
}
else {
apr_bucket *e;
f->r->status_line = "500 Internal Server Error";
apr_brigade_cleanup(bb);
e = ap_bucket_error_create(HTTP_INTERNAL_SERVER_ERROR,
NULL, r->pool,
f->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, e);
e = apr_bucket_eos_create(f->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, e);
ap_pass_brigade(f->next, bb);
return AP_FILTER_ERROR;
}
}
ctx = f->ctx;
}
if (ctx->noop) {
ap_remove_output_filter(f);
return ap_pass_brigade(f->next, bb);
}
rv = ef_unified_filter(f, bb);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"ef_unified_filter() failed");
}
if ((rv = ap_pass_brigade(f->next, bb)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"ap_pass_brigade() failed");
}
return rv;
}
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);
}
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 bail_out_on_error(apr_bucket_brigade *bb,
ap_filter_t *f,
int http_error)
{
apr_bucket *e;
apr_brigade_cleanup(bb);
e = ap_bucket_error_create(http_error,
NULL, f->r->pool,
f->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, e);
e = apr_bucket_eos_create(f->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, e);
return ap_pass_brigade(f->r->output_filters, bb);
}
static apr_status_t ef_input_filter(ap_filter_t *f, apr_bucket_brigade *bb,
ap_input_mode_t mode, apr_read_type_e block,
apr_off_t readbytes)
{
ef_ctx_t *ctx = f->ctx;
apr_status_t rv;
if (!ctx) {
if ((rv = init_filter_instance(f)) != APR_SUCCESS) {
ctx = f->ctx;
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, f->r, APLOGNO(01470)
"can't initialise input filter %s: %s",
f->frec->name,
(ctx->dc->onfail == 1) ? "removing" : "aborting");
ap_remove_input_filter(f);
if (ctx->dc->onfail == 1) {
return ap_get_brigade(f->next, bb, mode, block, readbytes);
}
else {
f->r->status = HTTP_INTERNAL_SERVER_ERROR;
return HTTP_INTERNAL_SERVER_ERROR;
}
}
ctx = f->ctx;
}
if (ctx->hit_eos) {
/* Match behaviour of HTTP_IN if filter is re-invoked after
* hitting EOS: give back another EOS. */
apr_bucket *e = apr_bucket_eos_create(f->c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, e);
return APR_SUCCESS;
}
if (ctx->noop) {
ap_remove_input_filter(f);
return ap_get_brigade(f->next, bb, mode, block, readbytes);
}
rv = ap_get_brigade(f->next, bb, mode, block, readbytes);
if (rv != APR_SUCCESS) {
return rv;
}
rv = ef_unified_filter(f, bb);
return rv;
}
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;
}
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;
}
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);
}
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);
}
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;
}
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;
}
// This input filter handles the job of rewriting the request, it's injected at
// runtime by the porter fixup filter. All it does is remove itself from the
// filter chain and pass the newly modified content up the filter chain.
static apr_status_t porter_input_filter(ap_filter_t *f, apr_bucket_brigade *bb,
ap_input_mode_t mode, apr_read_type_e block,
apr_off_t readbytes)
{
porter_upload_request_t *ur = f->ctx;
if (!ur) {
// Because we add ourselves dynamically, this should never occur.
// but handle it anyway.
return ap_get_brigade(f->next, bb, mode, block, readbytes);
}
// Remove ourselves so we don't trigger again.
ap_remove_input_filter(f);
APR_BRIGADE_INSERT_TAIL(bb, apr_bucket_eos_create(bb->bucket_alloc)) ;
APR_BRIGADE_PREPEND(bb, ur->bucket_brigade);
apr_brigade_destroy(ur->bucket_brigade);
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");
}
}