frame_validator.c File Reference

Frame validation implementation for IMAGE_FRAME packets. More...

Go to the source code of this file.

Functions
asciichat_error_t	frame_check_size_overflow (size_t header_size, size_t data_size)
asciichat_error_t	frame_validate_legacy (size_t len, size_t expected_rgb_size)
asciichat_error_t	frame_validate_new (void *data, size_t len, bool *out_compressed, uint32_t *out_data_size)
void	frame_extract_dimensions (const void *data, uint32_t *width, uint32_t *height)
void	frame_extract_new_header (const void *data, uint32_t *compressed, uint32_t *data_size)

Detailed Description

Frame validation implementation for IMAGE_FRAME packets.

Definition in file network/frame_validator.c.

Function Documentation

frame_check_size_overflow()

asciichat_error_t frame_check_size_overflow	(	size_t	header_size,
		size_t	data_size
	)

Definition at line 15 of file network/frame_validator.c.

                                                                                  {
  if (data_size > SIZE_MAX - header_size) {
    char size_str[32];
    format_bytes_pretty(data_size, size_str, sizeof(size_str));
    SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Frame size overflow: %s", size_str);
    return ERROR_BUFFER_OVERFLOW;
  }
  return ASCIICHAT_OK;
}

References format_bytes_pretty().

Referenced by frame_validate_legacy(), frame_validate_new(), and handle_image_frame_packet().

frame_extract_dimensions()

void frame_extract_dimensions	(	const void *	data,
		uint32_t *	width,
		uint32_t *	height
	)

Definition at line 86 of file network/frame_validator.c.

                                                                                   {
  uint32_t width_net, height_net;
  memcpy(&width_net, data, FRAME_HEADER_FIELD_SIZE);
  memcpy(&height_net, (char *)data + FRAME_HEADER_FIELD_SIZE, FRAME_HEADER_FIELD_SIZE);
  *width = NET_TO_HOST_U32(width_net);
  *height = NET_TO_HOST_U32(height_net);
}

frame_extract_new_header()

void frame_extract_new_header	(	const void *	data,
		uint32_t *	compressed,
		uint32_t *	data_size
	)

Definition at line 94 of file network/frame_validator.c.

                                                                                           {
  uint32_t compressed_net, size_net;
  memcpy(&compressed_net, (char *)data + FRAME_HEADER_FIELD_SIZE * 2, FRAME_HEADER_FIELD_SIZE);
  memcpy(&size_net, (char *)data + FRAME_HEADER_FIELD_SIZE * 3, FRAME_HEADER_FIELD_SIZE);
  *compressed = NET_TO_HOST_U32(compressed_net);
  *data_size = NET_TO_HOST_U32(size_net);
}

Referenced by frame_validate_new().

frame_validate_legacy()

asciichat_error_t frame_validate_legacy	(	size_t	len,
		size_t	expected_rgb_size
	)

Definition at line 25 of file network/frame_validator.c.

                                                                              {
  // Check minimum header size
  if (len < FRAME_HEADER_SIZE_LEGACY) {
    SET_ERRNO(ERROR_INVALID_FRAME, "Legacy frame header too small: %zu bytes", len);
    return ERROR_INVALID_FRAME;
  }
 
  // Check for overflow
  asciichat_error_t err = frame_check_size_overflow(FRAME_HEADER_SIZE_LEGACY, expected_rgb_size);
  if (err != ASCIICHAT_OK) {
    return err;
  }
 
  size_t expected_total = FRAME_HEADER_SIZE_LEGACY + expected_rgb_size;
  if (len != expected_total) {
    SET_ERRNO(ERROR_INVALID_FRAME, "Legacy frame length mismatch: expected %zu got %zu", expected_total, len);
    return ERROR_INVALID_FRAME;
  }
 
  return ASCIICHAT_OK;
}

References frame_check_size_overflow().

Referenced by handle_image_frame_packet().

frame_validate_new()

asciichat_error_t frame_validate_new	(	void *	data,
		size_t	len,
		bool *	out_compressed,
		uint32_t *	out_data_size
	)

Definition at line 47 of file network/frame_validator.c.

                                                                                                            {
  // Check minimum new format header size
  if (len < FRAME_HEADER_SIZE_NEW) {
    SET_ERRNO(ERROR_INVALID_FRAME, "New frame header too small: %zu bytes", len);
    return ERROR_INVALID_FRAME;
  }
 
  uint32_t compressed_flag, data_size;
  frame_extract_new_header(data, &compressed_flag, &data_size);
 
  size_t data_size_sz = (size_t)data_size;
 
  // Check data size against maximum
  if (data_size_sz > IMAGE_MAX_PIXELS_SIZE) {
    char size_str[32];
    format_bytes_pretty(data_size_sz, size_str, sizeof(size_str));
    SET_ERRNO(ERROR_INVALID_FRAME, "Frame data too large: %s", size_str);
    return ERROR_INVALID_FRAME;
  }
 
  // Check for overflow
  asciichat_error_t err = frame_check_size_overflow(FRAME_HEADER_SIZE_NEW, data_size_sz);
  if (err != ASCIICHAT_OK) {
    return err;
  }
 
  size_t expected_total = FRAME_HEADER_SIZE_NEW + data_size_sz;
  if (len != expected_total) {
    SET_ERRNO(ERROR_INVALID_FRAME, "New frame length mismatch: expected %zu got %zu", expected_total, len);
    return ERROR_INVALID_FRAME;
  }
 
  if (out_compressed)
    *out_compressed = (compressed_flag != 0);
  if (out_data_size)
    *out_data_size = data_size;
  return ASCIICHAT_OK;
}

References format_bytes_pretty(), frame_check_size_overflow(), and frame_extract_new_header().