packet.h

Go to the documentation of this file.

 
#pragma once
 
#include "platform/socket.h"
#include "platform/abstraction.h"
#include "crypto/crypto.h"
#include "log/logging.h"
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <errno.h>
 
// Pack network protocol structures tightly for wire format
#ifdef _WIN32
#pragma pack(push, 1)
#endif
 
#define LARGE_PACKET_THRESHOLD (100 * 1024)
 
#define MAX_PACKET_SIZE ((size_t)5 * 1024 * 1024)
 
#define MAX_ERROR_MESSAGE_LENGTH 512
 
#define MAX_REMOTE_LOG_MESSAGE_LENGTH 512
 
#define BASE_SEND_TIMEOUT 5
 
#define LARGE_PACKET_EXTRA_TIMEOUT_PER_MB 0.8
 
#define MIN_CLIENT_TIMEOUT 10
 
#define MAX_CLIENT_TIMEOUT 60
 
#define AUDIO_BATCH_COUNT 32
 
#define AUDIO_BATCH_SAMPLES (AUDIO_SAMPLES_PER_PACKET * AUDIO_BATCH_COUNT)
 
#define AUDIO_BATCH_MS 186
 
#define AUDIO_SAMPLES_PER_PACKET 256
 
#define PACKET_MAGIC 0xDEADBEEF
 
typedef enum {
  PACKET_TYPE_PROTOCOL_VERSION = 1,
 
  PACKET_TYPE_ASCII_FRAME = 2,
  PACKET_TYPE_IMAGE_FRAME = 3,
 
  PACKET_TYPE_AUDIO = 4,
  PACKET_TYPE_CLIENT_CAPABILITIES = 5,
  PACKET_TYPE_PING = 6,
  PACKET_TYPE_PONG = 7,
 
  PACKET_TYPE_CLIENT_JOIN = 8,
  PACKET_TYPE_CLIENT_LEAVE = 9,
  PACKET_TYPE_STREAM_START = 10,
  PACKET_TYPE_STREAM_STOP = 11,
  PACKET_TYPE_CLEAR_CONSOLE = 12,
  PACKET_TYPE_SERVER_STATE = 13,
 
  PACKET_TYPE_CRYPTO_CAPABILITIES = 14,
  PACKET_TYPE_CRYPTO_PARAMETERS = 15,
  PACKET_TYPE_CRYPTO_KEY_EXCHANGE_INIT = 16,
  PACKET_TYPE_CRYPTO_KEY_EXCHANGE_RESP = 17,
  PACKET_TYPE_CRYPTO_AUTH_CHALLENGE = 18,
  PACKET_TYPE_CRYPTO_AUTH_RESPONSE = 19,
  PACKET_TYPE_CRYPTO_AUTH_FAILED = 20,
  PACKET_TYPE_CRYPTO_SERVER_AUTH_RESP = 21,
  PACKET_TYPE_CRYPTO_HANDSHAKE_COMPLETE = 22,
  PACKET_TYPE_CRYPTO_NO_ENCRYPTION = 23,
  PACKET_TYPE_ENCRYPTED = 24,
 
  PACKET_TYPE_CRYPTO_REKEY_REQUEST = 25,
  PACKET_TYPE_CRYPTO_REKEY_RESPONSE = 26,
  PACKET_TYPE_CRYPTO_REKEY_COMPLETE = 27,
 
  PACKET_TYPE_AUDIO_BATCH = 28,
 
  PACKET_TYPE_SIZE_MESSAGE = 29,
  PACKET_TYPE_AUDIO_MESSAGE = 30,
  PACKET_TYPE_TEXT_MESSAGE = 31,
  PACKET_TYPE_ERROR_MESSAGE = 32,
  PACKET_TYPE_REMOTE_LOG = 33,
 
  PACKET_TYPE_AUDIO_OPUS = 34,
  PACKET_TYPE_AUDIO_OPUS_BATCH = 35,
 
  // ============================================================================
  // Discovery Service Protocol (ACDS)
  // ============================================================================
  // ACIP packets use range 100-199 to avoid conflicts with ascii-chat protocol (1-35)
  // See network/acip/protocol.h for protocol overview and utility functions
  // See network/acip/acds.h for ACDS message structures and detailed documentation
 
  PACKET_TYPE_ACIP_SESSION_CREATE = 100,
  PACKET_TYPE_ACIP_SESSION_CREATED = 101,
  PACKET_TYPE_ACIP_SESSION_LOOKUP = 102,
  PACKET_TYPE_ACIP_SESSION_INFO = 103,
  PACKET_TYPE_ACIP_SESSION_JOIN = 104,
  PACKET_TYPE_ACIP_SESSION_JOINED = 105,
  PACKET_TYPE_ACIP_SESSION_LEAVE = 106,
  PACKET_TYPE_ACIP_SESSION_END = 107,
  PACKET_TYPE_ACIP_SESSION_RECONNECT = 108,
 
  PACKET_TYPE_ACIP_WEBRTC_SDP = 110,
  PACKET_TYPE_ACIP_WEBRTC_ICE = 111,
 
  PACKET_TYPE_ACIP_STRING_RESERVE = 120,
  PACKET_TYPE_ACIP_STRING_RESERVED = 121,
  PACKET_TYPE_ACIP_STRING_RENEW = 122,
  PACKET_TYPE_ACIP_STRING_RELEASE = 123,
 
  PACKET_TYPE_ACIP_DISCOVERY_PING = 150,
  PACKET_TYPE_ACIP_ERROR = 199
} packet_type_t;
 
static inline bool packet_is_handshake_type(packet_type_t type) {
  // Initial handshake packets (14-23)
  if (type >= PACKET_TYPE_CRYPTO_CAPABILITIES && type <= PACKET_TYPE_CRYPTO_NO_ENCRYPTION) {
    return true;
  }
  // Rekey packets (25-27) - Note: REKEY_COMPLETE is encrypted with new key but still considered handshake
  if (type >= PACKET_TYPE_CRYPTO_REKEY_REQUEST && type <= PACKET_TYPE_CRYPTO_REKEY_COMPLETE) {
    return true;
  }
  return false;
}
 
static inline bool packet_is_precompressed(packet_type_t type) {
  // Opus audio packets are already compressed by Opus codec
  return (type == PACKET_TYPE_AUDIO_OPUS || type == PACKET_TYPE_AUDIO_OPUS_BATCH);
}
 
typedef struct {
  uint32_t magic;
  uint16_t type;
  uint32_t length;
  uint32_t crc32;
  uint32_t client_id;
} 
PACKED_ATTR  packet_header_t;
 
#define ASCIICHAT_DEFAULT_DISPLAY_NAME "AsciiChatter"
 
typedef struct {
  uint32_t width;
  uint32_t height;
} 
PACKED_ATTR  size_packet_t;
 
typedef struct {
  uint32_t client_id;
  char display_name[MAX_DISPLAY_NAME_LEN];
  uint32_t capabilities;
} 
PACKED_ATTR  client_info_packet_t;
 
typedef struct {
  uint32_t client_id;
  uint32_t stream_type;
  uint32_t timestamp;
} 
PACKED_ATTR  stream_header_t;
 
typedef struct {
  uint32_t client_count;
  client_info_packet_t clients[MAX_CLIENTS];
} 
PACKED_ATTR  client_list_packet_t;
 
typedef struct {
  uint32_t connected_client_count;
  uint32_t active_client_count;
  uint32_t reserved[6];
} 
PACKED_ATTR  server_state_packet_t;
 
typedef struct {
  uint32_t error_code;
  uint32_t message_length;
} 
PACKED_ATTR  error_packet_t;
 
#define REMOTE_LOG_FLAG_TRUNCATED 0x0001U 
typedef struct {
  uint8_t log_level;
  uint8_t direction;
  uint16_t flags;
  uint32_t message_length;
} 
PACKED_ATTR  remote_log_packet_t;
 
typedef enum {
  AUTH_FAIL_PASSWORD_REQUIRED = 0x01,
  AUTH_FAIL_PASSWORD_INCORRECT = 0x02,
  AUTH_FAIL_CLIENT_KEY_REQUIRED = 0x04,
  AUTH_FAIL_CLIENT_KEY_REJECTED = 0x08,
  AUTH_FAIL_SIGNATURE_INVALID = 0x10
} auth_failure_reason_t;
 
typedef struct {
  uint8_t reason_flags;
  uint8_t reserved[7];
} 
PACKED_ATTR  auth_failure_packet_t;
 
#define FEATURE_RLE_ENCODING 0x01 
#define FEATURE_DELTA_FRAMES 0x02 
typedef struct {
  uint16_t protocol_version;
  uint16_t protocol_revision;
  uint8_t supports_encryption;
  uint8_t compression_algorithms;
  uint8_t compression_threshold;
  uint16_t feature_flags;
  uint8_t reserved[7];
} 
PACKED_ATTR  protocol_version_packet_t;
 
typedef struct {
  uint32_t width;
  uint32_t height;
  uint32_t original_size;
  uint32_t compressed_size;
  uint32_t checksum;
  uint32_t flags;
} 
PACKED_ATTR  ascii_frame_packet_t;
 
typedef struct {
  uint32_t width;
  uint32_t height;
  uint32_t pixel_format;
  uint32_t compressed_size;
  uint32_t checksum;
  uint32_t timestamp;
} 
PACKED_ATTR  image_frame_packet_t;
 
typedef struct {
  uint32_t batch_count;
  uint32_t total_samples;
  uint32_t sample_rate;
  uint32_t channels;
} 
PACKED_ATTR  audio_batch_packet_t;
 
#define CLIENT_CAP_VIDEO 0x01   
#define CLIENT_CAP_AUDIO 0x02   
#define CLIENT_CAP_COLOR 0x04   
#define CLIENT_CAP_STRETCH 0x08 
#define STREAM_TYPE_VIDEO 0x01 
#define STREAM_TYPE_AUDIO 0x02 
typedef struct {
  uint16_t supported_kex_algorithms;
  uint16_t supported_auth_algorithms;
  uint16_t supported_cipher_algorithms;
  uint8_t requires_verification;
  uint8_t preferred_kex;
  uint8_t preferred_auth;
  uint8_t preferred_cipher;
} 
PACKED_ATTR  crypto_capabilities_packet_t;
 
typedef struct {
  uint8_t selected_kex;
  uint8_t selected_auth;
  uint8_t selected_cipher;
  uint8_t verification_enabled;
  uint16_t kex_public_key_size;
  uint16_t auth_public_key_size;
  uint16_t signature_size;
  uint16_t shared_secret_size;
  uint8_t nonce_size;
  uint8_t mac_size;
  uint8_t hmac_size;
  uint8_t reserved[3];
} 
PACKED_ATTR  crypto_parameters_packet_t;
 
typedef struct {
  uint32_t capabilities;
  uint32_t color_level;
  uint32_t color_count;
  uint32_t render_mode;
  uint16_t width;
  uint16_t height;
  char term_type[32];
  char colorterm[32];
  uint8_t detection_reliable;
  uint32_t utf8_support;
  uint32_t palette_type;
  char palette_custom[64];
  uint8_t desired_fps;
  uint8_t reserved[2];
} 
PACKED_ATTR  terminal_capabilities_packet_t;
 
#define KEX_ALGO_X25519 0x01               
#define AUTH_ALGO_ED25519 0x01             
#define AUTH_ALGO_NONE 0x00                
#define CIPHER_ALGO_XSALSA20_POLY1305 0x01 
#ifdef _WIN32
#pragma pack(pop)
#endif
 
typedef struct {
  packet_type_t type;
  void *data;
  size_t len;
  bool was_encrypted;
  void *allocated_buffer;
  size_t allocated_size;
} packet_envelope_t;
 
typedef enum {
  PACKET_RECV_SUCCESS = 0,
  PACKET_RECV_EOF = -1,
  PACKET_RECV_ERROR = -2,
  PACKET_RECV_SECURITY_VIOLATION = -3
} packet_recv_result_t;
 
asciichat_error_t packet_validate_header(const packet_header_t *header, uint16_t *pkt_type, uint32_t *pkt_len,
                                         uint32_t *expected_crc);
 
asciichat_error_t packet_validate_crc32(const void *data, size_t len, uint32_t expected_crc);
 
asciichat_error_t packet_send(socket_t sockfd, packet_type_t type, const void *data, size_t len);
 
asciichat_error_t packet_receive(socket_t sockfd, packet_type_t *type, void **data, size_t *len);
 
asciichat_error_t send_packet_secure(socket_t sockfd, packet_type_t type, const void *data, size_t len,
                                     crypto_context_t *crypto_ctx);
 
packet_recv_result_t receive_packet_secure(socket_t sockfd, void *crypto_ctx, bool enforce_encryption,
                                           packet_envelope_t *envelope);
 
int send_packet(socket_t sockfd, packet_type_t type, const void *data, size_t len);
 
int receive_packet(socket_t sockfd, packet_type_t *type, void **data, size_t *len);
 
int send_ping_packet(socket_t sockfd);
 
int send_pong_packet(socket_t sockfd);
 
int send_clear_console_packet(socket_t sockfd);
 
asciichat_error_t packet_send_error(socket_t sockfd, const crypto_context_t *crypto_ctx, asciichat_error_t error_code,
                                    const char *message);
 
asciichat_error_t packet_parse_error_message(const void *data, size_t len, asciichat_error_t *out_error_code,
                                             char *message_buffer, size_t message_buffer_size,
                                             size_t *out_message_length);
 
asciichat_error_t packet_send_remote_log(socket_t sockfd, const crypto_context_t *crypto_ctx, log_level_t level,
                                         remote_log_direction_t direction, uint16_t flags, const char *message);
 
asciichat_error_t packet_parse_remote_log(const void *data, size_t len, log_level_t *out_level,
                                          remote_log_direction_t *out_direction, uint16_t *out_flags,
                                          char *message_buffer, size_t message_buffer_size, size_t *out_message_length);
 
int send_protocol_version_packet(socket_t sockfd, const protocol_version_packet_t *version);
 
int send_crypto_capabilities_packet(socket_t sockfd, const crypto_capabilities_packet_t *caps);
 
int send_crypto_parameters_packet(socket_t sockfd, const crypto_parameters_packet_t *params);
 
asciichat_error_t send_audio_batch_packet(socket_t sockfd, const float *samples, int num_samples, int batch_count,
                                          crypto_context_t *crypto_ctx);
 
asciichat_error_t av_send_audio_opus_batch(socket_t sockfd, const uint8_t *opus_data, size_t opus_size,
                                           const uint16_t *frame_sizes, int sample_rate, int frame_duration,
                                           int frame_count, crypto_context_t *crypto_ctx);
 
asciichat_error_t send_ascii_frame_packet(socket_t sockfd, const char *frame_data, size_t frame_size);
 
asciichat_error_t send_image_frame_packet(socket_t sockfd, const void *image_data, uint16_t width, uint16_t height,
                                          uint8_t format);