metrics.c File Reference

Ring consensus metrics collection and wire protocol implementation. More...

Go to the source code of this file.

Data Structures
struct	consensus_metrics_collection
	Metrics collection structure for participant quality measurements. More...

Macros
#define	DEFAULT_BANDWIDTH_KBPS   50000
#define	DEFAULT_RTT_MS   25
#define	NUM_STUN_PROBES   10

Typedefs
typedef struct consensus_metrics_collection	consensus_metrics_collection_t
	Metrics collection structure for participant quality measurements.

Functions
	__attribute__ ((unused))
asciichat_error_t	consensus_metrics_measure (const uint8_t my_id[16], participant_metrics_t *out_metrics)
asciichat_error_t	consensus_metrics_to_wire (const participant_metrics_t *metrics, participant_metrics_t *out_wire)
asciichat_error_t	consensus_metrics_from_wire (const participant_metrics_t *wire_metrics, participant_metrics_t *out_metrics)
asciichat_error_t	consensus_metrics_collection_create (consensus_metrics_collection_t **out_collection)
asciichat_error_t	consensus_metrics_collection_add (consensus_metrics_collection_t *collection, const participant_metrics_t *metrics)
asciichat_error_t	consensus_metrics_collection_get (const consensus_metrics_collection_t *collection, const participant_metrics_t **out_metrics, int *out_count)
void	consensus_metrics_collection_destroy (consensus_metrics_collection_t *collection)

Detailed Description

Ring consensus metrics collection and wire protocol implementation.

Definition in file metrics.c.

Macro Definition Documentation

DEFAULT_BANDWIDTH_KBPS

#define DEFAULT_BANDWIDTH_KBPS   50000

Default bandwidth estimate (50 Mbps = 50000 Kbps)

Definition at line 29 of file metrics.c.

DEFAULT_RTT_MS

#define DEFAULT_RTT_MS   25

Default RTT estimate (25 milliseconds)

Definition at line 34 of file metrics.c.

NUM_STUN_PROBES

#define NUM_STUN_PROBES   10

Number of STUN probes to send for success rate measurement

Definition at line 39 of file metrics.c.

Typedef Documentation

consensus_metrics_collection_t

typedef struct consensus_metrics_collection consensus_metrics_collection_t

Metrics collection structure for participant quality measurements.

Dynamic array storing network quality metrics for all participants in a consensus session.

Function Documentation

__attribute__()

__attribute__

(

(unused)

)

Convert NAT type to tier (0=best, 4=worst)

Mapping:

• Open/LAN (no NAT) = 0
• Full cone NAT = 1
• Address-restricted NAT = 2
• Port-restricted NAT = 3
• Symmetric NAT = 4

Note: This function is reserved for future use when NAT detection is integrated. For now, we use a hardcoded default tier.

Definition at line 72 of file metrics.c.

                                                                      {
  // ACIP_NAT_TYPE_* enum values:
  // 0 = Open (OPEN = no NAT, essentially LAN)
  // 1 = Full cone (best NAT)
  // 2 = Address-restricted
  // 3 = Port-restricted
  // 4 = Symmetric (worst NAT)
 
  if (nat_type < 0 || nat_type > 4) {
    return 4; // Default to worst case
  }
  return (uint8_t)nat_type;
}

consensus_metrics_collection_add()

asciichat_error_t consensus_metrics_collection_add	(	consensus_metrics_collection_t *	collection,
		const participant_metrics_t *	metrics
	)

Definition at line 179 of file metrics.c.

                                                                                         {
  if (!collection || !metrics) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters to collection_add");
  }
 
  // Resize if needed
  if (collection->count >= collection->capacity) {
    int new_capacity = collection->capacity * 2;
    participant_metrics_t *new_metrics =
        SAFE_MALLOC(new_capacity * sizeof(participant_metrics_t), participant_metrics_t *);
 
    if (!new_metrics) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate metrics array");
    }
 
    // Copy existing metrics
    if (collection->count > 0 && collection->metrics) {
      memcpy(new_metrics, collection->metrics, collection->count * sizeof(participant_metrics_t));
      SAFE_FREE(collection->metrics);
    }
 
    collection->metrics = new_metrics;
    collection->capacity = new_capacity;
  }
 
  // Add new metrics
  if (!collection->metrics) {
    return SET_ERRNO(ERROR_MEMORY, "Collection metrics array is NULL");
  }
 
  memcpy(&collection->metrics[collection->count], metrics, sizeof(*metrics));
  collection->count++;
 
  return ASCIICHAT_OK;
}

References consensus_metrics_collection::capacity, consensus_metrics_collection::count, and consensus_metrics_collection::metrics.

consensus_metrics_collection_create()

asciichat_error_t consensus_metrics_collection_create

(

consensus_metrics_collection_t **

out_collection

)

Definition at line 163 of file metrics.c.

                                                                                                       {
  if (!out_collection) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid output parameter");
  }
 
  consensus_metrics_collection_t *collection = SAFE_MALLOC(sizeof(*collection), consensus_metrics_collection_t *);
  memset(collection, 0, sizeof(*collection));
 
  collection->capacity = 10; // Start with capacity for 10 participants
  collection->metrics = SAFE_MALLOC(collection->capacity * sizeof(participant_metrics_t), participant_metrics_t *);
  collection->count = 0;
 
  *out_collection = collection;
  return ASCIICHAT_OK;
}

References consensus_metrics_collection::capacity, consensus_metrics_collection::count, and consensus_metrics_collection::metrics.

consensus_metrics_collection_destroy()

void consensus_metrics_collection_destroy

(

consensus_metrics_collection_t *

collection

)

Definition at line 228 of file metrics.c.

                                                                                      {
  if (!collection) {
    return;
  }
 
  if (collection->metrics) {
    SAFE_FREE(collection->metrics);
  }
 
  SAFE_FREE(collection);
}

References consensus_metrics_collection::metrics.

consensus_metrics_collection_get()

asciichat_error_t consensus_metrics_collection_get	(	const consensus_metrics_collection_t *	collection,
		const participant_metrics_t **	out_metrics,
		int *	out_count
	)

Definition at line 216 of file metrics.c.

                                                                                                              {
  if (!collection || !out_metrics || !out_count) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters to collection_get");
  }
 
  *out_metrics = collection->metrics;
  *out_count = collection->count;
 
  return ASCIICHAT_OK;
}

References consensus_metrics_collection::count, and consensus_metrics_collection::metrics.

consensus_metrics_from_wire()

asciichat_error_t consensus_metrics_from_wire	(	const participant_metrics_t *	wire_metrics,
		participant_metrics_t *	out_metrics
	)

Definition at line 144 of file metrics.c.

                                                                                  {
  if (!wire_metrics || !out_metrics) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters to consensus_metrics_from_wire");
  }
 
  // Copy entire structure first
  memcpy(out_metrics, wire_metrics, sizeof(*out_metrics));
 
  // Convert multi-byte fields from network byte order
  out_metrics->upload_kbps = endian_unpack_u32(wire_metrics->upload_kbps);
  out_metrics->rtt_ns = endian_unpack_u32(wire_metrics->rtt_ns);
  out_metrics->public_port = endian_unpack_u16(wire_metrics->public_port);
  out_metrics->measurement_time_ns = endian_unpack_u64(wire_metrics->measurement_time_ns);
  out_metrics->measurement_window_ns = endian_unpack_u64(wire_metrics->measurement_window_ns);
 
  return ASCIICHAT_OK;
}

consensus_metrics_measure()

asciichat_error_t consensus_metrics_measure	(	const uint8_t	my_id[16],
		participant_metrics_t *	out_metrics
	)

Definition at line 86 of file metrics.c.

                                                                                                         {
  if (!my_id || !out_metrics) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters to consensus_metrics_measure");
  }
 
  // Initialize metrics structure
  memset(out_metrics, 0, sizeof(*out_metrics));
 
  // Copy participant ID
  memcpy(out_metrics->participant_id, my_id, 16);
 
  // NAT tier: Default to 1 (Public IP, no NAT needed)
  // TODO: In production, query NAT detection module
  out_metrics->nat_tier = 1;
 
  // Upload bandwidth: Default 50 Mbps
  out_metrics->upload_kbps = DEFAULT_BANDWIDTH_KBPS;
 
  // RTT: Default 25ms (25,000,000 nanoseconds)
  out_metrics->rtt_ns = DEFAULT_RTT_MS * NS_PER_MS;
 
  // STUN probe success rate: Measure by sending probes
  out_metrics->stun_probe_success_pct = measure_stun_probe_success();
 
  // Public address and port: Placeholder values
  snprintf(out_metrics->public_address, sizeof(out_metrics->public_address), "127.0.0.1");
  out_metrics->public_port = 27224;
 
  // Connection type: Default to direct
  out_metrics->connection_type = 0; // Direct connection
 
  // Measurement time: Current time in nanoseconds
  out_metrics->measurement_time_ns = time_get_realtime_ns();
 
  // Measurement window: 1 second in nanoseconds
  out_metrics->measurement_window_ns = 1 * NS_PER_SEC;
 
  return ASCIICHAT_OK;
}

References DEFAULT_BANDWIDTH_KBPS, DEFAULT_RTT_MS, and time_get_realtime_ns().

consensus_metrics_to_wire()

asciichat_error_t consensus_metrics_to_wire	(	const participant_metrics_t *	metrics,
		participant_metrics_t *	out_wire
	)

Definition at line 126 of file metrics.c.

                                                                                                                   {
  if (!metrics || !out_wire) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters to consensus_metrics_to_wire");
  }
 
  // Copy entire structure first
  memcpy(out_wire, metrics, sizeof(*out_wire));
 
  // Convert multi-byte fields to network byte order
  out_wire->upload_kbps = endian_pack_u32(metrics->upload_kbps);
  out_wire->rtt_ns = endian_pack_u32(metrics->rtt_ns);
  out_wire->public_port = endian_pack_u16(metrics->public_port);
  out_wire->measurement_time_ns = endian_pack_u64(metrics->measurement_time_ns);
  out_wire->measurement_window_ns = endian_pack_u64(metrics->measurement_window_ns);
 
  return ASCIICHAT_OK;
}