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;
}