398 lines
12 KiB
C
398 lines
12 KiB
C
/* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
|
|
#include <apr_lib.h>
|
|
#include <apr_strings.h>
|
|
#include <apr_buckets.h>
|
|
|
|
#include "md_http.h"
|
|
#include "md_log.h"
|
|
#include "md_util.h"
|
|
|
|
struct md_http_t {
|
|
apr_pool_t *pool;
|
|
apr_bucket_alloc_t *bucket_alloc;
|
|
int next_id;
|
|
apr_off_t resp_limit;
|
|
md_http_impl_t *impl;
|
|
void *impl_data; /* to be used by the implementation */
|
|
const char *user_agent;
|
|
const char *proxy_url;
|
|
const char *unix_socket_path;
|
|
md_http_timeouts_t timeout;
|
|
const char *ca_file;
|
|
};
|
|
|
|
static md_http_impl_t *cur_impl;
|
|
static int cur_init_done;
|
|
|
|
void md_http_use_implementation(md_http_impl_t *impl)
|
|
{
|
|
if (cur_impl != impl) {
|
|
cur_impl = impl;
|
|
cur_init_done = 0;
|
|
}
|
|
}
|
|
|
|
static apr_status_t http_cleanup(void *data)
|
|
{
|
|
md_http_t *http = data;
|
|
if (http && http->impl && http->impl->cleanup) {
|
|
http->impl->cleanup(http, http->pool);
|
|
}
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
apr_status_t md_http_create(md_http_t **phttp, apr_pool_t *p, const char *user_agent,
|
|
const char *proxy_url)
|
|
{
|
|
md_http_t *http;
|
|
apr_status_t rv = APR_SUCCESS;
|
|
|
|
if (!cur_impl) {
|
|
*phttp = NULL;
|
|
return APR_ENOTIMPL;
|
|
}
|
|
|
|
if (!cur_init_done) {
|
|
if (APR_SUCCESS == (rv = cur_impl->init())) {
|
|
cur_init_done = 1;
|
|
}
|
|
else {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
http = apr_pcalloc(p, sizeof(*http));
|
|
http->pool = p;
|
|
http->impl = cur_impl;
|
|
http->user_agent = apr_pstrdup(p, user_agent);
|
|
http->proxy_url = proxy_url? apr_pstrdup(p, proxy_url) : NULL;
|
|
http->bucket_alloc = apr_bucket_alloc_create(p);
|
|
if (!http->bucket_alloc) {
|
|
return APR_EGENERAL;
|
|
}
|
|
apr_pool_cleanup_register(p, http, http_cleanup, apr_pool_cleanup_null);
|
|
*phttp = http;
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
apr_status_t md_http_clone(md_http_t **phttp,
|
|
apr_pool_t *p, md_http_t *source_http)
|
|
{
|
|
apr_status_t rv;
|
|
|
|
rv = md_http_create(phttp, p, source_http->user_agent, source_http->proxy_url);
|
|
if (APR_SUCCESS == rv) {
|
|
(*phttp)->resp_limit = source_http->resp_limit;
|
|
(*phttp)->timeout = source_http->timeout;
|
|
if (source_http->unix_socket_path) {
|
|
(*phttp)->unix_socket_path = apr_pstrdup(p, source_http->unix_socket_path);
|
|
}
|
|
if (source_http->ca_file) {
|
|
(*phttp)->ca_file = apr_pstrdup(p, source_http->ca_file);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
void md_http_set_impl_data(md_http_t *http, void *data)
|
|
{
|
|
http->impl_data = data;
|
|
}
|
|
|
|
void *md_http_get_impl_data(md_http_t *http)
|
|
{
|
|
return http->impl_data;
|
|
}
|
|
|
|
void md_http_set_response_limit(md_http_t *http, apr_off_t resp_limit)
|
|
{
|
|
http->resp_limit = resp_limit;
|
|
}
|
|
|
|
void md_http_set_timeout_default(md_http_t *http, apr_time_t timeout)
|
|
{
|
|
http->timeout.overall = timeout;
|
|
}
|
|
|
|
void md_http_set_timeout(md_http_request_t *req, apr_time_t timeout)
|
|
{
|
|
req->timeout.overall = timeout;
|
|
}
|
|
|
|
void md_http_set_connect_timeout_default(md_http_t *http, apr_time_t timeout)
|
|
{
|
|
http->timeout.connect = timeout;
|
|
}
|
|
|
|
void md_http_set_connect_timeout(md_http_request_t *req, apr_time_t timeout)
|
|
{
|
|
req->timeout.connect = timeout;
|
|
}
|
|
|
|
void md_http_set_stalling_default(md_http_t *http, long bytes_per_sec, apr_time_t timeout)
|
|
{
|
|
http->timeout.stall_bytes_per_sec = bytes_per_sec;
|
|
http->timeout.stalled = timeout;
|
|
}
|
|
|
|
void md_http_set_stalling(md_http_request_t *req, long bytes_per_sec, apr_time_t timeout)
|
|
{
|
|
req->timeout.stall_bytes_per_sec = bytes_per_sec;
|
|
req->timeout.stalled = timeout;
|
|
}
|
|
|
|
void md_http_set_ca_file(md_http_t *http, const char *ca_file)
|
|
{
|
|
http->ca_file = ca_file;
|
|
}
|
|
|
|
void md_http_set_unix_socket_path(md_http_t *http, const char *path)
|
|
{
|
|
http->unix_socket_path = path;
|
|
}
|
|
|
|
static apr_status_t req_set_body(md_http_request_t *req, const char *content_type,
|
|
apr_bucket_brigade *body, apr_off_t body_len,
|
|
int detect_len)
|
|
{
|
|
apr_status_t rv = APR_SUCCESS;
|
|
|
|
if (body && detect_len) {
|
|
rv = apr_brigade_length(body, 1, &body_len);
|
|
if (rv != APR_SUCCESS) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
req->body = body;
|
|
req->body_len = body? body_len : 0;
|
|
if (content_type) {
|
|
apr_table_set(req->headers, "Content-Type", content_type);
|
|
}
|
|
else {
|
|
apr_table_unset(req->headers, "Content-Type");
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
static apr_status_t req_set_body_data(md_http_request_t *req, const char *content_type,
|
|
const md_data_t *body)
|
|
{
|
|
apr_bucket_brigade *bbody = NULL;
|
|
apr_status_t rv;
|
|
|
|
if (body && body->len > 0) {
|
|
bbody = apr_brigade_create(req->pool, req->http->bucket_alloc);
|
|
rv = apr_brigade_write(bbody, NULL, NULL, body->data, body->len);
|
|
if (rv != APR_SUCCESS) {
|
|
return rv;
|
|
}
|
|
}
|
|
return req_set_body(req, content_type, bbody, body? (apr_off_t)body->len : 0, 0);
|
|
}
|
|
|
|
static apr_status_t req_create(md_http_request_t **preq, md_http_t *http,
|
|
const char *method, const char *url,
|
|
struct apr_table_t *headers)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_pool_t *pool;
|
|
apr_status_t rv;
|
|
|
|
rv = apr_pool_create(&pool, http->pool);
|
|
if (rv != APR_SUCCESS) {
|
|
return rv;
|
|
}
|
|
apr_pool_tag(pool, "md_http_req");
|
|
|
|
req = apr_pcalloc(pool, sizeof(*req));
|
|
req->pool = pool;
|
|
req->id = http->next_id++;
|
|
req->bucket_alloc = http->bucket_alloc;
|
|
req->http = http;
|
|
req->method = method;
|
|
req->url = url;
|
|
req->headers = headers? apr_table_copy(req->pool, headers) : apr_table_make(req->pool, 5);
|
|
req->resp_limit = http->resp_limit;
|
|
req->user_agent = http->user_agent;
|
|
req->proxy_url = http->proxy_url;
|
|
req->timeout = http->timeout;
|
|
req->ca_file = http->ca_file;
|
|
req->unix_socket_path = http->unix_socket_path;
|
|
*preq = req;
|
|
return rv;
|
|
}
|
|
|
|
void md_http_req_destroy(md_http_request_t *req)
|
|
{
|
|
if (req->internals) {
|
|
req->http->impl->req_cleanup(req);
|
|
req->internals = NULL;
|
|
}
|
|
apr_pool_destroy(req->pool);
|
|
}
|
|
|
|
void md_http_set_on_status_cb(md_http_request_t *req, md_http_status_cb *cb, void *baton)
|
|
{
|
|
req->cb.on_status = cb;
|
|
req->cb.on_status_data = baton;
|
|
}
|
|
|
|
void md_http_set_on_response_cb(md_http_request_t *req, md_http_response_cb *cb, void *baton)
|
|
{
|
|
req->cb.on_response = cb;
|
|
req->cb.on_response_data = baton;
|
|
}
|
|
|
|
apr_status_t md_http_perform(md_http_request_t *req)
|
|
{
|
|
return req->http->impl->perform(req);
|
|
}
|
|
|
|
typedef struct {
|
|
md_http_next_req *nextreq;
|
|
void *baton;
|
|
} nextreq_proxy_t;
|
|
|
|
static apr_status_t proxy_nextreq(md_http_request_t **preq, void *baton,
|
|
md_http_t *http, int in_flight)
|
|
{
|
|
nextreq_proxy_t *proxy = baton;
|
|
|
|
return proxy->nextreq(preq, proxy->baton, http, in_flight);
|
|
}
|
|
|
|
apr_status_t md_http_multi_perform(md_http_t *http, md_http_next_req *nextreq, void *baton)
|
|
{
|
|
nextreq_proxy_t proxy;
|
|
|
|
proxy.nextreq = nextreq;
|
|
proxy.baton = baton;
|
|
return http->impl->multi_perform(http, http->pool, proxy_nextreq, &proxy);
|
|
}
|
|
|
|
apr_status_t md_http_GET_create(md_http_request_t **preq, md_http_t *http, const char *url,
|
|
struct apr_table_t *headers)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_status_t rv;
|
|
|
|
rv = req_create(&req, http, "GET", url, headers);
|
|
*preq = (APR_SUCCESS == rv)? req : NULL;
|
|
return rv;
|
|
}
|
|
|
|
apr_status_t md_http_HEAD_create(md_http_request_t **preq, md_http_t *http, const char *url,
|
|
struct apr_table_t *headers)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_status_t rv;
|
|
|
|
rv = req_create(&req, http, "HEAD", url, headers);
|
|
*preq = (APR_SUCCESS == rv)? req : NULL;
|
|
return rv;
|
|
}
|
|
|
|
apr_status_t md_http_POST_create(md_http_request_t **preq, md_http_t *http, const char *url,
|
|
struct apr_table_t *headers, const char *content_type,
|
|
struct apr_bucket_brigade *body, int detect_len)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_status_t rv;
|
|
|
|
rv = req_create(&req, http, "POST", url, headers);
|
|
if (APR_SUCCESS == rv) {
|
|
rv = req_set_body(req, content_type, body, -1, detect_len);
|
|
}
|
|
*preq = (APR_SUCCESS == rv)? req : NULL;
|
|
return rv;
|
|
}
|
|
|
|
apr_status_t md_http_POSTd_create(md_http_request_t **preq, md_http_t *http, const char *url,
|
|
struct apr_table_t *headers, const char *content_type,
|
|
const struct md_data_t *body)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_status_t rv;
|
|
|
|
rv = req_create(&req, http, "POST", url, headers);
|
|
if (APR_SUCCESS != rv) goto cleanup;
|
|
rv = req_set_body_data(req, content_type, body);
|
|
cleanup:
|
|
if (APR_SUCCESS == rv) {
|
|
*preq = req;
|
|
}
|
|
else {
|
|
*preq = NULL;
|
|
if (req) md_http_req_destroy(req);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
apr_status_t md_http_GET_perform(struct md_http_t *http,
|
|
const char *url, struct apr_table_t *headers,
|
|
md_http_response_cb *cb, void *baton)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_status_t rv;
|
|
|
|
rv = md_http_GET_create(&req, http, url, headers);
|
|
if (APR_SUCCESS == rv) md_http_set_on_response_cb(req, cb, baton);
|
|
return (APR_SUCCESS == rv)? md_http_perform(req) : rv;
|
|
}
|
|
|
|
apr_status_t md_http_HEAD_perform(struct md_http_t *http,
|
|
const char *url, struct apr_table_t *headers,
|
|
md_http_response_cb *cb, void *baton)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_status_t rv;
|
|
|
|
rv = md_http_HEAD_create(&req, http, url, headers);
|
|
if (APR_SUCCESS == rv) md_http_set_on_response_cb(req, cb, baton);
|
|
return (APR_SUCCESS == rv)? md_http_perform(req) : rv;
|
|
}
|
|
|
|
apr_status_t md_http_POST_perform(struct md_http_t *http, const char *url,
|
|
struct apr_table_t *headers, const char *content_type,
|
|
apr_bucket_brigade *body, int detect_len,
|
|
md_http_response_cb *cb, void *baton)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_status_t rv;
|
|
|
|
rv = md_http_POST_create(&req, http, url, headers, content_type, body, detect_len);
|
|
if (APR_SUCCESS == rv) md_http_set_on_response_cb(req, cb, baton);
|
|
return (APR_SUCCESS == rv)? md_http_perform(req) : rv;
|
|
}
|
|
|
|
apr_status_t md_http_POSTd_perform(md_http_t *http, const char *url,
|
|
struct apr_table_t *headers, const char *content_type,
|
|
const md_data_t *body,
|
|
md_http_response_cb *cb, void *baton)
|
|
{
|
|
md_http_request_t *req;
|
|
apr_status_t rv;
|
|
|
|
rv = md_http_POSTd_create(&req, http, url, headers, content_type, body);
|
|
if (APR_SUCCESS == rv) md_http_set_on_response_cb(req, cb, baton);
|
|
return (APR_SUCCESS == rv)? md_http_perform(req) : rv;
|
|
}
|