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