ABI
Tracker

(serf)



Headers diff: 1.3.9 vs current



 serf.h (1.3.9)   serf.h (current) 
skipping to change at line 56 skipping to change at line 56
typedef struct serf_bucket_type_t serf_bucket_type_t; typedef struct serf_bucket_type_t serf_bucket_type_t;
typedef struct serf_bucket_alloc_t serf_bucket_alloc_t; typedef struct serf_bucket_alloc_t serf_bucket_alloc_t;
typedef struct serf_connection_t serf_connection_t; typedef struct serf_connection_t serf_connection_t;
typedef struct serf_listener_t serf_listener_t; typedef struct serf_listener_t serf_listener_t;
typedef struct serf_incoming_t serf_incoming_t; typedef struct serf_incoming_t serf_incoming_t;
typedef struct serf_incoming_request_t serf_incoming_request_t; typedef struct serf_incoming_request_t serf_incoming_request_t;
typedef struct serf_request_t serf_request_t; typedef struct serf_request_t serf_request_t;
#if 0
typedef struct serf_connection_type_t serf_connection_type_t;
typedef struct serf_protocol_t serf_protocol_t;
typedef struct serf_protocol_type_t serf_protocol_type_t;
#endif /* Connection and protocol API v2 */
typedef struct serf_config_t serf_config_t;
/** /**
* @defgroup serf high-level constructs * @defgroup serf high-level constructs
* @ingroup serf * @ingroup serf
* @{ * @{
*/ */
/** /**
* Serf-specific error codes * Serf-specific error codes
*/ */
#define SERF_ERROR_RANGE 100 #define SERF_ERROR_RANGE 100
skipping to change at line 94 skipping to change at line 102
#define SERF_ERROR_DECOMPRESSION_FAILED (SERF_ERROR_START + 4) #define SERF_ERROR_DECOMPRESSION_FAILED (SERF_ERROR_START + 4)
/* This code is for when a response received from a http server is not in /* This code is for when a response received from a http server is not in
* http-compliant syntax. */ * http-compliant syntax. */
#define SERF_ERROR_BAD_HTTP_RESPONSE (SERF_ERROR_START + 5) #define SERF_ERROR_BAD_HTTP_RESPONSE (SERF_ERROR_START + 5)
/* The server sent less data than what was announced. */ /* The server sent less data than what was announced. */
#define SERF_ERROR_TRUNCATED_HTTP_RESPONSE (SERF_ERROR_START + 6) #define SERF_ERROR_TRUNCATED_HTTP_RESPONSE (SERF_ERROR_START + 6)
/* The proxy server returned an error while setting up the SSL tunnel. */ /* The proxy server returned an error while setting up the SSL tunnel. */
#define SERF_ERROR_SSLTUNNEL_SETUP_FAILED (SERF_ERROR_START + 7) #define SERF_ERROR_SSLTUNNEL_SETUP_FAILED (SERF_ERROR_START + 7)
/* The server unexpectedly closed the connection prematurely. */ /* The server unexpectedly closed the connection prematurely. */
#define SERF_ERROR_ABORTED_CONNECTION (SERF_ERROR_START + 8) #define SERF_ERROR_ABORTED_CONNECTION (SERF_ERROR_START + 8)
/* Generic 'The line too long'. Used internally. */
#define SERF_ERROR_LINE_TOO_LONG (SERF_ERROR_START + 9)
/* The HTTP response status line too long. */
#define SERF_ERROR_STATUS_LINE_TOO_LONG (SERF_ERROR_START + 10)
/* The HTTP response header too long. */
#define SERF_ERROR_RESPONSE_HEADER_TOO_LONG (SERF_ERROR_START + 11)
/* The connection to the server timed out. */
#define SERF_ERROR_CONNECTION_TIMEDOUT (SERF_ERROR_START + 12)
/* The stream returned less data than was expected */
#define SERF_ERROR_TRUNCATED_STREAM (SERF_ERROR_START + 13)
/* The stream is empty */
#define SERF_ERROR_EMPTY_STREAM (SERF_ERROR_START + 14)
/* An empty read was returned. */
#define SERF_ERROR_EMPTY_READ (SERF_ERROR_START + 15)
/* Http-2 stream errors, mapped into our error range */
#define SERF_ERROR_HTTP2_NO_ERROR (SERF_ERROR_START + 50)
#define SERF_ERROR_HTTP2_PROTOCOL_ERROR (SERF_ERROR_START + 51)
#define SERF_ERROR_HTTP2_INTERNAL_ERROR (SERF_ERROR_START + 52)
#define SERF_ERROR_HTTP2_FLOW_CONTROL_ERROR (SERF_ERROR_START + 53)
#define SERF_ERROR_HTTP2_SETTINGS_TIMEOUT (SERF_ERROR_START + 54)
#define SERF_ERROR_HTTP2_STREAM_CLOSED (SERF_ERROR_START + 55)
#define SERF_ERROR_HTTP2_FRAME_SIZE_ERROR (SERF_ERROR_START + 56)
#define SERF_ERROR_HTTP2_REFUSED_STREAM (SERF_ERROR_START + 57)
#define SERF_ERROR_HTTP2_CANCEL (SERF_ERROR_START + 58)
#define SERF_ERROR_HTTP2_COMPRESSION_ERROR (SERF_ERROR_START + 59)
#define SERF_ERROR_HTTP2_CONNECT_ERROR (SERF_ERROR_START + 60)
#define SERF_ERROR_HTTP2_ENHANCE_YOUR_CALM (SERF_ERROR_START + 61)
#define SERF_ERROR_HTTP2_INADEQUATE_SECURITY (SERF_ERROR_START + 62)
#define SERF_ERROR_HTTP2_HTTP_1_1_REQUIRED (SERF_ERROR_START + 63)
/* SSL certificates related errors */ /* SSL certificates related errors */
#define SERF_ERROR_SSL_CERT_FAILED (SERF_ERROR_START + 70) #define SERF_ERROR_SSL_CERT_FAILED (SERF_ERROR_START + 70)
/* SSL communications related errors */ /* SSL communications related errors */
#define SERF_ERROR_SSL_COMM_FAILED (SERF_ERROR_START + 71) #define SERF_ERROR_SSL_COMM_FAILED (SERF_ERROR_START + 71)
/* SSL handshake failed */
#define SERF_ERROR_SSL_SETUP_FAILED (SERF_ERROR_START + 72)
/* Serf-internal error code, raised when the server initiates SSL renegotia
tion
on a connection that uses HTTP pipelining. */
#define SERF_ERROR_SSL_NEGOTIATE_IN_PROGRESS (SERF_ERROR_START + 73)
/* General authentication related errors */ /* General authentication related errors */
#define SERF_ERROR_AUTHN_FAILED (SERF_ERROR_START + 90) #define SERF_ERROR_AUTHN_FAILED (SERF_ERROR_START + 90)
/* None of the available authn mechanisms for the request are supported */ /* None of the available authn mechanisms for the request are supported */
#define SERF_ERROR_AUTHN_NOT_SUPPORTED (SERF_ERROR_START + 91) #define SERF_ERROR_AUTHN_NOT_SUPPORTED (SERF_ERROR_START + 91)
/* Authn was requested by the server but the header lacked some attribute */ /* Authn was requested by the server but the header lacked some attribute */
#define SERF_ERROR_AUTHN_MISSING_ATTRIBUTE (SERF_ERROR_START + 92) #define SERF_ERROR_AUTHN_MISSING_ATTRIBUTE (SERF_ERROR_START + 92)
/* Authentication handler initialization related errors */ /* Authentication handler initialization related errors */
#define SERF_ERROR_AUTHN_INITALIZATION_FAILED (SERF_ERROR_START + 93) #define SERF_ERROR_AUTHN_INITALIZATION_FAILED (SERF_ERROR_START + 93)
/* The user credentials were rejected by the server */
#define SERF_ERROR_AUTHN_CREDENTIALS_REJECTED (SERF_ERROR_START + 94)
/* Error code reserved for use in the test suite. */ /* Error code reserved for use in the test suite. */
#define SERF_ERROR_ISSUE_IN_TESTSUITE (SERF_ERROR_START + 99) #define SERF_ERROR_ISSUE_IN_TESTSUITE (SERF_ERROR_START + 99)
/* This macro groups errors potentially raised when reading a http response . */ /* This macro groups errors potentially raised when reading a http response . */
#define SERF_BAD_RESPONSE_ERROR(status) ((status) \ #define SERF_BAD_RESPONSE_ERROR(status) ((status) \
&& ((SERF_ERROR_DECOMPRESSION_FAILED == (status)) \ && ((SERF_ERROR_DECOMPRESSION_FAILED == (status)) \
||(SERF_ERROR_BAD_HTTP_RESPONSE == (status)) \ ||(SERF_ERROR_BAD_HTTP_RESPONSE == (status)) \
||(SERF_ERROR_TRUNCATED_HTTP_RESPONSE == (status)))) ||(SERF_ERROR_TRUNCATED_HTTP_RESPONSE == (status))))
/** /**
skipping to change at line 334 skipping to change at line 382
* *
* All temporary allocations should be made in @a pool. * All temporary allocations should be made in @a pool.
*/ */
typedef void (*serf_connection_closed_t)( typedef void (*serf_connection_closed_t)(
serf_connection_t *conn, serf_connection_t *conn,
void *closed_baton, void *closed_baton,
apr_status_t why, apr_status_t why,
apr_pool_t *pool); apr_pool_t *pool);
/** /**
* Like serf_connection_closed_t, but applies to incoming connections.
*/
typedef apr_status_t (*serf_incoming_closed_t)(
serf_incoming_t *incoming,
void *closed_baton,
apr_status_t why,
apr_pool_t *pool);
/**
* Response data has arrived and should be processed. * Response data has arrived and should be processed.
* *
* Whenever response data for @a request arrives (initially, or continued d ata * Whenever response data for @a request arrives (initially, or continued d ata
* arrival), this handler is invoked. The response data is available in the * arrival), this handler is invoked. The response data is available in the
* @a response bucket. The @a handler_baton is passed along from the baton * @a response bucket. The @a handler_baton is passed along from the baton
* provided by the request setup callback (@see serf_request_setup_t). * provided by the request setup callback (@see serf_request_setup_t).
* *
* The handler MUST process data from the @a response bucket until the * The handler MUST process data from the @a response bucket until the
* bucket's read function states it would block (see APR_STATUS_IS_EAGAIN). * bucket's read function states it would block (see APR_STATUS_IS_EAGAIN).
* The handler is invoked only when new data arrives. If no further data * The handler is invoked only when new data arrives. If no further data
skipping to change at line 388 skipping to change at line 445
int code, const char *authn_type, int code, const char *authn_type,
const char *realm, const char *realm,
apr_pool_t *pool); apr_pool_t *pool);
/** /**
* Create a new connection associated with the @a ctx serf context. * Create a new connection associated with the @a ctx serf context.
* *
* If no proxy server is configured, a connection will be created to * If no proxy server is configured, a connection will be created to
* (eventually) connect to the address specified by @a address. The address must * (eventually) connect to the address specified by @a address. The address must
* live at least as long as @a pool (thus, as long as the connection object ). * live at least as long as @a pool (thus, as long as the connection object ).
* If a proxy server is configured, @address will be ignored. * If a proxy server is configured, @a address will be ignored.
* *
* The connection object will be allocated within @a pool. Clearing or * The connection object will be allocated within @a pool. Clearing or
* destroying this pool will close the connection, and terminate any * destroying this pool will close the connection, and terminate any
* outstanding requests or responses. * outstanding requests or responses.
* *
* When the connection is closed (upon request or because of an error), * When the connection is closed (upon request or because of an error),
* then the @a closed callback is invoked, and @a closed_baton is passed. * then the @a closed callback is invoked, and @a closed_baton is passed.
* *
* ### doc on setup(_baton). tweak below comment re: acceptor. * ### doc on setup(_baton). tweak below comment re: acceptor.
* NULL may be passed for @a acceptor and @a closed; default implementation s * NULL may be passed for @a acceptor and @a closed; default implementation s
* will be used. * will be used.
* *
* Note: the connection is not made immediately. It will be opened on * @note The connection is not made immediately. It will be opened on
* the next call to @see serf_context_run. * the next call to @see serf_context_run.
*/ */
serf_connection_t *serf_connection_create( serf_connection_t *serf_connection_create(
serf_context_t *ctx, serf_context_t *ctx,
apr_sockaddr_t *address, apr_sockaddr_t *address,
serf_connection_setup_t setup, serf_connection_setup_t setup,
void *setup_baton, void *setup_baton,
serf_connection_closed_t closed, serf_connection_closed_t closed,
void *closed_baton, void *closed_baton,
apr_pool_t *pool); apr_pool_t *pool);
/** /**
* Create a new connection associated with the @a ctx serf context. * Create a new connection associated with the @a ctx serf context.
* *
* Like @see serf_connection_create3 but with @a host_address set to @c NUL
L.
*/
apr_status_t serf_connection_create2(
serf_connection_t **conn,
serf_context_t *ctx,
apr_uri_t host_info,
serf_connection_setup_t setup,
void *setup_baton,
serf_connection_closed_t closed,
void *closed_baton,
apr_pool_t *pool);
/**
* Create a new connection associated with the @a ctx serf context.
*
* A connection will be created to (eventually) connect to the address * A connection will be created to (eventually) connect to the address
* specified by @a address. The address must live at least as long as * specified by @a address. The address must live at least as long as
* @a pool (thus, as long as the connection object). * @a pool (thus, as long as the connection object).
* *
* The host address will be looked up based on the hostname in @a host_info * If @a host_address is @c NULL, the host address will be looked up
. * based on the hostname in @a host_info; otherwise @a host_address
* will be used to connect and @a host_info will only be used for
* setting request headers.
* *
* The connection object will be allocated within @a pool. Clearing or * The connection object will be allocated within @a pool. Clearing or
* destroying this pool will close the connection, and terminate any * destroying this pool will close the connection, and terminate any
* outstanding requests or responses. * outstanding requests or responses.
* *
* When the connection is closed (upon request or because of an error), * When the connection is closed (upon request or because of an error),
* then the @a closed callback is invoked, and @a closed_baton is passed. * then the @a closed callback is invoked, and @a closed_baton is passed.
* *
* ### doc on setup(_baton). tweak below comment re: acceptor. * ### doc on setup(_baton). tweak below comment re: acceptor.
* NULL may be passed for @a acceptor and @a closed; default implementation s * NULL may be passed for @a acceptor and @a closed; default implementation s
* will be used. * will be used.
* *
* Note: the connection is not made immediately. It will be opened on * @note the connection is not made immediately. It will be opened on
* the next call to @see serf_context_run. * the next call to @see serf_context_run.
*/ */
apr_status_t serf_connection_create2( apr_status_t serf_connection_create3(
serf_connection_t **conn, serf_connection_t **conn,
serf_context_t *ctx, serf_context_t *ctx,
apr_uri_t host_info, apr_uri_t host_info,
apr_sockaddr_t *host_address,
serf_connection_setup_t setup, serf_connection_setup_t setup,
void *setup_baton, void *setup_baton,
serf_connection_closed_t closed, serf_connection_closed_t closed,
void *closed_baton, void *closed_baton,
apr_pool_t *pool); apr_pool_t *pool);
typedef apr_status_t (*serf_accept_client_t)( typedef apr_status_t (*serf_accept_client_t)(
serf_context_t *ctx, serf_context_t *ctx,
serf_listener_t *l, serf_listener_t *l,
void *accept_baton, void *accept_baton,
skipping to change at line 462 skipping to change at line 538
apr_status_t serf_listener_create( apr_status_t serf_listener_create(
serf_listener_t **listener, serf_listener_t **listener,
serf_context_t *ctx, serf_context_t *ctx,
const char *host, const char *host,
apr_uint16_t port, apr_uint16_t port,
void *accept_baton, void *accept_baton,
serf_accept_client_t accept_func, serf_accept_client_t accept_func,
apr_pool_t *pool); apr_pool_t *pool);
typedef apr_status_t (*serf_incoming_request_cb_t)( typedef apr_status_t (*serf_incoming_request_handler_t)(
serf_context_t *ctx, serf_incoming_request_t *req,
serf_bucket_t *request,
void *handler_baton,
apr_pool_t *pool);
typedef apr_status_t (*serf_incoming_response_setup_t)(
serf_bucket_t **resp_bkt,
serf_incoming_request_t *req,
void *setup_baton,
serf_bucket_alloc_t *allocator,
apr_pool_t *pool);
typedef apr_status_t (*serf_incoming_request_setup_t)(
serf_bucket_t **req_bkt,
serf_bucket_t *stream,
serf_incoming_request_t *req, serf_incoming_request_t *req,
void *request_baton, void *request_baton,
serf_incoming_request_handler_t *handler,
void **handler_baton,
serf_incoming_response_setup_t *response_setup,
void **response_setup_baton,
apr_pool_t *pool); apr_pool_t *pool);
/* ### Deprecated: can't do anything with request */
typedef apr_status_t(*serf_incoming_request_cb_t)(
serf_context_t *ctx,
serf_incoming_request_t *req,
void *request_baton,
apr_pool_t *pool);
/* ### Deprecated: Misses ssl support and actual
request handling. */
apr_status_t serf_incoming_create( apr_status_t serf_incoming_create(
serf_incoming_t **client, serf_incoming_t **client,
serf_context_t *ctx, serf_context_t *ctx,
apr_socket_t *insock, apr_socket_t *insock,
void *request_baton, void *request_baton,
serf_incoming_request_cb_t request, serf_incoming_request_cb_t request,
apr_pool_t *pool); apr_pool_t *pool);
/** /**
* Creates a new client associated with @a ctx for socket @a insock. The cl
ient
* takes responsibility for @a client_pool and will destroy it after the
* connection is closed. Typically this would be the same pool as where the
* incomming socket @a insock is allocated in.
*
* This non-standard behavior is needed to support listeners inside the sam
e
* @a ctx instance without leaking memory for each used connections. Caller
s
* might want to create a specific client pool if they use a non-standard
* listening pattern.
*
* Once the connection is setup @a setup will be called with @a setup_baton
* to setup the connection's bucket support.
*
* When the connection closed @a closed will be called with @a closed_baton
to
* notify that the client and its pool are about to be destroyed.
*
* Once the connection is fully setup incoming requests will be routed to @
a
* req_setup with @a req_setup_baton, to handle processing.
*
* @since New in 1.4.
*/
apr_status_t serf_incoming_create2(
serf_incoming_t **client,
serf_context_t *ctx,
apr_socket_t *insock,
serf_connection_setup_t setup,
void *setup_baton,
serf_incoming_closed_t closed,
void *closed_baton,
serf_incoming_request_setup_t req_setup,
void *req_setup_baton,
apr_pool_t *client_pool);
/* Allows creating a response before the request is completely
read. Will call the response create function if it hasn't
been called yet. */
apr_status_t serf_incoming_response_create(
serf_incoming_request_t *request);
/**
* Reset the connection, but re-open the socket again. * Reset the connection, but re-open the socket again.
*/ */
apr_status_t serf_connection_reset( apr_status_t serf_connection_reset(
serf_connection_t *conn); serf_connection_t *conn);
/** /**
* Close the connection associated with @a conn and cancel all pending requ ests. * Close the connection associated with @a conn and cancel all pending requ ests.
* *
* The closed callback passed to serf_connection_create() will be invoked * The closed callback passed to serf_connection_create() will be invoked
* with APR_SUCCESS. * with APR_SUCCESS.
skipping to change at line 510 skipping to change at line 653
serf_connection_t *conn, serf_connection_t *conn,
unsigned int max_requests); unsigned int max_requests);
void serf_connection_set_async_responses( void serf_connection_set_async_responses(
serf_connection_t *conn, serf_connection_t *conn,
serf_response_acceptor_t acceptor, serf_response_acceptor_t acceptor,
void *acceptor_baton, void *acceptor_baton,
serf_response_handler_t handler, serf_response_handler_t handler,
void *handler_baton); void *handler_baton);
typedef enum serf_connection_framing_type_t {
SERF_CONNECTION_FRAMING_TYPE_NONE = 0,
SERF_CONNECTION_FRAMING_TYPE_HTTP1,
SERF_CONNECTION_FRAMING_TYPE_HTTP2,
SERF_CONNECTION_FRAMING_TYPE_FCGI
} serf_connection_framing_type_t;
/**
* Sets the connection framing on the connection to the specified type. The
* NONE type specifies that the framing type is undetermined yet and no
* requests should be written to the connection until the framing type is
* set. Connections default to HTTP1 framing.
*
* @since New in 1.4.
*/
void serf_connection_set_framing_type(
serf_connection_t *conn,
serf_connection_framing_type_t framing_type);
/**
* @since New in 1.4.
*/
void serf_incoming_set_framing_type(
serf_incoming_t *client,
serf_connection_framing_type_t framing_type);
/** /**
* Setup the @a request for delivery on its connection. * Setup the @a request for delivery on its connection.
* *
* Right before this is invoked, @a pool will be built within the * Right before this is invoked, @a pool will be built within the
* connection's pool for the request to use. The associated response will * connection's pool for the request to use. The associated response will
* be allocated within that subpool. An associated bucket allocator will * be allocated within that subpool. An associated bucket allocator will
* be built. These items may be fetched from the request object through * be built. These items may be fetched from the request object through
* @see serf_request_get_pool or @see serf_request_get_alloc. * @see serf_request_get_pool or @see serf_request_get_alloc.
* *
* The content of the request is specified by the @a req_bkt bucket. When * The content of the request is specified by the @a req_bkt bucket. When
skipping to change at line 574 skipping to change at line 743
* with @see serf_request_cancel. * with @see serf_request_cancel.
* *
* Invoking any calls other than @see serf_request_cancel before the setup * Invoking any calls other than @see serf_request_cancel before the setup
* callback executes is not supported. * callback executes is not supported.
*/ */
serf_request_t *serf_connection_priority_request_create( serf_request_t *serf_connection_priority_request_create(
serf_connection_t *conn, serf_connection_t *conn,
serf_request_setup_t setup, serf_request_setup_t setup,
void *setup_baton); void *setup_baton);
/** The default request priority */
#define SERF_REQUEST_PRIORITY_DEFAULT 0x1000
/**
* Updates the request's priority information. Some protocol implementation
s,
* such as HTTP/2 may use this information for response scheduling. The
* actual behavior depends on the server, intermediate proxies and of cours
e
* the protocol implementation.
*
* It is recommended to prioritize a request before sending it to the serve
r,
* as that avoids race conditions and receiving unwanted results.
*
* If @a depends_on is set, then the request is marked as dependent on
* @a depends_on, and the result of @a request will only be received if
* no progress can be made on @a depends_on itself.
*
* @a priority is used to relatively prioritize multiple dependencies on th
e
* same target. Passing 0 will keep the original priority. In case of HTTP/
2
* this value is mapped to a 8 bit value by ignoring the lowest 8 bits.
*
* By default a request is created at priority SERF_REQUEST_PRIORITY_DEFAUL
T.
*
* If @a exclusive is set to TRUE, then all existing dependencies on @a
* depends_on will be updated to now depend on @a request, to make @a
* request the only dependency of @a request. When FALSE, request will just
* be added as a dependency.
*
* @since New in 1.4.
*/
void serf_connection_request_prioritize(serf_request_t *request,
serf_request_t *depends_on,
apr_uint16_t priority,
int exclusive);
/** Returns detected network latency for the @a conn connection. Negative /** Returns detected network latency for the @a conn connection. Negative
* value means that latency is unknwon. * value means that latency is unknwon.
*/ */
apr_interval_time_t serf_connection_get_latency(serf_connection_t *conn); apr_interval_time_t serf_connection_get_latency(serf_connection_t *conn);
/**
* Returns the number of requests waiting to be sent over connection CONN.
*/
unsigned int serf_connection_queued_requests(serf_connection_t *conn);
/**
* Returns the total number of requests for which a response hasn't been
* received yet on connection CONN. This includes requests:
* - that are queued but not sent.
* - that have been sent but no response has been completely received yet.
*/
unsigned int serf_connection_pending_requests(serf_connection_t *conn);
/** Check if a @a request has been completely written. /** Check if a @a request has been completely written.
* *
* Returns APR_SUCCESS if the request was written completely on the connect ion. * Returns APR_SUCCESS if the request was written completely on the connect ion.
* Returns APR_EBUSY if the request is not yet or partially written. * Returns APR_EBUSY if the request is not yet or partially written.
*/ */
apr_status_t serf_request_is_written( apr_status_t serf_request_is_written(
serf_request_t *request); serf_request_t *request);
/** /**
* Cancel the request specified by the @a request object. * Cancel the request specified by the @a request object.
skipping to change at line 689 skipping to change at line 905
apr_socket_t *skt, apr_socket_t *skt,
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
/** /**
* Create a bucket of type 'request bucket'. * Create a bucket of type 'request bucket'.
* This is basically a wrapper around @a serf_bucket_request_create, which * This is basically a wrapper around @a serf_bucket_request_create, which
* initializes the bucket using request, connection and/or context specific * initializes the bucket using request, connection and/or context specific
* settings. * settings.
* *
* This function will set following header(s): * This function will set following header(s):
* - Host: if the connection was created with @a serf_connection_create2. * - Host: if the connection was created with @see serf_connection_create2
* or @see serf_connection_create3
*/ */
serf_bucket_t *serf_request_bucket_request_create( serf_bucket_t *serf_request_bucket_request_create(
serf_request_t *request, serf_request_t *request,
const char *method, const char *method,
const char *uri, const char *uri,
serf_bucket_t *body, serf_bucket_t *body,
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
/** @} */ /** @} */
skipping to change at line 735 skipping to change at line 952
* Note: an alternative to using this symbol would be for callers to see * Note: an alternative to using this symbol would be for callers to see
* the SERF_NEWLINE_CR return value, and know that some "end of buffer" was * the SERF_NEWLINE_CR return value, and know that some "end of buffer" was
* reached. While this works well for @see serf_util_readline, it does not * reached. While this works well for @see serf_util_readline, it does not
* necessary work as well for buckets (there is no obvious "end of buffer", * necessary work as well for buckets (there is no obvious "end of buffer",
* although there is an "end of bucket"). The other problem with that * although there is an "end of bucket"). The other problem with that
* alternative is that developers might miss the condition. This symbol * alternative is that developers might miss the condition. This symbol
* calls out the possibility and ensures that callers will watch for it. * calls out the possibility and ensures that callers will watch for it.
*/ */
#define SERF_NEWLINE_CRLF_SPLIT 0x0010 #define SERF_NEWLINE_CRLF_SPLIT 0x0010
/** Used to indicate that length of remaining data in bucket is unknown. Se
e
* serf_bucket_type_t->get_remaining().
*/
#define SERF_LENGTH_UNKNOWN ((apr_uint64_t) -1)
struct serf_bucket_type_t { struct serf_bucket_type_t {
/** name of this bucket type */ /** name of this bucket type */
const char *name; const char *name;
/** /**
* Read (and consume) up to @a requested bytes from @a bucket. * Read (and consume) up to @a requested bytes from @a bucket.
* *
* A pointer to the data will be returned in @a data, and its length * A pointer to the data will be returned in @a data, and its length
* is specified by @a len. * is specified by @a len.
* *
* The data will exist until one of two conditions occur: * The data will exist until one of two conditions occur:
* *
* 1) this bucket is destroyed * 1) this bucket is destroyed
* 2) another call to any read function or to peek() * 2) another call to any read function, get_remaining() or to peek()
* *
* If an application needs the data to exist for a longer duration, * If an application needs the data to exist for a longer duration,
* then it must make a copy. * then it must make a copy.
*/ */
apr_status_t (*read)(serf_bucket_t *bucket, apr_size_t requested, apr_status_t (*read)(serf_bucket_t *bucket, apr_size_t requested,
const char **data, apr_size_t *len); const char **data, apr_size_t *len);
/** /**
* Read (and consume) a line of data from @a bucket. * Read (and consume) a line of data from @a bucket.
* *
* The acceptable forms of a newline are given by @a acceptable, and * The acceptable forms of a newline are given by @a acceptable, and
* the type found is returned in @a found. If a newline is not present * the type found is returned in @a found. If a newline is not present
* in the returned data, then SERF_NEWLINE_NONE is stored into @a found . * in the returned data, then SERF_NEWLINE_NONE is stored into @a found .
* *
* A pointer to the data is returned in @a data, and its length is * A pointer to the data is returned in @a data, and its length is
* specified by @a len. The data will include the newline, if present. * specified by @a len. The data will include the newline, if present.
* *
* Note that there is no way to limit the amount of data returned * Note that there is no way to limit the amount of data returned
* by this function. * by this function. @see serf_bucket_limited_readline().
* *
* The lifetime of the data is the same as that of the @see read * The lifetime of the data is the same as that of the @see read
* function above. * function above.
*/ */
apr_status_t (*readline)(serf_bucket_t *bucket, int acceptable, apr_status_t (*readline)(serf_bucket_t *bucket, int acceptable,
int *found, int *found,
const char **data, apr_size_t *len); const char **data, apr_size_t *len);
/** /**
* Read a set of pointer/length pairs from the bucket. * Read a set of pointer/length pairs from the bucket.
skipping to change at line 871 skipping to change at line 1093
* APR_EAGAIN will never be returned. * APR_EAGAIN will never be returned.
*/ */
apr_status_t (*peek)(serf_bucket_t *bucket, apr_status_t (*peek)(serf_bucket_t *bucket,
const char **data, apr_size_t *len); const char **data, apr_size_t *len);
/** /**
* Destroy @a bucket, along with any associated resources. * Destroy @a bucket, along with any associated resources.
*/ */
void (*destroy)(serf_bucket_t *bucket); void (*destroy)(serf_bucket_t *bucket);
/* The following members are valid only if read_bucket equals to
* serf_buckets_are_v2() (or in a future spec _v3, etc.). */
/* Real pointer to read_bucket() method when read_bucket is
* serf_buckets_are_v2().
*
* @since New in 1.4 / Buckets v2.
*/
serf_bucket_t * (*read_bucket_v2)(serf_bucket_t *bucket,
const serf_bucket_type_t *type);
/* Returns length of remaining data to be read in @a bucket. Returns
* SERF_LENGTH_UNKNOWN if length is unknown.
*
* @since New in 1.4 / Buckets v2.
*/
apr_uint64_t (*get_remaining)(serf_bucket_t *bucket);
/* Provides a reference to a config object containing all configuration
* values relevant for this bucket.
*
* @since New in 1.4 / Buckets v2
*/
apr_status_t (*set_config)(serf_bucket_t *bucket, serf_config_t *config
);
/* ### apr buckets have 'copy', 'split', and 'setaside' functions. /* ### apr buckets have 'copy', 'split', and 'setaside' functions.
### not sure whether those will be needed in this bucket model. ### not sure whether those will be needed in this bucket model.
*/ */
}; };
/** /**
* Should the use and lifecycle of buckets be tracked? * Should the use and lifecycle of buckets be tracked?
* *
* When tracking, the system will ensure several semantic requirements * When tracking, the system will ensure several semantic requirements
* of bucket use: * of bucket use:
skipping to change at line 897 skipping to change at line 1144
* - buckets should not be destroyed before they return APR_EOF unless * - buckets should not be destroyed before they return APR_EOF unless
* the connection is closed for some reason. * the connection is closed for some reason.
* *
* Undefine this symbol to avoid the tracking (and a performance gain). * Undefine this symbol to avoid the tracking (and a performance gain).
* *
* ### we may want to examine when/how we provide this. should it always * ### we may want to examine when/how we provide this. should it always
* ### be compiled in? and apps select it before including this header? * ### be compiled in? and apps select it before including this header?
*/ */
/* #define SERF_DEBUG_BUCKET_USE */ /* #define SERF_DEBUG_BUCKET_USE */
/* Predefined value for read_bucket vtable member to declare v2 buckets
* vtable.
*
* @since New in 1.4.
*/
serf_bucket_t * serf_buckets_are_v2(serf_bucket_t *bucket,
const serf_bucket_type_t *type);
/** Gets the serf bucket type of the bucket if the bucket implements at lea
st
* buckets version, or if not a bucket type providing a default implementat
ion
*
* @since New in 1.4.
*/
const serf_bucket_type_t *serf_get_type(serf_bucket_t *bucket,
int min_version);
/* Internal macros for tracking bucket use. */ /* Internal macros for tracking bucket use. */
#ifdef SERF_DEBUG_BUCKET_USE #ifdef SERF_DEBUG_BUCKET_USE
#define SERF__RECREAD(b,s) serf_debug__record_read(b,s) #define SERF__RECREAD(b,s) serf_debug__record_read(b,s)
#else #else
#define SERF__RECREAD(b,s) (s) #define SERF__RECREAD(b,s) (s)
#endif #endif
#define serf_bucket_read(b,r,d,l) SERF__RECREAD(b, (b)->type->read(b,r,d,l) ) #define serf_bucket_read(b,r,d,l) SERF__RECREAD(b, (b)->type->read(b,r,d,l) )
#define serf_bucket_readline(b,a,f,d,l) \ #define serf_bucket_readline(b,a,f,d,l) \
SERF__RECREAD(b, (b)->type->readline(b,a,f,d,l)) SERF__RECREAD(b, (b)->type->readline(b,a,f,d,l))
#define serf_bucket_read_iovec(b,r,s,v,u) \ #define serf_bucket_read_iovec(b,r,s,v,u) \
SERF__RECREAD(b, (b)->type->read_iovec(b,r,s,v,u)) SERF__RECREAD(b, (b)->type->read_iovec(b,r,s,v,u))
#define serf_bucket_read_for_sendfile(b,r,h,f,o,l) \ #define serf_bucket_read_for_sendfile(b,r,h,f,o,l) \
SERF__RECREAD(b, (b)->type->read_for_sendfile(b,r,h,f,o,l)) SERF__RECREAD(b, (b)->type->read_for_sendfile(b,r,h,f,o,l))
#define serf_bucket_read_bucket(b,t) ((b)->type->read_bucket(b,t)) #define serf_bucket_read_bucket(b,t) ((b)->type->read_bucket(b,t))
#define serf_bucket_peek(b,d,l) ((b)->type->peek(b,d,l)) #define serf_bucket_peek(b,d,l) ((b)->type->peek(b,d,l))
#define serf_bucket_destroy(b) ((b)->type->destroy(b)) #define serf_bucket_destroy(b) ((b)->type->destroy(b))
#define serf_bucket_get_remaining(b) (serf_get_type(b, 2)->get_remaining(b)
)
#define serf_bucket_set_config(b,c) (serf_get_type(b, 2)->set_config(b, c))
/** /**
* Check whether a real error occurred. Note that bucket read functions * Check whether a real error occurred. Note that bucket read functions
* can return EOF and EAGAIN as part of their "normal" operation, so they * can return EOF and EAGAIN as part of their "normal" operation, so they
* should not be considered an error. * should not be considered an error.
*/ */
#define SERF_BUCKET_READ_ERROR(status) ((status) \ #define SERF_BUCKET_READ_ERROR(status) ((status) \
&& !APR_STATUS_IS_EOF(status) \ && !APR_STATUS_IS_EOF(status) \
&& !APR_STATUS_IS_EAGAIN(status) \ && !APR_STATUS_IS_EAGAIN(status) \
&& (SERF_ERROR_WAIT_CONN != status) ) && (SERF_ERROR_WAIT_CONN != status) )
skipping to change at line 942 skipping to change at line 1207
/** the allocator used for this bucket (needed at destroy time) */ /** the allocator used for this bucket (needed at destroy time) */
serf_bucket_alloc_t *allocator; serf_bucket_alloc_t *allocator;
}; };
/** /**
* Generic macro to construct "is TYPE" macros. * Generic macro to construct "is TYPE" macros.
*/ */
#define SERF_BUCKET_CHECK(b, btype) ((b)->type == &serf_bucket_type_ ## bty pe) #define SERF_BUCKET_CHECK(b, btype) ((b)->type == &serf_bucket_type_ ## bty pe)
/** @} */
/** /**
* Notification callback for a block that was not returned to the bucket * Notification callback for a block that was not returned to the bucket
* allocator when its pool was destroyed. * allocator when its pool was destroyed.
* *
* The block of memory is given by @a block. The baton provided when the * The block of memory is given by @a block. The baton provided when the
* allocator was constructed is passed as @a unfreed_baton. * allocator was constructed is passed as @a unfreed_baton.
*/ */
typedef void (*serf_unfreed_func_t)( typedef void (*serf_unfreed_func_t)(
void *unfreed_baton, void *unfreed_baton,
void *block); void *block);
skipping to change at line 1000 skipping to change at line 1267
* Since it is entirely possible for a line to be broken by APR_EAGAIN, * Since it is entirely possible for a line to be broken by APR_EAGAIN,
* this structure can be used to accumulate the data until a complete line * this structure can be used to accumulate the data until a complete line
* has been read from a bucket. * has been read from a bucket.
*/ */
/* This limit applies to the line buffer functions. If an application needs /* This limit applies to the line buffer functions. If an application needs
* longer lines, then they will need to manually handle line buffering. * longer lines, then they will need to manually handle line buffering.
*/ */
#define SERF_LINEBUF_LIMIT 8000 #define SERF_LINEBUF_LIMIT 8000
typedef struct { typedef struct serf_linebuf_t {
/* Current state of the buffer. */ /* Current state of the buffer. */
enum { enum {
SERF_LINEBUF_EMPTY, SERF_LINEBUF_EMPTY,
SERF_LINEBUF_READY, SERF_LINEBUF_READY,
SERF_LINEBUF_PARTIAL, SERF_LINEBUF_PARTIAL,
SERF_LINEBUF_CRLF_SPLIT SERF_LINEBUF_CRLF_SPLIT
} state; } state;
/* How much of the buffer have we used? */ /* How much of the buffer have we used? */
apr_size_t used; apr_size_t used;
/* The line is read into this buffer, minus CR/LF */ /* The line is read into this buffer, minus CR/LF.
*
* NOTE: Before serf 2.0 buffer IS NOT NUL terminated
* and @a used should be used to find line length.
*
* Since serf 2.0 buffer is always NUL terminated.
**/
char line[SERF_LINEBUF_LIMIT]; char line[SERF_LINEBUF_LIMIT];
} serf_linebuf_t; } serf_linebuf_t;
/** /**
* Initialize the @a linebuf structure. * Initialize the @a linebuf structure.
*/ */
void serf_linebuf_init(serf_linebuf_t *linebuf); void serf_linebuf_init(serf_linebuf_t *linebuf);
/** /**
skipping to change at line 1036 skipping to change at line 1309
* acceptable for this fetch. * acceptable for this fetch.
* *
* ### we should return a data/len pair so that we can avoid a copy, * ### we should return a data/len pair so that we can avoid a copy,
* ### rather than having callers look into our state and line buffer. * ### rather than having callers look into our state and line buffer.
*/ */
apr_status_t serf_linebuf_fetch( apr_status_t serf_linebuf_fetch(
serf_linebuf_t *linebuf, serf_linebuf_t *linebuf,
serf_bucket_t *bucket, serf_bucket_t *bucket,
int acceptable); int acceptable);
/*** Configuration store declarations ***/
typedef const apr_uint32_t serf_config_key_t;
/* The left-most byte of the int32 key holds the category (bit flags).
The other bytes are a number representing the key.
Serf will not use the second byte for its own keys, so applications can
use this byte to define custom keys.
*/
typedef enum serf_config_categories_t {
SERF_CONFIG_PER_CONTEXT = 0x10000000,
SERF_CONFIG_PER_HOST = 0x20000000,
SERF_CONFIG_PER_CONNECTION = 0x40000000,
} serf_config_categories_t;
#define SERF_CONFIG_HOST_NAME (SERF_CONFIG_PER_HOST | 0x000001)
#define SERF_CONFIG_HOST_PORT (SERF_CONFIG_PER_HOST | 0x000002)
#define SERF_CONFIG_CONN_LOCALIP (SERF_CONFIG_PER_CONNECTION | 0x000001)
#define SERF_CONFIG_CONN_REMOTEIP (SERF_CONFIG_PER_CONNECTION | 0x000002)
#define SERF_CONFIG_CONN_PIPELINING (SERF_CONFIG_PER_CONNECTION | 0x000003)
#define SERF_CONFIG_CTX_LOGBATON (SERF_CONFIG_PER_CONTEXT | 0x000001)
/* Configuration values stored in the configuration store:
Category Key Value Type
-------- --- ----------
Context logbaton log_baton_t *
Context proxyauthn apr_hash_t * (not implemented)
Connection localip const char *
Connection remoteip const char *
Host hostname const char *
Host hostport const char *
Host authn apr_hash_t * (not implemented)
*/
/* Set a value of type const char * for configuration item CATEGORY+KEY.
@since New in 1.4.
*/
apr_status_t serf_config_set_string(serf_config_t *config,
serf_config_key_t key,
const char *value);
/* Copy a value of type const char * and set it for configuration item
CATEGORY+KEY.
@since New in 1.4.
*/
apr_status_t serf_config_set_stringc(serf_config_t *config,
serf_config_key_t key,
const char *value);
/* Set a value of generic type for configuration item CATEGORY+KEY.
See @a serf_set_config_string for COPY_FLAGS description.
@since New in 1.4.
*/
apr_status_t serf_config_set_stringf(serf_config_t *config,
serf_config_key_t key,
apr_pool_t *scratch_pool,
const char *fmt, ...);
/* Set a value of generic type for configuration item CATEGORY+KEY.
See @a serf_set_config_string for COPY_FLAGS description.
@since New in 1.4.
*/
apr_status_t serf_config_set_object(serf_config_t *config,
serf_config_key_t key,
void *value);
/* Get the value for configuration item CATEGORY+KEY. The value's type will
be fixed, see the above table.
Returns APR_EINVAL when getting a key from a category that this config
object doesn't contain, APR_SUCCESS otherwise.
@since New in 1.4.
*/
apr_status_t serf_config_get_string(serf_config_t *config,
serf_config_key_t key,
const char **value);
apr_status_t serf_config_get_object(serf_config_t *config,
serf_config_key_t key,
void **value);
/* Remove the value for configuration item CATEGORY+KEY from the configurat
ion
store.
@since New in 1.4.
*/
apr_status_t serf_config_remove_value(serf_config_t *config,
serf_config_key_t key);
/*** Serf logging API ***/
/* Ordered list of log levels, more detailed log levels include less
detailed levels. (e.g. level DEBUG also logs ERROR, WARNING & INFO messa
ges).
*/
#define SERF_LOG_ERROR 0x0001
#define SERF_LOG_WARNING 0x0002
#define SERF_LOG_INFO 0x0004
#define SERF_LOG_DEBUG 0x0008
#define SERF_LOG_NONE 0x0000
/* List of components, used as a mask. */
#define SERF_LOGCOMP_ALL_MSG 0xFFFF /* All components, including message
content */
#define SERF_LOGCOMP_RAWMSG 0x0100 /* logs requests and responses directl
y on
the socket layer. */
#define SERF_LOGCOMP_SSLMSG 0x0200 /* logs decrypted requests and respons
es. */
#define SERF_LOGCOMP_ALL 0x00FF /* All components, no message content
*/
#define SERF_LOGCOMP_SSL 0x0001 /* The SSL component */
#define SERF_LOGCOMP_AUTHN 0x0002 /* Authentication components */
#define SERF_LOGCOMP_CONN 0x0004 /* Connection-related events */
#define SERF_LOGCOMP_COMPR 0x0008 /* The compression (deflate) component
*/
#define SERF_LOGCOMP_PROTOCOL 0x0010 /* The protocol components */
#define SERF_LOGCOMP_NONE 0x0000
typedef struct serf_log_output_t serf_log_output_t;
typedef struct serf_log_layout_t serf_log_layout_t;
/* The default log layout. It's format is:
[TIMESTAMP] [LOG LEVEL] [l:LOCALIP:PORT r:REMOTEIP:PORT] FILENAME MESSAG
E
*/
#define SERF_LOG_DEFAULT_LAYOUT ((serf_log_layout_t *)NULL)
/* TODO: it's not yet possible to define custom layouts */
/* Create a stream output for log info. This can be used with one of the
standard streams stderr or stdout.
LAYOUT should be SERF_LOG_DEFAULT_LAYOUT (there's no alternative for now
).
The lifetime of POOL should be atleast the same as that of CTX, but it c
an
be used by multiple contexts. */
apr_status_t serf_logging_create_stream_output(serf_log_output_t **output,
serf_context_t *ctx,
apr_uint32_t level,
apr_uint32_t comp_mask,
serf_log_layout_t *layout,
FILE *fp,
apr_pool_t *pool);
/* Define an output handler for a log level and a (set of) log component(s)
.
OUTPUT is the object returned by one of the serf_logging_create_XXX_outp
ut
factory functions. */
apr_status_t serf_logging_add_output(serf_context_t *ctx,
const serf_log_output_t *output);
/*** Connection and protocol API v2 ***/
#if 0
/* ### docco. */
apr_status_t serf_connection_switch_protocol(
serf_connection_t *conn,
serf_protocol_t *proto
/* ### other params? */
);
/* ### docco. */
typedef struct serf_queue_item_t serf_queue_item_t;
/**
* Present a response to the application.
*
* Called when a response has been processed by the current protocol (to an
y
* extent necessary) and is ready for the application to handle.
*
* Note: @a request may be NULL if this response is server-pushed rather th
an
* specifically requested.
*/
typedef apr_status_t (*serf_begin_response_t)(
/* ### args not settled */
void **handler_baton,
serf_request_t *request,
serf_bucket_t *response,
apr_pool_t *scratch_pool);
/* ### better name? */
typedef apr_status_t (*serf_handler_t)(
/* ### args not settled */
void *handler_baton,
serf_bucket_t *response,
apr_pool_t *scratch_pool);
struct serf_protocol_type_t {
/** Name of this protocol type. */
const char *name;
/** Vtable version. */
int version;
#define SERF_PROTOCOL_TYPE_VERSION 1
/**
* When a pending request reaches the front of the queue, then it becom
es
* "active". This callback is used to build/provide the protocol-specif
ic
* request bucket.
*
* ### more docco
*/
apr_status_t (*serf_request_activate_t)(
serf_bucket_t **request_bkt,
serf_queue_item_t *request_qi,
void *request_baton,
serf_bucket_alloc_t *request_bktalloc,
apr_pool_t *scratch_pool);
/**
* Construct a protocol parsing bucket, for passing to the process_data
* vtable entry.
*
* When data arrives on the connection, and a parser is not already
* processing the connection's data, then build a new bucket to parse
* this incoming data (according to the protocol).
*/
serf_bucket_t * (*build_parser)(serf_protocol_t *proto,
apr_pool_t *scratch_pool);
/**
* The protocol should parse all available response data, per the proto
col.
*
* This is called when data has become available to the parser. The pro
tocol
* should read all available data before returning.
*/
apr_status_t (*process_data)(serf_protocol_t *proto,
serf_bucket_t *parser,
apr_pool_t *scratch_pool);
};
/**
* Activate an HTTP request when it reaches the front of the queue.
*
* ### more docco
*/
typedef apr_status_t (*serf_http_activate_t)(
serf_bucket_t **body_bkt,
serf_bucket_t *request_bkt, /* type REQUEST */
serf_queue_item_t *request_qi,
void *request_baton,
serf_bucket_alloc_t *request_bktalloc,
apr_pool_t *scratch_pool);
/**
* Create a new connection and associated HTTP protocol parser.
*
* The new connection/protocol will be associated with @a ctx. It will be
* opened once a request is placed into its outgoing queue. The connection
* will use @a hostname and @a port for the origin server. If
* @a proxy_hostname is not NULL, then all requests will go through the
* proxy specified by @a proxy_hostname and @a proxy_port.
*
* DNS lookups for @a hostname and @a proxy_hostname will be performed
* when the connection first opened, then cached in case the connection
* ever needs to be re-opened.
*
* When a queued request reaches the front of the queue, and is ready for
* delivery, then @a activate_cb will be called to prepare the request.
*
* @a authn_types specifies the types of authentication allowed on this
* connection. Normally, it should be SERF_AUTHN_ALL. When authentication
* credentials are required (for the origin server or the proxy), then
* @a creds_cb will be called with @a app_baton.
*
* When the connection is closed (upon request or because of an error),
* then @a closed_cb will be called with @a app_baton.
*
* The connection and protocol paresr will be allocated in @a result_pool.
* This function will use @a scratch_pool for temporary allocations.
*/
apr_status_t serf_http_protocol_create(
serf_protocol_t **proto,
serf_context_t *ctx,
const char *hostname,
int port,
const char *proxy_hostname,
int proxy_port,
int authn_types,
serf_http_activate_t activate_cb,
/* ### do we need different params for CREDS_CB and CLOSED_CB ? */
serf_credentials_callback_t creds_cb,
serf_connection_closed_t closed_cb,
void *app_baton,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
/* ### docco. create http proto parser with an encrypted connection. */
apr_status_t serf_https_protocol_create(
serf_protocol_t **proto,
serf_context_t *ctx,
const char *hostname,
int port,
/* ### client certs, credential validation callbacks, etc */
serf_connection_closed_t closed,
void *closed_baton,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
/* ### docco. queue up an http request. */
serf_queue_item_t *serf_http_request_queue(
serf_protocol_t *proto,
int priority,
void *request_baton);
/**
* ### rationalize against "serf connections and request" group above
*
* @defgroup serf connections
* @ingroup serf
* @{
*/
struct serf_connection_type_t {
/** Name of this connection type. */
const char *name;
/** Vtable version. */
int version;
#define SERF_CONNECTION_TYPE_VERSION 1
/**
* Initiate a connection to the server.
*
* ### docco. note async. note that request(s) may be queued.
* ### can we somehow defer the SSL tunnel's CONNECT to the higher
* ### layer? then have the HTTP protocol layer wrap a CONN_PLAIN
* ### into a CONN_TLS connection once the tunnel is established?
*/
apr_status_t (*connect)(serf_connection_t *conn);
/**
* Returns a bucket for reading from this connection.
*
* This bucket remains constant for the lifetime of the connection. It
has
* built-in BARRIER bucket protection, so it can safely be "destroyed"
* without problem (and a later call to this vtable function will retur
n
* the same bucket again).
*
* For all intents and purposes, this bucket is borrowed by the caller.
*
* This bucket effectively maps to the underlying socket, or possibly t
o
* a decrypting bucket layered over the socket.
*/
serf_bucket_t * (*get_read_bucket)(serf_connection_t *conn);
/**
* Write some data into into the connection.
*
* Attempt to write a number of iovecs into the connection. The number
of
* vectors *completely* written will be returned in @a vecs_written. If
that
* equals @a vecs_size, then @a last_written will be set to 0. If it is
less
* (not all iovecs were written), then the amount written from the next
,
* incompletely written iovec is returned in @a last_written.
*
* In other words, the first byte of unwritten content is located at:
*
* <pre>
* first = vecs[vecs_written][last_written];
* </pre>
*
* If all bytes are written, then APR_SUCCESS is returned. If only a po
rtion
* was written, then APR_EAGAIN will be returned.
*/
apr_status_t (*writev)(serf_connection_t *conn,
int vecs_size, struct iovec *vecs,
int *vecs_written, apr_size_t *last_written);
};
#endif /* Connection and protocol API v2 */
/** @} */ /** @} */
/* Internal functions for bucket use and lifecycle tracking */ /* Internal functions for bucket use and lifecycle tracking */
apr_status_t serf_debug__record_read( apr_status_t serf_debug__record_read(
const serf_bucket_t *bucket, const serf_bucket_t *bucket,
apr_status_t status); apr_status_t status);
void serf_debug__entered_loop( void serf_debug__entered_loop(
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
void serf_debug__closed_conn( void serf_debug__closed_conn(
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
void serf_debug__bucket_destroy( void serf_debug__bucket_destroy(
const serf_bucket_t *bucket); const serf_bucket_t *bucket);
void serf_debug__bucket_alloc_check( void serf_debug__bucket_alloc_check(
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
/* Version info */ /* Version info */
#define SERF_MAJOR_VERSION 1 #define SERF_MAJOR_VERSION 2
#define SERF_MINOR_VERSION 3 #define SERF_MINOR_VERSION 0
#define SERF_PATCH_VERSION 9 #define SERF_PATCH_VERSION 0
/* Version number string */ /* Version number string */
#define SERF_VERSION_STRING APR_STRINGIFY(SERF_MAJOR_VERSION) "." \ #define SERF_VERSION_STRING APR_STRINGIFY(SERF_MAJOR_VERSION) "." \
APR_STRINGIFY(SERF_MINOR_VERSION) "." \ APR_STRINGIFY(SERF_MINOR_VERSION) "." \
APR_STRINGIFY(SERF_PATCH_VERSION) APR_STRINGIFY(SERF_PATCH_VERSION)
/** /**
* Check at compile time if the Serf version is at least a certain * Check at compile time if the Serf version is at least a certain
* level. * level.
* @param major The major version component of the version checked * @param major The major version component of the version checked
 End of changes. 31 change blocks. 
16 lines changed or deleted 692 lines changed or added


 serf_bucket_types.h (1.3.9)   serf_bucket_types.h (current) 
skipping to change at line 62 skipping to change at line 62
/* Send a Content-Length header with @a len. The @a body bucket should /* Send a Content-Length header with @a len. The @a body bucket should
contain precisely that much data. */ contain precisely that much data. */
void serf_bucket_request_set_CL( void serf_bucket_request_set_CL(
serf_bucket_t *bucket, serf_bucket_t *bucket,
apr_int64_t len); apr_int64_t len);
serf_bucket_t *serf_bucket_request_get_headers( serf_bucket_t *serf_bucket_request_get_headers(
serf_bucket_t *request); serf_bucket_t *request);
/** Transform @a bucket in-place into a request bucket.
*
* It is callers responsibility to free resources held by the original
* bucket */
void serf_bucket_request_become( void serf_bucket_request_become(
serf_bucket_t *bucket, serf_bucket_t *bucket,
const char *method, const char *method,
const char *uri, const char *uri,
serf_bucket_t *body); serf_bucket_t *body);
/** /**
* Sets the root url of the remote host. If this request contains a relativ e * Sets the root url of the remote host. If this request contains a relativ e
* url, it will be prefixed with the root url to form an absolute url. * url, it will be prefixed with the root url to form an absolute url.
* @a bucket is the request bucket. @a root_url is the absolute url of the * @a bucket is the request bucket. @a root_url is the absolute url of the
* root of the remote host, without the closing '/'. * root of the remote host, without the closing '/'.
*/ */
void serf_bucket_request_set_root( void serf_bucket_request_set_root(
serf_bucket_t *bucket, serf_bucket_t *bucket,
const char *root_url); const char *root_url);
/* ==================================================================== */ /* ==================================================================== */
extern const serf_bucket_type_t serf_bucket_type_incoming_request;
#define SERF_BUCKET_IS_INCOMING_REQUEST(b) \
SERF_BUCKET_CHECK((b), incoming_request)
serf_bucket_t *serf_bucket_incoming_request_create(
serf_bucket_t *body,
serf_bucket_alloc_t *allocator);
/* All output arguments optional. Waits for the request line to have arrive
d
with the normal read responses. */
/* ### Add RESULT_POOL argument? */
apr_status_t serf_bucket_incoming_request_read(
serf_bucket_t **headers,
const char **method,
const char **path,
int *http_version,
serf_bucket_t *request);
apr_status_t serf_bucket_incoming_request_wait_for_headers(
serf_bucket_t *response);
/* ==================================================================== */
extern const serf_bucket_type_t serf_bucket_type_response; extern const serf_bucket_type_t serf_bucket_type_response;
#define SERF_BUCKET_IS_RESPONSE(b) SERF_BUCKET_CHECK((b), response) #define SERF_BUCKET_IS_RESPONSE(b) SERF_BUCKET_CHECK((b), response)
serf_bucket_t *serf_bucket_response_create( serf_bucket_t *serf_bucket_response_create(
serf_bucket_t *stream, serf_bucket_t *stream,
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
#define SERF_HTTP_VERSION(major, minor) ((major) * 1000 + (minor)) #define SERF_HTTP_VERSION(major, minor) ((major) * 1000 + (minor))
#define SERF_HTTP_11 SERF_HTTP_VERSION(1, 1) #define SERF_HTTP_11 SERF_HTTP_VERSION(1, 1)
#define SERF_HTTP_10 SERF_HTTP_VERSION(1, 0) #define SERF_HTTP_10 SERF_HTTP_VERSION(1, 0)
/** @since New in 1.4. */
#define SERF_HTTP_20 SERF_HTTP_VERSION(2, 0)
#define SERF_HTTP_VERSION_MAJOR(shv) ((int)shv / 1000) #define SERF_HTTP_VERSION_MAJOR(shv) ((int)shv / 1000)
#define SERF_HTTP_VERSION_MINOR(shv) ((int)shv % 1000) #define SERF_HTTP_VERSION_MINOR(shv) ((int)shv % 1000)
typedef struct { typedef struct serf_status_line {
int version; int version;
int code; int code;
const char *reason; const char *reason;
} serf_status_line; } serf_status_line;
/** /**
* Return the Status-Line information, if available. This function * Return the Status-Line information, if available. This function
* works like other bucket read functions: it may return APR_EAGAIN or * works like other bucket read functions: it may return APR_EAGAIN or
* APR_EOF to signal the state of the bucket for reading. A return * APR_EOF to signal the state of the bucket for reading. A return
* value of APR_SUCCESS will always indicate that status line * value of APR_SUCCESS will always indicate that status line
skipping to change at line 122 skipping to change at line 151
/** /**
* Wait for the HTTP headers to be processed for a @a response. * Wait for the HTTP headers to be processed for a @a response.
* *
* If the headers are available, APR_SUCCESS is returned. * If the headers are available, APR_SUCCESS is returned.
* If the headers aren't available, APR_EAGAIN is returned. * If the headers aren't available, APR_EAGAIN is returned.
*/ */
apr_status_t serf_bucket_response_wait_for_headers( apr_status_t serf_bucket_response_wait_for_headers(
serf_bucket_t *response); serf_bucket_t *response);
/** /**
* Wait for the first HTTP headers to be processed for a @a response.
* If 1XX informational responses are received before the actual headers
* this function will return APR_SUCCESS as soon as such a set is processed
,
* while serf_bucket_response_wait_for_headers() will wait until the
* actual headers to be available.
*
* If @a wait_for_next is TRUE, the function will wait for the next set
* of informational header instead of returning success for the first set.
*
* @since New in 1.4.
*/
apr_status_t serf_bucket_response_wait_for_some_headers(
serf_bucket_t *response,
int wait_for_next);
/**
* Get the headers bucket for @a response. * Get the headers bucket for @a response.
*/ */
serf_bucket_t *serf_bucket_response_get_headers( serf_bucket_t *serf_bucket_response_get_headers(
serf_bucket_t *response); serf_bucket_t *response);
/** /**
* Advise the response @a bucket that this was from a HEAD request and * Advise the response @a bucket that this was from a HEAD request and
* that it should not expect to see a response body. * that it should not expect to see a response body.
*/ */
void serf_bucket_response_set_head( void serf_bucket_response_set_head(
serf_bucket_t *bucket); serf_bucket_t *bucket);
/**
* Ask the response @a bucket, to decode content based on the value of the
* 'Content- Encoding' header, or not. The default setting of a response
* bucket is to decode when the header is found.
*/
void serf_bucket_response_decode_content(
serf_bucket_t *bucket,
int decode);
/* ==================================================================== */ /* ==================================================================== */
extern const serf_bucket_type_t serf_bucket_type_response_body; extern const serf_bucket_type_t serf_bucket_type_response_body;
#define SERF_BUCKET_IS_RESPONSE_BODY(b) SERF_BUCKET_CHECK((b), response_bod y) #define SERF_BUCKET_IS_RESPONSE_BODY(b) SERF_BUCKET_CHECK((b), response_bod y)
serf_bucket_t *serf_bucket_response_body_create( serf_bucket_t *serf_bucket_response_body_create(
serf_bucket_t *stream, serf_bucket_t *stream,
apr_uint64_t limit, apr_uint64_t limit,
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
/* ==================================================================== */ /* ==================================================================== */
/** @since New in 1.4 */
extern const serf_bucket_type_t serf_bucket_type_outgoing_response;
/** @since New in 1.4 */
#define SERF_BUCKET_IS_OUTGOING_RESPONSE(b) \
SERF_BUCKET_CHECK((b), outgoing_response)
/** @since New in 1.4 */
serf_bucket_t *serf_bucket_outgoing_response_create(
serf_bucket_t *body,
int status,
const char *reason,
int http_version,
serf_bucket_alloc_t *allocator);
/** @since New in 1.4 */
serf_bucket_t *serf_bucket_outgoing_response_get_headers(
serf_bucket_t *outgoing_response);
/** @since New in 1.4 */
void serf_bucket_outgoing_response_prepare(
serf_bucket_t *outgoing_response,
int http_version,
int allow_chunking);
/* ==================================================================== */
extern const serf_bucket_type_t serf_bucket_type_bwtp_frame; extern const serf_bucket_type_t serf_bucket_type_bwtp_frame;
#define SERF_BUCKET_IS_BWTP_FRAME(b) SERF_BUCKET_CHECK((b), bwtp_frame) #define SERF_BUCKET_IS_BWTP_FRAME(b) SERF_BUCKET_CHECK((b), bwtp_frame)
extern const serf_bucket_type_t serf_bucket_type_bwtp_incoming_frame; extern const serf_bucket_type_t serf_bucket_type_bwtp_incoming_frame;
#define SERF_BUCKET_IS_BWTP_INCOMING_FRAME(b) SERF_BUCKET_CHECK((b), bwtp_i ncoming_frame) #define SERF_BUCKET_IS_BWTP_INCOMING_FRAME(b) SERF_BUCKET_CHECK((b), bwtp_i ncoming_frame)
int serf_bucket_bwtp_frame_get_channel( int serf_bucket_bwtp_frame_get_channel(
serf_bucket_t *hdr); serf_bucket_t *hdr);
skipping to change at line 209 skipping to change at line 288
/** serf_bucket_aggregate_cleanup will instantly destroy all buckets in /** serf_bucket_aggregate_cleanup will instantly destroy all buckets in
the aggregate bucket that have been read completely. Whereas normally, the aggregate bucket that have been read completely. Whereas normally,
these buckets are destroyed on every read operation. */ these buckets are destroyed on every read operation. */
void serf_bucket_aggregate_cleanup( void serf_bucket_aggregate_cleanup(
serf_bucket_t *bucket, serf_bucket_t *bucket,
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
serf_bucket_t *serf_bucket_aggregate_create( serf_bucket_t *serf_bucket_aggregate_create(
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
/* Creates a stream bucket. /** Transform @a bucket in-place into an aggregate bucket.
A stream bucket is like an aggregate bucket, but: *
- it doesn't destroy its child buckets on cleanup * It is callers responsibility to free resources held by the original
- one can always keep adding child buckets, the handler FN should return * bucket */
APR_EOF when no more buckets will be added.
Note: keep this factory function internal for now. If it turns out this
bucket type is useful outside serf, we should make it an actual separate
type.
*/
serf_bucket_t *serf__bucket_stream_create(
serf_bucket_alloc_t *allocator,
serf_bucket_aggregate_eof_t fn,
void *baton);
/** Transform @a bucket in-place into an aggregate bucket. */
void serf_bucket_aggregate_become( void serf_bucket_aggregate_become(
serf_bucket_t *bucket); serf_bucket_t *bucket);
void serf_bucket_aggregate_prepend( void serf_bucket_aggregate_prepend(
serf_bucket_t *aggregate_bucket, serf_bucket_t *aggregate_bucket,
serf_bucket_t *prepend_bucket); serf_bucket_t *prepend_bucket);
void serf_bucket_aggregate_append( void serf_bucket_aggregate_append(
serf_bucket_t *aggregate_bucket, serf_bucket_t *aggregate_bucket,
serf_bucket_t *append_bucket); serf_bucket_t *append_bucket);
skipping to change at line 318 skipping to change at line 385
* Equivalent to serf_bucket_simple_create, except that the bucket assumes * Equivalent to serf_bucket_simple_create, except that the bucket assumes
* responsibility for freeing the data on this allocator without making * responsibility for freeing the data on this allocator without making
* a copy. It is assumed that data was created by a call from allocator. * a copy. It is assumed that data was created by a call from allocator.
*/ */
serf_bucket_t *serf_bucket_simple_own_create( serf_bucket_t *serf_bucket_simple_own_create(
const char *data, const char *data,
apr_size_t len, apr_size_t len,
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
#define SERF_BUCKET_SIMPLE_STRING(s,a) \ #define SERF_BUCKET_SIMPLE_STRING(s,a) \
serf_bucket_simple_create(s, strlen(s), NULL, NULL, a); serf_bucket_simple_create(s, strlen(s), NULL, NULL, a)
#define SERF_BUCKET_SIMPLE_STRING_LEN(s,l,a) \ #define SERF_BUCKET_SIMPLE_STRING_LEN(s,l,a) \
serf_bucket_simple_create(s, l, NULL, NULL, a); serf_bucket_simple_create(s, l, NULL, NULL, a)
/* ==================================================================== */ /* ==================================================================== */
/* Note: apr_mmap_t is always defined, but if APR doesn't have mmaps, then /* Note: apr_mmap_t is always defined, but if APR doesn't have mmaps, then
the caller can never create an apr_mmap_t to pass to this function. */ the caller can never create an apr_mmap_t to pass to this function. */
extern const serf_bucket_type_t serf_bucket_type_mmap; extern const serf_bucket_type_t serf_bucket_type_mmap;
#define SERF_BUCKET_IS_MMAP(b) SERF_BUCKET_CHECK((b), mmap) #define SERF_BUCKET_IS_MMAP(b) SERF_BUCKET_CHECK((b), mmap)
serf_bucket_t *serf_bucket_mmap_create( serf_bucket_t *serf_bucket_mmap_create(
skipping to change at line 465 skipping to change at line 532
#define SERF_BUCKET_IS_DEFLATE(b) SERF_BUCKET_CHECK((b), deflate) #define SERF_BUCKET_IS_DEFLATE(b) SERF_BUCKET_CHECK((b), deflate)
#define SERF_DEFLATE_GZIP 0 #define SERF_DEFLATE_GZIP 0
#define SERF_DEFLATE_DEFLATE 1 #define SERF_DEFLATE_DEFLATE 1
serf_bucket_t *serf_bucket_deflate_create( serf_bucket_t *serf_bucket_deflate_create(
serf_bucket_t *stream, serf_bucket_t *stream,
serf_bucket_alloc_t *allocator, serf_bucket_alloc_t *allocator,
int format); int format);
serf_bucket_t *serf_bucket_deflate_compress_create(
serf_bucket_t *stream,
int memlevel,
int format,
serf_bucket_alloc_t *allocator);
/* ==================================================================== */ /* ==================================================================== */
extern const serf_bucket_type_t serf_bucket_type_limit; extern const serf_bucket_type_t serf_bucket_type_limit;
#define SERF_BUCKET_IS_LIMIT(b) SERF_BUCKET_CHECK((b), limit) #define SERF_BUCKET_IS_LIMIT(b) SERF_BUCKET_CHECK((b), limit)
serf_bucket_t *serf_bucket_limit_create( serf_bucket_t *serf_bucket_limit_create(
serf_bucket_t *stream, serf_bucket_t *stream,
apr_uint64_t limit, apr_uint64_t limit,
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
/* ==================================================================== */ /* ==================================================================== */
#define SERF_SSL_CERT_NOTYETVALID 1 #define SERF_SSL_CERT_NOTYETVALID 0x0001
#define SERF_SSL_CERT_EXPIRED 2 #define SERF_SSL_CERT_EXPIRED 0x0002
#define SERF_SSL_CERT_UNKNOWNCA 4 #define SERF_SSL_CERT_UNKNOWNCA 0x0004
#define SERF_SSL_CERT_SELF_SIGNED 8 #define SERF_SSL_CERT_SELF_SIGNED 0x0008
#define SERF_SSL_CERT_UNKNOWN_FAILURE 16 #define SERF_SSL_CERT_UNKNOWN_FAILURE 0x0010
#define SERF_SSL_CERT_REVOKED 32 #define SERF_SSL_CERT_REVOKED 0x0020
#define SERF_SSL_CERT_UNABLE_TO_GET_CRL 0x0040
#define SERF_SSL_CERT_INVALID_HOST 0x0080
#define SERF_SSL_OCSP_RESPONDER_TRYLATER 0x0100
#define SERF_SSL_OCSP_RESPONDER_ERROR 0x0200
#define SERF_SSL_OCSP_RESPONDER_UNKNOWN_FAILURE 0x0400
extern const serf_bucket_type_t serf_bucket_type_ssl_encrypt; extern const serf_bucket_type_t serf_bucket_type_ssl_encrypt;
#define SERF_BUCKET_IS_SSL_ENCRYPT(b) SERF_BUCKET_CHECK((b), ssl_encrypt) #define SERF_BUCKET_IS_SSL_ENCRYPT(b) SERF_BUCKET_CHECK((b), ssl_encrypt)
typedef struct serf_ssl_context_t serf_ssl_context_t; typedef struct serf_ssl_context_t serf_ssl_context_t;
typedef struct serf_ssl_certificate_t serf_ssl_certificate_t; typedef struct serf_ssl_certificate_t serf_ssl_certificate_t;
typedef apr_status_t (*serf_ssl_need_client_cert_t)( typedef apr_status_t (*serf_ssl_need_client_cert_t)(
void *data, void *data,
const char **cert_path); const char **cert_path);
typedef apr_status_t (*serf_ssl_need_cert_password_t)( typedef apr_status_t (*serf_ssl_need_cert_password_t)(
void *data, void *data,
const char *cert_path, const char *cert_path,
const char **password); const char **password);
/* Callback type for server certificate status info and OCSP responses.
Note that CERT can be NULL in case its called from the OCSP callback. */
typedef apr_status_t (*serf_ssl_need_server_cert_t)( typedef apr_status_t (*serf_ssl_need_server_cert_t)(
void *data, void *data,
int failures, int failures,
const serf_ssl_certificate_t *cert); const serf_ssl_certificate_t *cert);
typedef apr_status_t (*serf_ssl_server_cert_chain_cb_t)( typedef apr_status_t (*serf_ssl_server_cert_chain_cb_t)(
void *data, void *data,
int failures, int failures,
int error_depth, int error_depth,
const serf_ssl_certificate_t * const * certs, const serf_ssl_certificate_t * const * certs,
skipping to change at line 553 skipping to change at line 634
*/ */
apr_status_t serf_ssl_use_default_certificates( apr_status_t serf_ssl_use_default_certificates(
serf_ssl_context_t *context); serf_ssl_context_t *context);
/** /**
* Allow SNI indicators to be sent to the server. * Allow SNI indicators to be sent to the server.
*/ */
apr_status_t serf_ssl_set_hostname( apr_status_t serf_ssl_set_hostname(
serf_ssl_context_t *context, const char *hostname); serf_ssl_context_t *context, const char *hostname);
typedef apr_status_t (*serf_ssl_protocol_result_cb_t)(
void *data,
const char *protocol);
/**
* Enables ALPN negotiation with the server. Setups that the supported prot
ocols
* will be sent to the server, and enables handling the response via a call
back.
*
* SUPPORTED_PROTOCOLS is a comma separated list of protocols. No whitespac
e
* should be added as the values are used literally. E.g. "h2,http/1.1,h2-1
6"
*
* Returns APR_ENOTIMPL when the ssl library doesn't implement ALPN.
*
* If successfull CALLBACK will be called as soon as the protocol is negoti
ated
* or directly after the secured stream is connected.
*
* @since New in 1.4.
*/
apr_status_t serf_ssl_negotiate_protocol(
serf_ssl_context_t *context,
const char *protocols,
serf_ssl_protocol_result_cb_t callback,
void *callback_data);
/** /**
* Return the depth of the certificate. * Return the depth of the certificate.
*/ */
int serf_ssl_cert_depth( int serf_ssl_cert_depth(
const serf_ssl_certificate_t *cert); const serf_ssl_certificate_t *cert);
/** /**
* Extract the fields of the issuer in a table with keys (E, CN, OU, O, L, * Extract the fields of the issuer in a table with keys (E, CN, OU, O, L,
* ST and C). The returned table will be allocated in @a pool. * ST and C). The returned table will be allocated in @a pool.
*/ */
skipping to change at line 611 skipping to change at line 716
/** /**
* Adds the certificate @a cert to the list of trusted certificates in * Adds the certificate @a cert to the list of trusted certificates in
* @a ssl_ctx that will be used for verification. * @a ssl_ctx that will be used for verification.
* See also @a serf_ssl_load_cert_file. * See also @a serf_ssl_load_cert_file.
*/ */
apr_status_t serf_ssl_trust_cert( apr_status_t serf_ssl_trust_cert(
serf_ssl_context_t *ssl_ctx, serf_ssl_context_t *ssl_ctx,
serf_ssl_certificate_t *cert); serf_ssl_certificate_t *cert);
/** /**
* Load a CRL .pem file from @a file_path and enable CRL checking.
*/
apr_status_t serf_ssl_add_crl_from_file(serf_ssl_context_t *ssl_ctx,
const char *file_path,
apr_pool_t *pool);
/**
* Enable or disable CRL checking of all server certificates.
* @a enabled = 1 to enable CRL checking, 0 to disable CRL checking.
* Default = disabled.
*/
apr_status_t serf_ssl_check_crl(serf_ssl_context_t *ssl_ctx,
int enabled);
/**
* Enable or disable certificate status request (OCSP stapling) checking of
all
* server certificates.
* @a enabled = 1 to enable checking, 0 to disable checking.
* Default = disabled.
*/
apr_status_t
serf_ssl_check_cert_status_request(serf_ssl_context_t *ssl_ctx, int enabled
);
/**
* Enable or disable SSL compression on a SSL session. * Enable or disable SSL compression on a SSL session.
* @a enabled = 1 to enable compression, 0 to disable compression. * @a enabled = 1 to enable compression, 0 to disable compression.
* Default = disabled. * Default = disabled.
*/ */
apr_status_t serf_ssl_use_compression( apr_status_t serf_ssl_use_compression(
serf_ssl_context_t *ssl_ctx, serf_ssl_context_t *ssl_ctx,
int enabled); int enabled);
serf_bucket_t *serf_bucket_ssl_encrypt_create( serf_bucket_t *serf_bucket_ssl_encrypt_create(
serf_bucket_t *stream, serf_bucket_t *stream,
skipping to change at line 661 skipping to change at line 790
extern const serf_bucket_type_t serf_bucket_type_iovec; extern const serf_bucket_type_t serf_bucket_type_iovec;
#define SERF_BUCKET_IS_IOVEC(b) SERF_BUCKET_CHECK((b), iovec) #define SERF_BUCKET_IS_IOVEC(b) SERF_BUCKET_CHECK((b), iovec)
serf_bucket_t *serf_bucket_iovec_create( serf_bucket_t *serf_bucket_iovec_create(
struct iovec vecs[], struct iovec vecs[],
int len, int len,
serf_bucket_alloc_t *allocator); serf_bucket_alloc_t *allocator);
/* ==================================================================== */ /* ==================================================================== */
extern const serf_bucket_type_t serf_bucket_type_copy;
#define SERF_BUCKET_IS_COPY(b) SERF_BUCKET_CHECK((b), copy)
serf_bucket_t *serf_bucket_copy_create(
serf_bucket_t *wrapped,
apr_size_t min_size,
serf_bucket_alloc_t *allocator);
/* ==================================================================== */
/* Reads a specific number of bytes from an inner bucket and forwards that
to a callback, before reading the rest of the bucket normally.
If the internal bucket is at EOF before the prefix length is read, the
callback is called with whatever is read before returning EOF.
*/
extern const serf_bucket_type_t serf_bucket_type_prefix;
#define SERF_BUCKET_IS_PREFIX(b) SERF_BUCKET_CHECK((b), prefix)
/* Callback for the prefix handler */
typedef apr_status_t (*serf_bucket_prefix_handler_t)(
void *baton,
serf_bucket_t *stream,
const char *data,
apr_size_t len);
serf_bucket_t *serf_bucket_prefix_create(
serf_bucket_t *stream,
apr_size_t prefix_len,
serf_bucket_prefix_handler_t handler,
void *handler_baton,
serf_bucket_alloc_t *allocator);
/* ==================================================================== */
/* Creates two buckets, *HEAD and *TAIL, which together contain the output
of STREAM. If there is enough data in STREAM, HEAD will be a bucket of a
t
least MIN_CHUNK_SIZE and will never be larget than MAX_CHUNK_SIZE.
If STREAM is at EOF before MIN_CHUNK_SIZE, HEAD will contain the data,
while TAIL is immediately at EOF.
HEAD and TAIL will make sure that data read from TAIL will not break the
data availability promises on HEAD. Passing an existing tail of this
function as new stream may be handled specificaly, but the read promises
on all nodes ahead of stream will still hold.
HEAD and TAIL are allocated in STREAM->allocator. STREAM will be
destroyed when no longer referenced or after EOF.
*/
void serf_bucket_split_create(serf_bucket_t **head,
serf_bucket_t **tail,
serf_bucket_t *stream,
apr_size_t min_chunk_size,
apr_size_t max_chunk_size);
/**
* Check if Serf bucket functions support Brotli (RFC 7932) format.
* Return non-zero if Brotli is supported and zero otherwise. If Brotli
* is not supported, the behavior of all related bucket functions such
* as @a serf_bucket_brotli_decompress_create is undefined.
*
* @since New in 1.4.
*/
int serf_bucket_is_brotli_supported(void);
/** @since New in 1.4. */
extern const serf_bucket_type_t serf_bucket_type_brotli_decompress;
/** @since New in 1.4. */
#define SERF_BUCKET_IS_BROTLI_DECOMPRESS(b) \
SERF_BUCKET_CHECK((b), brotli_decompress)
/** @since New in 1.4. */
serf_bucket_t *
serf_bucket_brotli_decompress_create(serf_bucket_t *stream,
serf_bucket_alloc_t *alloc);
/* ### do we need a PIPE bucket type? they are simple apr_file_t objects */ /* ### do we need a PIPE bucket type? they are simple apr_file_t objects */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* !SERF_BUCKET_TYPES_H */ #endif /* !SERF_BUCKET_TYPES_H */
 End of changes. 17 change blocks. 
25 lines changed or deleted 242 lines changed or added


 serf_bucket_util.h (1.3.9)   serf_bucket_util.h (current) 
skipping to change at line 63 skipping to change at line 63
* then return it in the iovec. * then return it in the iovec.
*/ */
apr_status_t serf_default_read_iovec( apr_status_t serf_default_read_iovec(
serf_bucket_t *bucket, serf_bucket_t *bucket,
apr_size_t requested, apr_size_t requested,
int vecs_size, int vecs_size,
struct iovec *vecs, struct iovec *vecs,
int *vecs_used); int *vecs_used);
/** /**
* Default implementation of the @see readline functionality.
*
* This function will use the @see read function, when possible optimized b
y
* the @a peek function to return the requested result.
*/
apr_status_t serf_default_readline(serf_bucket_t *bucket, int acceptable,
int *found,
const char **data, apr_size_t *len);
/**
* Default implementation of the @see read_for_sendfile functionality. * Default implementation of the @see read_for_sendfile functionality.
* *
* This function will use the @see read function to get a block of memory, * This function will use the @see read function to get a block of memory,
* then return it as a header. No file will be returned. * then return it as a header. No file will be returned.
*/ */
apr_status_t serf_default_read_for_sendfile( apr_status_t serf_default_read_for_sendfile(
serf_bucket_t *bucket, serf_bucket_t *bucket,
apr_size_t requested, apr_size_t requested,
apr_hdtr_t *hdtr, apr_hdtr_t *hdtr,
apr_file_t **file, apr_file_t **file,
skipping to change at line 87 skipping to change at line 97
* Default implementation of the @see read_bucket functionality. * Default implementation of the @see read_bucket functionality.
* *
* This function will always return NULL, indicating that the @a type * This function will always return NULL, indicating that the @a type
* of bucket cannot be found within @a bucket. * of bucket cannot be found within @a bucket.
*/ */
serf_bucket_t *serf_default_read_bucket( serf_bucket_t *serf_default_read_bucket(
serf_bucket_t *bucket, serf_bucket_t *bucket,
const serf_bucket_type_t *type); const serf_bucket_type_t *type);
/** /**
* Default implementation of the @see peek functionality.
*
* This function will always state that there is no data available.
*
* @since New in 1.4.
*/
apr_status_t serf_default_peek(
serf_bucket_t *bucket,
const char **data,
apr_size_t *len);
/**
* Default implementation of the @see destroy functionality. * Default implementation of the @see destroy functionality.
* *
* This function will return the @a bucket to its allcoator. * This function will return the @a bucket to its allcoator.
*/ */
void serf_default_destroy( void serf_default_destroy(
serf_bucket_t *bucket); serf_bucket_t *bucket);
/** /**
* Default implementation of the @see destroy functionality. * Default implementation of the @see destroy functionality.
* *
* This function will return the @a bucket, and the data member to its * This function will return the @a bucket, and the data member to its
* allocator. * allocator.
*/ */
void serf_default_destroy_and_data( void serf_default_destroy_and_data(
serf_bucket_t *bucket); serf_bucket_t *bucket);
/** /**
* Implementation of a limited @see readline functionality.
*
* This function will use the @see read function, when possible optimized b
y
* the @a peek function to return the requested result.
*/
apr_status_t serf_bucket_limited_readline(serf_bucket_t *bucket, int accept
able,
apr_size_t requested, int *found,
const char **data, apr_size_t *le
n);
/**
* Default implementation of the @see get_remaining functionality.
*
* This function will just return SERF_LENGTH_UNKNOWN.
*/
apr_uint64_t serf_default_get_remaining(
serf_bucket_t *bucket);
/**
* Default implementation of the @see set_config functionality.
*
* This function will not do anything, it should be used in buckets
* that have no use for the shared config, and do not wrap other bucket(s).
*/
apr_status_t serf_default_ignore_config(serf_bucket_t *bucket,
serf_config_t *config);
/**
* Allocate @a size bytes of memory using @a allocator. * Allocate @a size bytes of memory using @a allocator.
* *
* Returns NULL of the requested memory size could not be allocated. * Returns NULL of the requested memory size could not be allocated.
*/ */
void *serf_bucket_mem_alloc( void *serf_bucket_mem_alloc(
serf_bucket_alloc_t *allocator, serf_bucket_alloc_t *allocator,
apr_size_t size); apr_size_t size);
/** /**
* Allocate @a size bytes of memory using @a allocator and set all of the * Allocate @a size bytes of memory using @a allocator and set all of the
skipping to change at line 223 skipping to change at line 272
apr_size_t *len); apr_size_t *len);
/** /**
* This structure is used as an intermediate data buffer for some "external " * This structure is used as an intermediate data buffer for some "external "
* source of data. It works as a scratch pad area for incoming data to be * source of data. It works as a scratch pad area for incoming data to be
* stored, and then returned as a ptr/len pair by the bucket read functions . * stored, and then returned as a ptr/len pair by the bucket read functions .
* *
* This structure should be initialized by calling @see serf_databuf_init. * This structure should be initialized by calling @see serf_databuf_init.
* Users should not bother to zero the structure beforehand. * Users should not bother to zero the structure beforehand.
*/ */
typedef struct { typedef struct serf_databuf_t {
/** The current data position within the buffer. */ /** The current data position within the buffer. */
const char *current; const char *current;
/** Amount of data remaining in the buffer. */ /** Amount of data remaining in the buffer. */
apr_size_t remaining; apr_size_t remaining;
/** Callback function. */ /** Callback function. */
serf_databuf_reader_t read; serf_databuf_reader_t read;
/** A baton to hold context-specific data. */ /** A baton to hold context-specific data. */
skipping to change at line 293 skipping to change at line 342
*/ */
apr_status_t serf_databuf_peek( apr_status_t serf_databuf_peek(
serf_databuf_t *databuf, serf_databuf_t *databuf,
const char **data, const char **data,
apr_size_t *len); apr_size_t *len);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* !SERF_BUCKET_UTIL_H */ #endif /* !SERF_BUCKET_UTIL_H */
 End of changes. 5 change blocks. 
1 lines changed or deleted 54 lines changed or added

This html diff was produced by rfcdiff 1.41.The latest version is available from http://tools.ietf.org/tools/rfcdiff/