webrtc_internal.h

Go to the documentation of this file.

 
#ifndef __CWIST_WEBRTC_INTERNAL_H__
#define __CWIST_WEBRTC_INTERNAL_H__
 
#include <cwist/net/webrtc.h>
#include <cwist/sys/io/reactor.h>
 
#include <netinet/in.h>
#include <openssl/ssl.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
 
struct socket; /* usrsctp */
 
#define CWIST_WEBRTC_MAX_MESSAGE 262144
#define CWIST_WEBRTC_MAX_BUFFERED (4u << 20)
#define CWIST_WEBRTC_DGRAM_MAX 2048
#define CWIST_WEBRTC_RX_BATCH 32
#define CWIST_WEBRTC_TX_BATCH 64
 
typedef enum {
    CWIST_CONN_STUN = 0,        
    CWIST_CONN_DTLS = 1,        
    CWIST_CONN_ESTABLISHED = 2, 
    CWIST_CONN_CLOSED = 3       
} cwist_conn_state;
 
typedef struct cwist_webrtc_msg {
    struct cwist_webrtc_msg *next; 
    struct cwist_webrtc_conn *conn; 
    uint32_t len;                 
    uint16_t channel;             
    uint8_t is_string;            
    uint8_t data[];               
} cwist_webrtc_msg;
 
struct cwist_webrtc_conn {
    cwist_webrtc_ctx *ctx;   
    atomic_int refs;         
    atomic_bool detached;    
    atomic_bool close_posted; 
    atomic_size_t buffered;  
    bool is_server_role;     
    cwist_conn_state state;  
    bool registered;         
    bool parked;             
    bool sctp_ready;         
    bool close_requested;    
    bool dirty;              
    bool notified_open;      
    struct sockaddr_in remote;              
    struct cwist_webrtc_conn *hnext;        
    struct cwist_webrtc_conn *dirty_next;   
    /* ICE */
    char peer_ufrag[64];     
    char peer_pwd[128];      
    uint8_t stun_txid[12];   
    int stun_attempts;       
    uint32_t stun_rto_ms;    
    /* DTLS */
    SSL *ssl;                
    const uint8_t *dtls_in;  
    size_t dtls_in_len;      
    /* SCTP */
    struct socket *sctp_sock; 
    struct socket *sctp_acc;  
    uint8_t *ch_bits;        
    uint32_t ch_bits_len;    
    uint8_t *rx_partial;     
    size_t rx_partial_len;   
    size_t rx_partial_cap;   
    cwist_webrtc_msg *pending_head; 
    cwist_webrtc_msg *pending_tail; 
    _Atomic(cwist_webrtc_msg *) inbox; 
    /* Timers and posts */
    cwist_reactor_timer_t timer;   
    uint64_t created_ns;           
    uint64_t last_rx_ns;           
    cwist_reactor_post_t reg_post;   
    cwist_reactor_post_t close_post; 
    cwist_reactor_post_t kick_post;  
};
 
struct cwist_webrtc_ctx {
    cwist_reactor_t *reactor; 
    bool owns_reactor;        
    pid_t owner_pid;          
    pthread_t thread;         
    bool thread_running;      
    atomic_int refs;          
    int udp_fd;               
    uint16_t port;            
    bool udp_armed;           
    bool closed;              
    atomic_int ice_lite_server; 
    X509 *cert;               
    EVP_PKEY *pkey;           
    SSL_CTX *server_ssl_ctx;  
    SSL_CTX *client_ssl_ctx;  
    char fingerprint[128];    
    char ice_ufrag[16];       
    char ice_pwd[64];         
    char host_ip[64];         
    cwist_webrtc_message_cb msg_cb; 
    void *msg_user;                 
    cwist_webrtc_channel_cb ch_cb;  
    void *ch_user;                  
    cwist_webrtc_close_cb close_cb; 
    void *close_user;               
    /* Connection table, keyed by remote address. */
    cwist_webrtc_conn **buckets; 
    uint32_t nbuckets;           
    uint32_t nconns;             
    cwist_webrtc_conn *parked;   
    cwist_webrtc_conn *dirty;    
    atomic_int ready_count;      
    /* SCTP clock */
    cwist_reactor_timer_t sctp_timer; 
    int sctp_assocs;                  
    uint64_t last_activity_ns;        
    bool sctp_fast;                   
    /* I/O */
    uint8_t *rx_bufs;   
    uint8_t *plain_buf; 
    uint8_t *sctp_buf;  
    uint8_t *tx_bufs;   
    size_t tx_len[CWIST_WEBRTC_TX_BATCH];             
    struct sockaddr_in tx_addr[CWIST_WEBRTC_TX_BATCH]; 
    uint32_t tx_n;      
    uint64_t now_ns;    
    /* Teardown handshake for ctxs on a caller-run reactor. */
    cwist_reactor_post_t free_post; 
    pthread_mutex_t free_mu;        
    pthread_cond_t free_cv;         
    bool fd_closed;                 
};
 
#define CWIST_STUN_BINDING_REQUEST 0x0001  
#define CWIST_STUN_BINDING_RESPONSE 0x0101 
int cwist_ice_stun_is_message(const uint8_t *buf, size_t len);
bool cwist_ice_stun_is_binding_request(const uint8_t *buf, size_t len);
bool cwist_ice_stun_has_use_candidate(const uint8_t *buf, size_t len);
int cwist_ice_stun_get_remote_ufrag(const uint8_t *buf, size_t len, char *out, size_t cap);
int cwist_ice_stun_validate_request(const uint8_t *buf, size_t len, const char *pwd);
int cwist_ice_stun_build_response(uint8_t *out, size_t cap, const uint8_t *req, size_t req_len,
                                  const struct sockaddr_in *mapped, const char *pwd);
int cwist_ice_stun_build_request(uint8_t *out, size_t cap, const uint8_t txid[12],
                                 const char *username);
int cwist_ice_stun_sign_request(uint8_t *msg, size_t cap, size_t msg_len, const char *pwd);
int cwist_ice_stun_parse_response(const uint8_t *buf, size_t len, const uint8_t txid[12],
                                  const char *pwd, struct sockaddr_in *mapped);
void cwist_ice_random_creds(char *ufrag, size_t ufrag_cap, char *pwd, size_t pwd_cap);
typedef struct {
    char ice_ufrag[64];     
    char ice_pwd[128];      
    char fingerprint[128];  
    char setup[16];         
    char mid[16];           
    int has_lite;           
} cwist_sdp_info;
 
int cwist_sdp_parse(const char *sdp, size_t len, cwist_sdp_info *info);
int cwist_sdp_write_answer(char *out, size_t cap, const char *fingerprint, const char *ufrag,
                           const char *pwd, const char *mid, const char *host, uint16_t port);
int cwist_sdp_write_offer(char *out, size_t cap, const char *fingerprint, const char *ufrag,
                          const char *pwd, const char *mid);
int cwist_dtls_generate_cert(X509 **cert, EVP_PKEY **pkey);
int cwist_dtls_fingerprint(X509 *cert, char *out, size_t cap);
SSL_CTX *cwist_dtls_ctx_new(int is_server, X509 *cert, EVP_PKEY *pkey);
BIO *cwist_dtls_bio_new(struct cwist_webrtc_conn *conn);
unsigned int cwist_dtls_link_mtu(void);
int cwist_sctp_global_init(void);
void cwist_sctp_tick(void);
int cwist_sctp_conn_open(struct cwist_webrtc_conn *conn);
void cwist_sctp_conn_close(struct cwist_webrtc_conn *conn);
void cwist_sctp_conn_input(struct cwist_webrtc_conn *conn, const uint8_t *data, size_t len);
int cwist_sctp_conn_drain(struct cwist_webrtc_conn *conn);
bool cwist_sctp_assoc_established(struct cwist_webrtc_conn *conn);
int cwist_sctp_send(struct cwist_webrtc_conn *conn, uint16_t channel, const uint8_t *data,
                    size_t len, int is_string);
bool cwist_webrtc_on_owner(const cwist_webrtc_ctx *ctx);
void cwist_webrtc_conn_dtls_out(struct cwist_webrtc_conn *conn, const uint8_t *data, size_t len);
void cwist_webrtc_conn_sctp_out(struct cwist_webrtc_conn *conn, const void *buffer, size_t len);
void cwist_webrtc_conn_on_message(struct cwist_webrtc_conn *conn, uint16_t channel,
                                  const uint8_t *data, size_t len, int is_string);
void cwist_webrtc_conn_on_channel_open(struct cwist_webrtc_conn *conn, uint16_t channel,
                                       const char *label);
cwist_webrtc_conn *cwist_webrtc_connect(cwist_webrtc_ctx *ctx, const struct sockaddr_in *remote,
                                        const char *peer_ufrag, const char *peer_pwd);
#endif