1251877Speter/* Copyright 2002-2004 Justin Erenkrantz and Greg Stein 2251877Speter * 3251877Speter * Licensed under the Apache License, Version 2.0 (the "License"); 4251877Speter * you may not use this file except in compliance with the License. 5251877Speter * You may obtain a copy of the License at 6251877Speter * 7251877Speter * http://www.apache.org/licenses/LICENSE-2.0 8251877Speter * 9251877Speter * Unless required by applicable law or agreed to in writing, software 10251877Speter * distributed under the License is distributed on an "AS IS" BASIS, 11251877Speter * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12251877Speter * See the License for the specific language governing permissions and 13251877Speter * limitations under the License. 14251877Speter */ 15251877Speter 16251877Speter#ifndef SERF_BUCKET_TYPES_H 17251877Speter#define SERF_BUCKET_TYPES_H 18251877Speter 19251877Speter#include <apr_mmap.h> 20251877Speter#include <apr_hash.h> 21251877Speter 22251877Speter/* this header and serf.h refer to each other, so take a little extra care */ 23251877Speter#ifndef SERF_H 24251877Speter#include "serf.h" 25251877Speter#endif 26251877Speter 27251877Speter 28251877Speter/** 29251877Speter * @file serf_bucket_types.h 30251877Speter * @brief serf-supported bucket types 31251877Speter */ 32251877Speter/* ### this whole file needs docco ... */ 33251877Speter 34251877Speter#ifdef __cplusplus 35251877Speterextern "C" { 36251877Speter#endif 37251877Speter 38251877Speter/* ==================================================================== */ 39251877Speter 40251877Speter 41251877Speterextern const serf_bucket_type_t serf_bucket_type_request; 42251877Speter#define SERF_BUCKET_IS_REQUEST(b) SERF_BUCKET_CHECK((b), request) 43251877Speter 44251877Speterserf_bucket_t *serf_bucket_request_create( 45251877Speter const char *method, 46251877Speter const char *URI, 47251877Speter serf_bucket_t *body, 48251877Speter serf_bucket_alloc_t *allocator); 49251877Speter 50251877Speter/* Send a Content-Length header with @a len. The @a body bucket should 51251877Speter contain precisely that much data. */ 52251877Spetervoid serf_bucket_request_set_CL( 53251877Speter serf_bucket_t *bucket, 54251877Speter apr_int64_t len); 55251877Speter 56251877Speterserf_bucket_t *serf_bucket_request_get_headers( 57251877Speter serf_bucket_t *request); 58251877Speter 59251877Spetervoid serf_bucket_request_become( 60251877Speter serf_bucket_t *bucket, 61251877Speter const char *method, 62251877Speter const char *uri, 63251877Speter serf_bucket_t *body); 64251877Speter 65251877Speter/** 66251877Speter * Sets the root url of the remote host. If this request contains a relative 67251877Speter * url, it will be prefixed with the root url to form an absolute url. 68251877Speter * @a bucket is the request bucket. @a root_url is the absolute url of the 69251877Speter * root of the remote host, without the closing '/'. 70251877Speter */ 71251877Spetervoid serf_bucket_request_set_root( 72251877Speter serf_bucket_t *bucket, 73251877Speter const char *root_url); 74251877Speter 75251877Speter/* ==================================================================== */ 76251877Speter 77251877Speter 78251877Speterextern const serf_bucket_type_t serf_bucket_type_response; 79251877Speter#define SERF_BUCKET_IS_RESPONSE(b) SERF_BUCKET_CHECK((b), response) 80251877Speter 81251877Speterserf_bucket_t *serf_bucket_response_create( 82251877Speter serf_bucket_t *stream, 83251877Speter serf_bucket_alloc_t *allocator); 84251877Speter 85251877Speter#define SERF_HTTP_VERSION(major, minor) ((major) * 1000 + (minor)) 86251877Speter#define SERF_HTTP_11 SERF_HTTP_VERSION(1, 1) 87251877Speter#define SERF_HTTP_10 SERF_HTTP_VERSION(1, 0) 88251877Speter#define SERF_HTTP_VERSION_MAJOR(shv) ((int)shv / 1000) 89251877Speter#define SERF_HTTP_VERSION_MINOR(shv) ((int)shv % 1000) 90251877Speter 91251877Spetertypedef struct { 92251877Speter int version; 93251877Speter int code; 94251877Speter const char *reason; 95251877Speter} serf_status_line; 96251877Speter 97251877Speter/** 98251877Speter * Return the Status-Line information, if available. This function 99251877Speter * works like other bucket read functions: it may return APR_EAGAIN or 100251877Speter * APR_EOF to signal the state of the bucket for reading. A return 101251877Speter * value of APR_SUCCESS will always indicate that status line 102251877Speter * information was returned; for other return values the caller must 103251877Speter * check the version field in @a sline. A value of 0 means that the 104251877Speter * data is not (yet) present. 105251877Speter */ 106251877Speterapr_status_t serf_bucket_response_status( 107251877Speter serf_bucket_t *bkt, 108251877Speter serf_status_line *sline); 109251877Speter 110251877Speter/** 111251877Speter * Wait for the HTTP headers to be processed for a @a response. 112251877Speter * 113251877Speter * If the headers are available, APR_SUCCESS is returned. 114251877Speter * If the headers aren't available, APR_EAGAIN is returned. 115251877Speter */ 116251877Speterapr_status_t serf_bucket_response_wait_for_headers( 117251877Speter serf_bucket_t *response); 118251877Speter 119251877Speter/** 120251877Speter * Get the headers bucket for @a response. 121251877Speter */ 122251877Speterserf_bucket_t *serf_bucket_response_get_headers( 123251877Speter serf_bucket_t *response); 124251877Speter 125251877Speter/** 126251877Speter * Advise the response @a bucket that this was from a HEAD request and 127251877Speter * that it should not expect to see a response body. 128251877Speter */ 129251877Spetervoid serf_bucket_response_set_head( 130251877Speter serf_bucket_t *bucket); 131251877Speter 132251877Speter/* ==================================================================== */ 133251877Speter 134251877Speterextern const serf_bucket_type_t serf_bucket_type_response_body; 135251877Speter#define SERF_BUCKET_IS_RESPONSE_BODY(b) SERF_BUCKET_CHECK((b), response_body) 136251877Speter 137251877Speterserf_bucket_t *serf_bucket_response_body_create( 138251877Speter serf_bucket_t *stream, 139251877Speter apr_uint64_t limit, 140251877Speter serf_bucket_alloc_t *allocator); 141251877Speter 142251877Speter/* ==================================================================== */ 143251877Speter 144251877Speterextern const serf_bucket_type_t serf_bucket_type_bwtp_frame; 145251877Speter#define SERF_BUCKET_IS_BWTP_FRAME(b) SERF_BUCKET_CHECK((b), bwtp_frame) 146251877Speter 147251877Speterextern const serf_bucket_type_t serf_bucket_type_bwtp_incoming_frame; 148251877Speter#define SERF_BUCKET_IS_BWTP_INCOMING_FRAME(b) SERF_BUCKET_CHECK((b), bwtp_incoming_frame) 149251877Speter 150251877Speterint serf_bucket_bwtp_frame_get_channel( 151251877Speter serf_bucket_t *hdr); 152251877Speter 153251877Speterint serf_bucket_bwtp_frame_get_type( 154251877Speter serf_bucket_t *hdr); 155251877Speter 156251877Speterconst char *serf_bucket_bwtp_frame_get_phrase( 157251877Speter serf_bucket_t *hdr); 158251877Speter 159251877Speterserf_bucket_t *serf_bucket_bwtp_frame_get_headers( 160251877Speter serf_bucket_t *hdr); 161251877Speter 162251877Speterserf_bucket_t *serf_bucket_bwtp_channel_open( 163251877Speter int channel, 164251877Speter const char *URI, 165251877Speter serf_bucket_alloc_t *allocator); 166251877Speter 167251877Speterserf_bucket_t *serf_bucket_bwtp_channel_close( 168251877Speter int channel, 169251877Speter serf_bucket_alloc_t *allocator); 170251877Speter 171251877Speterserf_bucket_t *serf_bucket_bwtp_header_create( 172251877Speter int channel, 173251877Speter const char *phrase, 174251877Speter serf_bucket_alloc_t *allocator); 175251877Speter 176251877Speterserf_bucket_t *serf_bucket_bwtp_message_create( 177251877Speter int channel, 178251877Speter serf_bucket_t *body, 179251877Speter serf_bucket_alloc_t *allocator); 180251877Speter 181251877Speterserf_bucket_t *serf_bucket_bwtp_incoming_frame_create( 182251877Speter serf_bucket_t *bkt, 183251877Speter serf_bucket_alloc_t *allocator); 184251877Speter 185251877Speterapr_status_t serf_bucket_bwtp_incoming_frame_wait_for_headers( 186251877Speter serf_bucket_t *bkt); 187251877Speter 188251877Speter/* ==================================================================== */ 189251877Speter 190251877Speter 191251877Speterextern const serf_bucket_type_t serf_bucket_type_aggregate; 192251877Speter#define SERF_BUCKET_IS_AGGREGATE(b) SERF_BUCKET_CHECK((b), aggregate) 193251877Speter 194251877Spetertypedef apr_status_t (*serf_bucket_aggregate_eof_t)( 195251877Speter void *baton, 196251877Speter serf_bucket_t *aggregate_bucket); 197251877Speter 198251877Speter/** serf_bucket_aggregate_cleanup will instantly destroy all buckets in 199251877Speter the aggregate bucket that have been read completely. Whereas normally, 200251877Speter these buckets are destroyed on every read operation. */ 201251877Spetervoid serf_bucket_aggregate_cleanup( 202251877Speter serf_bucket_t *bucket, 203251877Speter serf_bucket_alloc_t *allocator); 204251877Speter 205251877Speterserf_bucket_t *serf_bucket_aggregate_create( 206251877Speter serf_bucket_alloc_t *allocator); 207251877Speter 208251877Speter/* Creates a stream bucket. 209251877Speter A stream bucket is like an aggregate bucket, but: 210251877Speter - it doesn't destroy its child buckets on cleanup 211251877Speter - one can always keep adding child buckets, the handler FN should return 212251877Speter APR_EOF when no more buckets will be added. 213251877Speter 214251877Speter Note: keep this factory function internal for now. If it turns out this 215251877Speter bucket type is useful outside serf, we should make it an actual separate 216251877Speter type. 217251877Speter */ 218251877Speterserf_bucket_t *serf__bucket_stream_create( 219251877Speter serf_bucket_alloc_t *allocator, 220251877Speter serf_bucket_aggregate_eof_t fn, 221251877Speter void *baton); 222251877Speter 223251877Speter/** Transform @a bucket in-place into an aggregate bucket. */ 224251877Spetervoid serf_bucket_aggregate_become( 225251877Speter serf_bucket_t *bucket); 226251877Speter 227251877Spetervoid serf_bucket_aggregate_prepend( 228251877Speter serf_bucket_t *aggregate_bucket, 229251877Speter serf_bucket_t *prepend_bucket); 230251877Speter 231251877Spetervoid serf_bucket_aggregate_append( 232251877Speter serf_bucket_t *aggregate_bucket, 233251877Speter serf_bucket_t *append_bucket); 234251877Speter 235251877Spetervoid serf_bucket_aggregate_hold_open( 236251877Speter serf_bucket_t *aggregate_bucket, 237251877Speter serf_bucket_aggregate_eof_t fn, 238251877Speter void *baton); 239251877Speter 240251877Spetervoid serf_bucket_aggregate_prepend_iovec( 241251877Speter serf_bucket_t *aggregate_bucket, 242251877Speter struct iovec *vecs, 243251877Speter int vecs_count); 244251877Speter 245251877Spetervoid serf_bucket_aggregate_append_iovec( 246251877Speter serf_bucket_t *aggregate_bucket, 247251877Speter struct iovec *vecs, 248251877Speter int vecs_count); 249251877Speter 250251877Speter/* ==================================================================== */ 251251877Speter 252251877Speter 253251877Speterextern const serf_bucket_type_t serf_bucket_type_file; 254251877Speter#define SERF_BUCKET_IS_FILE(b) SERF_BUCKET_CHECK((b), file) 255251877Speter 256251877Speterserf_bucket_t *serf_bucket_file_create( 257251877Speter apr_file_t *file, 258251877Speter serf_bucket_alloc_t *allocator); 259251877Speter 260251877Speter 261251877Speter/* ==================================================================== */ 262251877Speter 263251877Speter 264251877Speterextern const serf_bucket_type_t serf_bucket_type_socket; 265251877Speter#define SERF_BUCKET_IS_SOCKET(b) SERF_BUCKET_CHECK((b), socket) 266251877Speter 267251877Speterserf_bucket_t *serf_bucket_socket_create( 268251877Speter apr_socket_t *skt, 269251877Speter serf_bucket_alloc_t *allocator); 270251877Speter 271251877Speter/** 272251877Speter * Call @a progress_func every time bytes are read from the socket, pass 273251877Speter * the number of bytes read. 274251877Speter * 275251877Speter * When using serf's bytes read & written progress indicator, pass 276251877Speter * @a serf_context_progress_delta for progress_func and the serf_context for 277251877Speter * progress_baton. 278251877Speter */ 279251877Spetervoid serf_bucket_socket_set_read_progress_cb( 280251877Speter serf_bucket_t *bucket, 281251877Speter const serf_progress_t progress_func, 282251877Speter void *progress_baton); 283251877Speter 284251877Speter/* ==================================================================== */ 285251877Speter 286251877Speter 287251877Speterextern const serf_bucket_type_t serf_bucket_type_simple; 288251877Speter#define SERF_BUCKET_IS_SIMPLE(b) SERF_BUCKET_CHECK((b), simple) 289251877Speter 290251877Spetertypedef void (*serf_simple_freefunc_t)( 291251877Speter void *baton, 292251877Speter const char *data); 293251877Speter 294251877Speterserf_bucket_t *serf_bucket_simple_create( 295251877Speter const char *data, 296251877Speter apr_size_t len, 297251877Speter serf_simple_freefunc_t freefunc, 298251877Speter void *freefunc_baton, 299251877Speter serf_bucket_alloc_t *allocator); 300251877Speter 301251877Speter/** 302251877Speter * Equivalent to serf_bucket_simple_create, except that the bucket takes 303251877Speter * ownership of a private copy of the data. 304251877Speter */ 305251877Speterserf_bucket_t *serf_bucket_simple_copy_create( 306251877Speter const char *data, 307251877Speter apr_size_t len, 308251877Speter serf_bucket_alloc_t *allocator); 309251877Speter 310253895Speter/** 311253895Speter * Equivalent to serf_bucket_simple_create, except that the bucket assumes 312253895Speter * responsibility for freeing the data on this allocator without making 313253895Speter * a copy. It is assumed that data was created by a call from allocator. 314253895Speter */ 315253895Speterserf_bucket_t *serf_bucket_simple_own_create( 316253895Speter const char *data, 317253895Speter apr_size_t len, 318253895Speter serf_bucket_alloc_t *allocator); 319253895Speter 320251877Speter#define SERF_BUCKET_SIMPLE_STRING(s,a) \ 321251877Speter serf_bucket_simple_create(s, strlen(s), NULL, NULL, a); 322251877Speter 323251877Speter#define SERF_BUCKET_SIMPLE_STRING_LEN(s,l,a) \ 324251877Speter serf_bucket_simple_create(s, l, NULL, NULL, a); 325251877Speter 326251877Speter/* ==================================================================== */ 327251877Speter 328251877Speter 329251877Speter/* Note: apr_mmap_t is always defined, but if APR doesn't have mmaps, then 330251877Speter the caller can never create an apr_mmap_t to pass to this function. */ 331251877Speter 332251877Speterextern const serf_bucket_type_t serf_bucket_type_mmap; 333251877Speter#define SERF_BUCKET_IS_MMAP(b) SERF_BUCKET_CHECK((b), mmap) 334251877Speter 335251877Speterserf_bucket_t *serf_bucket_mmap_create( 336251877Speter apr_mmap_t *mmap, 337251877Speter serf_bucket_alloc_t *allocator); 338251877Speter 339251877Speter 340251877Speter/* ==================================================================== */ 341251877Speter 342251877Speter 343251877Speterextern const serf_bucket_type_t serf_bucket_type_headers; 344251877Speter#define SERF_BUCKET_IS_HEADERS(b) SERF_BUCKET_CHECK((b), headers) 345251877Speter 346251877Speterserf_bucket_t *serf_bucket_headers_create( 347251877Speter serf_bucket_alloc_t *allocator); 348251877Speter 349251877Speter/** 350251877Speter * Set, default: value copied. 351251877Speter * 352251877Speter * Set the specified @a header within the bucket, copying the @a value 353251877Speter * into space from this bucket's allocator. The header is NOT copied, 354251877Speter * so it should remain in scope at least as long as the bucket. 355251877Speter */ 356251877Spetervoid serf_bucket_headers_set( 357251877Speter serf_bucket_t *headers_bucket, 358251877Speter const char *header, 359251877Speter const char *value); 360251877Speter 361251877Speter/** 362251877Speter * Set, copies: header and value copied. 363251877Speter * 364251877Speter * Copy the specified @a header and @a value into the bucket, using space 365251877Speter * from this bucket's allocator. 366251877Speter */ 367251877Spetervoid serf_bucket_headers_setc( 368251877Speter serf_bucket_t *headers_bucket, 369251877Speter const char *header, 370251877Speter const char *value); 371251877Speter 372251877Speter/** 373251877Speter * Set, no copies. 374251877Speter * 375251877Speter * Set the specified @a header and @a value into the bucket, without 376251877Speter * copying either attribute. Both attributes should remain in scope at 377251877Speter * least as long as the bucket. 378251877Speter * 379251877Speter * @note In the case where a header already exists this will result 380251877Speter * in a reallocation and copy, @see serf_bucket_headers_setn. 381251877Speter */ 382251877Spetervoid serf_bucket_headers_setn( 383251877Speter serf_bucket_t *headers_bucket, 384251877Speter const char *header, 385251877Speter const char *value); 386251877Speter 387251877Speter/** 388251877Speter * Set, extended: fine grained copy control of header and value. 389251877Speter * 390251877Speter * Set the specified @a header, with length @a header_size with the 391251877Speter * @a value, and length @a value_size, into the bucket. The header will 392251877Speter * be copied if @a header_copy is set, and the value is copied if 393251877Speter * @a value_copy is set. If the values are not copied, then they should 394251877Speter * remain in scope at least as long as the bucket. 395251877Speter * 396251877Speter * If @a headers_bucket already contains a header with the same name 397251877Speter * as @a header, then append @a value to the existing value, 398251877Speter * separating with a comma (as per RFC 2616, section 4.2). In this 399251877Speter * case, the new value must be allocated and the header re-used, so 400251877Speter * behave as if @a value_copy were true and @a header_copy false. 401251877Speter */ 402251877Spetervoid serf_bucket_headers_setx( 403251877Speter serf_bucket_t *headers_bucket, 404251877Speter const char *header, 405251877Speter apr_size_t header_size, 406251877Speter int header_copy, 407251877Speter const char *value, 408251877Speter apr_size_t value_size, 409251877Speter int value_copy); 410251877Speter 411251877Speterconst char *serf_bucket_headers_get( 412251877Speter serf_bucket_t *headers_bucket, 413251877Speter const char *header); 414251877Speter 415251877Speter/** 416251877Speter * @param baton opaque baton as passed to @see serf_bucket_headers_do 417251877Speter * @param key The header key from this iteration through the table 418251877Speter * @param value The header value from this iteration through the table 419251877Speter */ 420251877Spetertypedef int (serf_bucket_headers_do_callback_fn_t)( 421251877Speter void *baton, 422251877Speter const char *key, 423251877Speter const char *value); 424251877Speter 425251877Speter/** 426251877Speter * Iterates over all headers of the message and invokes the callback 427251877Speter * function with header key and value. Stop iterating when no more 428251877Speter * headers are available or when the callback function returned a 429251877Speter * non-0 value. 430251877Speter * 431251877Speter * @param headers_bucket headers to iterate over 432251877Speter * @param func callback routine to invoke for every header in the bucket 433251877Speter * @param baton baton to pass on each invocation to func 434251877Speter */ 435251877Spetervoid serf_bucket_headers_do( 436251877Speter serf_bucket_t *headers_bucket, 437251877Speter serf_bucket_headers_do_callback_fn_t func, 438251877Speter void *baton); 439251877Speter 440251877Speter 441251877Speter/* ==================================================================== */ 442251877Speter 443251877Speter 444251877Speterextern const serf_bucket_type_t serf_bucket_type_chunk; 445251877Speter#define SERF_BUCKET_IS_CHUNK(b) SERF_BUCKET_CHECK((b), chunk) 446251877Speter 447251877Speterserf_bucket_t *serf_bucket_chunk_create( 448251877Speter serf_bucket_t *stream, 449251877Speter serf_bucket_alloc_t *allocator); 450251877Speter 451251877Speter 452251877Speter/* ==================================================================== */ 453251877Speter 454251877Speter 455251877Speterextern const serf_bucket_type_t serf_bucket_type_dechunk; 456251877Speter#define SERF_BUCKET_IS_DECHUNK(b) SERF_BUCKET_CHECK((b), dechunk) 457251877Speter 458251877Speterserf_bucket_t *serf_bucket_dechunk_create( 459251877Speter serf_bucket_t *stream, 460251877Speter serf_bucket_alloc_t *allocator); 461251877Speter 462251877Speter 463251877Speter/* ==================================================================== */ 464251877Speter 465251877Speter 466251877Speterextern const serf_bucket_type_t serf_bucket_type_deflate; 467251877Speter#define SERF_BUCKET_IS_DEFLATE(b) SERF_BUCKET_CHECK((b), deflate) 468251877Speter 469251877Speter#define SERF_DEFLATE_GZIP 0 470251877Speter#define SERF_DEFLATE_DEFLATE 1 471251877Speter 472251877Speterserf_bucket_t *serf_bucket_deflate_create( 473251877Speter serf_bucket_t *stream, 474251877Speter serf_bucket_alloc_t *allocator, 475251877Speter int format); 476251877Speter 477251877Speter 478251877Speter/* ==================================================================== */ 479251877Speter 480251877Speter 481251877Speterextern const serf_bucket_type_t serf_bucket_type_limit; 482251877Speter#define SERF_BUCKET_IS_LIMIT(b) SERF_BUCKET_CHECK((b), limit) 483251877Speter 484251877Speterserf_bucket_t *serf_bucket_limit_create( 485251877Speter serf_bucket_t *stream, 486251877Speter apr_uint64_t limit, 487251877Speter serf_bucket_alloc_t *allocator); 488251877Speter 489251877Speter 490251877Speter/* ==================================================================== */ 491251877Speter#define SERF_SSL_CERT_NOTYETVALID 1 492251877Speter#define SERF_SSL_CERT_EXPIRED 2 493251877Speter#define SERF_SSL_CERT_UNKNOWNCA 4 494251877Speter#define SERF_SSL_CERT_SELF_SIGNED 8 495251877Speter#define SERF_SSL_CERT_UNKNOWN_FAILURE 16 496251877Speter#define SERF_SSL_CERT_REVOKED 32 497251877Speter 498251877Speterextern const serf_bucket_type_t serf_bucket_type_ssl_encrypt; 499251877Speter#define SERF_BUCKET_IS_SSL_ENCRYPT(b) SERF_BUCKET_CHECK((b), ssl_encrypt) 500251877Speter 501251877Spetertypedef struct serf_ssl_context_t serf_ssl_context_t; 502251877Spetertypedef struct serf_ssl_certificate_t serf_ssl_certificate_t; 503251877Speter 504251877Spetertypedef apr_status_t (*serf_ssl_need_client_cert_t)( 505251877Speter void *data, 506251877Speter const char **cert_path); 507251877Speter 508251877Spetertypedef apr_status_t (*serf_ssl_need_cert_password_t)( 509251877Speter void *data, 510251877Speter const char *cert_path, 511251877Speter const char **password); 512251877Speter 513251877Spetertypedef apr_status_t (*serf_ssl_need_server_cert_t)( 514251877Speter void *data, 515251877Speter int failures, 516251877Speter const serf_ssl_certificate_t *cert); 517251877Speter 518251877Spetertypedef apr_status_t (*serf_ssl_server_cert_chain_cb_t)( 519251877Speter void *data, 520251877Speter int failures, 521251877Speter int error_depth, 522251877Speter const serf_ssl_certificate_t * const * certs, 523251877Speter apr_size_t certs_len); 524251877Speter 525251877Spetervoid serf_ssl_client_cert_provider_set( 526251877Speter serf_ssl_context_t *context, 527251877Speter serf_ssl_need_client_cert_t callback, 528251877Speter void *data, 529251877Speter void *cache_pool); 530251877Speter 531251877Spetervoid serf_ssl_client_cert_password_set( 532251877Speter serf_ssl_context_t *context, 533251877Speter serf_ssl_need_cert_password_t callback, 534251877Speter void *data, 535251877Speter void *cache_pool); 536251877Speter 537251877Speter/** 538251877Speter * Set a callback to override the default SSL server certificate validation 539251877Speter * algorithm. 540251877Speter */ 541251877Spetervoid serf_ssl_server_cert_callback_set( 542251877Speter serf_ssl_context_t *context, 543251877Speter serf_ssl_need_server_cert_t callback, 544251877Speter void *data); 545251877Speter 546251877Speter/** 547251877Speter * Set callbacks to override the default SSL server certificate validation 548251877Speter * algorithm for the current certificate or the entire certificate chain. 549251877Speter */ 550251877Spetervoid serf_ssl_server_cert_chain_callback_set( 551251877Speter serf_ssl_context_t *context, 552251877Speter serf_ssl_need_server_cert_t cert_callback, 553251877Speter serf_ssl_server_cert_chain_cb_t cert_chain_callback, 554251877Speter void *data); 555251877Speter 556251877Speter/** 557251877Speter * Use the default root CA certificates as included with the OpenSSL library. 558251877Speter */ 559251877Speterapr_status_t serf_ssl_use_default_certificates( 560251877Speter serf_ssl_context_t *context); 561251877Speter 562251877Speter/** 563251877Speter * Allow SNI indicators to be sent to the server. 564251877Speter */ 565251877Speterapr_status_t serf_ssl_set_hostname( 566251877Speter serf_ssl_context_t *context, const char *hostname); 567251877Speter 568251877Speter/** 569251877Speter * Return the depth of the certificate. 570251877Speter */ 571251877Speterint serf_ssl_cert_depth( 572251877Speter const serf_ssl_certificate_t *cert); 573251877Speter 574251877Speter/** 575251877Speter * Extract the fields of the issuer in a table with keys (E, CN, OU, O, L, 576251877Speter * ST and C). The returned table will be allocated in @a pool. 577251877Speter */ 578251877Speterapr_hash_t *serf_ssl_cert_issuer( 579251877Speter const serf_ssl_certificate_t *cert, 580251877Speter apr_pool_t *pool); 581251877Speter 582251877Speter/** 583251877Speter * Extract the fields of the subject in a table with keys (E, CN, OU, O, L, 584251877Speter * ST and C). The returned table will be allocated in @a pool. 585251877Speter */ 586251877Speterapr_hash_t *serf_ssl_cert_subject( 587251877Speter const serf_ssl_certificate_t *cert, 588251877Speter apr_pool_t *pool); 589251877Speter 590251877Speter/** 591251877Speter * Extract the fields of the certificate in a table with keys (sha1, notBefore, 592253895Speter * notAfter, subjectAltName). The returned table will be allocated in @a pool. 593251877Speter */ 594251877Speterapr_hash_t *serf_ssl_cert_certificate( 595251877Speter const serf_ssl_certificate_t *cert, 596251877Speter apr_pool_t *pool); 597251877Speter 598251877Speter/** 599251877Speter * Export a certificate to base64-encoded, zero-terminated string. 600251877Speter * The returned string is allocated in @a pool. Returns NULL on failure. 601251877Speter */ 602251877Speterconst char *serf_ssl_cert_export( 603251877Speter const serf_ssl_certificate_t *cert, 604251877Speter apr_pool_t *pool); 605251877Speter 606251877Speter/** 607251877Speter * Load a CA certificate file from a path @a file_path. If the file was loaded 608251877Speter * and parsed correctly, a certificate @a cert will be created and returned. 609251877Speter * This certificate object will be alloced in @a pool. 610251877Speter */ 611251877Speterapr_status_t serf_ssl_load_cert_file( 612251877Speter serf_ssl_certificate_t **cert, 613251877Speter const char *file_path, 614251877Speter apr_pool_t *pool); 615251877Speter 616251877Speter/** 617251877Speter * Adds the certificate @a cert to the list of trusted certificates in 618251877Speter * @a ssl_ctx that will be used for verification. 619251877Speter * See also @a serf_ssl_load_cert_file. 620251877Speter */ 621251877Speterapr_status_t serf_ssl_trust_cert( 622251877Speter serf_ssl_context_t *ssl_ctx, 623251877Speter serf_ssl_certificate_t *cert); 624251877Speter 625251877Speter/** 626251877Speter * Enable or disable SSL compression on a SSL session. 627251877Speter * @a enabled = 1 to enable compression, 0 to disable compression. 628251877Speter * Default = disabled. 629251877Speter */ 630251877Speterapr_status_t serf_ssl_use_compression( 631251877Speter serf_ssl_context_t *ssl_ctx, 632251877Speter int enabled); 633251877Speter 634251877Speterserf_bucket_t *serf_bucket_ssl_encrypt_create( 635251877Speter serf_bucket_t *stream, 636251877Speter serf_ssl_context_t *ssl_context, 637251877Speter serf_bucket_alloc_t *allocator); 638251877Speter 639251877Speterserf_ssl_context_t *serf_bucket_ssl_encrypt_context_get( 640251877Speter serf_bucket_t *bucket); 641251877Speter 642251877Speter/* ==================================================================== */ 643251877Speter 644251877Speter 645251877Speterextern const serf_bucket_type_t serf_bucket_type_ssl_decrypt; 646251877Speter#define SERF_BUCKET_IS_SSL_DECRYPT(b) SERF_BUCKET_CHECK((b), ssl_decrypt) 647251877Speter 648251877Speterserf_bucket_t *serf_bucket_ssl_decrypt_create( 649251877Speter serf_bucket_t *stream, 650251877Speter serf_ssl_context_t *ssl_context, 651251877Speter serf_bucket_alloc_t *allocator); 652251877Speter 653251877Speterserf_ssl_context_t *serf_bucket_ssl_decrypt_context_get( 654251877Speter serf_bucket_t *bucket); 655251877Speter 656251877Speter 657251877Speter/* ==================================================================== */ 658251877Speter 659251877Speter 660251877Speterextern const serf_bucket_type_t serf_bucket_type_barrier; 661251877Speter#define SERF_BUCKET_IS_BARRIER(b) SERF_BUCKET_CHECK((b), barrier) 662251877Speter 663251877Speterserf_bucket_t *serf_bucket_barrier_create( 664251877Speter serf_bucket_t *stream, 665251877Speter serf_bucket_alloc_t *allocator); 666251877Speter 667251877Speter 668251877Speter/* ==================================================================== */ 669251877Speter 670251877Speterextern const serf_bucket_type_t serf_bucket_type_iovec; 671251877Speter#define SERF_BUCKET_IS_IOVEC(b) SERF_BUCKET_CHECK((b), iovec) 672251877Speter 673251877Speterserf_bucket_t *serf_bucket_iovec_create( 674251877Speter struct iovec vecs[], 675251877Speter int len, 676251877Speter serf_bucket_alloc_t *allocator); 677251877Speter 678251877Speter 679251877Speter/* ==================================================================== */ 680251877Speter 681251877Speter/* ### do we need a PIPE bucket type? they are simple apr_file_t objects */ 682251877Speter 683251877Speter 684251877Speter#ifdef __cplusplus 685251877Speter} 686251877Speter#endif 687251877Speter 688251877Speter#endif /* !SERF_BUCKET_TYPES_H */ 689