http3.h

Go to the documentation of this file.

 
#ifndef __CWIST_HTTP3_H__
#define __CWIST_HTTP3_H__
 
#include <cwist/net/http/http.h>
#include <cwist/sys/err/cwist_err.h>
#include <openssl/ssl.h>
#include <stdbool.h>
#include <stdint.h>
#include <pthread.h>
 
typedef struct cwist_http3_context cwist_http3_context;
 
typedef void (*cwist_webtransport_handler_func)(cwist_http_request *req, cwist_http_response *res,
                                                void *stream);
 
struct cwist_http3_context {
    SSL_CTX *ssl_ctx; 
    int udp_fd;       
    void *engine;     
    void (*handler)(void *user_ctx, cwist_http_request *req, cwist_http_response *res);
    void *user_ctx;
    volatile int running; 
    int push_enabled;     
    int early_data_enabled; 
    int early_data_guard;   
    int allow_migration;  
    int datagram_enabled; 
    void (*datagram_cb)(const void *data, size_t len, void *user_ctx);
    void *datagram_user_ctx;
    cwist_webtransport_handler_func wt_handler; 
    void (*wt_new_stream_handler)(void *stream,
                                  void *user_ctx); 
    void *wt_new_stream_ctx; 
    int idle_timeout_ms;       
    int handshake_timeout_ms;  
    int ping_period_ms;        
    int noprogress_timeout_ms; 
    void *hsets; 
    /* Hot reload (cwist_http3_reload_context): ssl_ctx is swapped under
     * ssl_ctx_lock. ssl_ctx_handout pins the SSL_CTX most recently handed to
     * lsquic's per-connection ea_get_ssl_ctx callback until the next handout
     * or destroy, bridging the window between the callback returning a
     * pointer and lsquic's SSL_new() taking the connection's own reference.
     * ticket_key owns the shared session-ticket key material installed on
     * every SSL_CTX this context has used, so QUIC session resumption (and
     * 0-RTT) survives a reload. */
    pthread_rwlock_t ssl_ctx_lock;
    SSL_CTX *ssl_ctx_handout;
    void *ticket_key;
};
 
typedef void (*cwist_http3_request_handler_func)(void *user_ctx, cwist_http_request *req,
                                                 cwist_http_response *res);
 
cwist_error_t cwist_http3_init_context(cwist_http3_context **ctx, const char *cert_path,
                                       const char *key_path);
 
cwist_error_t cwist_http3_init_context_ephemeral(cwist_http3_context **ctx);
 
void cwist_http3_destroy_context(cwist_http3_context *ctx);
 
cwist_error_t cwist_http3_reload_context(cwist_http3_context *ctx, const char *cert_path,
                                         const char *key_path);
 
cwist_error_t cwist_http3_server_loop(int udp_fd, cwist_http3_context *ctx,
                                      cwist_http3_request_handler_func handler, void *user_ctx);
 
void cwist_http3_set_early_data(cwist_http3_context *ctx, bool enabled);
 
void cwist_http3_set_early_data_guard(cwist_http3_context *ctx, int enabled);
 
void cwist_http3_set_push_enabled(cwist_http3_context *ctx, int enabled);
 
int cwist_http3_push_resource(cwist_http_request *req, const char *path, const char *content_type);
 
int cwist_http3_set_stream_priority(cwist_http_request *req, unsigned priority);
 
void cwist_http3_set_datagram_enabled(cwist_http3_context *ctx, int enabled);
 
void cwist_http3_set_datagram_callback(cwist_http3_context *ctx,
                                       void (*cb)(const void *data, size_t len, void *user_ctx),
                                       void *user_ctx);
 
int cwist_http3_send_datagram(void *conn, const void *data, size_t len);
 
void cwist_http3_set_webtransport_handler(cwist_http3_context *ctx,
                                          cwist_webtransport_handler_func handler);
 
ssize_t cwist_webtransport_read(void *stream, void *buf, size_t len);
 
ssize_t cwist_webtransport_write(void *stream, const void *data, size_t len);
 
int cwist_webtransport_flush(void *stream);
 
int cwist_webtransport_close_stream(void *stream);
 
void cwist_webtransport_set_new_stream_handler(cwist_http3_context *ctx,
                                               void (*handler)(void *stream, void *user_ctx),
                                               void *user_ctx);
 
int cwist_webtransport_open_bidi_stream(void *session);
 
int cwist_webtransport_open_uni_stream(void *session);
 
ssize_t cwist_webtransport_send_datagram(void *session, const void *data, size_t len);
 
size_t cwist_webtransport_max_datagram_size(void *session);
 
int cwist_webtransport_close_session(void *session, uint64_t code, const char *reason);
 
void cwist_http3_set_idle_timeout(cwist_http3_context *ctx, int ms);
 
void cwist_http3_set_handshake_timeout(cwist_http3_context *ctx, int ms);
 
void cwist_http3_set_ping_period(cwist_http3_context *ctx, int ms);
 
void cwist_http3_set_noprogress_timeout(cwist_http3_context *ctx, int ms);
 
#endif