/* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __mod_h2__h2_proxy_util__ #define __mod_h2__h2_proxy_util__ /******************************************************************************* * some debugging/format helpers ******************************************************************************/ struct h2_proxy_request; struct nghttp2_frame; int h2_proxy_util_frame_print(const nghttp2_frame *frame, char *buffer, size_t maxlen); /******************************************************************************* * ihash - hash for structs with int identifier ******************************************************************************/ typedef struct h2_proxy_ihash_t h2_proxy_ihash_t; typedef int h2_proxy_ihash_iter_t(void *ctx, void *val); /** * Create a hash for structures that have an identifying int member. * @param pool the pool to use * @param offset_of_int the offsetof() the int member in the struct */ h2_proxy_ihash_t *h2_proxy_ihash_create(apr_pool_t *pool, size_t offset_of_int); size_t h2_proxy_ihash_count(h2_proxy_ihash_t *ih); int h2_proxy_ihash_empty(h2_proxy_ihash_t *ih); void *h2_proxy_ihash_get(h2_proxy_ihash_t *ih, int id); /** * Iterate over the hash members (without defined order) and invoke * fn for each member until 0 is returned. * @param ih the hash to iterate over * @param fn the function to invoke on each member * @param ctx user supplied data passed into each iteration call * @return 0 if one iteration returned 0, otherwise != 0 */ int h2_proxy_ihash_iter(h2_proxy_ihash_t *ih, h2_proxy_ihash_iter_t *fn, void *ctx); void h2_proxy_ihash_add(h2_proxy_ihash_t *ih, void *val); void h2_proxy_ihash_remove(h2_proxy_ihash_t *ih, int id); void h2_proxy_ihash_remove_val(h2_proxy_ihash_t *ih, void *val); void h2_proxy_ihash_clear(h2_proxy_ihash_t *ih); size_t h2_proxy_ihash_shift(h2_proxy_ihash_t *ih, void **buffer, size_t max); size_t h2_proxy_ihash_ishift(h2_proxy_ihash_t *ih, int *buffer, size_t max); /******************************************************************************* * iqueue - sorted list of int with user defined ordering ******************************************************************************/ typedef struct h2_proxy_iqueue { int *elts; int head; int nelts; int nalloc; apr_pool_t *pool; } h2_proxy_iqueue; /** * Comparator for two int to determine their order. * * @param i1 first int to compare * @param i2 second int to compare * @param ctx provided user data * @return value is the same as for strcmp() and has the effect: * == 0: s1 and s2 are treated equal in ordering * < 0: s1 should be sorted before s2 * > 0: s2 should be sorted before s1 */ typedef int h2_proxy_iq_cmp(int i1, int i2, void *ctx); /** * Allocate a new queue from the pool and initialize. * @param id the identifier of the queue * @param pool the memory pool */ h2_proxy_iqueue *h2_proxy_iq_create(apr_pool_t *pool, int capacity); /** * Return != 0 iff there are no tasks in the queue. * @param q the queue to check */ int h2_proxy_iq_empty(h2_proxy_iqueue *q); /** * Return the number of int in the queue. * @param q the queue to get size on */ int h2_proxy_iq_count(h2_proxy_iqueue *q); /** * Add a stream id to the queue. * * @param q the queue to append the task to * @param sid the stream id to add * @param cmp the comparator for sorting * @param ctx user data for comparator */ void h2_proxy_iq_add(h2_proxy_iqueue *q, int sid, h2_proxy_iq_cmp *cmp, void *ctx); /** * Remove the stream id from the queue. Return != 0 iff task * was found in queue. * @param q the task queue * @param sid the stream id to remove * @return != 0 iff task was found in queue */ int h2_proxy_iq_remove(h2_proxy_iqueue *q, int sid); /** * Remove all entries in the queue. */ void h2_proxy_iq_clear(h2_proxy_iqueue *q); /** * Sort the stream idqueue again. Call if the task ordering * has changed. * * @param q the queue to sort * @param cmp the comparator for sorting * @param ctx user data for the comparator */ void h2_proxy_iq_sort(h2_proxy_iqueue *q, h2_proxy_iq_cmp *cmp, void *ctx); /** * Get the first stream id from the queue or NULL if the queue is empty. * The task will be removed. * * @param q the queue to get the first task from * @return the first stream id of the queue, 0 if empty */ int h2_proxy_iq_shift(h2_proxy_iqueue *q); /******************************************************************************* * common helpers ******************************************************************************/ /* h2_proxy_log2(n) iff n is a power of 2 */ unsigned char h2_proxy_log2(int n); /******************************************************************************* * HTTP/2 header helpers ******************************************************************************/ void h2_proxy_util_camel_case_header(char *s, size_t len); int h2_proxy_res_ignore_header(const char *name, size_t len); /******************************************************************************* * nghttp2 helpers ******************************************************************************/ typedef struct h2_proxy_ngheader { nghttp2_nv *nv; apr_size_t nvlen; } h2_proxy_ngheader; h2_proxy_ngheader *h2_proxy_util_nghd_make_req(apr_pool_t *p, const struct h2_proxy_request *req); /******************************************************************************* * h2_proxy_request helpers ******************************************************************************/ typedef struct h2_proxy_request h2_proxy_request; struct h2_proxy_request { const char *method; /* pseudo header values, see ch. 8.1.2.3 */ const char *scheme; const char *authority; const char *path; apr_table_t *headers; apr_time_t request_time; unsigned int chunked : 1; /* iff requst body needs to be forwarded as chunked */ unsigned int serialize : 1; /* iff this request is written in HTTP/1.1 serialization */ }; h2_proxy_request *h2_proxy_req_create(int id, apr_pool_t *pool, int serialize); apr_status_t h2_proxy_req_make(h2_proxy_request *req, apr_pool_t *pool, const char *method, const char *scheme, const char *authority, const char *path, apr_table_t *headers); /******************************************************************************* * reverse mapping for link headers ******************************************************************************/ const char *h2_proxy_link_reverse_map(request_rec *r, proxy_dir_conf *conf, const char *real_server_uri, const char *proxy_server_uri, const char *s); /******************************************************************************* * FIFO queue ******************************************************************************/ /** * A thread-safe FIFO queue with some extra bells and whistles, if you * do not need anything special, better use 'apr_queue'. */ typedef struct h2_proxy_fifo h2_proxy_fifo; /** * Create a FIFO queue that can hold up to capacity elements. Elements can * appear several times. */ apr_status_t h2_proxy_fifo_create(h2_proxy_fifo **pfifo, apr_pool_t *pool, int capacity); /** * Create a FIFO set that can hold up to capacity elements. Elements only * appear once. Pushing an element already present does not change the * queue and is successful. */ apr_status_t h2_proxy_fifo_set_create(h2_proxy_fifo **pfifo, apr_pool_t *pool, int capacity); apr_status_t h2_proxy_fifo_term(h2_proxy_fifo *fifo); apr_status_t h2_proxy_fifo_interrupt(h2_proxy_fifo *fifo); int h2_proxy_fifo_capacity(h2_proxy_fifo *fifo); int h2_proxy_fifo_count(h2_proxy_fifo *fifo); /** * Push en element into the queue. Blocks if there is no capacity left. * * @param fifo the FIFO queue * @param elem the element to push * @return APR_SUCCESS on push, APR_EAGAIN on try_push on a full queue, * APR_EEXIST when in set mode and elem already there. */ apr_status_t h2_proxy_fifo_push(h2_proxy_fifo *fifo, void *elem); apr_status_t h2_proxy_fifo_try_push(h2_proxy_fifo *fifo, void *elem); apr_status_t h2_proxy_fifo_pull(h2_proxy_fifo *fifo, void **pelem); apr_status_t h2_proxy_fifo_try_pull(h2_proxy_fifo *fifo, void **pelem); /** * Remove the elem from the queue, will remove multiple appearances. * @param elem the element to remove * @return APR_SUCCESS iff > 0 elems were removed, APR_EAGAIN otherwise. */ apr_status_t h2_proxy_fifo_remove(h2_proxy_fifo *fifo, void *elem); #endif /* defined(__mod_h2__h2_proxy_util__) */