connection.h

Go to the documentation of this file.

#ifndef KEEL_CONNECTION_H
#define KEEL_CONNECTION_H
 
#include <keel/allocator.h>
#include <keel/chunked.h>
#include <keel/file_io.h>
#include <keel/request.h>
#include <keel/response.h>
#include <keel/parser.h>
#include <keel/router.h>
#include <stddef.h>
#include <stdint.h>
 
#define KL_READ_BUF_SIZE 8192
 
typedef struct KlTls KlTls;
typedef struct KlWsServerConn KlWsServerConn;
typedef struct KlH2ServerConn KlH2ServerConn;
typedef struct KlH2ServerConfig KlH2ServerConfig;
 
typedef enum {
    KL_CONN_TLS_HANDSHAKE,   
    KL_CONN_READING,         
    KL_CONN_READING_BODY,    
    KL_CONN_PROCESSING,      
    KL_CONN_SENDING,         
    KL_CONN_WEBSOCKET,       
    KL_CONN_HTTP2,           
    KL_CONN_SUSPENDED,       
    KL_CONN_CLOSED           
} KlConnState;
 
typedef struct KlConn {
    int fd;                     
    KlConnState state;          
    KlAllocator *alloc;         
    char *read_buf;             
    size_t read_len;            
    size_t read_cap;            
    size_t max_header_size;     
    KlRequest req;              
    KlResponse res;             
    KlParser *parser;           
    size_t hdr_sent;            
    KlRoute *route;             
    KlParam params[KL_MAX_PARAMS]; 
    int num_params;             
    int route_result;           
    uint64_t last_active_ms;    
    uint64_t request_start_ms;  
    uint64_t body_start_ms;     
    KlChunkedDecoder chunked_dec; 
    KlTls *tls;                 
    int tls_want;               
    KlWsServerConn *ws;         
    KlH2ServerConn *h2;         
    KlH2ServerConfig *h2_config; 
    KlRouter *router;           
    size_t max_body_size;       
    struct KlAsyncOp *async_op; 
    uint64_t suspend_start_ms;  
    KlFileIO *file_io;          
    int file_io_phase;          
    size_t file_io_len;         
    size_t file_io_sent;        
    void (*access_log)(const KlRequest *req, int status,
                       size_t body_bytes, double duration_ms,
                       void *user_data); 
    void *access_log_data;      
    struct KlConn *next_free;   
} KlConn;
 
typedef struct {
    KlConn *conns;          
    int capacity;           
    int active_count;       
    KlConn *free_list;      
    KlAllocator *alloc;     
} KlConnPool;
 
int     kl_conn_pool_init(KlConnPool *pool, int capacity, KlAllocator *alloc);
 
KlConn *kl_conn_acquire(KlConnPool *pool, int fd);
 
void    kl_conn_release(KlConnPool *pool, KlConn *c);
 
void    kl_conn_pool_free(KlConnPool *pool);
 
KlConnState kl_conn_on_handshake(KlConn *c);
 
KlConnState kl_conn_on_readable(KlConn *c, KlRouter *router);
 
KlConnState kl_conn_on_writable(KlConn *c);
 
KlConnState kl_conn_on_file_complete(KlConn *c, ssize_t result, int zero_copy);
 
uint64_t kl_monotonic_ms(void);
 
#endif