Quelle h2_proxy_util.h Sprache: C

/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#ifndef __mod_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_ngheader *h2_proxy_util_nghd_make(apr_pool_t *p, apr_table_t *headers);

/*******************************************************************************
* 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;

    int chunked;   /* iff request body needs to be forwarded as chunked */
};

h2_proxy_request *h2_proxy_req_create(int id, apr_pool_t *pool);
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__) */

quality100%

¤ Dauer der Verarbeitung: 0.2 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.