quic.h

Go to the documentation of this file.

 
#ifndef IMQUIC_QUIC_H
#define IMQUIC_QUIC_H
 
#include <sys/socket.h>
 
#include <glib.h>
 
#include "../imquic/imquic.h"
#include "connection.h"
#include "stream.h"
#include "utils.h"
 
void imquic_quic_init(void);
void imquic_quic_deinit(void);
 
void imquic_quic_connection_add(imquic_connection *conn, imquic_connection_id *cid);
void imquic_quic_connection_remove(imquic_connection_id *cid);
 
typedef enum imquic_long_packet_type {
        IMQUIC_INITIAL = 0x00,
        IMQUIC_0RTT = 0x01,
        IMQUIC_HANDSHAKE = 0x02,
        IMQUIC_RETRY = 0x03
} imquic_long_packet_type;
const char *imquic_long_packet_type_str(imquic_long_packet_type type);
 
typedef enum imquic_frame_type {
        IMQUIC_PADDING = 0x00,
        IMQUIC_PING = 0x01,
        IMQUIC_ACK = 0x02,      /* Also 0x03 */
                IMQUIC_ACK_WITH_ECN = 0x03,
        IMQUIC_RESET_STREAM = 0x04,
        IMQUIC_STOP_SENDING = 0x05,
        IMQUIC_CRYPTO = 0x06,
        IMQUIC_NEW_TOKEN = 0x07,
        IMQUIC_STREAM = 0x08,   /* Also 0x09-0x0F */
                IMQUIC_STREAM_F = 0x09,
                IMQUIC_STREAM_L = 0x0A,
                IMQUIC_STREAM_LF = 0x0B,
                IMQUIC_STREAM_O = 0x0C,
                IMQUIC_STREAM_OF = 0x0D,
                IMQUIC_STREAM_OL = 0x0E,
                IMQUIC_STREAM_OLF = 0x0F,
        IMQUIC_MAX_DATA = 0x10,
        IMQUIC_MAX_STREAM_DATA = 0x11,
        IMQUIC_MAX_STREAMS = 0x12,      /* Also 0x13 */
                IMQUIC_MAX_STREAMS_UNI = 0x13,
        IMQUIC_DATA_BLOCKED = 0x14,
        IMQUIC_STREAM_DATA_BLOCKED = 0x15,
        IMQUIC_STREAMS_BLOCKED = 0x16,  /* Also 0x17 */
                IMQUIC_STREAMS_BLOCKED_UNI = 0x17,
        IMQUIC_NEW_CONNECTION_ID = 0x18,
        IMQUIC_RETIRE_CONNECTION_ID = 0x19,
        IMQUIC_PATH_CHALLENGE = 0x1A,
        IMQUIC_PATH_RESPONSE = 0x1B,
        IMQUIC_CONNECTION_CLOSE = 0x1C, /* Also 0x1D */
                IMQUIC_CONNECTION_CLOSE_APP = 0x1D,
        IMQUIC_HANDSHAKE_DONE = 0x1E,
        IMQUIC_DATAGRAM = 0x30, /* Also 0x31 */
                IMQUIC_DATAGRAM_L = 0x31
} imquic_frame_type;
const char *imquic_frame_type_str(imquic_frame_type type);
 
typedef struct imquic_frame {
        imquic_frame_type type;
        uint8_t *buffer;
        size_t size;
} imquic_frame;
imquic_frame *imquic_frame_create(imquic_frame_type type, uint8_t *buffer, size_t size);
void imquic_frame_destroy(imquic_frame *frame);
 
typedef enum imquic_transport_parameter {
        IMQUIC_ORIGINAL_DESTINATION_CONNECTION_ID = 0x00,
        IMQUIC_MAX_IDLE_TIMEOUT = 0x01,
        IMQUIC_STATELESS_RESET_TOKEN = 0x02,
        IMQUIC_MAX_UDP_PAYLOAD_SIZE = 0x03,
        IMQUIC_INITIAL_MAX_DATA = 0x04,
        IMQUIC_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL = 0x05,
        IMQUIC_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE = 0x06,
        IMQUIC_INITIAL_MAX_STREAM_DATA_UNI = 0x07,
        IMQUIC_INITIAL_MAX_STREAMS_BIDI = 0x08,
        IMQUIC_INITIAL_MAX_STREAMS_UNI = 0x09,
        IMQUIC_ACK_DELAY_EXPONENT = 0x0A,
        IMQUIC_MAX_ACK_DELAY = 0x0B,
        IMQUIC_DISABLE_ACTIVE_MIGRATION = 0x0C,
        IMQUIC_PREFERRED_ADDRESS = 0x0D,
        IMQUIC_ACTIVE_CONNECTION_ID_LIMIT = 0x0E,
        IMQUIC_INITIAL_SOURCE_CONNECTION_ID = 0x0F,
        IMQUIC_RETRY_SOURCE_CONNECTION_ID = 0x10,
        IMQUIC_MAX_DATAGRAM_FRAME_SIZE = 0x20
} imquic_transport_parameter;
const char *imquic_transport_parameter_str(imquic_transport_parameter param);
 
typedef struct imquic_packet {
        gboolean is_valid, is_protected, is_encrypted;
        enum ssl_encryption_level_t level;
        gboolean longheader;
        gboolean spin_bit, key_phase;
        imquic_long_packet_type type;
        uint32_t version;
        imquic_connection_id destination;
        imquic_connection_id source;
        uint64_t packet_number;
        size_t length_offset, pkn_offset, payload_offset;
        GList *frames;
        size_t frames_size;
        gboolean ack_eliciting;
        gboolean retransmit_if_lost;
        imquic_data_fixed payload, data;
} imquic_packet;
imquic_packet *imquic_packet_create(void);
int imquic_packet_long_init(imquic_packet *pkt, imquic_long_packet_type type, imquic_connection_id *src, imquic_connection_id *dest);
int imquic_packet_short_init(imquic_packet *pkt, imquic_connection_id *dest);
void imquic_packet_destroy(imquic_packet *pkt);
 
typedef struct imquic_sent_packet {
        imquic_connection *conn;
        imquic_packet *packet;
        enum ssl_encryption_level_t level;
        uint64_t packet_number;
        size_t packet_size;
        int64_t sent_time;
        gboolean ack_eliciting;
        /* TODO We should add info on whether this packet contained an ACK,
         * so that we can decide when to move on with our own ACK ranges */
} imquic_sent_packet;
void imquic_sent_packet_destroy(imquic_sent_packet *sent_pkt);
 
 
void imquic_process_message(imquic_network_endpoint *socket, imquic_network_address *sender, uint8_t *quic, size_t bytes);
int imquic_parse_packet(imquic_network_endpoint *socket, imquic_network_address *sender, imquic_connection **pconn, imquic_packet *pkt, uint8_t *quic, size_t bytes);
void imquic_check_incoming_crypto(imquic_connection *conn);
void imquic_check_incoming_stream(imquic_connection *conn);
 
 
int imquic_parse_frames(imquic_connection *conn, imquic_packet *pkt);
size_t imquic_payload_parse_ack(imquic_connection *conn, uint8_t *bytes, size_t blen, enum ssl_encryption_level_t level);
size_t imquic_payload_parse_reset_stream(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_stop_sending(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_crypto(imquic_connection *conn, uint8_t *bytes, size_t blen, enum ssl_encryption_level_t level);
size_t imquic_payload_parse_new_token(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_stream(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_max_data(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_max_stream_data(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_max_streams(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_data_blocked(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_stream_data_blocked(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_streams_blocked(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_new_connection_id(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_retire_connection_id(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_path_challenge(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_path_response(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_connection_close(imquic_connection *conn, uint8_t *bytes, size_t blen);
size_t imquic_payload_parse_datagram(imquic_connection *conn, uint8_t *bytes, size_t blen);
 
 
size_t imquic_payload_add_padding(uint8_t *bytes, size_t blen, size_t padding);
size_t imquic_payload_add_ping(uint8_t *bytes, size_t blen);
size_t imquic_payload_add_ack(uint8_t *bytes, size_t blen, GList *received, uint64_t delay, uint64_t *ecn_counts);
size_t imquic_payload_add_reset_stream(uint8_t *bytes, size_t blen, uint64_t stream_id, uint64_t error_code, uint64_t final_size);
size_t imquic_payload_add_stop_sending(uint8_t *bytes, size_t blen, uint64_t stream_id, uint64_t error_code);
size_t imquic_payload_add_crypto(uint8_t *bytes, size_t blen, uint8_t *crypto, size_t crypto_offset, size_t crypto_length);
size_t imquic_payload_add_new_token(uint8_t *bytes, size_t blen, uint8_t *token, size_t token_length);
size_t imquic_payload_add_stream(uint8_t *bytes, size_t blen, uint64_t stream_id, uint8_t *stream, size_t stream_offset, size_t stream_length, gboolean complete, gboolean last);
size_t imquic_payload_add_max_data(uint8_t *bytes, size_t blen, uint64_t max_data);
size_t imquic_payload_add_max_stream_data(uint8_t *bytes, size_t blen, uint64_t stream_id, uint64_t max_data);
size_t imquic_payload_add_max_streams(uint8_t *bytes, size_t blen, gboolean bidirectional, uint64_t max_streams);
size_t imquic_payload_add_data_blocked(uint8_t *bytes, size_t blen, uint64_t max_data);
size_t imquic_payload_add_stream_data_blocked(uint8_t *bytes, size_t blen, uint64_t stream_id, uint64_t max_data);
size_t imquic_payload_add_streams_blocked(uint8_t *bytes, size_t blen, uint64_t max_streams);
size_t imquic_payload_add_new_connection_id(uint8_t *bytes, size_t blen, uint64_t seqnum, uint64_t retire_prior_to, imquic_connection_id *cid, uint8_t *reset_token);
size_t imquic_payload_add_retire_connection_id(uint8_t *bytes, size_t blen, uint64_t seqnum);
size_t imquic_payload_add_path_challenge(uint8_t *bytes, size_t blen, uint8_t *data);
size_t imquic_payload_add_path_response(uint8_t *bytes, size_t blen, uint8_t *data);
size_t imquic_payload_add_connection_close(uint8_t *bytes, size_t blen, imquic_error_code error_code, imquic_frame_type frame_type, const char *reason);
size_t imquic_payload_add_handshake_done(uint8_t *bytes, size_t blen);
size_t imquic_payload_add_datagram(uint8_t *bytes, size_t blen, uint8_t *datagram, size_t datagram_length, gboolean last);
 
 
size_t imquic_transport_parameter_add_novalue(uint8_t *bytes, size_t blen, imquic_transport_parameter param);
size_t imquic_transport_parameter_add_int(uint8_t *bytes, size_t blen, imquic_transport_parameter param, uint64_t number);
size_t imquic_transport_parameter_add_data(uint8_t *bytes, size_t blen, imquic_transport_parameter param, uint8_t *buf, size_t buflen);
size_t imquic_transport_parameter_add_connection_id(uint8_t *bytes, size_t blen, imquic_transport_parameter param, imquic_connection_id *cid);
 
 
int imquic_parse_transport_parameters(imquic_connection *conn, uint8_t *bytes, size_t blen);
 
 
int imquic_send_ack(imquic_connection *conn, enum ssl_encryption_level_t level, imquic_connection_id *src, imquic_connection_id *dest);
int imquic_send_pending_crypto(imquic_connection *conn, imquic_connection_id *src, imquic_connection_id *dest);
int imquic_send_keepalive(imquic_connection *conn, imquic_connection_id *dest);
int imquic_send_pending_stream(imquic_connection *conn, imquic_connection_id *dest);
int imquic_send_pending_datagram(imquic_connection *conn, imquic_connection_id *dest);
int imquic_send_close_connection(imquic_connection *conn, imquic_error_code error_code, imquic_frame_type frame_type, const char *reason);
int imquic_serialize_packet(imquic_connection *conn, imquic_packet *pkt);
int imquic_send_packet(imquic_connection *conn, imquic_packet *pkt);
int imquic_retransmit_packet(imquic_connection *conn, imquic_sent_packet *sent_pkt);
 
gboolean imquic_handle_event(imquic_connection *conn);
 
int imquic_start_quic_client(imquic_network_endpoint *socket);
 
#endif