h2_util.h

Go to the documentation of this file.

/* 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_util__
#define __mod_h2__h2_util__
 
#include <nghttp2/nghttp2.h>
#include <http_protocol.h>
 
#include "h2.h"
#include "h2_headers.h"
 
/*******************************************************************************
 * some debugging/format helpers
 ******************************************************************************/
struct h2_request;
struct nghttp2_frame;
 
size_t h2_util_hex_dump(char *buffer, size_t maxlen,
                        const char *data, size_t datalen);
 
void h2_util_camel_case_header(char *s, size_t len);
 
int h2_util_frame_print(const nghttp2_frame *frame, char *buffer, size_t maxlen);
 
/*******************************************************************************
 * ihash - hash for structs with int identifier
 ******************************************************************************/
typedef struct h2_ihash_t h2_ihash_t;
typedef int h2_ihash_iter_t(void *ctx, void *val);
 
h2_ihash_t *h2_ihash_create(apr_pool_t *pool, size_t offset_of_int);
 
unsigned int h2_ihash_count(h2_ihash_t *ih);
int h2_ihash_empty(h2_ihash_t *ih);
void *h2_ihash_get(h2_ihash_t *ih, int id);
 
int h2_ihash_iter(h2_ihash_t *ih, h2_ihash_iter_t *fn, void *ctx);
 
void h2_ihash_add(h2_ihash_t *ih, void *val);
void h2_ihash_remove(h2_ihash_t *ih, int id);
void h2_ihash_remove_val(h2_ihash_t *ih, void *val);
void h2_ihash_clear(h2_ihash_t *ih);
 
size_t h2_ihash_shift(h2_ihash_t *ih, void **buffer, size_t max);
 
/*******************************************************************************
 * iqueue - sorted list of int with user defined ordering
 ******************************************************************************/
typedef struct h2_iqueue {
    int *elts;
    int head;
    int nelts;
    int nalloc;
    apr_pool_t *pool;
} h2_iqueue;
 
typedef int h2_iq_cmp(int i1, int i2, void *ctx);
 
h2_iqueue *h2_iq_create(apr_pool_t *pool, int capacity);
 
int h2_iq_empty(h2_iqueue *q);
 
int h2_iq_count(h2_iqueue *q);
 
int h2_iq_add(h2_iqueue *q, int sid, h2_iq_cmp *cmp, void *ctx);
 
int h2_iq_append(h2_iqueue *q, int sid);
 
int h2_iq_remove(h2_iqueue *q, int sid);
 
void h2_iq_clear(h2_iqueue *q);
 
void h2_iq_sort(h2_iqueue *q, h2_iq_cmp *cmp, void *ctx);
 
int h2_iq_shift(h2_iqueue *q);
 
size_t h2_iq_mshift(h2_iqueue *q, int *pint, size_t max);
 
int h2_iq_contains(h2_iqueue *q, int sid);
 
/*******************************************************************************
 * FIFO queue (void* elements)
 ******************************************************************************/
 
typedef struct h2_fifo h2_fifo;
 
apr_status_t h2_fifo_create(h2_fifo **pfifo, apr_pool_t *pool, int capacity);
 
apr_status_t h2_fifo_set_create(h2_fifo **pfifo, apr_pool_t *pool, int capacity);
 
apr_status_t h2_fifo_term(h2_fifo *fifo);
 
int h2_fifo_count(h2_fifo *fifo);
 
apr_status_t h2_fifo_push(h2_fifo *fifo, void *elem);
apr_status_t h2_fifo_try_push(h2_fifo *fifo, void *elem);
 
apr_status_t h2_fifo_pull(h2_fifo *fifo, void **pelem);
apr_status_t h2_fifo_try_pull(h2_fifo *fifo, void **pelem);
 
typedef enum {
    H2_FIFO_OP_PULL,   /* pull the element from the queue, ie discard it */
    H2_FIFO_OP_REPUSH, /* pull and immediately re-push it */
} h2_fifo_op_t;
 
typedef h2_fifo_op_t h2_fifo_peek_fn(void *head, void *ctx);
 
apr_status_t h2_fifo_peek(h2_fifo *fifo, h2_fifo_peek_fn *fn, void *ctx);
 
apr_status_t h2_fifo_try_peek(h2_fifo *fifo, h2_fifo_peek_fn *fn, void *ctx);
 
apr_status_t h2_fifo_remove(h2_fifo *fifo, void *elem);
 
/*******************************************************************************
 * iFIFO queue (int elements)
 ******************************************************************************/
 
typedef struct h2_ififo h2_ififo;
 
apr_status_t h2_ififo_create(h2_ififo **pfifo, apr_pool_t *pool, int capacity);
 
apr_status_t h2_ififo_set_create(h2_ififo **pfifo, apr_pool_t *pool, int capacity);
 
apr_status_t h2_ififo_term(h2_ififo *fifo);
 
int h2_ififo_count(h2_ififo *fifo);
 
apr_status_t h2_ififo_push(h2_ififo *fifo, int id);
apr_status_t h2_ififo_try_push(h2_ififo *fifo, int id);
 
apr_status_t h2_ififo_pull(h2_ififo *fifo, int *pi);
apr_status_t h2_ififo_try_pull(h2_ififo *fifo, int *pi);
 
typedef h2_fifo_op_t h2_ififo_peek_fn(int head, void *ctx);
 
apr_status_t h2_ififo_peek(h2_ififo *fifo, h2_ififo_peek_fn *fn, void *ctx);
 
apr_status_t h2_ififo_try_peek(h2_ififo *fifo, h2_ififo_peek_fn *fn, void *ctx);
 
apr_status_t h2_ififo_remove(h2_ififo *fifo, int id);
 
/*******************************************************************************
 * common helpers
 ******************************************************************************/
/* h2_log2(n) iff n is a power of 2 */
unsigned char h2_log2(int n);
 
apr_size_t h2_util_table_bytes(apr_table_t *t, apr_size_t pair_extra);
 
#define H2_HD_MATCH_LIT(l, name, nlen)  \
    ((nlen == sizeof(l) - 1) && !ap_cstr_casecmp(l, name))
 
/*******************************************************************************
 * HTTP/2 header helpers
 ******************************************************************************/
int h2_ignore_req_trailer(const char *name, size_t len);
int h2_ignore_resp_trailer(const char *name, size_t len);
 
int h2_push_policy_determine(apr_table_t *headers, apr_pool_t *p, int push_enabled);
 
/*******************************************************************************
 * base64 url encoding, different table from normal base64
 ******************************************************************************/
apr_size_t h2_util_base64url_decode(const char **decoded, 
                                    const char *encoded, 
                                    apr_pool_t *pool);
const char *h2_util_base64url_encode(const char *data, 
                                     apr_size_t len, apr_pool_t *pool);
 
/*******************************************************************************
 * nghttp2 helpers
 ******************************************************************************/
 
int h2_util_ignore_resp_header(const char *name);
 
typedef struct h2_ngheader {
    nghttp2_nv *nv;
    apr_size_t nvlen;
} h2_ngheader;
 
#if AP_HAS_RESPONSE_BUCKETS
apr_status_t h2_res_create_ngtrailer(h2_ngheader **ph, apr_pool_t *p,
                                     ap_bucket_headers *headers);
apr_status_t h2_res_create_ngheader(h2_ngheader **ph, apr_pool_t *p,
                                    ap_bucket_response *response);
apr_status_t h2_req_create_ngheader(h2_ngheader **ph, apr_pool_t *p,
                                    const struct h2_request *req);
#else
apr_status_t h2_res_create_ngtrailer(h2_ngheader **ph, apr_pool_t *p, 
                                     struct h2_headers *headers); 
apr_status_t h2_res_create_ngheader(h2_ngheader **ph, apr_pool_t *p, 
                                    struct h2_headers *headers); 
apr_status_t h2_req_create_ngheader(h2_ngheader **ph, apr_pool_t *p, 
                                    const struct h2_request *req);
#endif
 
apr_status_t h2_req_add_header(apr_table_t *headers, apr_pool_t *pool, 
                               const char *name, size_t nlen,
                               const char *value, size_t vlen,
                               size_t max_field_len, int *pwas_added);
 
/*******************************************************************************
 * apr brigade helpers
 ******************************************************************************/
 
apr_status_t h2_brigade_concat_length(apr_bucket_brigade *dest, 
                                      apr_bucket_brigade *src,
                                      apr_off_t length);
                                
apr_status_t h2_brigade_copy_length(apr_bucket_brigade *dest, 
                                    apr_bucket_brigade *src,
                                    apr_off_t length);
                                
typedef apr_status_t h2_util_pass_cb(void *ctx,
                                     const char *data, apr_off_t len);
 
apr_size_t h2_util_bucket_print(char *buffer, apr_size_t bmax, 
                                apr_bucket *b, const char *sep);
                                
apr_size_t h2_util_bb_print(char *buffer, apr_size_t bmax, 
                            const char *tag, const char *sep, 
                            apr_bucket_brigade *bb);
#define h2_util_bb_log(c, sid, level, tag, bb) \
if (APLOG_C_IS_LEVEL(c, level)) { \
    do { \
        char buffer[4 * 1024]; \
        const char *line = "(null)"; \
        apr_size_t len, bmax = sizeof(buffer)/sizeof(buffer[0]); \
        len = h2_util_bb_print(buffer, bmax, (tag), "", (bb)); \
        ap_log_cerror(APLOG_MARK, level, 0, (c), "bb_dump(%ld): %s", \
            ((c)->master? (c)->master->id : (c)->id), (len? buffer : line)); \
    } while(0); \
}
 
 
typedef int h2_bucket_gate(apr_bucket *b);
apr_status_t h2_append_brigade(apr_bucket_brigade *to,
                               apr_bucket_brigade *from, 
                               apr_off_t *plen,
                               int *peos,
                               h2_bucket_gate *should_append);
 
apr_off_t h2_brigade_mem_size(apr_bucket_brigade *bb);
 
void h2_util_drain_pipe(apr_file_t *pipe);
 
apr_status_t h2_util_wait_on_pipe(apr_file_t *pipe);
 
 
#if AP_HAS_RESPONSE_BUCKETS
apr_size_t headers_length_estimate(ap_bucket_headers *hdrs);
 
apr_size_t response_length_estimate(ap_bucket_response *resp);
#endif /* AP_HAS_RESPONSE_BUCKETS */
 
#endif /* defined(__mod_h2__h2_util__) */