fdo-mirrors/libfprint
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libfprint/libfprint.git synced 2026-05-11 08:28:08 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor(validity): inline one-liner SSM wrappers into switch cases

Browse source 
Remove single-caller send/recv wrapper functions that just build a
command buffer and call vcsfw_*_cmd_send or check status and call
fpi_ssm_next_state. Move their bodies directly into the SSM switch
cases to reduce indirection and code size (-579 lines net).

Files: verify.c (7), enroll.c (33), fwext.c (10), pair.c (16),
db.c (10 dead/single-caller functions removed).
Tests updated to call validity_pack_new directly.
This commit is contained in:
Leonardo Francisco 2026-04-21 14:48:09 -04:00 • committed by lewohart
parent 0594fbf7d7
commit 6510bcb178
8 changed files with 467 additions and 1046 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

106
libfprint/drivers/validity/validity_db.c
View file

@ -89,13 +89,6 @@ validity_record_children_clear (ValidityRecordChildren *children)
* The caller must g_free() the result.
* ================================================================ */
/* cmd 0x45: DB info */
guint8 *
validity_db_build_cmd_info (gsize *out_len)
{
return validity_pack_new (out_len, "b", VCSFW_CMD_DB_INFO);
}
/* cmd 0x4B: Get user storage
* Format: 0x4B | dbid(2LE) | name_len(2LE) | name(NUL-terminated) */
guint8 *
@ -124,42 +117,6 @@ validity_db_build_cmd_get_user (guint16 dbid,
VCSFW_CMD_GET_USER, dbid, 0, 0);
}
/* cmd 0x4A: Lookup user by identity within a storage
* Format: 0x4A | 0(2LE) | storage_dbid(2LE) | identity_len(2LE) | identity */
guint8 *
validity_db_build_cmd_lookup_user (guint16 storage_dbid,
const guint8 *identity,
gsize identity_len,
gsize *out_len)
{
return validity_pack_new (out_len, "bhhhd",
VCSFW_CMD_GET_USER,
0, /* dbid = 0 (lookup by identity) */
(int) storage_dbid,
(int) identity_len,
identity, identity_len);
}
/* cmd 0x49: Get record value
* Format: 0x49 | dbid(2LE) */
guint8 *
validity_db_build_cmd_get_record_value (guint16 dbid,
gsize *out_len)
{
return validity_pack_new (out_len, "bh",
VCSFW_CMD_GET_RECORD_VALUE, dbid);
}
/* cmd 0x46: Get record children
* Format: 0x46 | dbid(2LE) */
guint8 *
validity_db_build_cmd_get_record_children (guint16 dbid,
gsize *out_len)
{
return validity_pack_new (out_len, "bh",
VCSFW_CMD_GET_RECORD_CHILDREN, dbid);
}
/* cmd 0x47: New record
* Format: 0x47 | parent(2LE) | type(2LE) | storage(2LE) | data_len(2LE) | data */
guint8 *
@ -206,17 +163,6 @@ validity_db_build_cmd_create_enrollment (gboolean start,
(guint32) (start ? 1 : 0));
}
/* cmd 0x68: Enrollment update start
* PY format: pack('<BLL', 0x68, key, 0) → 9 bytes: 0x68, key(4LE), 0(4LE) */
guint8 *
validity_db_build_cmd_enrollment_update_start (guint32 key,
gsize *out_len)
{
return validity_pack_new (out_len, "bww",
VCSFW_CMD_ENROLLMENT_UPDATE_START,
key, (guint32) 0);
}
/* cmd 0x6B: Enrollment update (with template data)
* Format: 0x6B | prev_data */
guint8 *
@ -229,58 +175,6 @@ validity_db_build_cmd_enrollment_update (const guint8 *prev_data,
prev_data, prev_len);
}
/* cmd 0x51: Get program status
* Format: 0x51 | flags(4bytes)
* extended=FALSE: 00000000, extended=TRUE: 00200000 */
guint8 *
validity_db_build_cmd_get_prg_status (gboolean extended,
gsize *out_len)
{
return validity_pack_new (out_len, "bw",
VCSFW_CMD_GET_PRG_STATUS,
(guint32) (extended ? 0x2000 : 0));
}
/* cmd 0x04: Capture stop */
guint8 *
validity_db_build_cmd_capture_stop (gsize *out_len)
{
return validity_pack_new (out_len, "b", VCSFW_CMD_CAPTURE_STOP);
}
/* cmd 0x5E: Match finger
* Format: 0x5E | type(1) | 0xFF | stg_id(2LE) | usr_id(2LE) | 1(2LE) | 0(2LE) | 0(2LE)
* type=2 matches against any storage/user */
guint8 *
validity_db_build_cmd_match_finger (gsize *out_len)
{
return validity_pack_new (out_len, "bbbhhhhh",
VCSFW_CMD_MATCH_FINGER,
0x02, /* match type: match against any storage/user */
0xFF, /* match against all subtypes */
0, /* stg_id = any */
0, /* usr_id = any */
1, /* unknown, always 1 */
0, 0);
}
/* cmd 0x60: Get match result
* Format: 0x60 | 00000000 */
guint8 *
validity_db_build_cmd_get_match_result (gsize *out_len)
{
return validity_pack_new (out_len, "bw",
VCSFW_CMD_GET_MATCH_RESULT, (guint32) 0);
}
/* cmd 0x62: Match cleanup
* Format: 0x62 | 00000000 */
guint8 *
validity_db_build_cmd_match_cleanup (gsize *out_len)
{
return validity_pack_new (out_len, "bw",
VCSFW_CMD_MATCH_CLEANUP, (guint32) 0);
}
/* ================================================================
* Response parsers

39
libfprint/drivers/validity/validity_db.h
View file

@ -160,9 +160,6 @@ gboolean validity_parse_match_result (const guint8 *data,
* All returned buffers are g_malloc'd and must be g_free'd by caller.
* ================================================================ */
/* cmd 0x45: DB info */
guint8 *validity_db_build_cmd_info (gsize *out_len);
/* cmd 0x4B: Get user storage by name */
guint8 *validity_db_build_cmd_get_user_storage (const gchar *name,
gsize *out_len);
@ -171,20 +168,6 @@ guint8 *validity_db_build_cmd_get_user_storage (const gchar *name,
guint8 *validity_db_build_cmd_get_user (guint16 dbid,
gsize *out_len);
/* cmd 0x4A: Lookup user by identity within a storage */
guint8 *validity_db_build_cmd_lookup_user (guint16 storage_dbid,
const guint8 *identity,
gsize identity_len,
gsize *out_len);
/* cmd 0x49: Get record value */
guint8 *validity_db_build_cmd_get_record_value (guint16 dbid,
gsize *out_len);
/* cmd 0x46: Get record children */
guint8 *validity_db_build_cmd_get_record_children (guint16 dbid,
gsize *out_len);
/* cmd 0x47: New record */
guint8 *validity_db_build_cmd_new_record (guint16 parent,
guint16 type,
@ -267,35 +250,15 @@ void validity_record_children_clear (ValidityRecordChildren *children);
guint8 *validity_db_build_cmd_create_enrollment (gboolean start,
gsize *out_len);
/* cmd 0x68: Enrollment update start */
guint8 *validity_db_build_cmd_enrollment_update_start (guint32 key,
gsize *out_len);
/* cmd 0x6B: Enrollment update (with template data) */
guint8 *validity_db_build_cmd_enrollment_update (const guint8 *prev_data,
gsize prev_len,
gsize *out_len);
/* cmd 0x51: Get program status */
guint8 *validity_db_build_cmd_get_prg_status (gboolean extended,
gsize *out_len);
/* cmd 0x04: Capture stop */
guint8 *validity_db_build_cmd_capture_stop (gsize *out_len);
/* ================================================================
* Match commands
* Match commands (inlined at call sites in verify/enroll SSMs)
* ================================================================ */
/* cmd 0x5E: Match finger */
guint8 *validity_db_build_cmd_match_finger (gsize *out_len);
/* cmd 0x60: Get match result */
guint8 *validity_db_build_cmd_get_match_result (gsize *out_len);
/* cmd 0x62: Match cleanup */
guint8 *validity_db_build_cmd_match_cleanup (gsize *out_len);
/* ================================================================
* db_write_enable blob access
* ================================================================ */

621
libfprint/drivers/validity/validity_enroll.c
View file

@ -319,19 +319,6 @@ enroll_cleanup_stale (FpiSsm *ssm,
g_free (cmd);
}
static void
enroll_pre_get_storage (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Check for existing user records that would cause 0x0526 */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_get_user_storage (
VALIDITY_STORAGE_NAME, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_pre_get_storage_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -395,33 +382,6 @@ enroll_pre_del_user_recv (FpiSsm *ssm,
fpi_ssm_jump_to_state (ssm, ENROLL_PRE_DEL_USER);
}
static void
enroll_start (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x69 flag=1: create enrollment session */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_create_enrollment (TRUE, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_start_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("create_enrollment failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
fpi_ssm_next_state (ssm);
}
static void
enroll_led_on_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -509,19 +469,6 @@ enroll_capture_stop_recv (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
enroll_update_start (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x68: enrollment_update_start(key) */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_enrollment_update_start (
self->enroll_key, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_update_start_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -559,40 +506,6 @@ enroll_wait_update_start_int (FpiSsm *ssm,
update_interrupt_cb, ssm);
}
static void
enroll_db_write_enable (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: write_enable() before 1st enrollment_update */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
static void
enroll_db_write_enable_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("db_write_enable (1st) failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
}
static void
enroll_append_image (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x6B: enrollment_update with current template */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_enrollment_update (
self->enroll_template, self->enroll_template_len, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_append_image_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -613,30 +526,6 @@ enroll_append_image_recv (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
enroll_cleanups (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: call_cleanups() in finally block of enrollment_update (1st) */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_cleanups_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Status 0x0491 = nothing to commit, which is OK */
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("call_cleanups (1st) failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
}
static void
enroll_wait_update_int (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -654,41 +543,6 @@ enroll_wait_update_int (FpiSsm *ssm,
update_interrupt_cb, ssm);
}
static void
enroll_db_write_enable_read (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: write_enable() before 2nd enrollment_update */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
static void
enroll_db_write_enable_read_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("db_write_enable (2nd) failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
}
static void
enroll_append_image_read (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Second cmd 0x6B: enrollment_update — reads the actual result
* with template/header/tid data. Same payload as the first call. */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_enrollment_update (
self->enroll_template, self->enroll_template_len, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_append_image_read_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -747,43 +601,6 @@ enroll_append_image_read_recv (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
enroll_cleanups_read (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: call_cleanups() in finally block of enrollment_update (2nd) */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_cleanups_read_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("call_cleanups (2nd) failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
}
static void
enroll_update_end (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: enrollment_update_end() → pack('<BL', 0x69, 0)
* Same as create_enrollment(FALSE) — signals end of this iteration's
* update cycle. Called in PY's finally block for each iteration. */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_create_enrollment (FALSE, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_loop_check (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -823,34 +640,6 @@ enroll_loop_check (FpiSsm *ssm,
fpi_ssm_jump_to_state (ssm, ENROLL_LED_ON);
}
static void
enroll_update_end2 (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: second enrollment_update_end() after the loop.
* Same command: pack('<BL', 0x69, 0) */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_create_enrollment (FALSE, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_get_storage (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Discover the StgWindsor storage dbid — PY uses
* db.get_user_storage(name='StgWindsor').dbid for all record ops. */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_get_user_storage (
VALIDITY_STORAGE_NAME, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_get_storage_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -885,100 +674,6 @@ enroll_get_storage_recv (FpiSsm *ssm,
fpi_ssm_jump_to_state (ssm, ENROLL_DB_WRITE_ENABLE2);
}
static void
enroll_init_storage_we (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: db.new_user_storate() → new_record(1, 4, 3, 'StgWindsor\0')
* First: db_write_enable */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
static void
enroll_init_storage_we_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("db_write_enable (init_storage) failed: 0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
}
static void
enroll_init_storage_create (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: db.new_record(1, 4, 3, b'StgWindsor\0')
* parent=1 (root), type=4 (storage), storage=3, data=name */
const gchar *name = VALIDITY_STORAGE_NAME;
gsize name_len = strlen (name) + 1; /* include NUL */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_new_record (
1, 4, 3, (const guint8 *) name, name_len, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_init_storage_create_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("create storage failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
fp_info ("StgWindsor storage created successfully");
fpi_ssm_next_state (ssm);
}
static void
enroll_init_storage_clean (FpiSsm *ssm,
FpiDeviceValidity *self)
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_db_write_enable2 (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Enable DB writes for storing the finger record */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
static void
enroll_db_write_enable2_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("db_write_enable for finger creation failed: 0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
/* Proceed to create a new user record with a UUID identity.
* python-validity: usr = db.new_user(identity) */
fpi_ssm_next_state (ssm);
}
static void
enroll_create_user (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -1062,44 +757,6 @@ enroll_create_user_recv (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
enroll_create_user_cleanups (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: new_record always calls call_cleanups in finally block */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_db_write_enable3 (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* PY: new_record calls db_write_enable before each cmd 0x47 */
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
static void
enroll_db_write_enable3_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("db_write_enable3 failed: 0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
fpi_ssm_next_state (ssm);
}
static void
enroll_create_finger (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -1159,17 +816,6 @@ enroll_create_finger_recv (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
enroll_final_cleanups (FpiSsm *ssm,
FpiDeviceValidity *self)
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
enroll_wait_finger_int (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -1186,46 +832,6 @@ enroll_wait_finger_int (FpiSsm *ssm,
update_interrupt_cb, ssm);
}
static void
enroll_led_on (FpiSsm *ssm,
FpiDeviceValidity *self)
{
gsize cmd_len;
const guint8 *cmd = validity_capture_glow_start_cmd (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
enroll_get_prg_status (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x51: get_prg_status2 (after scan complete, before capture stop) */
const guint8 cmd[] = { 0x51, 0x00, 0x20, 0x00, 0x00 };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
enroll_capture_stop (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x04: capture stop/cleanup */
const guint8 cmd[] = { 0x04 };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
enroll_led_off (FpiSsm *ssm,
FpiDeviceValidity *self)
{
gsize cmd_len;
const guint8 *cmd = validity_capture_glow_end_cmd (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
enroll_run_state (FpiSsm *ssm,
FpDevice *dev)
@ -1244,7 +850,13 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_PRE_GET_STORAGE:
enroll_pre_get_storage (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_get_user_storage (
VALIDITY_STORAGE_NAME, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_PRE_GET_STORAGE_RECV:
@ -1260,15 +872,32 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_START:
enroll_start (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_create_enrollment (TRUE, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_START_RECV:
enroll_start_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("create_enrollment failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
break;
}
fpi_ssm_next_state (ssm);
break;
case ENROLL_LED_ON:
enroll_led_on (ssm, self);
{
gsize cmd_len;
const guint8 *cmd = validity_capture_glow_start_cmd (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
break;
case ENROLL_LED_ON_RECV:
@ -1303,7 +932,10 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_GET_PRG_STATUS:
enroll_get_prg_status (ssm, self);
{
const guint8 cmd[] = { 0x51, 0x00, 0x20, 0x00, 0x00 };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
break;
case ENROLL_GET_PRG_STATUS_RECV:
@ -1312,7 +944,10 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_CAPTURE_STOP:
enroll_capture_stop (ssm, self);
{
const guint8 cmd[] = { 0x04 };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
break;
case ENROLL_CAPTURE_STOP_RECV:
@ -1320,7 +955,14 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_UPDATE_START:
enroll_update_start (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_pack_new (&cmd_len, "bww",
VCSFW_CMD_ENROLLMENT_UPDATE_START,
self->enroll_key, (guint32) 0);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_UPDATE_START_RECV:
@ -1332,15 +974,28 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_DB_WRITE_ENABLE:
enroll_db_write_enable (ssm, self);
{
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
break;
case ENROLL_DB_WRITE_ENABLE_RECV:
enroll_db_write_enable_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("db_write_enable (1st) failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
case ENROLL_APPEND_IMAGE:
enroll_append_image (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_enrollment_update (
self->enroll_template, self->enroll_template_len, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_APPEND_IMAGE_RECV:
@ -1348,11 +1003,20 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_CLEANUPS:
enroll_cleanups (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_CLEANUPS_RECV:
enroll_cleanups_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("call_cleanups (1st) failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
case ENROLL_WAIT_UPDATE_INT:
@ -1360,15 +1024,28 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_DB_WRITE_ENABLE_READ:
enroll_db_write_enable_read (ssm, self);
{
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
break;
case ENROLL_DB_WRITE_ENABLE_READ_RECV:
enroll_db_write_enable_read_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("db_write_enable (2nd) failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
case ENROLL_APPEND_IMAGE_READ:
enroll_append_image_read (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_enrollment_update (
self->enroll_template, self->enroll_template_len, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_APPEND_IMAGE_READ_RECV:
@ -1376,15 +1053,29 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_CLEANUPS_READ:
enroll_cleanups_read (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_CLEANUPS_READ_RECV:
enroll_cleanups_read_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("call_cleanups (2nd) failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
case ENROLL_UPDATE_END:
enroll_update_end (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_create_enrollment (FALSE, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_UPDATE_END_RECV:
@ -1396,7 +1087,12 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_UPDATE_END2:
enroll_update_end2 (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_create_enrollment (FALSE, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_UPDATE_END2_RECV:
@ -1405,7 +1101,13 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_GET_STORAGE:
enroll_get_storage (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_get_user_storage (
VALIDITY_STORAGE_NAME, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_GET_STORAGE_RECV:
@ -1413,23 +1115,52 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_INIT_STORAGE_WE:
enroll_init_storage_we (ssm, self);
{
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
break;
case ENROLL_INIT_STORAGE_WE_RECV:
enroll_init_storage_we_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("db_write_enable (init_storage) failed: 0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
case ENROLL_INIT_STORAGE_CREATE:
enroll_init_storage_create (ssm, self);
{
const gchar *name = VALIDITY_STORAGE_NAME;
gsize name_len = strlen (name) + 1;
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_new_record (
1, 4, 3, (const guint8 *) name, name_len, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_INIT_STORAGE_CREATE_RECV:
enroll_init_storage_create_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("create storage failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
break;
}
fp_info ("StgWindsor storage created successfully");
fpi_ssm_next_state (ssm);
break;
case ENROLL_INIT_STORAGE_CLEAN:
enroll_init_storage_clean (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_INIT_STORAGE_CLEAN_RECV:
@ -1438,11 +1169,23 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_DB_WRITE_ENABLE2:
enroll_db_write_enable2 (ssm, self);
{
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
break;
case ENROLL_DB_WRITE_ENABLE2_RECV:
enroll_db_write_enable2_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("db_write_enable for finger creation failed: 0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
break;
}
fpi_ssm_next_state (ssm);
break;
case ENROLL_CREATE_USER:
@ -1454,7 +1197,12 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_CREATE_USER_CLEANUPS:
enroll_create_user_cleanups (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_CREATE_USER_CLEANUPS_RECV:
@ -1462,11 +1210,23 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_DB_WRITE_ENABLE3:
enroll_db_write_enable3 (ssm, self);
{
gsize blob_len;
const guint8 *blob = validity_db_get_write_enable_blob (self, &blob_len);
vcsfw_tls_cmd_send (self, ssm, blob, blob_len, NULL);
}
break;
case ENROLL_DB_WRITE_ENABLE3_RECV:
enroll_db_write_enable3_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("db_write_enable3 failed: 0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
break;
}
fpi_ssm_next_state (ssm);
break;
case ENROLL_CREATE_FINGER:
@ -1478,7 +1238,12 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_FINAL_CLEANUPS:
enroll_final_cleanups (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_call_cleanups (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case ENROLL_FINAL_CLEANUPS_RECV:
@ -1490,7 +1255,11 @@ enroll_run_state (FpiSsm *ssm,
break;
case ENROLL_LED_OFF:
enroll_led_off (ssm, self);
{
gsize cmd_len;
const guint8 *cmd = validity_capture_glow_end_cmd (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
break;
case ENROLL_LED_OFF_RECV:

212
libfprint/drivers/validity/validity_fwext.c
View file

@ -352,46 +352,6 @@ fwext_upload_data_free (gpointer data)
}
static void
fwext_send_write_hw_reg (FpiSsm *ssm,
FpiDeviceValidity *self)
{
guint8 cmd[10];
gsize cmd_len;
validity_fwext_build_write_hw_reg32 (FWEXT_HW_REG_WRITE_ADDR,
FWEXT_HW_REG_WRITE_VALUE,
cmd, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
fwext_recv_write_hw_reg (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
"WRITE_HW_REG failed: status=0x%04x",
self->cmd_response_status));
return;
}
fpi_ssm_next_state (ssm);
}
static void
fwext_send_read_hw_reg (FpiSsm *ssm,
FpiDeviceValidity *self)
{
guint8 cmd[6];
gsize cmd_len;
validity_fwext_build_read_hw_reg32 (FWEXT_HW_REG_READ_ADDR,
cmd, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
fwext_recv_read_hw_reg (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -484,22 +444,6 @@ fwext_send_db_write_enable (FpiSsm *ssm,
vcsfw_tls_cmd_send (self, ssm, dbe, dbe_len, NULL);
}
static void
fwext_recv_db_write_enable (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
"db_write_enable failed: "
"status=0x%04x",
self->cmd_response_status));
return;
}
fpi_ssm_next_state (ssm);
}
static void
fwext_send_write_chunk (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -528,22 +472,6 @@ fwext_send_write_chunk (FpiSsm *ssm,
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
fwext_recv_write_chunk (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
"WRITE_FLASH chunk failed: "
"status=0x%04x",
self->cmd_response_status));
return;
}
fpi_ssm_next_state (ssm);
}
static void
fwext_recv_cleanup (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -590,22 +518,6 @@ fwext_send_write_signature (FpiSsm *ssm,
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
fwext_recv_write_signature (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
"WRITE_FW_SIG failed: "
"status=0x%04x",
self->cmd_response_status));
return;
}
fpi_ssm_next_state (ssm);
}
static void
fwext_recv_verify (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -629,49 +541,6 @@ fwext_recv_verify (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
fwext_send_reboot (FpiSsm *ssm,
FpiDeviceValidity *self)
{
guint8 cmd[3];
gsize cmd_len;
validity_fwext_build_reboot (cmd, &cmd_len);
fp_info ("FWEXT: Rebooting sensor to activate new firmware");
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
fwext_recv_reboot (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Sensor will disconnect and re-enumerate on USB.
* We mark SSM completed -- the caller (open sequence)
* handles the post-reboot re-init. */
fp_info ("FWEXT: Reboot sent. Device will re-enumerate.");
fpi_ssm_mark_completed (ssm);
}
static void
fwext_send_cleanup (FpiSsm *ssm,
FpiDeviceValidity *self)
{
guint8 cmd[] = { VCSFW_CMD_CLEANUP };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
fwext_send_verify (FpiSsm *ssm,
FpiDeviceValidity *self)
{
guint8 cmd[] = { VCSFW_CMD_GET_FW_INFO, FWEXT_PARTITION };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
void
validity_fwext_upload_run_state (FpiSsm *ssm,
FpDevice *dev)
@ -681,15 +550,36 @@ validity_fwext_upload_run_state (FpiSsm *ssm,
switch (fpi_ssm_get_cur_state (ssm))
{
case FWEXT_SEND_WRITE_HW_REG:
fwext_send_write_hw_reg (ssm, self);
{
guint8 cmd[10];
gsize cmd_len;
validity_fwext_build_write_hw_reg32 (FWEXT_HW_REG_WRITE_ADDR,
FWEXT_HW_REG_WRITE_VALUE,
cmd, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
break;
case FWEXT_RECV_WRITE_HW_REG:
fwext_recv_write_hw_reg (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
"WRITE_HW_REG failed: status=0x%04x",
self->cmd_response_status));
break;
}
fpi_ssm_next_state (ssm);
break;
case FWEXT_SEND_READ_HW_REG:
fwext_send_read_hw_reg (ssm, self);
{
guint8 cmd[6];
gsize cmd_len;
validity_fwext_build_read_hw_reg32 (FWEXT_HW_REG_READ_ADDR,
cmd, &cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
break;
case FWEXT_RECV_READ_HW_REG:
@ -705,7 +595,16 @@ validity_fwext_upload_run_state (FpiSsm *ssm,
break;
case FWEXT_RECV_DB_WRITE_ENABLE:
fwext_recv_db_write_enable (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
"db_write_enable failed: "
"status=0x%04x",
self->cmd_response_status));
break;
}
fpi_ssm_next_state (ssm);
break;
case FWEXT_SEND_WRITE_CHUNK:
@ -713,11 +612,23 @@ validity_fwext_upload_run_state (FpiSsm *ssm,
break;
case FWEXT_RECV_WRITE_CHUNK:
fwext_recv_write_chunk (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
"WRITE_FLASH chunk failed: "
"status=0x%04x",
self->cmd_response_status));
break;
}
fpi_ssm_next_state (ssm);
break;
case FWEXT_SEND_CLEANUP:
fwext_send_cleanup (ssm, self);
{
guint8 cmd[] = { VCSFW_CMD_CLEANUP };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
break;
case FWEXT_RECV_CLEANUP:
@ -729,11 +640,23 @@ validity_fwext_upload_run_state (FpiSsm *ssm,
break;
case FWEXT_RECV_WRITE_SIGNATURE:
fwext_recv_write_signature (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fpi_ssm_mark_failed (ssm,
fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
"WRITE_FW_SIG failed: "
"status=0x%04x",
self->cmd_response_status));
break;
}
fpi_ssm_next_state (ssm);
break;
case FWEXT_SEND_VERIFY:
fwext_send_verify (ssm, self);
{
guint8 cmd[] = { VCSFW_CMD_GET_FW_INFO, FWEXT_PARTITION };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
break;
case FWEXT_RECV_VERIFY:
@ -741,11 +664,18 @@ validity_fwext_upload_run_state (FpiSsm *ssm,
break;
case FWEXT_SEND_REBOOT:
fwext_send_reboot (ssm, self);
{
guint8 cmd[3];
gsize cmd_len;
validity_fwext_build_reboot (cmd, &cmd_len);
fp_info ("FWEXT: Rebooting sensor to activate new firmware");
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
break;
case FWEXT_RECV_REBOOT:
fwext_recv_reboot (ssm, self);
fp_info ("FWEXT: Reboot sent. Device will re-enumerate.");
fpi_ssm_mark_completed (ssm);
break;
}
}

8
libfprint/drivers/validity/validity_pack.h
View file

@ -102,7 +102,7 @@ validity_unpack_one (FpiByteReader *r,
case 'd':
{
const guint8 **out = va_arg (*ap, const guint8 **);
const guint8 **out = va_arg (*ap, const guint8 * *);
gsize len = va_arg (*ap, gsize);
return fpi_byte_reader_get_data (r, len, out);
}
@ -175,7 +175,8 @@ validity_pack_new (gsize *out_len,
size += 1;
break;
case 'h': case 'H':
case 'h':
case 'H':
size += 2;
(void) va_arg (ap, int);
break;
@ -185,7 +186,8 @@ validity_pack_new (gsize *out_len,
(void) va_arg (ap, guint32);
break;
case 'w': case 'W':
case 'w':
case 'W':
size += 4;
(void) va_arg (ap, guint32);
break;

350
libfprint/drivers/validity/validity_pair.c
View file

@ -655,23 +655,6 @@ pair_check_needed (FpiSsm *ssm,
fpi_ssm_jump_to_state (ssm, PAIR_SEND_RESET_BLOB);
}
static void
pair_verify_tls_send (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Read flash partition 1 (TLS cert store) to verify keys exist */
guint8 cmd[13];
validity_pack (cmd, sizeof (cmd), "bbbhww",
VCSFW_CMD_READ_FLASH,
(guint8) 0x01, /* partition */
(guint8) 0x01, /* access flag */
(guint16) 0x0000,
(guint32) 0x0000,
(guint32) 0x1000);
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
pair_verify_tls_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -770,21 +753,6 @@ pair_send_reset_blob (FpiSsm *ssm,
vcsfw_cmd_send (self, ssm, reset_data, reset_len, NULL);
}
static void
pair_send_reset_blob_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("reset_blob failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
fpi_ssm_next_state (ssm);
}
static void
pair_generate_keys (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -937,62 +905,6 @@ pair_partition_flash_recv (FpiSsm *ssm,
fpi_ssm_jump_to_state (ssm, PAIR_CMD50_SEND);
}
static void
pair_factory_reset_send (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* CMD 0x10 + 0x61 zero bytes: wipes flash partition table.
* python-validity: usb.cmd(b'\x10' + b'\0' * 0x61) */
guint8 cmd[98];
FpiByteWriter writer;
fpi_byte_writer_init_with_data (&writer, cmd, sizeof (cmd), FALSE);
fpi_byte_writer_put_uint8 (&writer, 0x10);
fpi_byte_writer_fill (&writer, 0, sizeof (cmd) - 1);
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
pair_factory_reset_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("Factory reset cmd 0x10 status=0x%04x",
self->cmd_response_status);
else
fp_info ("Factory reset complete — rebooting sensor");
/* Reboot; next device open will pair from clean state */
fpi_ssm_jump_to_state (ssm, PAIR_REBOOT_SEND);
}
static void
pair_cmd50_send (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* CMD 0x50: get ECDH server parameters
* python-validity: usb.cmd(unhex('50')) */
guint8 cmd[] = { VCSFW_CMD_GET_ECDH };
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
pair_cmd50_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("CMD 0x50 failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
fpi_ssm_next_state (ssm);
}
static void
pair_cmd50_process (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -1137,31 +1049,6 @@ pair_cmd50_process (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
pair_cleanups_send (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* CMD 0x1a: call_cleanups after CMD 0x50
* python-validity: call_cleanups() in finally block */
guint8 cmd[] = { VCSFW_CMD_CLEANUPS };
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
pair_cleanups_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Ignore "nothing to commit" (0x0491) status */
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("cleanups failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
return;
}
/* ---- Phase 2: TLS handshake ---- */
static void
@ -1211,47 +1098,6 @@ pair_erase_dbe_send (FpiSsm *ssm,
vcsfw_tls_cmd_send (self, ssm, dbe_data, dbe_len, NULL);
}
static void
pair_erase_send (FpiSsm *ssm,
FpiDeviceValidity *self)
{
ValidityPairState *ps = &self->pair_state;
/* CMD 0x3f: erase partition */
guint8 cmd[2];
validity_pack (cmd, sizeof (cmd), "bb",
VCSFW_CMD_ERASE_FLASH,
pair_erase_partition_ids[ps->erase_step]);
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
pair_erase_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
ValidityPairState *ps = &self->pair_state;
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("erase partition %u failed: status=0x%04x",
pair_erase_partition_ids[ps->erase_step],
self->cmd_response_status);
fpi_ssm_next_state (ssm);
}
static void
pair_erase_clean_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* Ignore "nothing to commit" */
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("post-erase cleanups status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
}
static void
pair_erase_loop (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -1326,34 +1172,6 @@ pair_write_flash_send (FpiSsm *ssm,
g_free (cmd);
}
static void
pair_write_flash_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("write_flash failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
fpi_ssm_next_state (ssm);
}
static void
pair_write_clean_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
{
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("post-write cleanups status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
return;
}
/* ---- Phase 5: Reboot ---- */
static void
pair_reboot_send (FpiSsm *ssm,
@ -1369,35 +1187,6 @@ pair_reboot_send (FpiSsm *ssm,
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
pair_get_flash_info (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* CMD 0x3e: GET_FLASH_INFO — ask how many partitions exist */
guint8 cmd[] = { VCSFW_CMD_GET_FLASH_INFO };
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
pair_erase_clean_send (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* CMD 0x1a: call_cleanups after erase */
guint8 cmd[] = { VCSFW_CMD_CLEANUPS };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
pair_write_clean_send (FpiSsm *ssm,
FpiDeviceValidity *self)
{
guint8 cmd[] = { VCSFW_CMD_CLEANUPS };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
void
validity_pair_run_state (FpiSsm *ssm,
FpDevice *dev)
@ -1407,8 +1196,11 @@ validity_pair_run_state (FpiSsm *ssm,
switch (fpi_ssm_get_cur_state (ssm))
{
case PAIR_GET_FLASH_INFO:
pair_get_flash_info (ssm, self);
break;
{
guint8 cmd[] = { VCSFW_CMD_GET_FLASH_INFO };
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
break;
}
case PAIR_GET_FLASH_INFO_RECV:
/* Response already in self->cmd_response_* from vcsfw_cmd_send sub-SSM.
@ -1421,8 +1213,18 @@ validity_pair_run_state (FpiSsm *ssm,
break;
case PAIR_VERIFY_TLS_SEND:
pair_verify_tls_send (ssm, self);
break;
{
guint8 cmd[13];
validity_pack (cmd, sizeof (cmd), "bbbhww",
VCSFW_CMD_READ_FLASH,
(guint8) 0x01,
(guint8) 0x01,
(guint16) 0x0000,
(guint32) 0x0000,
(guint32) 0x1000);
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
break;
}
case PAIR_VERIFY_TLS_RECV:
pair_verify_tls_recv (ssm, self);
@ -1433,7 +1235,15 @@ validity_pair_run_state (FpiSsm *ssm,
break;
case PAIR_SEND_RESET_BLOB_RECV:
pair_send_reset_blob_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("reset_blob failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
break;
}
fpi_ssm_next_state (ssm);
break;
case PAIR_GENERATE_KEYS:
@ -1449,19 +1259,42 @@ validity_pair_run_state (FpiSsm *ssm,
break;
case PAIR_FACTORY_RESET_SEND:
pair_factory_reset_send (ssm, self);
break;
{
guint8 cmd[98];
FpiByteWriter writer;
fpi_byte_writer_init_with_data (&writer, cmd, sizeof (cmd), FALSE);
fpi_byte_writer_put_uint8 (&writer, 0x10);
fpi_byte_writer_fill (&writer, 0, sizeof (cmd) - 1);
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
break;
}
case PAIR_FACTORY_RESET_RECV:
pair_factory_reset_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("Factory reset cmd 0x10 status=0x%04x",
self->cmd_response_status);
else
fp_info ("Factory reset complete — rebooting sensor");
fpi_ssm_jump_to_state (ssm, PAIR_REBOOT_SEND);
break;
case PAIR_CMD50_SEND:
pair_cmd50_send (ssm, self);
break;
{
guint8 cmd[] = { VCSFW_CMD_GET_ECDH };
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
break;
}
case PAIR_CMD50_RECV:
pair_cmd50_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("CMD 0x50 failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
break;
}
fpi_ssm_next_state (ssm);
break;
case PAIR_CMD50_PROCESS:
@ -1469,11 +1302,19 @@ validity_pair_run_state (FpiSsm *ssm,
break;
case PAIR_CLEANUPS_SEND:
pair_cleanups_send (ssm, self);
break;
{
guint8 cmd[] = { VCSFW_CMD_CLEANUPS };
vcsfw_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
break;
}
case PAIR_CLEANUPS_RECV:
pair_cleanups_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("cleanups failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
case PAIR_TLS_HANDSHAKE:
pair_tls_handshake (ssm, self);
@ -1488,19 +1329,40 @@ validity_pair_run_state (FpiSsm *ssm,
break;
case PAIR_ERASE_SEND:
pair_erase_send (ssm, self);
break;
{
ValidityPairState *ps = &self->pair_state;
guint8 cmd[2];
validity_pack (cmd, sizeof (cmd), "bb",
VCSFW_CMD_ERASE_FLASH,
pair_erase_partition_ids[ps->erase_step]);
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
break;
}
case PAIR_ERASE_RECV:
pair_erase_recv (ssm, self);
break;
{
ValidityPairState *ps = &self->pair_state;
if (self->cmd_response_status != VCSFW_STATUS_OK)
fp_warn ("erase partition %u failed: status=0x%04x",
pair_erase_partition_ids[ps->erase_step],
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
}
case PAIR_ERASE_CLEAN_SEND:
pair_erase_clean_send (ssm, self);
break;
{
guint8 cmd[] = { VCSFW_CMD_CLEANUPS };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
break;
}
case PAIR_ERASE_CLEAN_RECV:
pair_erase_clean_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("post-erase cleanups status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
case PAIR_ERASE_LOOP:
@ -1519,15 +1381,31 @@ validity_pair_run_state (FpiSsm *ssm,
break;
case PAIR_WRITE_FLASH_RECV:
pair_write_flash_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK)
{
fp_warn ("write_flash failed: status=0x%04x",
self->cmd_response_status);
fpi_ssm_mark_failed (ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
break;
}
fpi_ssm_next_state (ssm);
break;
case PAIR_WRITE_CLEAN_SEND:
pair_write_clean_send (ssm, self);
break;
{
guint8 cmd[] = { VCSFW_CMD_CLEANUPS };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
break;
}
case PAIR_WRITE_CLEAN_RECV:
pair_write_clean_recv (ssm, self);
if (self->cmd_response_status != VCSFW_STATUS_OK &&
self->cmd_response_status != 0x0491)
fp_warn ("post-write cleanups status=0x%04x",
self->cmd_response_status);
fpi_ssm_next_state (ssm);
break;
case PAIR_REBOOT_SEND:
pair_reboot_send (ssm, self);

125
libfprint/drivers/validity/validity_verify.c
View file

@ -364,18 +364,6 @@ verify_capture_recv (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
verify_match_start (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x5E: match_finger */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_match_finger (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
verify_match_start_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -391,18 +379,6 @@ verify_match_start_recv (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
verify_get_result (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x60: get_match_result */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_get_match_result (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
verify_get_result_recv (FpiSsm *ssm,
FpiDeviceValidity *self)
@ -427,58 +403,6 @@ verify_get_result_recv (FpiSsm *ssm,
fpi_ssm_next_state (ssm);
}
static void
verify_cleanup (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x62: match_cleanup */
gsize cmd_len;
guint8 *cmd = validity_db_build_cmd_match_cleanup (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
static void
verify_led_on (FpiSsm *ssm,
FpiDeviceValidity *self)
{
gsize cmd_len;
const guint8 *cmd = validity_capture_glow_start_cmd (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
verify_get_prg_status (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x51: get_prg_status2 (after scan complete, before capture stop) */
const guint8 cmd[] = { 0x51, 0x00, 0x20, 0x00, 0x00 };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
verify_capture_stop (FpiSsm *ssm,
FpiDeviceValidity *self)
{
/* cmd 0x04: capture stop/cleanup */
const guint8 cmd[] = { 0x04 };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
static void
verify_led_off (FpiSsm *ssm,
FpiDeviceValidity *self)
{
gsize cmd_len;
const guint8 *cmd = validity_capture_glow_end_cmd (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
static void
verify_run_state (FpiSsm *ssm,
FpDevice *dev)
@ -488,7 +412,11 @@ verify_run_state (FpiSsm *ssm,
switch (fpi_ssm_get_cur_state (ssm))
{
case VERIFY_LED_ON:
verify_led_on (ssm, self);
{
gsize cmd_len;
const guint8 *cmd = validity_capture_glow_start_cmd (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
break;
case VERIFY_LED_ON_RECV:
@ -516,7 +444,10 @@ verify_run_state (FpiSsm *ssm,
break;
case VERIFY_GET_PRG_STATUS:
verify_get_prg_status (ssm, self);
{
const guint8 cmd[] = { 0x51, 0x00, 0x20, 0x00, 0x00 };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
break;
case VERIFY_GET_PRG_STATUS_RECV:
@ -525,7 +456,10 @@ verify_run_state (FpiSsm *ssm,
break;
case VERIFY_CAPTURE_STOP:
verify_capture_stop (ssm, self);
{
const guint8 cmd[] = { 0x04 };
vcsfw_tls_cmd_send (self, ssm, cmd, sizeof (cmd), NULL);
}
break;
case VERIFY_CAPTURE_STOP_RECV:
@ -534,7 +468,14 @@ verify_run_state (FpiSsm *ssm,
break;
case VERIFY_MATCH_START:
verify_match_start (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_pack_new (&cmd_len, "bbbhhhhh",
VCSFW_CMD_MATCH_FINGER,
0x02, 0xFF, 0, 0, 1, 0, 0);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case VERIFY_MATCH_START_RECV:
@ -547,7 +488,14 @@ verify_run_state (FpiSsm *ssm,
break;
case VERIFY_GET_RESULT:
verify_get_result (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_pack_new (&cmd_len, "bw",
VCSFW_CMD_GET_MATCH_RESULT,
(guint32) 0);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case VERIFY_GET_RESULT_RECV:
@ -555,7 +503,14 @@ verify_run_state (FpiSsm *ssm,
break;
case VERIFY_CLEANUP:
verify_cleanup (ssm, self);
{
gsize cmd_len;
guint8 *cmd = validity_pack_new (&cmd_len, "bw",
VCSFW_CMD_MATCH_CLEANUP,
(guint32) 0);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
g_free (cmd);
}
break;
case VERIFY_CLEANUP_RECV:
@ -564,7 +519,11 @@ verify_run_state (FpiSsm *ssm,
break;
case VERIFY_LED_OFF:
verify_led_off (ssm, self);
{
gsize cmd_len;
const guint8 *cmd = validity_capture_glow_end_cmd (&cmd_len);
vcsfw_tls_cmd_send (self, ssm, cmd, cmd_len, NULL);
}
break;
case VERIFY_LED_OFF_RECV:

52
tests/test-validity.c
View file

@ -33,6 +33,7 @@
#include "drivers/validity/validity_sensor.h"
#include "drivers/validity/validity_fwext.h"
#include "drivers/validity/vcsfw_protocol.h"
#include "drivers/validity/validity_pack.h"
#include "drivers/validity/validity_db.h"
#include "drivers/validity/validity_capture.h"
#include "drivers/validity/validity_tls.h"
@ -1408,7 +1409,7 @@ static void
test_cmd_db_info (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_info (&len);
g_autofree guint8 *cmd = validity_pack_new (&len, "b", VCSFW_CMD_DB_INFO);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 1);
@ -1482,8 +1483,13 @@ test_cmd_lookup_user (void)
{
gsize len;
guint8 identity[] = { 0x01, 0x02, 0x03, 0x04 };
g_autofree guint8 *cmd = validity_db_build_cmd_lookup_user (
0x0003, identity, sizeof (identity), &len);
g_autofree guint8 *cmd = validity_pack_new (
&len, "bhhhd",
VCSFW_CMD_GET_USER,
(guint16) 0, /* dbid = 0 → lookup by name */
(guint16) 0x0003, /* storage */
(guint16) sizeof (identity), /* identity_len */
identity, (gsize) sizeof (identity));
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 7 + sizeof (identity));
@ -1569,7 +1575,10 @@ static void
test_cmd_enrollment_update_start (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_enrollment_update_start (0x12345678, &len);
g_autofree guint8 *cmd = validity_pack_new (&len, "bww",
VCSFW_CMD_ENROLLMENT_UPDATE_START,
(guint32) 0x12345678,
(guint32) 0);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 9);
@ -1587,7 +1596,9 @@ static void
test_cmd_match_finger (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_match_finger (&len);
g_autofree guint8 *cmd = validity_pack_new (&len, "bbbhhhhh",
VCSFW_CMD_MATCH_FINGER,
0x02, 0xFF, 0, 0, 1, 0, 0);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 13);
@ -1610,7 +1621,9 @@ static void
test_cmd_get_match_result (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_get_match_result (&len);
g_autofree guint8 *cmd = validity_pack_new (&len, "bw",
VCSFW_CMD_GET_MATCH_RESULT,
(guint32) 0);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 5);
@ -1631,7 +1644,9 @@ static void
test_cmd_match_cleanup (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_match_cleanup (&len);
g_autofree guint8 *cmd = validity_pack_new (&len, "bw",
VCSFW_CMD_MATCH_CLEANUP,
(guint32) 0);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 5);
@ -1648,7 +1663,9 @@ test_cmd_get_prg_status (void)
{
gsize len;
g_autofree guint8 *normal = validity_db_build_cmd_get_prg_status (FALSE, &len);
g_autofree guint8 *normal = validity_pack_new (&len, "bw",
VCSFW_CMD_GET_PRG_STATUS,
(guint32) 0);
g_assert_cmpuint (len, ==, 5);
g_assert_cmpuint (normal[0], ==, VCSFW_CMD_GET_PRG_STATUS);
@ -1658,7 +1675,9 @@ test_cmd_get_prg_status (void)
g_assert_cmpuint (normal[3], ==, 0);
g_assert_cmpuint (normal[4], ==, 0);
g_autofree guint8 *ext = validity_db_build_cmd_get_prg_status (TRUE, &len);
g_autofree guint8 *ext = validity_pack_new (&len, "bw",
VCSFW_CMD_GET_PRG_STATUS,
(guint32) 0x00002000);
g_assert_cmpuint (len, ==, 5);
g_assert_cmpuint (ext[0], ==, VCSFW_CMD_GET_PRG_STATUS);
/* Extended: 00200000 LE */
@ -1677,7 +1696,8 @@ static void
test_cmd_capture_stop (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_capture_stop (&len);
g_autofree guint8 *cmd = validity_pack_new (&len, "b",
VCSFW_CMD_CAPTURE_STOP);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 1);
@ -2065,7 +2085,9 @@ static void
test_cmd_get_record_value (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_get_record_value (0x5678, &len);
g_autofree guint8 *cmd = validity_pack_new (&len, "bh",
VCSFW_CMD_GET_RECORD_VALUE,
(guint16) 0x5678);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 3);
@ -2082,7 +2104,9 @@ static void
test_cmd_get_record_children (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_get_record_children (0x1234, &len);
g_autofree guint8 *cmd = validity_pack_new (&len, "bh",
VCSFW_CMD_GET_RECORD_CHILDREN,
(guint16) 0x1234);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 3);
@ -2477,7 +2501,9 @@ static void
test_match_finger_size (void)
{
gsize len;
g_autofree guint8 *cmd = validity_db_build_cmd_match_finger (&len);
g_autofree guint8 *cmd = validity_pack_new (&len, "bbbhhhhh",
VCSFW_CMD_MATCH_FINGER,
0x02, 0xFF, 0, 0, 1, 0, 0);
g_assert_nonnull (cmd);
g_assert_cmpuint (len, ==, 13);