rate_limit.c File Reference

🚦 Rate limiting implementation with backend abstraction More...

Go to the source code of this file.

Data Structures
struct	rate_limiter_s
	Rate limiter structure. More...

Functions
rate_limiter_t *	rate_limiter_create_memory (void)
	Create in-memory rate limiter.
rate_limiter_t *	rate_limiter_create_sqlite (const char *db_path)
	Create SQLite-backed rate limiter.
void	rate_limiter_set_sqlite_db (rate_limiter_t *limiter, void *db)
	Set SQLite database handle for rate limiter.
void	rate_limiter_destroy (rate_limiter_t *limiter)
	Destroy rate limiter and free resources.
asciichat_error_t	rate_limiter_check (rate_limiter_t *limiter, const char *ip_address, rate_event_type_t event_type, const rate_limit_config_t *config, bool *allowed)
	Check if an event from an IP address should be rate limited.
asciichat_error_t	rate_limiter_record (rate_limiter_t *limiter, const char *ip_address, rate_event_type_t event_type)
	Record a rate limit event.
asciichat_error_t	rate_limiter_cleanup (rate_limiter_t *limiter, uint32_t max_age_secs)
	Clean up old rate limit events.
uint64_t	rate_limiter_get_time_ms (void)
	Get current time in milliseconds.
const char *	rate_limiter_event_type_string (rate_event_type_t event_type)
	Get event type string for logging.

Variables
const rate_limit_config_t	DEFAULT_RATE_LIMITS [RATE_EVENT_MAX]
	Default rate limits for each event type.

Detailed Description

🚦 Rate limiting implementation with backend abstraction

Definition in file rate_limit.c.

Function Documentation

rate_limiter_check()

asciichat_error_t rate_limiter_check	(	rate_limiter_t *	limiter,
		const char *	ip_address,
		rate_event_type_t	event_type,
		const rate_limit_config_t *	config,
		bool *	allowed
	)

Check if an event from an IP address should be rate limited.

Uses sliding window: counts events in the last window_secs seconds.

Parameters

	limiter	Rate limiter instance
	ip_address	IP address string (IPv4 or IPv6)
	event_type	Type of event
	config	Rate limit configuration (NULL = use defaults)
[out]	allowed	True if event is allowed, false if rate limited

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 127 of file rate_limit.c.

                                                                                       {
  if (!limiter || !limiter->ops || !limiter->ops->check) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid rate limiter");
  }
 
  if (!ip_address || !allowed) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "ip_address or allowed is NULL");
  }
 
  if (event_type >= RATE_EVENT_MAX) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid event_type: %d", event_type);
  }
 
  return limiter->ops->check(limiter->backend_data, ip_address, event_type, config, allowed);
}

References rate_limiter_s::backend_data, rate_limiter_backend_ops_t::check, ERROR_INVALID_PARAM, rate_limiter_s::ops, RATE_EVENT_MAX, and SET_ERRNO.

Referenced by check_and_record_rate_limit().

rate_limiter_cleanup()

asciichat_error_t rate_limiter_cleanup	(	rate_limiter_t *	limiter,
		uint32_t	max_age_secs
	)

Clean up old rate limit events.

Deletes events older than the specified age to prevent unbounded growth. Should be called periodically (e.g., every 5 minutes).

Parameters

limiter	Rate limiter instance
max_age_secs	Delete events older than this (0 = use default 1 hour)

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 160 of file rate_limit.c.

                                                                                       {
  if (!limiter || !limiter->ops || !limiter->ops->cleanup) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid rate limiter");
  }
 
  return limiter->ops->cleanup(limiter->backend_data, max_age_secs);
}

References rate_limiter_s::backend_data, rate_limiter_backend_ops_t::cleanup, ERROR_INVALID_PARAM, rate_limiter_s::ops, and SET_ERRNO.

rate_limiter_create_memory()

rate_limiter_t * rate_limiter_create_memory

(

void

)

Create in-memory rate limiter.

Thread-safe implementation using uthash and mutexes. Suitable for ascii-chat server where persistence is not needed.

Returns

Rate limiter instance or NULL on failure

Definition at line 72 of file rate_limit.c.

                                                 {
  rate_limiter_t *limiter = malloc(sizeof(rate_limiter_t));
  if (!limiter) {
    log_error("Failed to allocate rate limiter");
    return NULL;
  }
 
  limiter->backend_data = memory_backend_create();
  if (!limiter->backend_data) {
    free(limiter);
    return NULL;
  }
 
  limiter->ops = &memory_backend_ops;
  return limiter;
}

References rate_limiter_s::backend_data, log_error, memory_backend_create(), memory_backend_ops, and rate_limiter_s::ops.

Referenced by server_main().

rate_limiter_create_sqlite()

rate_limiter_t * rate_limiter_create_sqlite

(

const char *

db_path

)

Create SQLite-backed rate limiter.

Persistent implementation using SQLite database. Suitable for acds discovery server where persistence is needed.

Parameters

db_path

Path to SQLite database (NULL = externally managed database)

Returns

Rate limiter instance or NULL on failure

Definition at line 89 of file rate_limit.c.

                                                                {
  rate_limiter_t *limiter = malloc(sizeof(rate_limiter_t));
  if (!limiter) {
    log_error("Failed to allocate rate limiter");
    return NULL;
  }
 
  limiter->backend_data = sqlite_backend_create(db_path);
  if (!limiter->backend_data) {
    free(limiter);
    return NULL;
  }
 
  limiter->ops = &sqlite_backend_ops;
  return limiter;
}

References rate_limiter_s::backend_data, log_error, rate_limiter_s::ops, sqlite_backend_create(), and sqlite_backend_ops.

Referenced by acds_server_init().

rate_limiter_destroy()

void rate_limiter_destroy

(

rate_limiter_t *

limiter

)

Destroy rate limiter and free resources.

Parameters

limiter

Rate limiter instance (NULL-safe)

Definition at line 115 of file rate_limit.c.

                                                   {
  if (!limiter) {
    return;
  }
 
  if (limiter->ops && limiter->ops->destroy) {
    limiter->ops->destroy(limiter->backend_data);
  }
 
  free(limiter);
}

References rate_limiter_s::backend_data, rate_limiter_backend_ops_t::destroy, and rate_limiter_s::ops.

Referenced by acds_server_init(), acds_server_shutdown(), and server_main().

rate_limiter_event_type_string()

const char * rate_limiter_event_type_string

(

rate_event_type_t

event_type

)

Get event type string for logging.

Helper: Get event type string for logging.

Definition at line 184 of file rate_limit.c.

                                                                         {
  if (event_type >= RATE_EVENT_MAX) {
    return "unknown";
  }
  return event_type_strings[event_type];
}

References RATE_EVENT_MAX.

rate_limiter_get_time_ms()

uint64_t rate_limiter_get_time_ms

(

void

)

Get current time in milliseconds.

Helper: Get current time in milliseconds.

Definition at line 175 of file rate_limit.c.

                                        {
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}

rate_limiter_record()

asciichat_error_t rate_limiter_record	(	rate_limiter_t *	limiter,
		const char *	ip_address,
		rate_event_type_t	event_type
	)

Record a rate limit event.

Should be called after rate_limiter_check() returns allowed=true.

Parameters

limiter	Rate limiter instance
ip_address	IP address string
event_type	Type of event

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 144 of file rate_limit.c.

                                                                                                                     {
  if (!limiter || !limiter->ops || !limiter->ops->record) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid rate limiter");
  }
 
  if (!ip_address) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "ip_address is NULL");
  }
 
  if (event_type >= RATE_EVENT_MAX) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid event_type: %d", event_type);
  }
 
  return limiter->ops->record(limiter->backend_data, ip_address, event_type);
}

References rate_limiter_s::backend_data, ERROR_INVALID_PARAM, rate_limiter_s::ops, RATE_EVENT_MAX, rate_limiter_backend_ops_t::record, and SET_ERRNO.

Referenced by check_and_record_rate_limit().

rate_limiter_set_sqlite_db()

void rate_limiter_set_sqlite_db	(	rate_limiter_t *	limiter,
		void *	db
	)

Set SQLite database handle for rate limiter.

For SQLite-backed rate limiters where the database lifecycle is managed externally (e.g., ACDS manages its own database). Must be called after rate_limiter_create_sqlite(NULL).

Parameters

limiter	Rate limiter instance (must be SQLite backend)
db	SQLite database handle

Definition at line 106 of file rate_limit.c.

                                                                   {
  if (!limiter || !limiter->backend_data) {
    return;
  }
 
  // Call the SQLite backend function to set the database handle
  sqlite_backend_set_db(limiter->backend_data, (sqlite3 *)db);
}

References rate_limiter_s::backend_data, and sqlite_backend_set_db().

Referenced by acds_server_init().

Variable Documentation

DEFAULT_RATE_LIMITS

const rate_limit_config_t DEFAULT_RATE_LIMITS[RATE_EVENT_MAX]

Initial value:

= {
 
 
 
 
 
 
 
 
 
 
 
 
 
    
    [RATE_EVENT_SESSION_CREATE] = {.max_events = 15, .window_secs = 60}, 
    [RATE_EVENT_SESSION_LOOKUP] = {.max_events = 45, .window_secs = 60}, 
    [RATE_EVENT_SESSION_JOIN] = {.max_events = 30, .window_secs = 60},   
    [RATE_EVENT_CONNECTION] = {.max_events = 75, .window_secs = 60},     
    [RATE_EVENT_IMAGE_FRAME] = {.max_events = 12960, .window_secs = 60}, 
    [RATE_EVENT_AUDIO] = {.max_events = 15480, .window_secs = 60},       
    [RATE_EVENT_PING] = {.max_events = 180, .window_secs = 60},          
    [RATE_EVENT_CLIENT_JOIN] = {.max_events = 25, .window_secs = 60},    
    [RATE_EVENT_CONTROL] = {.max_events = 150, .window_secs = 60},       
 
}

Default rate limits for each event type.

Definition at line 29 of file rate_limit.c.

                                                                {
// ACDS discovery server limits
#ifdef NDEBUG
    // Release mode: production limits (144 FPS video, 172 FPS audio)
    [RATE_EVENT_SESSION_CREATE] = {.max_events = 10, .window_secs = 60}, // 10 creates per minute
    [RATE_EVENT_SESSION_LOOKUP] = {.max_events = 30, .window_secs = 60}, // 30 lookups per minute
    [RATE_EVENT_SESSION_JOIN] = {.max_events = 20, .window_secs = 60},   // 20 joins per minute
    [RATE_EVENT_CONNECTION] = {.max_events = 50, .window_secs = 60},     // 50 connections per minute
    [RATE_EVENT_IMAGE_FRAME] = {.max_events = 8640, .window_secs = 60},  // 8640 frames/min = 144 FPS
    [RATE_EVENT_AUDIO] = {.max_events = 10320, .window_secs = 60},       // 10320 packets/min = 172 FPS
    [RATE_EVENT_PING] = {.max_events = 120, .window_secs = 60},          // 120 pings/min = 2 Hz max
    [RATE_EVENT_CLIENT_JOIN] = {.max_events = 10, .window_secs = 60},    // 10 joins per minute
    [RATE_EVENT_CONTROL] = {.max_events = 100, .window_secs = 60},       // 100 control packets/min
#else
    // Debug mode: slightly relaxed limits for development/testing (1.5x production limits)
    [RATE_EVENT_SESSION_CREATE] = {.max_events = 15, .window_secs = 60}, // 15 creates per minute
    [RATE_EVENT_SESSION_LOOKUP] = {.max_events = 45, .window_secs = 60}, // 45 lookups per minute
    [RATE_EVENT_SESSION_JOIN] = {.max_events = 30, .window_secs = 60},   // 30 joins per minute
    [RATE_EVENT_CONNECTION] = {.max_events = 75, .window_secs = 60},     // 75 connections per minute
    [RATE_EVENT_IMAGE_FRAME] = {.max_events = 12960, .window_secs = 60}, // 12960 frames/min = 216 FPS
    [RATE_EVENT_AUDIO] = {.max_events = 15480, .window_secs = 60},       // 15480 packets/min = 258 FPS
    [RATE_EVENT_PING] = {.max_events = 180, .window_secs = 60},          // 180 pings/min = 3 Hz
    [RATE_EVENT_CLIENT_JOIN] = {.max_events = 25, .window_secs = 60},    // 25 joins per minute (for testing reconnects)
    [RATE_EVENT_CONTROL] = {.max_events = 150, .window_secs = 60},       // 150 control packets/min
#endif
};