Apache2
|
Modules | |
AJP API functions | |
Private | |
Data Structures | |
struct | proxy_hcmethods_t |
struct | proxy_wstat_t |
struct | proxy_remote |
struct | proxy_alias |
struct | dirconn_entry |
struct | noproxy_entry |
struct | proxy_server_conf |
struct | proxy_dir_conf |
struct | proxy_req_conf |
struct | proxy_conn_rec |
struct | proxy_completion |
struct | proxy_conn_pool |
struct | proxy_hashes |
struct | proxy_worker_shared |
struct | proxy_worker |
struct | proxy_balancer_shared |
struct | proxy_balancer |
struct | proxy_balancer_method |
struct | proxy_tunnel_rec |
Typedefs | |
typedef struct proxy_balancer | proxy_balancer |
typedef struct proxy_worker | proxy_worker |
typedef struct proxy_conn_pool | proxy_conn_pool |
typedef struct proxy_balancer_method | proxy_balancer_method |
typedef const char *(* | ap_proxy_header_reverse_map_fn) (request_rec *, proxy_dir_conf *, const char *) |
typedef int() | proxy_is_best_callback_fn_t(proxy_worker *current, proxy_worker *prev_best, void *baton) |
typedef struct proxy_tunnel_conn | proxy_tunnel_conn_t |
Enumerations | |
enum | enctype { enc_path , enc_search , enc_user , enc_fpath , enc_parm } |
enum | hcmethod_t { NONE , TCP , OPTIONS , HEAD , GET , CPING , PROVIDER , OPTIONS11 , HEAD11 , GET11 , EOT } |
enum | proxy_hash_t { PROXY_HASHFUNC_DEFAULT , PROXY_HASHFUNC_APR , PROXY_HASHFUNC_FNV } |
Variables | |
PROXY_DECLARE_DATA proxy_hcmethods_t | proxy_hcmethods [] |
PROXY_DECLARE_DATA proxy_wstat_t | proxy_wstat_tbl [] |
proxy_worker * | worker |
proxy_worker proxy_server_conf * | conf |
proxy_worker proxy_server_conf char * | url |
proxy_worker proxy_server_conf char const char * | proxyhost |
proxy_worker proxy_server_conf char const char apr_port_t | proxyport |
PROXY | |
int | |
detach_backend | |
request_rec * | r |
const char * | src |
const char apr_size_t | dlen |
apr_table_t * | headers |
module PROXY_DECLARE_DATA | proxy_module |
#define ALIGNED_PROXY_BALANCER_SHARED_SIZE (APR_ALIGN_DEFAULT(sizeof(proxy_balancer_shared))) |
#define ALIGNED_PROXY_WORKER_SHARED_SIZE (APR_ALIGN_DEFAULT(sizeof(proxy_worker_shared))) |
#define AP_PROXY_TRANSFER_FLUSH_AFTER (0x01) |
#define AP_PROXY_TRANSFER_FLUSH_EACH (0x00) |
#define AP_PROXY_TRANSFER_YIELD_MAX_READS (0x04) |
#define AP_PROXY_TRANSFER_YIELD_PENDING (0x02) |
#define AP_PROXY_WORKER_IS_MALLOCED (1u << 2) |
#define AP_PROXY_WORKER_IS_MATCH (1u << 1) |
#define AP_PROXY_WORKER_IS_PREFIX (1u << 0) |
#define AP_PROXY_WORKER_NO_UDS (1u << 3) |
#define AP_VOLATILIZE_T | ( | T, | |
x | |||
) | (*(T volatile *)&(x)) |
#define APR_WANT_STRFUNC |
#define BALANCER_PREFIX "balancer://" |
#define CRLF "\015\012" |
#define DEFAULT_MAX_FORWARDS -1 |
#define HCHECK_WATHCHDOG_DEFAULT_INTERVAL (30) |
#define PROXY_BALANCER_MAX_HOSTNAME_SIZE 64 |
#define PROXY_BALANCER_MAX_NAME_SIZE 64 |
#define PROXY_BALANCER_MAX_ROUTE_SIZE 64 |
#define PROXY_BALANCER_MAX_STICKY_SIZE 64 |
#define PROXY_CANONENC_FORCEDEC 0x01 |
#define PROXY_CANONENC_NOENCODEDSLASHENCODING 0x02 |
#define PROXY_CHECK_CONN_EMPTY (1 << 0) |
#define PROXY_COPY_CONF_PARAMS | ( | w, | |
c | |||
) |
#define PROXY_DECLARE | ( | type | ) | type |
#define PROXY_DECLARE_DATA |
#define PROXY_DECLARE_NONSTD | ( | type | ) | type |
#define PROXY_DECLARE_OPTIONAL_HOOK APR_DECLARE_EXTERNAL_HOOK |
#define PROXY_DO_100_CONTINUE | ( | w, | |
r | |||
) |
#define PROXY_DYNAMIC_BALANCER_LIMIT 16 |
#define PROXY_FLUSH_WAIT 10000 |
#define PROXY_GLOBAL_LOCK | ( | x | ) | ( (x) && (x)->gmutex ? apr_global_mutex_lock((x)->gmutex) : APR_SUCCESS) |
#define PROXY_GLOBAL_UNLOCK | ( | x | ) | ( (x) && (x)->gmutex ? apr_global_mutex_unlock((x)->gmutex) : APR_SUCCESS) |
#define PROXY_LBMETHOD "proxylbmethod" |
#define PROXY_MAX_PROVIDER_NAME_SIZE 16 |
#define PROXY_RFC1035_HOSTNAME_SIZE 256 |
#define PROXY_SHOULD_PING_100_CONTINUE | ( | w, | |
r | |||
) |
#define PROXY_THREAD_LOCK | ( | x | ) | ( (x) && (x)->tmutex ? apr_thread_mutex_lock((x)->tmutex) : APR_SUCCESS) |
#define PROXY_THREAD_UNLOCK | ( | x | ) | ( (x) && (x)->tmutex ? apr_thread_mutex_unlock((x)->tmutex) : APR_SUCCESS) |
#define PROXY_WORKER_DEFAULT_RETRY 60 |
#define PROXY_WORKER_DISABLED 0x0020 |
#define PROXY_WORKER_DISABLED_FLAG 'D' |
#define PROXY_WORKER_DRAIN 0x0004 |
#define PROXY_WORKER_DRAIN_FLAG 'N' |
#define PROXY_WORKER_FREE 0x0200 |
#define PROXY_WORKER_FREE_FLAG 'F' |
#define PROXY_WORKER_GENERIC 0x0008 |
#define PROXY_WORKER_GENERIC_FLAG 'G' |
#define PROXY_WORKER_HC_FAIL 0x0400 |
#define PROXY_WORKER_HC_FAIL_FLAG 'C' |
#define PROXY_WORKER_HOT_SPARE 0x0800 |
#define PROXY_WORKER_HOT_SPARE_FLAG 'R' |
#define PROXY_WORKER_HOT_STANDBY 0x0100 |
#define PROXY_WORKER_HOT_STANDBY_FLAG 'H' |
#define PROXY_WORKER_IGNORE_ERRORS 0x0002 |
#define PROXY_WORKER_IGNORE_ERRORS_FLAG 'I' |
#define PROXY_WORKER_IN_ERROR 0x0080 |
#define PROXY_WORKER_IN_ERROR_FLAG 'E' |
#define PROXY_WORKER_IN_SHUTDOWN 0x0010 |
#define PROXY_WORKER_IN_SHUTDOWN_FLAG 'U' |
#define PROXY_WORKER_INITIALIZED 0x0001 |
#define PROXY_WORKER_INITIALIZED_FLAG 'O' |
#define PROXY_WORKER_IS_DRAINING | ( | f | ) | ( (f)->s->status & PROXY_WORKER_DRAIN ) |
#define PROXY_WORKER_IS_ERROR | ( | f | ) | ( (f)->s->status & PROXY_WORKER_IN_ERROR ) |
#define PROXY_WORKER_IS_GENERIC | ( | f | ) | ( (f)->s->status & PROXY_WORKER_GENERIC ) |
#define PROXY_WORKER_IS_HCFAILED | ( | f | ) | ( (f)->s->status & PROXY_WORKER_HC_FAIL ) |
#define PROXY_WORKER_IS_INITIALIZED | ( | f | ) | ( (f)->s->status & PROXY_WORKER_INITIALIZED ) |
#define PROXY_WORKER_IS_SPARE | ( | f | ) | ( (f)->s->status & PROXY_WORKER_HOT_SPARE ) |
#define PROXY_WORKER_IS_STANDBY | ( | f | ) | ( (f)->s->status & PROXY_WORKER_HOT_STANDBY ) |
#define PROXY_WORKER_IS_USABLE | ( | f | ) |
#define PROXY_WORKER_MAX_HOSTNAME_SIZE 96 |
#define PROXY_WORKER_MAX_NAME_SIZE 384 |
#define PROXY_WORKER_MAX_ROUTE_SIZE 96 |
#define PROXY_WORKER_MAX_SCHEME_SIZE 16 |
#define PROXY_WORKER_MAX_SECRET_SIZE 64 |
#define PROXY_WORKER_NOT_USABLE_BITMAP |
#define PROXY_WORKER_RFC1035_NAME_SIZE 512 |
#define PROXY_WORKER_STOPPED 0x0040 |
#define PROXY_WORKER_STOPPED_FLAG 'S' |
#define PROXY_WORKER_UDS_PATH_SIZE 256 |
#define PROXYPASS_INTERPOLATE 0x02 |
#define PROXYPASS_MAP_ENCODED 0x08 |
#define PROXYPASS_MAP_SERVLET 0x18 /* + MAP_ENCODED */ |
#define PROXYPASS_NOCANON 0x01 |
#define PROXYPASS_NOQUERY 0x04 |
typedef const char*(* ap_proxy_header_reverse_map_fn) (request_rec *, proxy_dir_conf *, const char *) |
typedef struct proxy_balancer proxy_balancer |
typedef struct proxy_balancer_method proxy_balancer_method |
typedef struct proxy_conn_pool proxy_conn_pool |
typedef int() proxy_is_best_callback_fn_t(proxy_worker *current, proxy_worker *prev_best, void *baton) |
typedef struct proxy_tunnel_conn proxy_tunnel_conn_t |
typedef struct proxy_worker proxy_worker |
enum enctype |
enum hcmethod_t |
enum proxy_hash_t |
apr_status_t ajp_handle_cping_cpong | ( | apr_socket_t * | sock, |
request_rec * | r, | ||
apr_interval_time_t | timeout | ||
) |
Do a AJP CPING and wait for CPONG on the socket
int ap_proxy_acquire_connection | ( | const char * | proxy_function, |
proxy_conn_rec ** | conn, | ||
proxy_worker * | worker, | ||
server_rec * | s | ||
) |
Acquire a connection from worker connection pool
proxy_function | calling proxy scheme (http, ajp, ...) |
conn | acquired connection |
worker | worker used for obtaining connection |
s | current server record |
void ap_proxy_backend_broke | ( | request_rec * | r, |
apr_bucket_brigade * | brigade | ||
) |
Fill a brigade that can be sent downstream to signal that the connection to the backend broke in the middle of the response. The brigade will contain an error bucket with status HTTP_BAD_GATEWAY and an EOS bucket.
r | current request record of client request |
brigade | the brigade to fill |
proxy_worker* ap_proxy_balancer_get_best_worker | ( | proxy_balancer * | balancer, |
request_rec * | r, | ||
proxy_is_best_callback_fn_t * | is_best, | ||
void * | baton | ||
) |
Retrieve the best worker in a balancer for the current request
balancer | balancer for which to find the best worker |
r | current request record |
is_best | a callback function provide by the lbmethod that determines if the current worker is best |
baton | an lbmethod-specific context pointer (baton) passed to the is_best callback |
apr_status_t ap_proxy_buckets_lifetime_transform | ( | request_rec * | r, |
apr_bucket_brigade * | from, | ||
apr_bucket_brigade * | to | ||
) |
void ap_proxy_c2hex | ( | int | ch, |
char * | x | ||
) |
char* ap_proxy_canon_netloc | ( | apr_pool_t * | p, |
char **const | urlp, | ||
char ** | userp, | ||
char ** | passwordp, | ||
char ** | hostp, | ||
apr_port_t * | port | ||
) |
char* ap_proxy_canonenc | ( | apr_pool_t * | p, |
const char * | x, | ||
int | len, | ||
enum enctype | t, | ||
int | forcedec, | ||
int | proxyreq | ||
) |
char* ap_proxy_canonenc_ex | ( | apr_pool_t * | p, |
const char * | x, | ||
int | len, | ||
enum enctype | t, | ||
int | flags, | ||
int | proxyreq | ||
) |
apr_status_t ap_proxy_check_connection | ( | const char * | scheme, |
proxy_conn_rec * | conn, | ||
server_rec * | server, | ||
unsigned | max_blank_lines, | ||
int | flags | ||
) |
Check a connection to the backend
scheme | calling proxy scheme (http, ajp, ...) |
conn | acquired connection |
server | current server record |
max_blank_lines | how many blank lines to consume, or zero for none (considered data) |
flags | PROXY_CHECK_* bitmask |
int ap_proxy_checkproxyblock | ( | request_rec * | r, |
proxy_server_conf * | conf, | ||
const char * | hostname, | ||
apr_sockaddr_t * | addr | ||
) |
Test whether the hostname/address of the request are blocked by the ProxyBlock configuration.
r | request |
conf | server configuration |
hostname | hostname from request URI |
addr | resolved address of hostname, or NULL if not known |
int ap_proxy_connect_backend | ( | const char * | proxy_function, |
proxy_conn_rec * | conn, | ||
proxy_worker * | worker, | ||
server_rec * | s | ||
) |
Make a connection to the backend
proxy_function | calling proxy scheme (http, ajp, ...) |
conn | acquired connection |
worker | connection worker |
s | current server record |
int ap_proxy_connect_to_backend | ( | apr_socket_t ** | , |
const char * | , | ||
apr_sockaddr_t * | , | ||
const char * | , | ||
proxy_server_conf * | , | ||
request_rec * | |||
) |
apr_status_t ap_proxy_connect_uds | ( | apr_socket_t * | sock, |
const char * | uds_path, | ||
apr_pool_t * | p | ||
) |
Make a connection to a Unix Domain Socket (UDS) path
sock | UDS to connect |
uds_path | UDS path to connect to |
p | pool to make the sock addr |
int ap_proxy_connection_create | ( | const char * | proxy_function, |
proxy_conn_rec * | conn, | ||
conn_rec * | c, | ||
server_rec * | s | ||
) |
Make a connection record for backend connection
proxy_function | calling proxy scheme (http, ajp, ...) |
conn | acquired connection |
c | client connection record (unused, deprecated) |
s | current server record |
int ap_proxy_connection_create_ex | ( | const char * | proxy_function, |
proxy_conn_rec * | conn, | ||
request_rec * | r | ||
) |
Make a connection record for backend connection, using request dir config
proxy_function | calling proxy scheme (http, ajp, ...) |
conn | acquired connection |
r | current request record |
int ap_proxy_connection_reusable | ( | proxy_conn_rec * | conn | ) |
Determine if proxy connection can potentially be reused at the end of this request.
conn | proxy connection |
const char* ap_proxy_cookie_reverse_map | ( | request_rec * | r, |
proxy_dir_conf * | conf, | ||
const char * | str | ||
) |
int ap_proxy_create_hdrbrgd | ( | apr_pool_t * | p, |
apr_bucket_brigade * | header_brigade, | ||
request_rec * | r, | ||
proxy_conn_rec * | p_conn, | ||
proxy_worker * | worker, | ||
proxy_server_conf * | conf, | ||
apr_uri_t * | uri, | ||
char * | url, | ||
char * | server_portstr, | ||
char ** | old_cl_val, | ||
char ** | old_te_val | ||
) |
Create a HTTP request header brigade, old_cl_val and old_te_val as required.
p | pool |
header_brigade | header brigade to use/fill |
r | request |
p_conn | proxy connection rec |
worker | selected worker |
conf | per-server proxy config |
uri | uri |
url | url |
server_portstr | port as string |
old_cl_val | stored old content-len val |
old_te_val | stored old TE val |
const char* ap_proxy_de_socketfy | ( | apr_pool_t * | p, |
const char * | url | ||
) |
Strip a unix domain socket (UDS) prefix from the input URL
p | pool to allocate result from |
url | a URL potentially prefixed with a UDS path |
char* ap_proxy_define_balancer | ( | apr_pool_t * | p, |
proxy_balancer ** | balancer, | ||
proxy_server_conf * | conf, | ||
const char * | url, | ||
const char * | alias, | ||
int | do_malloc | ||
) |
Define and Allocate space for the balancer to proxy configuration
p | memory pool to allocate balancer from |
balancer | the new balancer |
conf | current proxy server configuration |
url | url containing balancer name |
alias | alias/fake-path to this balancer |
do_malloc | true if shared struct should be malloced |
char* ap_proxy_define_match_worker | ( | apr_pool_t * | p, |
proxy_worker ** | worker, | ||
proxy_balancer * | balancer, | ||
proxy_server_conf * | conf, | ||
const char * | url, | ||
int | do_malloc | ||
) |
Define and Allocate space for the ap_strcmp_match()able worker to proxy configuration.
p | memory pool to allocate worker from |
worker | the new worker |
balancer | the balancer that the worker belongs to |
conf | current proxy server configuration |
url | url containing worker name (produces match pattern) |
do_malloc | true if shared struct should be malloced |
char* ap_proxy_define_worker | ( | apr_pool_t * | p, |
proxy_worker ** | worker, | ||
proxy_balancer * | balancer, | ||
proxy_server_conf * | conf, | ||
const char * | url, | ||
int | do_malloc | ||
) |
Define and Allocate space for the worker to proxy configuration
p | memory pool to allocate worker from |
worker | the new worker |
balancer | the balancer that the worker belongs to |
conf | current proxy server configuration |
url | url containing worker name |
do_malloc | true if shared struct should be malloced |
char* ap_proxy_define_worker_ex | ( | apr_pool_t * | p, |
proxy_worker ** | worker, | ||
proxy_balancer * | balancer, | ||
proxy_server_conf * | conf, | ||
const char * | url, | ||
unsigned int | mask | ||
) |
Define and Allocate space for the worker to proxy configuration, of either PREFIXED or MATCHED type according to given mask
p | memory pool to allocate worker from |
worker | the new worker |
balancer | the balancer that the worker belongs to |
conf | current proxy server configuration |
url | url containing worker name |
mask | bitmask of AP_PROXY_WORKER_IS_* |
int ap_proxy_determine_connection | ( | apr_pool_t * | p, |
request_rec * | r, | ||
proxy_server_conf * | conf, | ||
proxy_worker * | worker, | ||
proxy_conn_rec * | conn, | ||
apr_uri_t * | uri, | ||
char ** | url, | ||
const char * | proxyname, | ||
apr_port_t | proxyport, | ||
char * | server_portstr, | ||
int | server_portstr_size | ||
) |
Determine backend hostname and port
p | memory pool used for processing |
r | current request |
conf | current proxy server configuration |
worker | worker used for processing request |
conn | proxy connection struct |
uri | processed uri |
url | request url |
proxyname | are we connecting directly or via a proxy |
proxyport | proxy host port |
server_portstr | Via headers server port, must be non-NULL |
server_portstr_size | size of the server_portstr buffer; must be at least one, even if the protocol doesn't use this |
void ap_proxy_fill_error_brigade | ( | request_rec * | r, |
int | status, | ||
apr_bucket_brigade * | bb, | ||
int | eoc | ||
) |
Fill a brigade that can be sent downstream to signal that the connection to the backend broke in the middle of the response. The brigade will contain an error bucket with the given status and eventually an EOC bucket if asked to or heuristically if the response header was sent already.
r | current request record of client request |
status | the error status |
bb | the brigade to fill |
eoc | 0 do not add an EOC bucket, > 0 always add one, < 0 add one only if the response header was sent already |
proxy_balancer_shared* ap_proxy_find_balancershm | ( | ap_slotmem_provider_t * | storage, |
ap_slotmem_instance_t * | slot, | ||
proxy_balancer * | balancer, | ||
unsigned int * | index | ||
) |
Find the shm of the balancer as needed
storage | slotmem provider |
slot | slotmem instance |
balancer | balancer of shm to find |
index | pointer to index within slotmem of balancer |
proxy_worker_shared* ap_proxy_find_workershm | ( | ap_slotmem_provider_t * | storage, |
ap_slotmem_instance_t * | slot, | ||
proxy_worker * | worker, | ||
unsigned int * | index | ||
) |
Find the shm of the worker as needed
storage | slotmem provider |
slot | slotmem instance |
worker | worker to find |
index | pointer to index within slotmem of worker |
proxy_balancer* ap_proxy_get_balancer | ( | apr_pool_t * | p, |
proxy_server_conf * | conf, | ||
const char * | url, | ||
int | careactive | ||
) |
Get the balancer from proxy configuration
p | memory pool used for temporary storage while finding balancer |
conf | current proxy server configuration |
url | url to find the worker from; must have balancer:// prefix |
careactive | true if we care if the balancer is active or not |
proxy_worker* ap_proxy_get_worker | ( | apr_pool_t * | p, |
proxy_balancer * | balancer, | ||
proxy_server_conf * | conf, | ||
const char * | url | ||
) |
Get the worker from proxy configuration, both types
p | memory pool used for finding worker |
balancer | the balancer that the worker belongs to |
conf | current proxy server configuration |
url | url to find the worker from |
proxy_worker* ap_proxy_get_worker_ex | ( | apr_pool_t * | p, |
proxy_balancer * | balancer, | ||
proxy_server_conf * | conf, | ||
const char * | url, | ||
unsigned int | mask | ||
) |
Get the worker from proxy configuration, looking for either PREFIXED or MATCHED or both types of workers according to given mask
p | memory pool used for finding worker |
balancer | the balancer that the worker belongs to |
conf | current proxy server configuration |
url | url to find the worker from |
mask | bitmask of AP_PROXY_WORKER_IS_* |
unsigned int ap_proxy_hashfunc | ( | const char * | str, |
proxy_hash_t | method | ||
) |
int ap_proxy_hex2c | ( | const char * | x | ) |
apr_status_t ap_proxy_initialize_balancer | ( | proxy_balancer * | balancer, |
server_rec * | s, | ||
apr_pool_t * | p | ||
) |
Initialize the balancer as needed
balancer | balancer to initialize |
s | current server record |
p | memory pool used for mutex and connection pool |
apr_status_t ap_proxy_initialize_worker | ( | proxy_worker * | worker, |
server_rec * | s, | ||
apr_pool_t * | p | ||
) |
Initialize the worker by setting up worker connection pool and mutex
worker | worker to initialize |
s | current server record |
p | memory pool used for mutex and connection pool |
int ap_proxy_is_socket_connected | ( | apr_socket_t * | socket | ) |
socket | socket to test |
int ap_proxy_lb_workers | ( | void | ) |
Calculate maximum number of workers in scoreboard.
const char* ap_proxy_location_reverse_map | ( | request_rec * | r, |
proxy_dir_conf * | conf, | ||
const char * | url | ||
) |
char* ap_proxy_parse_wstatus | ( | apr_pool_t * | p, |
proxy_worker * | w | ||
) |
Create readable representation of worker status bitfield
p | pool |
w | worker to use |
int ap_proxy_pass_brigade | ( | apr_bucket_alloc_t * | bucket_alloc, |
request_rec * | r, | ||
proxy_conn_rec * | p_conn, | ||
conn_rec * | origin, | ||
apr_bucket_brigade * | bb, | ||
int | flush | ||
) |
bucket_alloc | bucket allocator |
r | request |
p_conn | proxy connection |
origin | connection rec of origin |
bb | brigade to send to origin |
flush | flush |
apr_port_t ap_proxy_port_of_scheme | ( | const char * | scheme | ) |
Return the port number of a known scheme (eg: http -> 80).
scheme | scheme to test |
int ap_proxy_post_request | ( | proxy_worker * | worker, |
proxy_balancer * | balancer, | ||
request_rec * | r, | ||
proxy_server_conf * | conf | ||
) |
Post request worker and balancer cleanup
worker | worker used for processing request |
balancer | balancer used for processing request |
r | current request |
conf | current proxy server configuration |
int ap_proxy_pre_http_request | ( | conn_rec * | c, |
request_rec * | r | ||
) |
int ap_proxy_pre_request | ( | proxy_worker ** | worker, |
proxy_balancer ** | balancer, | ||
request_rec * | r, | ||
proxy_server_conf * | conf, | ||
char ** | url | ||
) |
Get the most suitable worker and/or balancer for the request
worker | worker used for processing request |
balancer | balancer used for processing request |
r | current request |
conf | current proxy server configuration |
url | request url that balancer can rewrite. |
int ap_proxy_prefetch_input | ( | request_rec * | r, |
proxy_conn_rec * | backend, | ||
apr_bucket_brigade * | input_brigade, | ||
apr_read_type_e | block, | ||
apr_off_t * | bytes_read, | ||
apr_off_t | max_read | ||
) |
Prefetch the client request body (in memory), up to a limit. Read what's in the client pipe. If nonblocking is set and read is EAGAIN, pass a FLUSH bucket to the backend and read again in blocking mode.
r | client request |
backend | backend connection |
input_brigade | input brigade to use/fill |
block | blocking or non-blocking mode |
bytes_read | number of bytes read |
max_read | maximum number of bytes to read |
int ap_proxy_read_input | ( | request_rec * | r, |
proxy_conn_rec * | backend, | ||
apr_bucket_brigade * | input_brigade, | ||
apr_off_t | max_read | ||
) |
Read what's in the client pipe. If the read would block (EAGAIN), pass a FLUSH bucket to the backend and read again in blocking mode.
r | client request |
backend | backend connection |
input_brigade | brigade to use/fill |
max_read | maximum number of bytes to read |
int ap_proxy_release_connection | ( | const char * | proxy_function, |
proxy_conn_rec * | conn, | ||
server_rec * | s | ||
) |
Release a connection back to worker connection pool
proxy_function | calling proxy scheme (http, ajp, ...) |
conn | acquired connection |
s | current server record |
int ap_proxy_retry_worker | ( | const char * | proxy_function, |
proxy_worker * | worker, | ||
server_rec * | s | ||
) |
Mark a worker for retry
proxy_function | calling proxy scheme (http, ajp, ...) |
worker | worker used for retrying |
s | current server record |
apr_status_t ap_proxy_set_wstatus | ( | char | c, |
int | set, | ||
proxy_worker * | w | ||
) |
Set/unset the worker status bitfield depending on flag
c | flag |
set | set or unset bit |
w | worker to use |
apr_status_t ap_proxy_share_balancer | ( | proxy_balancer * | balancer, |
proxy_balancer_shared * | shm, | ||
int | i | ||
) |
Share a defined proxy balancer via shm
balancer | balancer to be shared |
shm | location of shared info |
i | index into shm |
apr_status_t ap_proxy_share_worker | ( | proxy_worker * | worker, |
proxy_worker_shared * | shm, | ||
int | i | ||
) |
Share a defined proxy worker via shm
worker | worker to be shared |
shm | location of shared info |
i | index into shm |
int ap_proxy_should_override | ( | proxy_dir_conf * | conf, |
int | code | ||
) |
Returns 1 if a response with the given status should be overridden.
conf | proxy directory configuration |
code | http status code |
const char* ap_proxy_show_hcmethod | ( | hcmethod_t | method | ) |
Return the name of the health check method (eg: "OPTIONS").
method | method enum |
int ap_proxy_spool_input | ( | request_rec * | r, |
proxy_conn_rec * | backend, | ||
apr_bucket_brigade * | input_brigade, | ||
apr_off_t * | bytes_spooled, | ||
apr_off_t | max_mem_spool | ||
) |
Spool the client request body to memory, or disk above given limit.
r | client request |
backend | backend connection |
input_brigade | input brigade to use/fill |
bytes_spooled | number of bytes spooled |
max_mem_spool | maximum number of in-memory bytes |
apr_status_t ap_proxy_ssl_connection_cleanup | ( | proxy_conn_rec * | conn, |
request_rec * | r | ||
) |
int ap_proxy_ssl_engine | ( | conn_rec * | c, |
ap_conf_vector_t * | per_dir_config, | ||
int | enable | ||
) |
const char* ap_proxy_ssl_val | ( | apr_pool_t * | p, |
server_rec * | s, | ||
conn_rec * | c, | ||
request_rec * | r, | ||
const char * | var | ||
) |
apr_status_t ap_proxy_sync_balancer | ( | proxy_balancer * | b, |
server_rec * | s, | ||
proxy_server_conf * | conf | ||
) |
Sync balancer and workers based on any updates w/i shm
b | balancer to check/update member list of |
s | server rec |
conf | config |
int ap_proxy_trans_match | ( | request_rec * | r, |
struct proxy_alias * | ent, | ||
proxy_dir_conf * | dconf | ||
) |
Find the matched alias for this request and setup for proxy handler
r | request |
ent | proxy_alias record |
dconf | per-dir config or NULL |
apr_status_t ap_proxy_transfer_between_connections | ( | request_rec * | r, |
conn_rec * | c_i, | ||
conn_rec * | c_o, | ||
apr_bucket_brigade * | bb_i, | ||
apr_bucket_brigade * | bb_o, | ||
const char * | name, | ||
int * | sent, | ||
apr_off_t | bsize, | ||
int | flags | ||
) |
apr_off_t ap_proxy_tunnel_conn_bytes_in | ( | const proxy_tunnel_conn_t * | tc | ) |
apr_off_t ap_proxy_tunnel_conn_bytes_out | ( | const proxy_tunnel_conn_t * | tc | ) |
apr_status_t ap_proxy_tunnel_create | ( | proxy_tunnel_rec ** | tunnel, |
request_rec * | r, | ||
conn_rec * | c_o, | ||
const char * | scheme | ||
) |
Create a tunnel, to be activated by ap_proxy_tunnel_run().
tunnel | tunnel created |
r | client request |
c_o | connection to origin |
scheme | caller proxy scheme (connect, ws(s), http(s), ...) |
int ap_proxy_tunnel_run | ( | proxy_tunnel_rec * | tunnel | ) |
Forward anything from either side of the tunnel to the other, until one end aborts or a polling timeout/error occurs.
tunnel | tunnel to run |
char* ap_proxy_update_balancer | ( | apr_pool_t * | p, |
proxy_balancer * | balancer, | ||
const char * | url | ||
) |
Update the balancer's vhost related fields
p | memory pool used for temporary storage while finding balancer |
balancer | balancer to be updated |
url | url to find vhost info |
Verifies valid balancer name (eg: balancer://foo)
name | name to test |
i | number of chars to test; 0 for all. |
int ap_proxy_worker_can_upgrade | ( | apr_pool_t * | p, |
const proxy_worker * | worker, | ||
const char * | upgrade, | ||
const char * | dflt | ||
) |
Return whether a worker upgrade configuration matches Upgrade header
p | memory pool used for displaying worker name |
worker | the worker |
upgrade | the Upgrade header to match |
dflt | default protocol (NULL for none) |
char* ap_proxy_worker_name | ( | apr_pool_t * | p, |
proxy_worker * | worker | ||
) |
Return the user-land, UDS aware worker name
p | memory pool used for displaying worker name |
worker | the worker |
int ap_proxyerror | ( | request_rec * | r, |
int | statuscode, | ||
const char * | message | ||
) |
apr_status_t balancer_manage | ( | request_rec * | , |
apr_table_t * | params | ||
) |
Configure and create workers (and balancer) in mod_balancer.
r | request |
params | table with the parameters like b=mycluster etc. |
void hc_select_exprs | ( | request_rec * | , |
const char * | |||
) |
void hc_show_exprs | ( | request_rec * | ) |
int hc_valid_expr | ( | request_rec * | , |
const char * | |||
) |
proxy_worker* proxy_balancer_get_best_worker | ( | proxy_balancer * | balancer, |
request_rec * | r, | ||
proxy_is_best_callback_fn_t * | is_best, | ||
void * | baton | ||
) |
PROXY_DECLARE_OPTIONAL_HOOK | ( | proxy | , |
PROXY | , | ||
int | , | ||
create_req | , | ||
(request_rec *r, request_rec *pr) | |||
) |
Let modules perform processing when the connection to the origin is being detached from the request.
r | The client request |
backend | The proxy representation of the backend connection |
PROXY_DECLARE_OPTIONAL_HOOK | ( | proxy | , |
PROXY | , | ||
int | , | ||
request_status | , | ||
(int *status, request_rec *r) | |||
) |
request status hook It is called after all proxy processing has been done. This gives other modules a chance to create default content on failure, for example
PROXY_DECLARE_OPTIONAL_HOOK | ( | proxy | , |
PROXY | , | ||
int | , | ||
section_post_config | , | ||
(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s, ap_conf_vector_t *section_config) | |||
) |
PROXY_DECLARE_OPTIONAL_HOOK | ( | proxy | , |
PROXY | , | ||
int | , | ||
tunnel_forward | , | ||
(proxy_tunnel_rec *tunnel, conn_rec *c_i, conn_rec *c_o, apr_bucket_brigade *bb) | |||
) |
Tunnel forwarding hook Called for every brigade forwarded by a tunnel from/to the client to/from the origin. Each hook receives incoming buckets in bb and produces outgoing buckets in the same bb, much like an output filter.
tunnel | the tunnel |
c | the connection the data are going to |
bb | the incoming data |
r | request |
headers | table of headers to clear |
int proxy_hook_canon_handler | ( | request_rec * | r, |
char * | url | ||
) |
int proxy_hook_check_trans | ( | request_rec * | r, |
const char * | url | ||
) |
int proxy_hook_post_request | ( | proxy_worker * | worker, |
proxy_balancer * | balancer, | ||
request_rec * | r, | ||
proxy_server_conf * | conf | ||
) |
post request hook. It is called after request for updating runtime balancer status.
request_rec proxy_conn_rec* backend int proxy_hook_pre_request | ( | proxy_worker ** | worker, |
proxy_balancer ** | balancer, | ||
request_rec * | r, | ||
proxy_server_conf * | conf, | ||
char ** | url | ||
) |
pre request hook. It will return the most suitable worker at the moment and corresponding balancer. The url is rewritten from balancer://cluster/uri to scheme://host:port/uri and then the scheme_handler is called.
const char* set_worker_hc_param | ( | apr_pool_t * | , |
server_rec * | , | ||
proxy_worker * | , | ||
const char * | , | ||
const char * | , | ||
void * | |||
) |
detach_backend |
const char apr_size_t dlen |
apr_table_t* headers |
int |
PROXY |
|
extern |
|
extern |
|
extern |
proxy_worker proxy_server_conf char const char* proxyhost |
proxy_worker proxy_server_conf char const char apr_port_t proxyport |
request_rec* r |
const char* src |
proxy_worker proxy_server_conf char* url |
proxy_worker* worker |