static apr_status_t setup_request(serf_request_t *request,
void *setup_baton,
serf_bucket_t **req_bkt,
serf_response_acceptor_t *acceptor,
void **acceptor_baton,
serf_response_handler_t *handler,
void **handler_baton,
apr_pool_t *pool)
{
handler_baton_t *ctx = setup_baton;
serf_bucket_t *hdrs_bkt;
*req_bkt = serf_bucket_request_create("GET", ctx->full_path, NULL,
serf_request_get_alloc(request));
hdrs_bkt = serf_bucket_request_get_headers(*req_bkt);
/* FIXME: Shouldn't we be able to figure out the host ourselves? */
serf_bucket_headers_setn(hdrs_bkt, "Host", ctx->hostinfo);
serf_bucket_headers_setn(hdrs_bkt, "User-Agent",
"Serf/" SERF_VERSION_STRING);
/* Shouldn't serf do this for us? */
serf_bucket_headers_setn(hdrs_bkt, "Accept-Encoding", "gzip");
if (ctx->app_ctx->authn != NULL) {
serf_bucket_headers_setn(hdrs_bkt, "Authorization",
ctx->app_ctx->authn);
}
if (ctx->app_ctx->using_ssl) {
serf_bucket_alloc_t *req_alloc;
req_alloc = serf_request_get_alloc(request);
if (ctx->app_ctx->ssl_ctx == NULL) {
*req_bkt = serf_bucket_ssl_encrypt_create(*req_bkt, NULL,
ctx->app_ctx->bkt_alloc);
ctx->app_ctx->ssl_ctx =
serf_bucket_ssl_encrypt_context_get(*req_bkt);
}
else {
*req_bkt =
serf_bucket_ssl_encrypt_create(*req_bkt, ctx->app_ctx->ssl_ctx,
ctx->app_ctx->bkt_alloc);
}
}
#ifdef SERF_VERBOSE
printf("Url requesting: %s\n", ctx->full_path);
#endif
*acceptor = ctx->acceptor;
*acceptor_baton = ctx->acceptor_baton;
*handler = ctx->handler;
*handler_baton = ctx;
return APR_SUCCESS;
}
static apr_status_t setup_request(serf_request_t *request,
void *setup_baton,
serf_bucket_t **req_bkt,
serf_response_acceptor_t *acceptor,
void **acceptor_baton,
serf_response_handler_t *handler,
void **handler_baton,
apr_pool_t *pool)
{
handler_baton_t *ctx = setup_baton;
serf_bucket_t *hdrs_bkt;
serf_bucket_t *body_bkt;
if (ctx->req_body_path) {
apr_file_t *file;
apr_status_t status;
status = apr_file_open(&file, ctx->req_body_path, APR_READ,
APR_OS_DEFAULT, pool);
if (status) {
printf("Error opening file (%s)\n", ctx->req_body_path);
return status;
}
body_bkt = serf_bucket_file_create(file,
serf_request_get_alloc(request));
}
else {
body_bkt = NULL;
}
*req_bkt = serf_request_bucket_request_create(request, ctx->method,
ctx->path, body_bkt,
serf_request_get_alloc(request));
hdrs_bkt = serf_bucket_request_get_headers(*req_bkt);
serf_bucket_headers_setn(hdrs_bkt, "User-Agent",
"Serf/" SERF_VERSION_STRING);
/* Shouldn't serf do this for us? */
serf_bucket_headers_setn(hdrs_bkt, "Accept-Encoding", "gzip");
#ifdef CONNECTION_CLOSE_HDR
serf_bucket_headers_setn(hdrs_bkt, "Connection", "close");
#endif
/* Add the extra headers from the command line */
if (ctx->req_hdrs != NULL) {
serf_bucket_headers_do(ctx->req_hdrs, append_request_headers, hdrs_bkt);
}
*acceptor = ctx->acceptor;
*acceptor_baton = ctx->acceptor_baton;
*handler = ctx->handler;
*handler_baton = ctx;
return APR_SUCCESS;
}
apr_status_t setup_request(serf_request_t *request,
void *setup_baton,
serf_bucket_t **req_bkt,
serf_response_acceptor_t *acceptor,
void **acceptor_baton,
serf_response_handler_t *handler,
void **handler_baton,
apr_pool_t *pool)
{
handler_baton_t *ctx = setup_baton;
serf_bucket_t *body_bkt;
if (ctx->request)
{
/* Create a raw request bucket. */
*req_bkt = serf_bucket_simple_create(ctx->request, strlen(ctx->request),
NULL, NULL,
serf_request_get_alloc(request));
}
else
{
if (ctx->req_id >= 0) {
/* create a simple body text */
const char *str = apr_psprintf(pool, "%d", ctx->req_id);
body_bkt = serf_bucket_simple_create(
str, strlen(str), NULL, NULL,
serf_request_get_alloc(request));
}
else
body_bkt = NULL;
*req_bkt =
serf_request_bucket_request_create(request,
ctx->method, ctx->path,
body_bkt,
serf_request_get_alloc(request));
}
APR_ARRAY_PUSH(ctx->sent_requests, int) = ctx->req_id;
*acceptor = ctx->acceptor;
*acceptor_baton = ctx;
*handler = ctx->handler;
*handler_baton = ctx;
return APR_SUCCESS;
}
serf_bucket_t* accept_response(serf_request_t *request,
serf_bucket_t *stream,
void *acceptor_baton,
apr_pool_t *pool)
{
serf_bucket_t *c;
serf_bucket_alloc_t *bkt_alloc;
handler_baton_t *ctx = acceptor_baton;
serf_bucket_t *response;
/* get the per-request bucket allocator */
bkt_alloc = serf_request_get_alloc(request);
/* Create a barrier so the response doesn't eat us! */
c = serf_bucket_barrier_create(stream, bkt_alloc);
APR_ARRAY_PUSH(ctx->accepted_requests, int) = ctx->req_id;
response = serf_bucket_response_create(c, bkt_alloc);
if (strcasecmp(ctx->method, "HEAD") == 0)
serf_bucket_response_set_head(response);
return response;
}
static serf_bucket_t *
s_accept_response(serf_request_t *request, serf_bucket_t *stream, void *UNUSED(acceptor_baton), apr_pool_t *UNUSED(pool))
{
serf_bucket_alloc_t *bkt_alloc;
serf_bucket_t *c;
bkt_alloc = serf_request_get_alloc(request);
c = serf_bucket_barrier_create(stream, bkt_alloc);
return serf_bucket_response_create(c, bkt_alloc);
}
static apr_status_t setup_request(serf_request_t *request,
void *vbaton,
serf_bucket_t **req_bkt,
serf_response_acceptor_t *acceptor,
void **acceptor_baton,
serf_response_handler_t *handler,
void **handler_baton,
apr_pool_t *pool)
{
s_baton_t *ctx = vbaton;
serf_bucket_t *hdrs_bkt;
*req_bkt = serf_bucket_request_create(ctx->r->method, ctx->r->unparsed_uri,
ctx->body_bkt,
serf_request_get_alloc(request));
hdrs_bkt = serf_bucket_request_get_headers(*req_bkt);
apr_table_do(copy_headers_in, hdrs_bkt, ctx->r->headers_in, NULL);
if (ctx->conf->preservehost) {
serf_bucket_headers_setn(hdrs_bkt, "Host",
apr_table_get(ctx->r->headers_in, "Host"));
}
else {
serf_bucket_headers_setn(hdrs_bkt, "Host", ctx->conf->url.hostname);
}
serf_bucket_headers_setn(hdrs_bkt, "Accept-Encoding", "gzip");
if (ctx->want_ssl) {
if (ctx->ssl_ctx == NULL) {
*req_bkt = serf_bucket_ssl_encrypt_create(*req_bkt, NULL,
ctx->bkt_alloc);
ctx->ssl_ctx = serf_bucket_ssl_encrypt_context_get(*req_bkt);
}
else {
*req_bkt = serf_bucket_ssl_encrypt_create(*req_bkt, ctx->ssl_ctx,
ctx->bkt_alloc);
}
}
*acceptor = accept_response;
*acceptor_baton = ctx;
*handler = handle_response;
*handler_baton = ctx;
return APR_SUCCESS;
}
static serf_bucket_t* accept_response(serf_request_t *request,
serf_bucket_t *stream,
void *acceptor_baton,
apr_pool_t *pool)
{
serf_bucket_t *c;
serf_bucket_alloc_t *bkt_alloc;
/* get the per-request bucket allocator */
bkt_alloc = serf_request_get_alloc(request);
/* Create a barrier so the response doesn't eat us! */
c = serf_bucket_barrier_create(stream, bkt_alloc);
return serf_bucket_response_create(c, bkt_alloc);
}
/* Prepare the CONNECT request. */
static apr_status_t setup_request(serf_request_t *request,
void *setup_baton,
serf_bucket_t **req_bkt,
serf_response_acceptor_t *acceptor,
void **acceptor_baton,
serf_response_handler_t *handler,
void **handler_baton,
apr_pool_t *pool)
{
req_ctx_t *ctx = setup_baton;
*req_bkt =
serf_request_bucket_request_create(request,
"CONNECT", ctx->uri,
NULL,
serf_request_get_alloc(request));
*acceptor = accept_response;
*acceptor_baton = ctx;
*handler = handle_response;
*handler_baton = ctx;
return APR_SUCCESS;
}
static serf_bucket_t* accept_response(serf_request_t *request,
serf_bucket_t *stream,
void *acceptor_baton,
apr_pool_t *pool)
{
serf_bucket_t *c;
serf_bucket_t *response;
serf_bucket_alloc_t *bkt_alloc;
app_baton_t *app_ctx = acceptor_baton;
/* get the per-request bucket allocator */
bkt_alloc = serf_request_get_alloc(request);
/* Create a barrier so the response doesn't eat us! */
c = serf_bucket_barrier_create(stream, bkt_alloc);
response = serf_bucket_response_create(c, bkt_alloc);
if (app_ctx->head_request)
serf_bucket_response_set_head(response);
return response;
}
static apr_status_t
s_setup_request(serf_request_t *request,
void *setup_ctx,
serf_bucket_t **req_bkt,
serf_response_acceptor_t *acceptor,
void **acceptor_ctx,
serf_response_handler_t *handler,
void **handler_ctx,
apr_pool_t *UNUSED(pool))
{
handler_ctx_t *ctx = setup_ctx;
serf_bucket_t *hdrs_bkt;
serf_bucket_t *body_bkt = NULL;
request_rec *r = ctx->r;
int ii;
if (ctx->post_data) {
body_bkt = serf_bucket_simple_create(ctx->post_data, ctx->post_data_len, NULL, NULL, serf_request_get_alloc(request));
}
*req_bkt = serf_bucket_request_create(ctx->method, ctx->path, body_bkt, serf_request_get_alloc(request));
hdrs_bkt = serf_bucket_request_get_headers(*req_bkt);
apr_array_header_t *headers = (apr_array_header_t*)apr_table_elts(r->headers_in);
apr_table_entry_t *hentryp = (apr_table_entry_t*)headers->elts;
for (ii=headers->nelts-1; ii>=0; ii--) {
DBG(ctx->r, "REQ[%X] REQUEST PREV key:[%s], val:[%s]", TO_ADDR(ctx->r), hentryp[ii].key, hentryp[ii].val);
serf_bucket_headers_setc(hdrs_bkt, hentryp[ii].key, (hentryp[ii].val) ? hentryp[ii].val : "");
DBG(ctx->r, "REQ[%X] REQUEST AFTER key:[%s], val:[%s]", TO_ADDR(ctx->r), hentryp[ii].key, hentryp[ii].val);
}
if (ctx->post_data) {
DBG(ctx->r, "REQ[%X] REQUEST PREV key:[%s], val:[%s]", TO_ADDR(ctx->r), "X-Chxj-Forward", "Done");
serf_bucket_headers_setc(hdrs_bkt, "X-Chxj-Forward", "Done");
DBG(ctx->r, "REQ[%X] REQUEST AFTER key:[%s], val:[%s]", TO_ADDR(ctx->r), "X-Chxj-Forward", "Done");
DBG(ctx->r, "REQ[%X] REQUEST PREV key:[%s], val:[%s]", TO_ADDR(ctx->r), "X-Chxj-Content-Length", apr_psprintf(r->pool, "%" APR_SIZE_T_FMT, ctx->post_data_len));
serf_bucket_headers_setc(hdrs_bkt, "X-Chxj-Content-Length", apr_psprintf(r->pool, "%" APR_SIZE_T_FMT , ctx->post_data_len));
DBG(ctx->r, "REQ[%X] REQUEST AFTER key:[%s], val:[%s]", TO_ADDR(ctx->r), "X-Chxj-Content-Length", apr_psprintf(r->pool, "%" APR_SIZE_T_FMT, ctx->post_data_len));
}
DBG(ctx->r, "REQ[%X] REQUEST Content-Length:[%s]", TO_ADDR(ctx->r), serf_bucket_headers_get(hdrs_bkt, "Content-Length"));
apr_atomic_inc32(&(ctx->requests_outstanding));
if (ctx->acceptor_ctx->ssl_flag) {
serf_bucket_alloc_t *req_alloc;
app_ctx_t *app_ctx = ctx->acceptor_ctx;
req_alloc = serf_request_get_alloc(request);
if (app_ctx->ssl_ctx == NULL) {
*req_bkt = serf_bucket_ssl_encrypt_create(*req_bkt, NULL, app_ctx->bkt_alloc);
app_ctx->ssl_ctx = serf_bucket_ssl_encrypt_context_get(*req_bkt);
}
else {
*req_bkt = serf_bucket_ssl_encrypt_create(*req_bkt, app_ctx->ssl_ctx, app_ctx->bkt_alloc);
}
}
*acceptor = ctx->acceptor;
*acceptor_ctx = ctx->acceptor_ctx;
*handler = ctx->handler;
*handler_ctx = ctx;
return APR_SUCCESS;
}
