http2.h

Go to the documentation of this file.

 
#ifndef __CWIST_HTTP2_H__
#define __CWIST_HTTP2_H__
 
#include <cwist/net/http/http.h>
#include <cwist/net/http/https.h>
 
typedef void (*cwist_http2_request_handler_func)(void *user_ctx, cwist_http_request *req,
                                                 cwist_http_response *res);
 
typedef struct cwist_h2_stream cwist_h2_stream;
 
typedef struct cwist_http2_header {
    const char *name;
    const char *value;
} cwist_http2_header;
 
typedef struct cwist_http2_stream_hooks {
    void *(*on_conn_open)(void *user_ctx);
    void (*on_conn_close)(void *conn_ctx);
    void *(*on_headers)(void *conn_ctx, cwist_http_request *req, cwist_h2_stream *stream);
    int (*on_data)(void *conn_ctx, void *stream_ctx, const unsigned char *data, size_t len,
                   int end_stream);
    void (*on_cancel)(void *conn_ctx, void *stream_ctx);
    int (*on_poll)(void *conn_ctx, void *stream_ctx);
    uint64_t (*next_deadline_ms)(void *conn_ctx);
    void (*on_close)(void *conn_ctx, void *stream_ctx);
} cwist_http2_stream_hooks;
 
cwist_error_t cwist_http2_serve_connection_ex(cwist_https_connection *conn, void *user_ctx,
                                              cwist_http2_request_handler_func handler,
                                              const cwist_http2_stream_hooks *hooks);
 
cwist_error_t cwist_http2_serve_connection(cwist_https_connection *conn, void *user_ctx,
                                           cwist_http2_request_handler_func handler);
 
int cwist_http2_push_resource(cwist_http_request *req, const char *path, const char *content_type,
                              const unsigned char *data, size_t data_len);
 
int cwist_http2_stream_send_headers(cwist_h2_stream *stream, int status,
                                    const cwist_http2_header *headers, size_t header_count,
                                    int end_stream);
int cwist_http2_stream_send_data(cwist_h2_stream *stream, const unsigned char *data, size_t len);
int cwist_http2_stream_send_trailers(cwist_h2_stream *stream, const cwist_http2_header *trailers,
                                     size_t trailer_count);
 
/* --- Async defer completion queue (internal; used by net/http/async.c) ---
 *
 * A handler on the HTTP/2 path may defer its response with
 * cwist_async_defer().  The completing worker thread never writes frames
 * itself (single-threaded HPACK/flow-control invariant); it enqueues the
 * finished exchange on the per-connection queue and pokes the wake fd, and
 * the connection thread drains the queue and emits HEADERS/DATA.  The queue
 * is refcounted: cwist_async_defer acquires a reference so a completion that
 * lands after connection teardown is discarded safely instead of touching
 * freed connection state. */
typedef struct cwist_h2_async_queue cwist_h2_async_queue;
 
cwist_h2_async_queue *cwist_h2_async_queue_acquire(cwist_h2_async_queue *q);
void cwist_h2_async_queue_release(cwist_h2_async_queue *q);
int cwist_h2_async_queue_enqueue(cwist_h2_async_queue *q, uint32_t stream_id,
                                 cwist_http_request *req, cwist_http_response *send,
                                 cwist_http_response *res, bool send_owned);
 
#ifdef __cplusplus
extern "C" {
#endif
 
int h2_decode_integer(const unsigned char *buf, size_t len, size_t *pos, uint8_t prefix_bits,
                      uint32_t *value);
 
char *h2_huffman_decode(const unsigned char *src, size_t src_len, size_t *out_len);
 
char *h2_decode_string(const unsigned char *buf, size_t len, size_t *pos);
 
typedef struct cwist_http2_static_header {
    const char *name;
    const char *value;
} cwist_http2_static_header;
 
const cwist_http2_static_header *h2_static_header(uint32_t index);
 
size_t h2_encode_integer(unsigned char *dst, size_t dst_cap, uint32_t value, uint8_t prefix_bits);
 
size_t h2_encode_string(unsigned char *dst, size_t dst_cap, const char *str);
 
#ifdef __cplusplus
}
#endif
 
#endif