// 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 #include #include #include #include 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; }