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