Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/ambient-light-native/fake.c

Raw
// Test-only LD_PRELOAD backend for the installed APIs used by read.c.
// No USB/protocol implementation. Every opaque instance is a plain GObject.
// Trace: one newline-delimited event, whitespace-separated fields; enum settings
// are logged as channel name, frequency percent, integration units. Queue IDs
// identify submissions/processes so an independent oracle can detect replay.
#include <colorhug.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>

typedef enum { COLOR, SCALE, INTEGRAL, SET_SCALE, RAW } Kind;
typedef struct {
	Kind kind;
	gpointer output;
	ChFreqScale scale;
} Job;
typedef struct {
	guint id;
	gboolean processed;
	GArray *jobs;
} Queue;

static const char *scenario;
static ChColorSelect channel = CH_COLOR_SELECT_BLUE;
static ChFreqScale scale;
static guint16 integral;
static guint queue_id, snapshots, samples;
static gboolean restoring;

static gboolean is(const char *name)
{
	return g_strcmp0(scenario, name) == 0;
}

static void trace(const char *format, ...)
{
	const char *path = g_getenv("NUGULAND_COLORHUG_FAKE_LOG");
	FILE *file = path ? fopen(path, "a") : NULL;
	va_list args;
	if (file == NULL)
		abort();
	va_start(args, format);
	vfprintf(file, format, args);
	va_end(args);
	fputc('\n', file);
	if (fclose(file) != 0)
		abort();
}

static int percent(ChFreqScale value)
{
	switch (value) {
	case CH_FREQ_SCALE_0: return 0;
	case CH_FREQ_SCALE_2: return 2;
	case CH_FREQ_SCALE_20: return 20;
	case CH_FREQ_SCALE_100: return 100;
	default: abort();
	}
}

static gboolean fail(GError **error)
{
	g_set_error_literal(error, G_IO_ERROR, G_IO_ERROR_FAILED, "fake failure");
	return FALSE;
}

static void check(gpointer object, const char *tag)
{
	if (object == NULL || !g_object_get_data(G_OBJECT(object), tag))
		abort();
}

static gpointer object(const char *tag)
{
	GObject *result = g_object_new(G_TYPE_OBJECT, NULL);
	g_object_set_data(result, tag, GINT_TO_POINTER(1));
	return result;
}

GUsbContext *g_usb_context_new(GError **error)
{
	static const char *const scenarios[] = {
		"active", "scale-zero", "integral-zero", "both-zero",
		"activation-ack-lost", "sample-failure", "restore-scale-failure",
		"verification-mismatch", "verification-failure", "work-timeout",
		"signal-work", "signal-restore", "restore-scale-ack-lost",
		"restore-scale-timeout", "restore-integral-timeout",
		"release-failure", "close-failure", "effective-mismatch",
		"effective-failure", "original-failure", "original-invalid",
		"verification-timeout", "missing"
	};
	gboolean known = FALSE;
	scenario = g_getenv("NUGULAND_COLORHUG_FAKE_SCENARIO");
	for (guint i = 0; i < G_N_ELEMENTS(scenarios); i++)
		known |= is(scenarios[i]);
	trace("context %s", scenario ? scenario : "missing");
	if (!known)
		return fail(error), NULL;
	scale = is("active") || is("integral-zero") ? CH_FREQ_SCALE_2 : CH_FREQ_SCALE_0;
	integral = is("active") || is("scale-zero") ? 77 : 0;
	trace("initial blue %d %u", percent(scale), (unsigned)integral);
	return object("context");
}

void g_usb_context_enumerate(GUsbContext *context)
{
	check(context, "context");
	trace("enumerate");
}

GPtrArray *g_usb_context_get_devices(GUsbContext *context)
{
	check(context, "context");
	GPtrArray *devices = g_ptr_array_new_with_free_func(g_object_unref);
	if (!is("missing"))
		g_ptr_array_add(devices, object("device"));
	return devices;
}

guint16 g_usb_device_get_vid(GUsbDevice *device)
{
	check(device, "device");
	return CH_USB_VID;
}

guint16 g_usb_device_get_pid(GUsbDevice *device)
{
	check(device, "device");
	return CH_USB_PID_FIRMWARE_ALS;
}

gboolean g_usb_device_open(GUsbDevice *device, GError **error)
{
	(void)error;
	check(device, "device");
	trace("open");
	return TRUE;
}

gint g_usb_device_get_configuration(GUsbDevice *device, GError **error)
{
	(void)error;
	check(device, "device");
	trace("configuration");
	return CH_USB_CONFIG;
}

gboolean g_usb_device_claim_interface(GUsbDevice *device, gint iface,
				     GUsbDeviceClaimInterfaceFlags flags, GError **error)
{
	(void)error;
	check(device, "device");
	if (iface != CH_USB_INTERFACE || flags != G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER)
		abort();
	trace("claim");
	return TRUE;
}

gboolean g_usb_device_release_interface(GUsbDevice *device, gint iface,
				       GUsbDeviceClaimInterfaceFlags flags, GError **error)
{
	check(device, "device");
	if (iface != CH_USB_INTERFACE || flags != G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER)
		abort();
	trace("release");
	return is("release-failure") ? fail(error) : TRUE;
}

gboolean g_usb_device_close(GUsbDevice *device, GError **error)
{
	check(device, "device");
	trace("close blue %d %u", percent(scale), (unsigned)integral);
	return is("close-failure") ? fail(error) : TRUE;
}

static void free_queue(gpointer data)
{
	Queue *q = data;
	trace("queue-free %u", q->id);
	g_array_unref(q->jobs);
	g_free(q);
}

ChDeviceQueue *ch_device_queue_new(void)
{
	GObject *result = object("queue");
	Queue *q = g_new0(Queue, 1);
	q->id = ++queue_id;
	q->jobs = g_array_new(FALSE, FALSE, sizeof(Job));
	g_object_set_data_full(result, "jobs", q, free_queue);
	trace("queue-new %u", q->id);
	return (ChDeviceQueue *)result;
}

static void add(ChDeviceQueue *queue, GUsbDevice *device, Job job)
{
	check(queue, "queue");
	check(device, "device");
	Queue *q = g_object_get_data(G_OBJECT(queue), "jobs");
	trace("enqueue %u %u", q->id, (unsigned)job.kind);
	g_array_append_val(q->jobs, job);
}

void ch_device_queue_get_color_select(ChDeviceQueue *q, GUsbDevice *d, ChColorSelect *v)
{
	add(q, d, (Job){ .kind = COLOR, .output = v });
}

void ch_device_queue_get_multiplier(ChDeviceQueue *q, GUsbDevice *d, ChFreqScale *v)
{
	add(q, d, (Job){ .kind = SCALE, .output = v });
}

void ch_device_queue_get_integral_time(ChDeviceQueue *q, GUsbDevice *d, guint16 *v)
{
	add(q, d, (Job){ .kind = INTEGRAL, .output = v });
}

void ch_device_queue_set_multiplier(ChDeviceQueue *q, GUsbDevice *d, ChFreqScale v)
{
	add(q, d, (Job){ .kind = SET_SCALE, .scale = v });
}

void ch_device_queue_take_reading_raw(ChDeviceQueue *q, GUsbDevice *d, guint32 *v)
{
	add(q, d, (Job){ .kind = RAW, .output = v });
}

static gboolean blocked(GCancellable *cancel, GError **error)
{
	trace("blocked");
	while (!g_cancellable_is_cancelled(cancel))
		g_main_context_iteration(NULL, TRUE);
	trace("cancelled");
	return g_cancellable_set_error_if_cancelled(cancel, error) ? FALSE : fail(error);
}

static void send_signal(void)
{
	trace("signal SIGTERM");
	raise(SIGTERM);
	// Unix signal sources are dispatched through the actual default context.
	g_main_context_iteration(NULL, TRUE);
	while (g_main_context_pending(NULL))
		g_main_context_iteration(NULL, FALSE);
}

gboolean ch_device_set_integral_time(GUsbDevice *device, guint16 value,
				     GCancellable *cancel, GError **error)
{
	check(device, "device");
	if (cancel == NULL || (value != 0 && value != CH_INTEGRAL_TIME_VALUE_100MS))
		abort();
	trace("direct-integral %u", (unsigned)value);
	if (value == 0) {
		restoring = TRUE;
		if (is("restore-integral-timeout"))
			return blocked(cancel, error);
	}
	if (g_cancellable_set_error_if_cancelled(cancel, error))
		return FALSE;
	integral = value;
	return TRUE;
}

gboolean ch_device_queue_process(ChDeviceQueue *queue, ChDeviceQueueProcessFlags flags,
				 GCancellable *cancel, GError **error)
{
	check(queue, "queue");
	Queue *q = g_object_get_data(G_OBJECT(queue), "jobs");
	if (flags != CH_DEVICE_QUEUE_PROCESS_FLAGS_NONE || cancel == NULL)
		abort();
	trace("process %u", q->id);
	if (q->processed) {
		trace("replay %u", q->id);
		return fail(error);
	}
	q->processed = TRUE;
	for (guint i = 0; i < q->jobs->len; i++) {
		Job *job = &g_array_index(q->jobs, Job, i);
		if (g_cancellable_set_error_if_cancelled(cancel, error))
			return FALSE;
		switch (job->kind) {
		case COLOR:
			snapshots++;
			// Simulate an external physical change, not a fabricated read value.
			if ((snapshots == 3 && is("verification-mismatch")) ||
			    (snapshots == 2 && is("effective-mismatch")))
				integral++;
			trace("snapshot %u blue %d %u", snapshots, percent(scale), (unsigned)integral);
			if (snapshots == 3 && is("verification-timeout"))
				return blocked(cancel, error);
			if ((snapshots == 1 && is("original-failure")) ||
			    (snapshots == 2 && is("effective-failure")) ||
			    (snapshots == 3 && is("verification-failure")))
				return fail(error);
			*(ChColorSelect *)job->output = snapshots == 1 && is("original-invalid") ?
				(ChColorSelect)255 : channel;
			break;
		case SCALE:
			*(ChFreqScale *)job->output = scale;
			break;
		case INTEGRAL:
			*(guint16 *)job->output = integral;
			break;
		case SET_SCALE:
			trace("set-scale %d", percent(job->scale));
			if (job->scale == CH_FREQ_SCALE_0) {
				restoring = TRUE;
				if (is("signal-restore")) {
					send_signal();
					trace("restore-cancelled %d", g_cancellable_is_cancelled(cancel));
				}
				if (is("restore-scale-timeout"))
					return blocked(cancel, error);
				if (is("restore-scale-failure"))
					return fail(error);
			} else if (job->scale != CH_FREQ_SCALE_20 || restoring) {
				trace("forbidden-scale");
				return fail(error);
			}
			scale = job->scale;
			if ((!restoring && is("activation-ack-lost")) ||
			    (restoring && is("restore-scale-ack-lost")))
				return fail(error);
			break;
		case RAW:
			trace("sample %u", ++samples);
			if (samples != 1 || scale == CH_FREQ_SCALE_0 || integral == 0 || restoring)
				return fail(error);
			if (is("signal-work")) {
				send_signal();
				return blocked(cancel, error);
			}
			if (is("work-timeout"))
				return blocked(cancel, error);
			if (is("sample-failure"))
				return fail(error);
			*(guint32 *)job->output = 123456;
			break;
		default:
			trace("unknown-operation");
			return fail(error);
		}
	}
	return TRUE;
}