273 lines
10 KiB
C
273 lines
10 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.
|
|
*/
|
|
|
|
#ifndef mod_md_md_http_h
|
|
#define mod_md_md_http_h
|
|
|
|
struct apr_table_t;
|
|
struct apr_bucket_brigade;
|
|
struct apr_bucket_alloc_t;
|
|
struct md_data_t;
|
|
|
|
typedef struct md_http_t md_http_t;
|
|
|
|
typedef struct md_http_request_t md_http_request_t;
|
|
typedef struct md_http_response_t md_http_response_t;
|
|
|
|
/**
|
|
* Callback invoked once per request, either when an error was encountered
|
|
* or when everything succeeded and the request is about to be released. Only
|
|
* in the last case will the status be APR_SUCCESS.
|
|
*/
|
|
typedef apr_status_t md_http_status_cb(const md_http_request_t *req, apr_status_t status, void *data);
|
|
|
|
/**
|
|
* Callback invoked when the complete response has been received.
|
|
*/
|
|
typedef apr_status_t md_http_response_cb(const md_http_response_t *res, void *data);
|
|
|
|
typedef struct md_http_callbacks_t md_http_callbacks_t;
|
|
struct md_http_callbacks_t {
|
|
md_http_status_cb *on_status;
|
|
void *on_status_data;
|
|
md_http_response_cb *on_response;
|
|
void *on_response_data;
|
|
};
|
|
|
|
typedef struct md_http_timeouts_t md_http_timeouts_t;
|
|
struct md_http_timeouts_t {
|
|
apr_time_t overall;
|
|
apr_time_t connect;
|
|
long stall_bytes_per_sec;
|
|
apr_time_t stalled;
|
|
};
|
|
|
|
struct md_http_request_t {
|
|
md_http_t *http;
|
|
apr_pool_t *pool;
|
|
int id;
|
|
struct apr_bucket_alloc_t *bucket_alloc;
|
|
const char *method;
|
|
const char *url;
|
|
const char *user_agent;
|
|
const char *proxy_url;
|
|
const char *ca_file;
|
|
const char *unix_socket_path;
|
|
apr_table_t *headers;
|
|
struct apr_bucket_brigade *body;
|
|
apr_off_t body_len;
|
|
apr_off_t resp_limit;
|
|
md_http_timeouts_t timeout;
|
|
md_http_callbacks_t cb;
|
|
void *internals;
|
|
};
|
|
|
|
struct md_http_response_t {
|
|
md_http_request_t *req;
|
|
int status;
|
|
apr_table_t *headers;
|
|
struct apr_bucket_brigade *body;
|
|
};
|
|
|
|
apr_status_t md_http_create(md_http_t **phttp, apr_pool_t *p, const char *user_agent,
|
|
const char *proxy_url);
|
|
|
|
void md_http_set_response_limit(md_http_t *http, apr_off_t resp_limit);
|
|
|
|
/**
|
|
* Clone a http instance, inheriting all settings from source_http.
|
|
* The cloned instance is not tied in any way to the source.
|
|
*/
|
|
apr_status_t md_http_clone(md_http_t **phttp,
|
|
apr_pool_t *p, md_http_t *source_http);
|
|
|
|
/**
|
|
* Set the timeout for the complete request. This needs to take everything from
|
|
* DNS looksups, to conntects, to transfer of all data into account and should
|
|
* be sufficiently large.
|
|
* Set to 0 the have no timeout for this.
|
|
*/
|
|
void md_http_set_timeout_default(md_http_t *http, apr_time_t timeout);
|
|
void md_http_set_timeout(md_http_request_t *req, apr_time_t timeout);
|
|
|
|
/**
|
|
* Set the timeout for establishing a connection.
|
|
* Set to 0 the have no special timeout for this.
|
|
*/
|
|
void md_http_set_connect_timeout_default(md_http_t *http, apr_time_t timeout);
|
|
void md_http_set_connect_timeout(md_http_request_t *req, apr_time_t timeout);
|
|
|
|
/**
|
|
* Set the condition for when a transfer is considered "stalled", e.g. does not
|
|
* progress at a sufficient rate and will be aborted.
|
|
* Set to 0 the have no stall detection in place.
|
|
*/
|
|
void md_http_set_stalling_default(md_http_t *http, long bytes_per_sec, apr_time_t timeout);
|
|
void md_http_set_stalling(md_http_request_t *req, long bytes_per_sec, apr_time_t timeout);
|
|
|
|
/**
|
|
* Set a CA file (in PERM format) to use for root certificates when
|
|
* verifying SSL connections. If not set (or set to NULL), the systems
|
|
* certificate store will be used.
|
|
*/
|
|
void md_http_set_ca_file(md_http_t *http, const char *ca_file);
|
|
|
|
/**
|
|
* Set the path of a unix domain socket for use instead of TCP
|
|
* in a connection. Disable by providing NULL as path.
|
|
*/
|
|
void md_http_set_unix_socket_path(md_http_t *http, const char *path);
|
|
|
|
/**
|
|
* Perform the request. Then this function returns, the request and
|
|
* all its memory has been freed and must no longer be used.
|
|
*/
|
|
apr_status_t md_http_perform(md_http_request_t *request);
|
|
|
|
/**
|
|
* Set the callback to be invoked once the status of a request is known.
|
|
* @param req the request
|
|
* @param cb the callback to invoke on the response
|
|
* @param baton data passed to the callback
|
|
*/
|
|
void md_http_set_on_status_cb(md_http_request_t *req, md_http_status_cb *cb, void *baton);
|
|
|
|
/**
|
|
* Set the callback to be invoked when the complete
|
|
* response has been successfully received. The HTTP status may
|
|
* be 500, however.
|
|
* @param req the request
|
|
* @param cb the callback to invoke on the response
|
|
* @param baton data passed to the callback
|
|
*/
|
|
void md_http_set_on_response_cb(md_http_request_t *req, md_http_response_cb *cb, void *baton);
|
|
|
|
/**
|
|
* Create a GET request.
|
|
* @param preq the created request after success
|
|
* @param http the md_http instance
|
|
* @param url the url to GET
|
|
* @param headers request headers
|
|
*/
|
|
apr_status_t md_http_GET_create(md_http_request_t **preq, md_http_t *http, const char *url,
|
|
struct apr_table_t *headers);
|
|
|
|
/**
|
|
* Create a HEAD request.
|
|
* @param preq the created request after success
|
|
* @param http the md_http instance
|
|
* @param url the url to GET
|
|
* @param headers request headers
|
|
*/
|
|
apr_status_t md_http_HEAD_create(md_http_request_t **preq, md_http_t *http, const char *url,
|
|
struct apr_table_t *headers);
|
|
|
|
/**
|
|
* Create a POST request with a bucket brigade as request body.
|
|
* @param preq the created request after success
|
|
* @param http the md_http instance
|
|
* @param url the url to GET
|
|
* @param headers request headers
|
|
* @param content_type the content_type of the body or NULL
|
|
* @param body the body of the request or NULL
|
|
* @param detect_len scan the body to detect its length
|
|
*/
|
|
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);
|
|
|
|
/**
|
|
* Create a POST request with known request body data.
|
|
* @param preq the created request after success
|
|
* @param http the md_http instance
|
|
* @param url the url to GET
|
|
* @param headers request headers
|
|
* @param content_type the content_type of the body or NULL
|
|
* @param body the body of the request or NULL
|
|
*/
|
|
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);
|
|
|
|
/*
|
|
* Convenience functions for create+perform.
|
|
*/
|
|
apr_status_t md_http_GET_perform(md_http_t *http, const char *url,
|
|
struct apr_table_t *headers,
|
|
md_http_response_cb *cb, void *baton);
|
|
apr_status_t md_http_HEAD_perform(md_http_t *http, const char *url,
|
|
struct apr_table_t *headers,
|
|
md_http_response_cb *cb, void *baton);
|
|
apr_status_t md_http_POST_perform(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_response_cb *cb, void *baton);
|
|
apr_status_t md_http_POSTd_perform(md_http_t *http, const char *url,
|
|
struct apr_table_t *headers, const char *content_type,
|
|
const struct md_data_t *body,
|
|
md_http_response_cb *cb, void *baton);
|
|
|
|
void md_http_req_destroy(md_http_request_t *req);
|
|
|
|
/** Return the next request for processing on APR_SUCCESS. Return ARP_ENOENT
|
|
* when no request is available. Anything else is an error.
|
|
*/
|
|
typedef apr_status_t md_http_next_req(md_http_request_t **preq, void *baton,
|
|
md_http_t *http, int in_flight);
|
|
|
|
/**
|
|
* Perform requests in parallel as retrieved from the nextreq function.
|
|
* There are as many requests in flight as the nextreq functions provides.
|
|
*
|
|
* To limit the number of parallel requests, nextreq should return APR_ENOENT when the limit
|
|
* is reached. It will be called again when the number of in_flight requests changes.
|
|
*
|
|
* When all requests are done, nextreq will be called one more time. Should it not
|
|
* return anything, this function returns.
|
|
*/
|
|
apr_status_t md_http_multi_perform(md_http_t *http, md_http_next_req *nextreq, void *baton);
|
|
|
|
/**************************************************************************************************/
|
|
/* interface to implementation */
|
|
|
|
typedef apr_status_t md_http_init_cb(void);
|
|
typedef void md_http_cleanup_cb(md_http_t *req, apr_pool_t *p);
|
|
typedef void md_http_req_cleanup_cb(md_http_request_t *req);
|
|
typedef apr_status_t md_http_perform_cb(md_http_request_t *req);
|
|
typedef apr_status_t md_http_multi_perform_cb(md_http_t *http, apr_pool_t *p,
|
|
md_http_next_req *nextreq, void *baton);
|
|
|
|
typedef struct md_http_impl_t md_http_impl_t;
|
|
struct md_http_impl_t {
|
|
md_http_init_cb *init;
|
|
md_http_req_cleanup_cb *req_cleanup;
|
|
md_http_perform_cb *perform;
|
|
md_http_multi_perform_cb *multi_perform;
|
|
md_http_cleanup_cb *cleanup;
|
|
};
|
|
|
|
void md_http_use_implementation(md_http_impl_t *impl);
|
|
|
|
/**
|
|
* get/set data the implementation wants to remember between requests
|
|
* in the same md_http_t instance.
|
|
*/
|
|
void md_http_set_impl_data(md_http_t *http, void *data);
|
|
void *md_http_get_impl_data(md_http_t *http);
|
|
|
|
|
|
#endif /* md_http_h */
|