util/validation.h

Go to the documentation of this file.

 
#pragma once
 
#include "../common.h"
#include <stdint.h>
#include <stddef.h>
 
/* Forward declarations to avoid circular dependencies */
typedef struct client_info client_info_t;
 
/* Function declaration - defined in src/server/protocol.c */
void disconnect_client_for_bad_data(client_info_t *client, const char *format, ...);
 
#define VALIDATE_NOTNULL_DATA(client, data, packet_name)                                                               \
  do {                                                                                                                 \
    if (!(data)) {                                                                                                     \
      disconnect_client_for_bad_data((client), "%s payload missing", (packet_name));                                   \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_MIN_SIZE(client, len, min_size, packet_name)                                                          \
  do {                                                                                                                 \
    if ((len) < (min_size)) {                                                                                          \
      disconnect_client_for_bad_data((client), "%s payload too small (len=%zu, min=%zu)", (packet_name), (len),        \
                                     (min_size));                                                                      \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_EXACT_SIZE(client, len, expected_size, packet_name)                                                   \
  do {                                                                                                                 \
    if ((len) != (expected_size)) {                                                                                    \
      disconnect_client_for_bad_data((client), "%s payload size mismatch (len=%zu, expected=%zu)", (packet_name),      \
                                     (len), (expected_size));                                                          \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_AUDIO_STREAM_ENABLED(client, packet_name)                                                             \
  do {                                                                                                                 \
    if (!atomic_load(&(client)->is_sending_audio)) {                                                                   \
      disconnect_client_for_bad_data((client), "%s received before audio stream enabled", (packet_name));              \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_AUDIO_SAMPLE_COUNT(client, num_samples, max_samples, packet_name)                                     \
  do {                                                                                                                 \
    if ((num_samples) <= 0 || (num_samples) > (max_samples)) {                                                         \
      disconnect_client_for_bad_data((client), "%s invalid sample count: %d (max %d)", (packet_name), (num_samples),   \
                                     (max_samples));                                                                   \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_AUDIO_ALIGNMENT(client, len, sample_size, packet_name)                                                \
  do {                                                                                                                 \
    if ((len) % (sample_size) != 0) {                                                                                  \
      disconnect_client_for_bad_data((client), "%s payload not aligned (len=%zu, sample_size=%zu)", (packet_name),     \
                                     (len), (sample_size));                                                            \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_RESOURCE_INITIALIZED(client, resource, resource_name)                                                 \
  do {                                                                                                                 \
    if (!(resource)) {                                                                                                 \
      disconnect_client_for_bad_data((client), "%s not initialized", (resource_name));                                 \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_PACKET_SIZE(client, data, len, expected_size, packet_name)                                            \
  do {                                                                                                                 \
    if (!(data)) {                                                                                                     \
      disconnect_client_for_bad_data((client), packet_name " payload missing");                                        \
      return;                                                                                                          \
    }                                                                                                                  \
    if ((len) != (expected_size)) {                                                                                    \
      disconnect_client_for_bad_data((client), packet_name " payload size %zu (expected %zu)", (len),                  \
                                     (expected_size));                                                                 \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_NONZERO(client, value, value_name, packet_name)                                                       \
  do {                                                                                                                 \
    if ((value) == 0) {                                                                                                \
      disconnect_client_for_bad_data((client), "%s %s cannot be zero", (packet_name), (value_name));                   \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_RANGE(client, value, min_val, max_val, value_name, packet_name)                                       \
  do {                                                                                                                 \
    if ((value) < (min_val) || (value) > (max_val)) {                                                                  \
      disconnect_client_for_bad_data((client), "%s %s out of range: %u (valid: %u-%u)", (packet_name), (value_name),   \
                                     (unsigned)(value), (unsigned)(min_val), (unsigned)(max_val));                     \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_CAPABILITY_FLAGS(client, flags, valid_mask, packet_name)                                              \
  do {                                                                                                                 \
    if (((flags) & (valid_mask)) == 0) {                                                                               \
      disconnect_client_for_bad_data((client), "%s no valid capability flags set (flags=0x%x, valid=0x%x)",            \
                                     (packet_name), (unsigned)(flags), (unsigned)(valid_mask));                        \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_FLAGS_MASK(client, flags, valid_mask, packet_name)                                                    \
  do {                                                                                                                 \
    if (((flags) & ~(valid_mask)) != 0) {                                                                              \
      disconnect_client_for_bad_data((client), "%s unknown flags set (flags=0x%x, valid=0x%x)", (packet_name),         \
                                     (unsigned)(flags), (unsigned)(valid_mask));                                       \
      return;                                                                                                          \
    }                                                                                                                  \
  } while (0)
 
#define VALIDATE_PACKET_NOT_NULL(client, data, packet_name)                                                            \
  ({                                                                                                                   \
    int _validation_failed = 0;                                                                                        \
    if (!(data)) {                                                                                                     \
      disconnect_client_for_bad_data((client), packet_name " payload missing");                                        \
      _validation_failed = 1;                                                                                          \
    }                                                                                                                  \
    _validation_failed;                                                                                                \
  })
 
/* ============================================================================
 * Image Dimension Validation (Function Implementation)
 * ============================================================================ */