public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
From: Kate Hsuan <hpa@redhat.com>
To: git-commits@fedoraproject.org
Subject: [rpms/libfprint] f43: Add EGIS readers (rhbz#2480599)
Date: Fri, 26 Jun 2026 07:19:22 GMT [thread overview]
Message-ID: <178245836253.1.9282662469454704043.rpms-libfprint-f99efa9929b2@fedoraproject.org> (raw)
A new commit has been pushed.
Repo : rpms/libfprint
Branch : f43
Commit : f99efa9929b2fd0a4cd0d165d8d76d75c66e8501
Author : Kate Hsuan <hpa@redhat.com>
Date : 2026-06-26T14:51:01+08:00
Stats : +4037/-0 in 8 file(s)
URL : https://src.fedoraproject.org/rpms/libfprint/c/f99efa9929b2fd0a4cd0d165d8d76d75c66e8501?branch=f43
Log:
Add EGIS readers (rhbz#2480599)
Add EGIS support. The MR can be found at
https://gitlab.freedesktop.org/libfprint/libfprint/-/merge_requests/561
Signed-off-by: Kate Hsuan <hpa@redhat.com>
---
diff --git a/0001-doc-Include-Binary-buffer-I-O-section-for-the-byte-r.patch b/0001-doc-Include-Binary-buffer-I-O-section-for-the-byte-r.patch
new file mode 100644
index 0000000..0df0565
--- /dev/null
+++ b/0001-doc-Include-Binary-buffer-I-O-section-for-the-byte-r.patch
@@ -0,0 +1,162 @@
+From 9c140036e9c4d173a19b8e3d6187526d68fbd97c Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Sat, 21 Feb 2026 05:40:56 +0100
+Subject: [PATCH 1/6] doc: Include Binary buffer I/O section for the byte
+ reader/writer
+
+---
+ doc/libfprint-2-sections.txt | 120 +++++++++++++++++++++++++++++++++++
+ doc/libfprint-docs.xml | 6 ++
+ 2 files changed, 126 insertions(+)
+
+diff --git a/doc/libfprint-2-sections.txt b/doc/libfprint-2-sections.txt
+index 0fb0cfa..9f3804f 100644
+--- a/doc/libfprint-2-sections.txt
++++ b/doc/libfprint-2-sections.txt
+@@ -134,6 +134,126 @@ fpi_line_asmbl_ctx
+ fpi_assemble_lines
+ </SECTION>
+
++<SECTION>
++<FILE>fpi-byte-reader</FILE>
++<TITLE>FpiByteReader</TITLE>
++FpiByteReader
++fpi_byte_reader_new
++fpi_byte_reader_free
++fpi_byte_reader_init
++fpi_byte_reader_peek_sub_reader
++fpi_byte_reader_get_sub_reader
++fpi_byte_reader_set_pos
++fpi_byte_reader_get_pos
++fpi_byte_reader_get_remaining
++fpi_byte_reader_get_size
++fpi_byte_reader_skip
++fpi_byte_reader_get_uint8
++fpi_byte_reader_get_int8
++fpi_byte_reader_peek_uint8
++fpi_byte_reader_peek_int8
++fpi_byte_reader_get_uint16_le
++fpi_byte_reader_get_int16_le
++fpi_byte_reader_peek_uint16_le
++fpi_byte_reader_peek_int16_le
++fpi_byte_reader_get_uint16_be
++fpi_byte_reader_get_int16_be
++fpi_byte_reader_peek_uint16_be
++fpi_byte_reader_peek_int16_be
++fpi_byte_reader_get_uint24_le
++fpi_byte_reader_get_int24_le
++fpi_byte_reader_peek_uint24_le
++fpi_byte_reader_peek_int24_le
++fpi_byte_reader_get_uint24_be
++fpi_byte_reader_get_int24_be
++fpi_byte_reader_peek_uint24_be
++fpi_byte_reader_peek_int24_be
++fpi_byte_reader_get_uint32_le
++fpi_byte_reader_get_int32_le
++fpi_byte_reader_peek_uint32_le
++fpi_byte_reader_peek_int32_le
++fpi_byte_reader_get_uint32_be
++fpi_byte_reader_get_int32_be
++fpi_byte_reader_peek_uint32_be
++fpi_byte_reader_peek_int32_be
++fpi_byte_reader_get_uint64_le
++fpi_byte_reader_get_int64_le
++fpi_byte_reader_peek_uint64_le
++fpi_byte_reader_peek_int64_le
++fpi_byte_reader_get_uint64_be
++fpi_byte_reader_get_int64_be
++fpi_byte_reader_peek_uint64_be
++fpi_byte_reader_peek_int64_be
++fpi_byte_reader_get_float32_le
++fpi_byte_reader_peek_float32_le
++fpi_byte_reader_get_float32_be
++fpi_byte_reader_peek_float32_be
++fpi_byte_reader_get_float64_le
++fpi_byte_reader_peek_float64_le
++fpi_byte_reader_get_float64_be
++fpi_byte_reader_peek_float64_be
++fpi_byte_reader_get_data
++fpi_byte_reader_peek_data
++fpi_byte_reader_dup_data
++fpi_byte_reader_masked_scan_uint32
++fpi_byte_reader_masked_scan_uint32_peek
++fpi_byte_reader_skip_string
++fpi_byte_reader_skip_string_utf8
++fpi_byte_reader_skip_string_utf16
++fpi_byte_reader_skip_string_utf32
++fpi_byte_reader_peek_string
++fpi_byte_reader_peek_string_utf8
++fpi_byte_reader_get_string_utf8
++fpi_byte_reader_dup_string_utf8
++fpi_byte_reader_dup_string_utf16
++fpi_byte_reader_dup_string_utf32
++</SECTION>
++
++<SECTION>
++<FILE>fpi-byte-writer</FILE>
++<TITLE>FpiByteWriter</TITLE>
++FpiByteWriter
++fpi_byte_writer_new
++fpi_byte_writer_new_with_size
++fpi_byte_writer_new_with_data
++fpi_byte_writer_init
++fpi_byte_writer_init_with_size
++fpi_byte_writer_init_with_data
++fpi_byte_writer_reset
++fpi_byte_writer_reset_and_get_data
++fpi_byte_writer_free
++fpi_byte_writer_free_and_get_data
++fpi_byte_writer_get_remaining
++fpi_byte_writer_ensure_free_space
++fpi_byte_writer_put_uint8
++fpi_byte_writer_put_uint16_be
++fpi_byte_writer_put_uint24_be
++fpi_byte_writer_put_uint32_be
++fpi_byte_writer_put_uint64_be
++fpi_byte_writer_put_uint16_le
++fpi_byte_writer_put_uint24_le
++fpi_byte_writer_put_uint32_le
++fpi_byte_writer_put_uint64_le
++fpi_byte_writer_put_int8
++fpi_byte_writer_put_int16_be
++fpi_byte_writer_put_int24_be
++fpi_byte_writer_put_int32_be
++fpi_byte_writer_put_int64_be
++fpi_byte_writer_put_int16_le
++fpi_byte_writer_put_int24_le
++fpi_byte_writer_put_int32_le
++fpi_byte_writer_put_int64_le
++fpi_byte_writer_put_float32_be
++fpi_byte_writer_put_float64_be
++fpi_byte_writer_put_float32_le
++fpi_byte_writer_put_float64_le
++fpi_byte_writer_put_string_utf8
++fpi_byte_writer_put_string_utf16
++fpi_byte_writer_put_string_utf32
++fpi_byte_writer_put_data
++fpi_byte_writer_fill
++</SECTION>
++
+ <SECTION>
+ <FILE>fpi-context</FILE>
+ fpi_get_driver_types
+diff --git a/doc/libfprint-docs.xml b/doc/libfprint-docs.xml
+index 0a57efb..09bb826 100644
+--- a/doc/libfprint-docs.xml
++++ b/doc/libfprint-docs.xml
+@@ -48,6 +48,12 @@
+ <xi:include href="xml/fpi-log.xml"/>
+ </chapter>
+
++ <chapter id="driver-data">
++ <title>Binary buffer I/O</title>
++ <xi:include href="xml/fpi-byte-reader.xml"/>
++ <xi:include href="xml/fpi-byte-writer.xml"/>
++ </chapter>
++
+ <chapter id="driver-img">
+ <title>Image manipulation</title>
+ <xi:include href="xml/fpi-image.xml"/>
+--
+2.54.0
+
diff --git a/0002-fpi-byte-writer-Add-APIs-to-write-and-get-GBytes.patch b/0002-fpi-byte-writer-Add-APIs-to-write-and-get-GBytes.patch
new file mode 100644
index 0000000..f883cc9
--- /dev/null
+++ b/0002-fpi-byte-writer-Add-APIs-to-write-and-get-GBytes.patch
@@ -0,0 +1,145 @@
+From 14763d29cf1e5ec9628fd639034675e9b22aff1e Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 14:11:09 +0200
+Subject: [PATCH 2/6] fpi-byte-writer: Add APIs to write and get GBytes
+
+It makes it handier to handle data elements without having to keep size
+and data separated
+---
+ doc/libfprint-2-sections.txt | 2 ++
+ libfprint/fpi-byte-writer.c | 39 ++++++++++++++++++++++++++++++++++++
+ libfprint/fpi-byte-writer.h | 22 ++++++++++++++++++++
+ 3 files changed, 63 insertions(+)
+
+diff --git a/doc/libfprint-2-sections.txt b/doc/libfprint-2-sections.txt
+index 9f3804f..995ad50 100644
+--- a/doc/libfprint-2-sections.txt
++++ b/doc/libfprint-2-sections.txt
+@@ -220,11 +220,13 @@ fpi_byte_writer_init
+ fpi_byte_writer_init_with_size
+ fpi_byte_writer_init_with_data
+ fpi_byte_writer_reset
++fpi_byte_writer_reset_and_get_bytes
+ fpi_byte_writer_reset_and_get_data
+ fpi_byte_writer_free
+ fpi_byte_writer_free_and_get_data
+ fpi_byte_writer_get_remaining
+ fpi_byte_writer_ensure_free_space
++fpi_byte_writer_put_bytes
+ fpi_byte_writer_put_uint8
+ fpi_byte_writer_put_uint16_be
+ fpi_byte_writer_put_uint24_be
+diff --git a/libfprint/fpi-byte-writer.c b/libfprint/fpi-byte-writer.c
+index cb3514a..00ff447 100644
+--- a/libfprint/fpi-byte-writer.c
++++ b/libfprint/fpi-byte-writer.c
+@@ -219,6 +219,36 @@ fpi_byte_writer_reset_and_get_data (FpiByteWriter * writer)
+ return data;
+ }
+
++/**
++ * fpi_byte_writer_reset_and_get_bytes:
++ * @writer: #FpiByteWriter instance
++ *
++ * Resets @writer and returns the current data as a #GBytes.
++ *
++ * Returns: (transfer full): the current data as a #GBytes.
++ */
++GBytes *
++fpi_byte_writer_reset_and_get_bytes (FpiByteWriter * writer)
++{
++ GBytes *bytes;
++
++ g_return_val_if_fail (writer != NULL, NULL);
++
++ if (!writer->owned)
++ {
++ bytes = g_bytes_new (g_steal_pointer (&writer->parent.data),
++ writer->parent.size);
++ }
++ else
++ {
++ bytes = g_bytes_new_take ((gpointer) g_steal_pointer (&writer->parent.data),
++ writer->parent.size);
++ }
++
++ fpi_byte_writer_reset (writer);
++ return g_steal_pointer (&bytes);
++}
++
+ /**
+ * fpi_byte_writer_free:
+ * @writer: (in) (transfer full): #FpiByteWriter instance
+@@ -602,6 +632,15 @@ CREATE_WRITE_STRING_FUNC (32, guint32);
+ *
+ * Returns: %TRUE if the value could be written
+ */
++/**
++ * fpi_byte_writer_put_bytes:
++ * @writer: #FpiByteWriter instance
++ * @bytes: (transfer none): Data to write
++ *
++ * Writes the contents of @bytes to @writer.
++ *
++ * Returns: %TRUE if the value could be written
++ */
+ /**
+ * fpi_byte_writer_fill:
+ * @writer: #FpiByteWriter instance
+diff --git a/libfprint/fpi-byte-writer.h b/libfprint/fpi-byte-writer.h
+index 9b21b5f..699e85e 100644
+--- a/libfprint/fpi-byte-writer.h
++++ b/libfprint/fpi-byte-writer.h
+@@ -77,6 +77,9 @@ void fpi_byte_writer_reset (FpiByteWriter *writer);
+
+ guint8 * fpi_byte_writer_reset_and_get_data (FpiByteWriter *writer);
+
++
++GBytes * fpi_byte_writer_reset_and_get_bytes (FpiByteWriter *writer);
++
+ /**
+ * fpi_byte_writer_get_pos:
+ * @writer: #FpiByteWriter instance
+@@ -204,6 +207,9 @@ gboolean fpi_byte_writer_put_float64_le (FpiByteWriter *writer, gdoubl
+ gboolean fpi_byte_writer_put_data (FpiByteWriter *writer, const guint8 *data, guint size);
+
+
++gboolean fpi_byte_writer_put_bytes (FpiByteWriter *writer, const GBytes *bytes);
++
++
+ gboolean fpi_byte_writer_fill (FpiByteWriter *writer, guint8 value, guint size);
+
+
+@@ -338,6 +344,18 @@ fpi_byte_writer_put_data_inline (FpiByteWriter * writer, const guint8 * data,
+ return TRUE;
+ }
+
++static inline gboolean
++fpi_byte_writer_put_bytes_inline (FpiByteWriter * writer, const GBytes * bytes)
++{
++ g_return_val_if_fail (writer != NULL, FALSE);
++ g_return_val_if_fail (bytes != NULL, FALSE);
++ const guint8 *data;
++ gsize size;
++
++ data = g_bytes_get_data ((GBytes *) bytes, &size);
++ return fpi_byte_writer_put_data_inline (writer, data, size);
++}
++
+ static inline void
+ fpi_byte_writer_fill_unchecked (FpiByteWriter * writer, guint8 value, guint size)
+ {
+@@ -413,6 +431,10 @@ fpi_byte_writer_fill_inline (FpiByteWriter * writer, guint8 value, guint size)
+
+ #define fpi_byte_writer_put_data(writer, data, size) \
+ G_LIKELY (fpi_byte_writer_put_data_inline (writer, data, size))
++#define fpi_byte_writer_put_data_static(writer, data) \
++ G_LIKELY (fpi_byte_writer_put_data_inline (writer, data, sizeof (data)))
++#define fpi_byte_writer_put_bytes(writer, bytes) \
++ G_LIKELY (fpi_byte_writer_put_bytes_inline (writer, bytes))
+ #define fpi_byte_writer_fill(writer, val, size) \
+ G_LIKELY (fpi_byte_writer_fill_inline (writer, val, size))
+
+--
+2.54.0
+
diff --git a/0003-fpi-byte-reader-Add-support-to-read-and-get-peek-GBy.patch b/0003-fpi-byte-reader-Add-support-to-read-and-get-peek-GBy.patch
new file mode 100644
index 0000000..3527bac
--- /dev/null
+++ b/0003-fpi-byte-reader-Add-support-to-read-and-get-peek-GBy.patch
@@ -0,0 +1,187 @@
+From dc48ab8b4018d1c1cc45cafaafbdac0e3d7726fd Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 14:15:28 +0200
+Subject: [PATCH 3/6] fpi-byte-reader: Add support to read and get/peek GBytes
+
+---
+ doc/libfprint-2-sections.txt | 4 +++
+ libfprint/fpi-byte-reader.c | 49 ++++++++++++++++++++++++++++++++++++
+ libfprint/fpi-byte-reader.h | 43 +++++++++++++++++++++++++++++++
+ 3 files changed, 96 insertions(+)
+
+diff --git a/doc/libfprint-2-sections.txt b/doc/libfprint-2-sections.txt
+index 995ad50..52ddb42 100644
+--- a/doc/libfprint-2-sections.txt
++++ b/doc/libfprint-2-sections.txt
+@@ -139,8 +139,10 @@ fpi_assemble_lines
+ <TITLE>FpiByteReader</TITLE>
+ FpiByteReader
+ fpi_byte_reader_new
++fpi_byte_reader_new_bytes
+ fpi_byte_reader_free
+ fpi_byte_reader_init
++fpi_byte_reader_init_bytes
+ fpi_byte_reader_peek_sub_reader
+ fpi_byte_reader_get_sub_reader
+ fpi_byte_reader_set_pos
+@@ -148,6 +150,8 @@ fpi_byte_reader_get_pos
+ fpi_byte_reader_get_remaining
+ fpi_byte_reader_get_size
+ fpi_byte_reader_skip
++fpi_byte_reader_get_bytes
++fpi_byte_reader_peek_bytes
+ fpi_byte_reader_get_uint8
+ fpi_byte_reader_get_int8
+ fpi_byte_reader_peek_uint8
+diff --git a/libfprint/fpi-byte-reader.c b/libfprint/fpi-byte-reader.c
+index 23bc5e7..1591825 100644
+--- a/libfprint/fpi-byte-reader.c
++++ b/libfprint/fpi-byte-reader.c
+@@ -65,6 +65,31 @@ fpi_byte_reader_new (const guint8 * data, guint size)
+ return ret;
+ }
+
++/**
++ * fpi_byte_reader_new_bytes: (skip)
++ * @bytes: (in) (transfer none): a #GBytes instance from which the
++ * #FpiByteReader should read
++ *
++ * Create a new #FpiByteReader instance, which will read from @bytes.
++ *
++ * Free-function: fpi_byte_reader_free
++ *
++ * Returns: (transfer full): a new #FpiByteReader instance
++ */
++FpiByteReader *
++fpi_byte_reader_new_bytes (GBytes * bytes)
++{
++ const guint8 *data;
++ gsize size = 0;
++
++ g_return_val_if_fail (bytes != NULL, NULL);
++
++ data = g_bytes_get_data (bytes, &size);
++ g_return_val_if_fail (size <= G_MAXUINT, NULL);
++
++ return fpi_byte_reader_new (data, (guint) size);
++}
++
+ /**
+ * fpi_byte_reader_free:
+ * @reader: (in) (transfer full): a #FpiByteReader instance
+@@ -100,6 +125,30 @@ fpi_byte_reader_init (FpiByteReader * reader, const guint8 * data, guint size)
+ reader->byte = 0;
+ }
+
++/**
++ * fpi_byte_reader_init_bytes:
++ * @reader: a #FpiByteReader instance
++ * @bytes: (in) (transfer none): a #GBytes instance from which
++ * the #FpiByteReader should read
++ *
++ * Initializes a #FpiByteReader instance to read from @bytes. This function
++ * can be called on already initialized instances.
++ */
++FpiByteReader *
++fpi_byte_reader_init_bytes (FpiByteReader * reader, GBytes * bytes)
++{
++ g_return_val_if_fail (reader != NULL, NULL);
++ g_return_val_if_fail (bytes != NULL, NULL);
++
++ gsize size = 0;
++ const guint8 *data = g_bytes_get_data (bytes, &size);
++
++ g_return_val_if_fail (size <= G_MAXUINT, NULL);
++ fpi_byte_reader_init (reader, data, (guint) size);
++
++ return reader;
++}
++
+ /**
+ * fpi_byte_reader_peek_sub_reader: (skip)
+ * @reader: an existing and initialized #FpiByteReader instance
+diff --git a/libfprint/fpi-byte-reader.h b/libfprint/fpi-byte-reader.h
+index c4e64d2..05a3989 100644
+--- a/libfprint/fpi-byte-reader.h
++++ b/libfprint/fpi-byte-reader.h
+@@ -50,6 +50,7 @@ typedef struct {
+
+ FpiByteReader * fpi_byte_reader_new (const guint8 *data, guint size) G_GNUC_MALLOC;
+
++FpiByteReader * fpi_byte_reader_new_bytes (GBytes *bytes) G_GNUC_MALLOC;
+
+ void fpi_byte_reader_free (FpiByteReader *reader);
+
+@@ -57,6 +58,9 @@ void fpi_byte_reader_free (FpiByteReader *reader);
+ void fpi_byte_reader_init (FpiByteReader *reader, const guint8 *data, guint size);
+
+
++FpiByteReader * fpi_byte_reader_init_bytes (FpiByteReader *reader, GBytes *bytes);
++
++
+ gboolean fpi_byte_reader_peek_sub_reader (FpiByteReader * reader,
+ FpiByteReader * sub_reader,
+ guint size);
+@@ -220,6 +224,13 @@ gboolean fpi_byte_reader_get_data (FpiByteReader * reader, guint s
+
+ gboolean fpi_byte_reader_peek_data (const FpiByteReader * reader, guint size, const guint8 ** val);
+
++
++GBytes * fpi_byte_reader_get_bytes (FpiByteReader *reader, guint size);
++
++
++GBytes * fpi_byte_reader_peek_bytes (const FpiByteReader *reader, guint size);
++
++
+ #define fpi_byte_reader_dup_string(reader,str) \
+ fpi_byte_reader_dup_string_utf8(reader,str)
+
+@@ -642,6 +653,34 @@ fpi_byte_reader_peek_data_inline (const FpiByteReader * reader, guint size, cons
+ return TRUE;
+ }
+
++static inline GBytes *
++fpi_byte_reader_peek_bytes_inline (const FpiByteReader *reader, guint size)
++{
++ const guint8 *data;
++
++ g_return_val_if_fail (reader != NULL, NULL);
++
++ if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
++ return NULL;
++
++ data = fpi_byte_reader_peek_data_unchecked (reader);
++ return g_bytes_new_static (data, size);
++}
++
++static inline GBytes *
++fpi_byte_reader_get_bytes_inline (FpiByteReader *reader, guint size)
++{
++ const guint8 *data;
++
++ g_return_val_if_fail (reader != NULL, NULL);
++
++ if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
++ return NULL;
++
++ data = fpi_byte_reader_get_data_unchecked (reader, size);
++ return g_bytes_new_static (data, size);
++}
++
+ static inline guint
+ fpi_byte_reader_get_pos_inline (const FpiByteReader * reader)
+ {
+@@ -672,6 +711,10 @@ fpi_byte_reader_skip_inline (FpiByteReader * reader, guint nbytes)
+ G_LIKELY(fpi_byte_reader_peek_data_inline(reader,size,val))
+ #define fpi_byte_reader_skip(reader,nbytes) \
+ G_LIKELY(fpi_byte_reader_skip_inline(reader,nbytes))
++#define fpi_byte_reader_get_bytes(reader,size) \
++ fpi_byte_reader_get_bytes_inline(reader,size)
++#define fpi_byte_reader_peek_bytes(reader,size) \
++ fpi_byte_reader_peek_bytes_inline(reader,size)
+
+ #endif /* FPI_BYTE_READER_DISABLE_INLINES */
+
+--
+2.54.0
+
diff --git a/0004-fpi-byte-reader-Add-support-to-read-to-a-static-buff.patch b/0004-fpi-byte-reader-Add-support-to-read-to-a-static-buff.patch
new file mode 100644
index 0000000..7fe3c22
--- /dev/null
+++ b/0004-fpi-byte-reader-Add-support-to-read-to-a-static-buff.patch
@@ -0,0 +1,160 @@
+From f6a8cae5b4f1555769706f7e5b222145fd3be8ee Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 14:16:36 +0200
+Subject: [PATCH 4/6] fpi-byte-reader: Add support to read to a static buffer
+
+This works through macros when the size of a buffer is statically
+defined
+---
+ doc/libfprint-2-sections.txt | 2 ++
+ libfprint/fpi-byte-reader.c | 35 ++++++++++++++++++++++
+ libfprint/fpi-byte-reader.h | 57 ++++++++++++++++++++++++++++++++++++
+ 3 files changed, 94 insertions(+)
+
+diff --git a/doc/libfprint-2-sections.txt b/doc/libfprint-2-sections.txt
+index 52ddb42..391f1f4 100644
+--- a/doc/libfprint-2-sections.txt
++++ b/doc/libfprint-2-sections.txt
+@@ -198,6 +198,8 @@ fpi_byte_reader_get_float64_be
+ fpi_byte_reader_peek_float64_be
+ fpi_byte_reader_get_data
+ fpi_byte_reader_peek_data
++fpi_byte_reader_get_data_static
++fpi_byte_reader_peek_data_static
+ fpi_byte_reader_dup_data
+ fpi_byte_reader_masked_scan_uint32
+ fpi_byte_reader_masked_scan_uint32_peek
+diff --git a/libfprint/fpi-byte-reader.c b/libfprint/fpi-byte-reader.c
+index 1591825..9709a41 100644
+--- a/libfprint/fpi-byte-reader.c
++++ b/libfprint/fpi-byte-reader.c
+@@ -848,6 +848,41 @@ fpi_byte_reader_peek_data (const FpiByteReader * reader, guint size,
+ return fpi_byte_reader_peek_data_inline (reader, size, val);
+ }
+
++/**
++ * fpi_byte_reader_get_data_fixed:
++ * @reader: a #FpiByteReader instance
++ * @size: Size in bytes
++ * @val: (out) (array length=size): address of a buffer to copy data into
++ *
++ * Copies @size bytes from the current data position into @val if at
++ * least @size bytes are left, and updates the current position.
++ *
++ * Returns: %TRUE if successful, %FALSE otherwise.
++ */
++gboolean
++(fpi_byte_reader_get_data_static) (FpiByteReader * reader, guint size,
++ const guint8 * val)
++{
++ return (fpi_byte_reader_get_data_inline_static) (reader, size, val);
++}
++
++/**
++ * fpi_byte_reader_peek_data_fixed:
++ * @reader: a #FpiByteReader instance
++ * @size: Size in bytes
++ * @val: (out) (array length=size): address of a buffer to copy data into
++ *
++ * Like fpi_byte_reader_get_data_fixed() but does not advance the position.
++ *
++ * Returns: %TRUE if successful, %FALSE otherwise.
++ */
++gboolean
++(fpi_byte_reader_peek_data_static) (const FpiByteReader * reader, guint size,
++ guint8 * val)
++{
++ return (fpi_byte_reader_peek_data_inline_static) (reader, size, val);
++}
++
+ /**
+ * fpi_byte_reader_dup_data:
+ * @reader: a #FpiByteReader instance
+diff --git a/libfprint/fpi-byte-reader.h b/libfprint/fpi-byte-reader.h
+index 05a3989..278959f 100644
+--- a/libfprint/fpi-byte-reader.h
++++ b/libfprint/fpi-byte-reader.h
+@@ -222,9 +222,15 @@ gboolean fpi_byte_reader_dup_data (FpiByteReader * reader, guint s
+ gboolean fpi_byte_reader_get_data (FpiByteReader * reader, guint size, const guint8 ** val);
+
+
++gboolean fpi_byte_reader_get_data_static (FpiByteReader * reader, guint size, const guint8 * val);
++
++
+ gboolean fpi_byte_reader_peek_data (const FpiByteReader * reader, guint size, const guint8 ** val);
+
+
++gboolean fpi_byte_reader_peek_data_static (const FpiByteReader * reader, guint size, guint8 * val);
++
++
+ GBytes * fpi_byte_reader_get_bytes (FpiByteReader *reader, guint size);
+
+
+@@ -681,6 +687,32 @@ fpi_byte_reader_get_bytes_inline (FpiByteReader *reader, guint size)
+ return g_bytes_new_static (data, size);
+ }
+
++static inline gboolean
++(fpi_byte_reader_get_data_inline_static) (FpiByteReader * reader, guint size, const guint8 * val)
++{
++ g_return_val_if_fail (reader != NULL, FALSE);
++ g_return_val_if_fail (val != NULL, FALSE);
++
++ if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
++ return FALSE;
++
++ memcpy ((void *) val, fpi_byte_reader_get_data_unchecked (reader, size), size);
++ return TRUE;
++}
++
++static inline gboolean
++(fpi_byte_reader_peek_data_inline_static) (const FpiByteReader * reader, guint size, guint8 * val)
++{
++ g_return_val_if_fail (reader != NULL, FALSE);
++ g_return_val_if_fail (val != NULL, FALSE);
++
++ if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
++ return FALSE;
++
++ memcpy (val, fpi_byte_reader_peek_data_unchecked (reader), size);
++ return TRUE;
++}
++
+ static inline guint
+ fpi_byte_reader_get_pos_inline (const FpiByteReader * reader)
+ {
+@@ -716,6 +748,31 @@ fpi_byte_reader_skip_inline (FpiByteReader * reader, guint nbytes)
+ #define fpi_byte_reader_peek_bytes(reader,size) \
+ fpi_byte_reader_peek_bytes_inline(reader,size)
+
++/**
++ * fpi_byte_reader_get_data_static:
++ * @reader: a #FpiByteReader
++ * @val: fixed-size array (e.g. `uint8_t buf[32]`)
++ *
++ * Reads @size bytes from @reader directly into @val, where @size is
++ * deduced via `sizeof()` - only safe with true C arrays.
++ *
++ * Returns: %TRUE on success, %FALSE otherwise.
++ */
++#define fpi_byte_reader_get_data_static(reader,val) \
++ (fpi_byte_reader_get_data_static) (reader,sizeof(val),val)
++
++/**
++ * fpi_byte_reader_peek_data_static:
++ * @reader: a #FpiByteReader
++ * @val: fixed-size array (e.g. `uint8_t buf[32]`)
++ *
++ * Like fpi_byte_reader_get_data_static() but does not advance the position.
++ *
++ * Returns: %TRUE on success, %FALSE otherwise.
++ */
++#define fpi_byte_reader_peek_data_static(reader,val) \
++ (fpi_byte_reader_peek_data_static) (reader,sizeof(val),val)
++
+ #endif /* FPI_BYTE_READER_DISABLE_INLINES */
+
+ G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiByteReader, fpi_byte_reader_free);
+--
+2.54.0
+
diff --git a/0005-fpi-usb-transfer-Add-missing-definition-of-set_short.patch b/0005-fpi-usb-transfer-Add-missing-definition-of-set_short.patch
new file mode 100644
index 0000000..d967dce
--- /dev/null
+++ b/0005-fpi-usb-transfer-Add-missing-definition-of-set_short.patch
@@ -0,0 +1,42 @@
+From e7c80e748ed3b00c432f3c00f2ec7b7262527db3 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 13:27:36 +0200
+Subject: [PATCH 5/6] fpi-usb-transfer: Add missing definition of
+ set_short_error()
+
+It was in the header but not implemented
+---
+ libfprint/fpi-usb-transfer.c | 20 ++++++++++++++++++++
+ 1 file changed, 20 insertions(+)
+
+diff --git a/libfprint/fpi-usb-transfer.c b/libfprint/fpi-usb-transfer.c
+index ac4f60c..067ae18 100644
+--- a/libfprint/fpi-usb-transfer.c
++++ b/libfprint/fpi-usb-transfer.c
+@@ -548,3 +548,23 @@ fpi_usb_transfer_submit_sync (FpiUsbTransfer *transfer,
+
+ return res;
+ }
++
++/**
++ * fpi_usb_transfer_set_short_error:
++ * @transfer: The transfer to submit, must have been filled.
++ * @short_is_error: Whether a short transfer should be considered an error
++ *
++ * Sets whether a short transfer (a transfer in which the transferred length
++ * does not match the expected length) should be considered an error
++ *
++ * By default, short transfers are not considered an error, but
++ * drivers can enforce a further check by setting this flag.
++ */
++void
++fpi_usb_transfer_set_short_error (FpiUsbTransfer *transfer,
++ gboolean short_is_error)
++{
++ g_return_if_fail (transfer);
++
++ transfer->short_is_error = short_is_error;
++}
+--
+2.54.0
+
diff --git a/0006-fpi-usb-transfer-Wrap-g_error_new-arguments.patch b/0006-fpi-usb-transfer-Wrap-g_error_new-arguments.patch
new file mode 100644
index 0000000..0671682
--- /dev/null
+++ b/0006-fpi-usb-transfer-Wrap-g_error_new-arguments.patch
@@ -0,0 +1,26 @@
+From 9d4e7fc87b76819c049fc23f92b3dccdaf365e75 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 14:36:10 +0200
+Subject: [PATCH 6/6] fpi-usb-transfer: Wrap g_error_new arguments
+
+---
+ libfprint/fpi-usb-transfer.c | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+diff --git a/libfprint/fpi-usb-transfer.c b/libfprint/fpi-usb-transfer.c
+index 067ae18..448c566 100644
+--- a/libfprint/fpi-usb-transfer.c
++++ b/libfprint/fpi-usb-transfer.c
+@@ -344,7 +344,8 @@ transfer_finish_cb (GObject *source_object, GAsyncResult *res, gpointer user_dat
+ {
+ error = g_error_new (G_USB_DEVICE_ERROR,
+ G_USB_DEVICE_ERROR_IO,
+- "Unexpected short error of %zd size (expected %zd)", transfer->actual_length, transfer->length);
++ "Unexpected short error of %zd size (expected %zd)",
++ transfer->actual_length, transfer->length);
+ }
+
+ callback = transfer->callback;
+--
+2.54.0
+
diff --git a/egis_reader.patch b/egis_reader.patch
new file mode 100644
index 0000000..57e83e5
--- /dev/null
+++ b/egis_reader.patch
@@ -0,0 +1,3304 @@
+From 9bddd90f06f4d9997389740b480e71d32bbc859f Mon Sep 17 00:00:00 2001
+From: Jason Huang <jason.huang@egistec.com>
+Date: Wed, 28 Jan 2026 21:06:48 +0800
+Subject: [PATCH 01/13] egis_etu905: Add 1c7a:05ae and 1c7a:9201 fingerprint
+ readers
+
+---
+ data/autosuspend.hwdb | 6 +
+ libfprint/drivers/egismoc/egis_etu905.c | 1635 +++++++++++++++++++++++
+ libfprint/drivers/egismoc/egis_etu905.h | 214 +++
+ libfprint/meson.build | 2 +
+ meson.build | 2 +
+ tests/egis_etu905/custom.pcapng | Bin 0 -> 33644 bytes
+ tests/egis_etu905/custom.py | 109 ++
+ tests/egis_etu905/device | 348 +++++
+ tests/meson.build | 1 +
+ 9 files changed, 2317 insertions(+)
+ create mode 100644 libfprint/drivers/egismoc/egis_etu905.c
+ create mode 100644 libfprint/drivers/egismoc/egis_etu905.h
+ create mode 100644 tests/egis_etu905/custom.pcapng
+ create mode 100644 tests/egis_etu905/custom.py
+ create mode 100644 tests/egis_etu905/device
+
+diff --git a/data/autosuspend.hwdb b/data/autosuspend.hwdb
+index 55b5cb4c..a3ff00af 100644
+--- a/data/autosuspend.hwdb
++++ b/data/autosuspend.hwdb
+@@ -77,6 +77,12 @@ usb:v1C7Ap0571*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
++# Supported by libfprint driver egis_etu905
++usb:v1C7Ap05AE*
++usb:v1C7Ap9201*
++ ID_AUTOSUSPEND=1
++ ID_PERSIST=0
++
+ # Supported by libfprint driver egismoc
+ usb:v1C7Ap0582*
+ usb:v1C7Ap0583*
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+new file mode 100644
+index 00000000..be0c6e05
+--- /dev/null
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -0,0 +1,1635 @@
++/*
++ * Driver for Egis Technology (LighTuning) Match-On-Chip sensors
++ *
++ * This library is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU Lesser General Public
++ * License as published by the Free Software Foundation; either
++ * version 2.1 of the License, or (at your option) any later version.
++ *
++ * This library is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public
++ * License along with this library; if not, write to the Free Software
++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++ */
++
++#define FP_COMPONENT "egis_etu905"
++
++#include <stdio.h>
++#include <glib.h>
++#include <sys/param.h>
++
++#include "drivers_api.h"
++#include "fpi-byte-writer.h"
++
++#include "egis_etu905.h"
++
++struct _FpiDeviceEgisEtu905
++{
++ FpDevice parent;
++ FpiSsm *task_ssm;
++ FpiSsm *cmd_ssm;
++ FpiUsbTransfer *cmd_transfer;
++ GCancellable *interrupt_cancellable;
++ GPtrArray *enrolled_ids;
++ gint max_enroll_stages;
++ guint8 sid[EGIS_ETU905_FINGERPRINT_DATA_SIZE];
++};
++
++G_DEFINE_TYPE (FpiDeviceEgisEtu905, fpi_device_egis_etu905, FP_TYPE_DEVICE);
++
++static const FpIdEntry egis_etu905_id_table[] = {
++ { .vid = 0x1c7a, .pid = 0x05ae, .driver_data = EGIS_ETU905_DRIVER_CHECK_PREFIX_TYPE1 },
++ { .vid = 0x1c7a, .pid = 0x9201, .driver_data = EGIS_ETU905_DRIVER_CHECK_PREFIX_TYPE1 },
++ { .vid = 0, .pid = 0, .driver_data = 0 }
++};
++
++typedef void (*SynCmdMsgCallback) (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error);
++
++typedef struct egis_etu905_command_data
++{
++ SynCmdMsgCallback callback;
++ guchar *buffer_in;
++ gsize length_in;
++} CommandData;
++
++static void
++egis_etu905_command_data_free (CommandData *data)
++{
++ g_free (data->buffer_in);
++ g_free (data);
++}
++
++typedef struct egis_etu905_enroll_print
++{
++ FpPrint *print;
++ int stage;
++} EnrollPrint;
++
++static void
++egis_etu905_finger_on_sensor_cb (FpiUsbTransfer *transfer,
++ FpDevice *device,
++ gpointer userdata,
++ GError *error)
++{
++ fp_dbg ("Finger on sensor callback");
++ fpi_device_report_finger_status (device, FP_FINGER_STATUS_PRESENT);
++
++ fpi_ssm_usb_transfer_cb (transfer, device, userdata, error);
++}
++
++static void
++egis_etu905_wait_finger_on_sensor (FpiSsm *ssm,
++ FpDevice *device)
++{
++ fp_dbg ("Wait for finger on sensor");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ g_autoptr(FpiUsbTransfer) transfer = fpi_usb_transfer_new (device);
++
++ fpi_usb_transfer_fill_interrupt (transfer, EGIS_ETU905_EP_CMD_INTERRUPT_IN,
++ EGIS_ETU905_USB_INTERRUPT_IN_RECV_LENGTH);
++ transfer->ssm = ssm;
++ /* Interrupt on this device always returns 1 byte short; this is expected */
++ transfer->short_is_error = FALSE;
++
++ fpi_device_report_finger_status (device, FP_FINGER_STATUS_NEEDED);
++
++ fpi_usb_transfer_submit (g_steal_pointer (&transfer),
++ EGIS_ETU905_USB_INTERRUPT_TIMEOUT,
++ self->interrupt_cancellable,
++ egis_etu905_finger_on_sensor_cb,
++ NULL);
++}
++
++static gboolean
++egis_etu905_validate_response_prefix (const guchar *buffer_in,
++ const gsize buffer_in_len,
++ const guchar *valid_prefix,
++ const gsize valid_prefix_len)
++{
++ const gboolean result = memcmp (buffer_in +
++ (egis_etu905_read_prefix_len +
++ EGIS_ETU905_CHECK_BYTES_LENGTH),
++ valid_prefix,
++ valid_prefix_len) == 0;
++
++ fp_dbg ("Response prefix valid: %s", result ? "yes" : "NO");
++ return result;
++}
++
++static gboolean
++egis_etu905_validate_response_suffix (const guchar *buffer_in,
++ const gsize buffer_in_len,
++ const guchar *valid_suffix,
++ const gsize valid_suffix_len)
++{
++ const gboolean result = memcmp (buffer_in + (buffer_in_len - valid_suffix_len),
++ valid_suffix,
++ valid_suffix_len) == 0;
++
++ fp_dbg ("Response suffix valid: %s", result ? "yes" : "NO");
++ return result;
++}
++
++static void
++egis_etu905_task_ssm_done (FpiSsm *ssm,
++ FpDevice *device,
++ GError *error)
++{
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ fp_dbg ("Task SSM done");
++
++ /* task_ssm is going to be freed by completion of SSM */
++ g_assert (!self->task_ssm || self->task_ssm == ssm);
++ self->task_ssm = NULL;
++
++ g_clear_pointer (&self->enrolled_ids, g_ptr_array_unref);
++
++ if (error)
++ fpi_device_action_error (device, error);
++}
++
++static void
++egis_etu905_commit_start_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ fp_dbg ("Task SSM commit start callback");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ if (error)
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ else
++ fpi_ssm_jump_to_state (self->task_ssm, ENROLL_COMMIT);
++}
++
++/*
++ * Generic callback for commands that don't need special handling on success.
++ * Advances the task SSM to the next state on success, or marks it failed on error.
++ */
++static void
++egis_etu905_task_ssm_next_state_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ fp_dbg ("Task SSM next state callback");
++
++ if (error)
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ else
++ fpi_ssm_next_state (self->task_ssm);
++}
++
++static void
++egis_etu905_cmd_receive_cb (FpiUsbTransfer *transfer,
++ FpDevice *device,
++ gpointer userdata,
++ GError *error)
++{
++ CommandData *data = userdata;
++
++ fp_dbg ("Command receive callback");
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (transfer->ssm, error);
++ return;
++ }
++ if (data == NULL || transfer->actual_length < egis_etu905_read_prefix_len)
++ {
++ fpi_ssm_mark_failed (transfer->ssm,
++ fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
++ return;
++ }
++
++ /* Store the response data and let the cmd_ssm_done callback invoke
++ * the actual callback with the stored data */
++ data->buffer_in = g_steal_pointer (&transfer->buffer);
++ data->length_in = transfer->actual_length;
++
++ fpi_ssm_mark_completed (transfer->ssm);
++}
++
++static void
++egis_etu905_cmd_run_state (FpiSsm *ssm,
++ FpDevice *device)
++{
++ g_autoptr(FpiUsbTransfer) transfer = NULL;
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ switch (fpi_ssm_get_cur_state (ssm))
++ {
++ case CMD_SEND:
++ if (self->cmd_transfer)
++ {
++ self->cmd_transfer->ssm = ssm;
++ fpi_usb_transfer_submit (g_steal_pointer (&self->cmd_transfer),
++ EGIS_ETU905_USB_SEND_TIMEOUT,
++ fpi_device_get_cancellable (device),
++ fpi_ssm_usb_transfer_cb,
++ NULL);
++ break;
++ }
++
++ fpi_ssm_next_state (ssm);
++ break;
++
++ case CMD_GET:
++ transfer = fpi_usb_transfer_new (device);
++ transfer->ssm = ssm;
++ fpi_usb_transfer_fill_bulk (transfer, EGIS_ETU905_EP_CMD_IN,
++ EGIS_ETU905_USB_IN_RECV_LENGTH);
++ fpi_usb_transfer_submit (g_steal_pointer (&transfer),
++ EGIS_ETU905_USB_RECV_TIMEOUT,
++ fpi_device_get_cancellable (device),
++ egis_etu905_cmd_receive_cb,
++ fpi_ssm_get_data (ssm));
++ break;
++ }
++}
++
++/*
++ * Command SSM done callback.
++ * Always invokes the callback with stored data on success or error.
++ */
++static void
++egis_etu905_cmd_ssm_done (FpiSsm *ssm,
++ FpDevice *device,
++ GError *error)
++{
++ g_autoptr(GError) local_error = error;
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ CommandData *data = fpi_ssm_get_data (ssm);
++
++ g_assert (self->cmd_ssm == ssm);
++ g_assert (!self->cmd_transfer || self->cmd_transfer->ssm == ssm);
++
++ self->cmd_ssm = NULL;
++ self->cmd_transfer = NULL;
++
++ if (data && data->callback)
++ {
++ data->callback (device,
++ g_steal_pointer (&data->buffer_in),
++ data->length_in,
++ g_steal_pointer (&local_error));
++ }
++}
++
++/*
++ * Derive the 2 "check bytes" for write payloads
++ * 32-bit big-endian sum of all 16-bit words (including check bytes) MOD 0xFFFF
++ * should be 0, otherwise the device will reject the payload
++ */
++static guint16
++egis_etu905_get_check_bytes (FpiByteReader *reader)
++{
++ fp_dbg ("Get check bytes");
++ size_t sum_values = 0;
++ guint16 val;
++
++ fpi_byte_reader_set_pos (reader, 0);
++
++ while (fpi_byte_reader_get_uint16_be (reader, &val))
++ sum_values += val;
++
++ return G_MAXUINT16 - (sum_values % G_MAXUINT16);
++}
++
++static void
++egis_etu905_exec_cmd (FpDevice *device,
++ guchar *cmd,
++ const gsize cmd_length,
++ GDestroyNotify cmd_destroy,
++ SynCmdMsgCallback callback)
++{
++ g_auto(FpiByteWriter) writer = {0};
++ g_autoptr(FpiUsbTransfer) transfer = NULL;
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ g_autofree CommandData *data = NULL;
++ gsize buffer_out_length = 0;
++ gboolean written = TRUE;
++ guint16 check_value;
++
++ fp_dbg ("Execute command and get response");
++
++ /*
++ * buffer_out should be a fully composed command (with prefix, check bytes, etc)
++ * which looks like this:
++ * E G I S 00 00 00 01 {cb1} {cb2} {payload}
++ * where cb1 and cb2 are some check bytes generated by the
++ * egis_etu905_get_check_bytes() method and payload is what is passed via the cmd
++ * parameter
++ */
++ buffer_out_length = egis_etu905_write_prefix_len
++ + EGIS_ETU905_CHECK_BYTES_LENGTH
++ + cmd_length;
++
++ fpi_byte_writer_init_with_size (&writer, buffer_out_length +
++ (buffer_out_length % 2 ? 1 : 0), TRUE);
++
++ /* Prefix */
++ written &= fpi_byte_writer_put_data (&writer, egis_etu905_write_prefix,
++ egis_etu905_write_prefix_len);
++
++ /* Check Bytes - leave them as 00 for now then later generate and copy over
++ * the real ones */
++ written &= fpi_byte_writer_change_pos (&writer, EGIS_ETU905_CHECK_BYTES_LENGTH);
++
++ /* Command Payload */
++ written &= fpi_byte_writer_put_data (&writer, cmd, cmd_length);
++
++ /* Now fetch and set the "real" check bytes based on the currently
++ * assembled payload */
++ check_value = egis_etu905_get_check_bytes (FPI_BYTE_READER (&writer));
++ fpi_byte_writer_set_pos (&writer, egis_etu905_write_prefix_len);
++ written &= fpi_byte_writer_put_uint16_be (&writer, check_value);
++
++ /* destroy cmd if requested */
++ if (cmd_destroy)
++ g_clear_pointer (&cmd, cmd_destroy);
++
++ g_assert (self->cmd_ssm == NULL);
++ self->cmd_ssm = fpi_ssm_new (device,
++ egis_etu905_cmd_run_state,
++ CMD_STATES);
++
++ data = g_new0 (CommandData, 1);
++ data->callback = callback;
++ fpi_ssm_set_data (self->cmd_ssm, g_steal_pointer (&data),
++ (GDestroyNotify) egis_etu905_command_data_free);
++
++ if (!written)
++ {
++ fpi_ssm_start (self->cmd_ssm, egis_etu905_cmd_ssm_done);
++ fpi_ssm_mark_failed (self->cmd_ssm,
++ fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
++ return;
++ }
++
++ transfer = fpi_usb_transfer_new (device);
++ transfer->short_is_error = TRUE;
++ transfer->ssm = self->cmd_ssm;
++
++ fpi_usb_transfer_fill_bulk_full (transfer,
++ EGIS_ETU905_EP_CMD_OUT,
++ fpi_byte_writer_reset_and_get_data (&writer),
++ buffer_out_length,
++ g_free);
++
++ g_assert (self->cmd_transfer == NULL);
++ self->cmd_transfer = g_steal_pointer (&transfer);
++ fpi_ssm_start (self->cmd_ssm, egis_etu905_cmd_ssm_done);
++}
++
++static void
++egis_etu905_set_print_data (FpPrint *print,
++ const gchar *device_print_id,
++ const gchar *user_id)
++{
++ GVariant *print_id_var = NULL;
++ GVariant *fpi_data = NULL;
++ g_autofree gchar *fill_user_id = NULL;
++
++ if (user_id)
++ fill_user_id = g_strdup (user_id);
++ else
++ fill_user_id = g_strndup (device_print_id, EGIS_ETU905_FINGERPRINT_DATA_SIZE);
++
++ fpi_print_fill_from_user_id (print, fill_user_id);
++
++ fpi_print_set_type (print, FPI_PRINT_RAW);
++ fpi_print_set_device_stored (print, TRUE);
++
++ g_object_set (print, "description", fill_user_id, NULL);
++
++ print_id_var = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
++ device_print_id,
++ EGIS_ETU905_FINGERPRINT_DATA_SIZE,
++ sizeof (guchar));
++ fpi_data = g_variant_new ("(@ay)", print_id_var);
++ g_object_set (print, "fpi-data", fpi_data, NULL);
++}
++
++static GPtrArray *
++egis_etu905_get_enrolled_prints (FpDevice *device)
++{
++ g_autoptr(GPtrArray) result = g_ptr_array_new_with_free_func (g_object_unref);
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ if (!self->enrolled_ids)
++ return g_steal_pointer (&result);
++
++ for (guint i = 0; i < self->enrolled_ids->len; i++)
++ {
++ FpPrint *print = fp_print_new (device);
++ egis_etu905_set_print_data (print, g_ptr_array_index (self->enrolled_ids, i), NULL);
++ g_ptr_array_add (result, g_object_ref_sink (print));
++ }
++
++ return g_steal_pointer (&result);
++}
++
++static void
++egis_etu905_list_fill_enrolled_ids_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ fp_dbg ("List callback");
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ return;
++ }
++
++ g_clear_pointer (&self->enrolled_ids, g_ptr_array_unref);
++ self->enrolled_ids = g_ptr_array_new_with_free_func (g_free);
++
++ FpiByteReader reader;
++ gboolean read = TRUE;
++
++ fpi_byte_reader_init (&reader, buffer_in, length_in);
++
++ read &= fpi_byte_reader_set_pos (&reader, EGIS_ETU905_LIST_RESPONSE_PREFIX_SIZE);
++
++ /*
++ * Each fingerprint ID will be returned in this response as a 32 byte array
++ * The other stuff in the payload is 16 bytes long, so if there is at least 1
++ * print then the length should be at least 16+32=48 bytes long
++ */
++ while (read)
++ {
++ const guint8 *data;
++ g_autofree gchar *print_id = NULL;
++
++ read &= fpi_byte_reader_get_data (&reader, EGIS_ETU905_FINGERPRINT_DATA_SIZE,
++ &data);
++ if (!read)
++ break;
++
++ print_id = g_memdup2 (data, EGIS_ETU905_FINGERPRINT_DATA_SIZE);
++ g_ptr_array_add (self->enrolled_ids, g_steal_pointer (&print_id));
++ }
++
++ fp_info ("Number of currently enrolled fingerprints on the device is %d",
++ self->enrolled_ids->len);
++
++ if (self->task_ssm)
++ fpi_ssm_next_state (self->task_ssm);
++}
++
++static void
++egis_etu905_list_run_state (FpiSsm *ssm,
++ FpDevice *device)
++{
++ g_autoptr(GPtrArray) enrolled_prints = NULL;
++
++ switch (fpi_ssm_get_cur_state (ssm))
++ {
++ case LIST_GET_ENROLLED_IDS:
++ egis_etu905_exec_cmd (device, cmd_list, cmd_list_len, NULL,
++ egis_etu905_list_fill_enrolled_ids_cb);
++ break;
++
++ case LIST_RETURN_ENROLLED_PRINTS:
++ enrolled_prints = egis_etu905_get_enrolled_prints (device);
++ fpi_device_list_complete (device, g_steal_pointer (&enrolled_prints), NULL);
++ fpi_ssm_next_state (ssm);
++ break;
++ }
++}
++
++static void
++egis_etu905_list (FpDevice *device)
++{
++ fp_dbg ("List");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ g_assert (self->task_ssm == NULL);
++ self->task_ssm = fpi_ssm_new (device,
++ egis_etu905_list_run_state,
++ LIST_STATES);
++ fpi_ssm_start (self->task_ssm, egis_etu905_task_ssm_done);
++}
++
++static guchar *
++egis_etu905_get_delete_cmd (FpDevice *device,
++ FpPrint *delete_print,
++ gsize *length_out)
++{
++ fp_dbg ("Get delete command");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ g_auto(FpiByteWriter) writer = {0};
++ g_autoptr(GVariant) print_data = NULL;
++ g_autoptr(GVariant) print_data_id_var = NULL;
++ const guchar *print_data_id = NULL;
++ gsize print_data_id_len = 0;
++ g_autofree gchar *print_description = NULL;
++ g_autofree guchar *enrolled_print_id = NULL;
++ g_autofree guchar *result = NULL;
++ gboolean written = TRUE;
++
++ /*
++ * The final command body should contain:
++ * 1) hard-coded 00 00
++ * 2) 2-byte size indiciator, 20*Number deleted identifiers plus 7 in form of:
++ * num_to_delete * 0x20 + 0x07
++ * Since max prints can be higher than 7 then this goes up to 2 bytes
++ * (e9 + 9 = 109)
++ * 3) Hard-coded prefix (cmd_delete_prefix)
++ * 4) 2-byte size indiciator, 20*Number of enrolled identifiers without plus 7
++ * (num_to_delete * 0x20)
++ * 5) All of the currently registered prints to delete in their 32-byte device
++ * identifiers (enrolled_list)
++ */
++
++ int num_to_delete = 0;
++ if (delete_print)
++ num_to_delete = 1;
++ else if (self->enrolled_ids)
++ num_to_delete = self->enrolled_ids->len;
++
++ const gsize body_length = sizeof (guchar) * EGIS_ETU905_FINGERPRINT_DATA_SIZE *
++ num_to_delete;
++ /* total_length is the 6 various bytes plus prefix and body payload */
++ const gsize total_length = (sizeof (guchar) * 6) + cmd_delete_prefix_len +
++ body_length;
++
++ /* pre-fill entire payload with 00s */
++ fpi_byte_writer_init_with_size (&writer, total_length, TRUE);
++
++ /* start with 00 00 (just move starting offset up by 2) */
++ written &= fpi_byte_writer_set_pos (&writer, 2);
++
++ /* Size Counter bytes */
++ /* "easiest" way to handle 2-bytes size for counter is to hard-code logic for
++ * when we go to the 2nd byte
++ * note this will not work in case any model ever supports more than 14 prints
++ * (assumed max is 10) */
++ if (num_to_delete > 7)
++ {
++ written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
++ written &= fpi_byte_writer_put_uint8 (&writer, ((num_to_delete - 8) * 0x20) + 0x07);
++ }
++ else
++ {
++ /* first byte is 0x00, just skip it */
++ written &= fpi_byte_writer_change_pos (&writer, 1);
++ written &= fpi_byte_writer_put_uint8 (&writer, (num_to_delete * 0x20) + 0x07);
++ }
++
++ /* command prefix */
++ written &= fpi_byte_writer_put_data (&writer, cmd_delete_prefix,
++ cmd_delete_prefix_len);
++
++ /* 2-bytes size logic for counter again */
++ if (num_to_delete > 7)
++ {
++ written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
++ written &= fpi_byte_writer_put_uint8 (&writer, (num_to_delete - 8) * 0x20);
++ }
++ else
++ {
++ /* first byte is 0x00, just skip it */
++ written &= fpi_byte_writer_change_pos (&writer, 1);
++ written &= fpi_byte_writer_put_uint8 (&writer, num_to_delete * 0x20);
++ }
++
++ /* append desired 32-byte fingerprint IDs */
++ /* if passed a delete_print then fetch its data from the FpPrint */
++ if (delete_print)
++ {
++ g_object_get (delete_print, "description", &print_description, NULL);
++ g_object_get (delete_print, "fpi-data", &print_data, NULL);
++
++ if (!g_variant_check_format_string (print_data, "(@ay)", FALSE))
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
++ return NULL;
++ }
++
++ g_variant_get (print_data, "(@ay)", &print_data_id_var);
++ print_data_id = g_variant_get_fixed_array (print_data_id_var,
++ &print_data_id_len, sizeof (guchar));
++
++ if (!g_str_has_prefix (print_description, "FP"))
++ fp_dbg ("Fingerprint '%s' was not created by libfprint; deleting anyway.",
++ print_description);
++
++ fp_info ("Delete fingerprint %s", print_description);
++
++ written &= fpi_byte_writer_put_data (&writer, print_data_id,
++ EGIS_ETU905_FINGERPRINT_DATA_SIZE);
++ }
++ /* Otherwise assume this is a "clear" - just loop through and append all enrolled IDs */
++ else if (self->enrolled_ids)
++ {
++ for (guint i = 0; i < self->enrolled_ids->len && written; i++)
++ {
++ written &= fpi_byte_writer_put_data (&writer,
++ g_ptr_array_index (self->enrolled_ids, i),
++ EGIS_ETU905_FINGERPRINT_DATA_SIZE);
++ }
++ }
++
++ g_assert (written);
++
++ if (length_out)
++ *length_out = total_length;
++
++ return fpi_byte_writer_reset_and_get_data (&writer);
++}
++
++static void
++egis_etu905_delete_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ fp_dbg ("Delete callback");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ return;
++ }
++
++ /* Check that the read payload indicates "success" with the delete */
++ if (egis_etu905_validate_response_prefix (buffer_in,
++ length_in,
++ rsp_delete_success_prefix,
++ rsp_delete_success_prefix_len))
++ {
++ if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_CLEAR_STORAGE)
++ {
++ fpi_device_clear_storage_complete (device, NULL);
++ fpi_ssm_next_state (self->task_ssm);
++ }
++ else if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_DELETE)
++ {
++ fpi_device_delete_complete (device, NULL);
++ fpi_ssm_next_state (self->task_ssm);
++ }
++ else
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "Unsupported delete action."));
++ }
++ }
++ else
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "Delete print was not successful"));
++ }
++}
++
++static void
++egis_etu905_delete_run_state (FpiSsm *ssm,
++ FpDevice *device)
++{
++ g_autofree guchar *payload = NULL;
++ gsize payload_length = 0;
++
++ switch (fpi_ssm_get_cur_state (ssm))
++ {
++ case DELETE_GET_ENROLLED_IDS:
++ /* get enrolled_ids from device for use building delete payload below */
++ egis_etu905_exec_cmd (device, cmd_list, cmd_list_len, NULL,
++ egis_etu905_list_fill_enrolled_ids_cb);
++ break;
++
++ case DELETE_DELETE:
++ if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_DELETE)
++ payload = egis_etu905_get_delete_cmd (device, fpi_ssm_get_data (ssm),
++ &payload_length);
++ else
++ payload = egis_etu905_get_delete_cmd (device, NULL, &payload_length);
++
++ egis_etu905_exec_cmd (device, g_steal_pointer (&payload), payload_length,
++ g_free, egis_etu905_delete_cb);
++ break;
++ }
++}
++
++static void
++egis_etu905_clear_storage (FpDevice *device)
++{
++ fp_dbg ("Clear storage");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ g_assert (self->task_ssm == NULL);
++ self->task_ssm = fpi_ssm_new (device,
++ egis_etu905_delete_run_state,
++ DELETE_STATES);
++ fpi_ssm_start (self->task_ssm, egis_etu905_task_ssm_done);
++}
++
++static void
++egis_etu905_delete (FpDevice *device)
++{
++ fp_dbg ("Delete");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ FpPrint *delete_print = NULL;
++
++ fpi_device_get_delete_data (device, &delete_print);
++
++ g_assert (self->task_ssm == NULL);
++ self->task_ssm = fpi_ssm_new (device,
++ egis_etu905_delete_run_state,
++ DELETE_STATES);
++ /* the print is owned by libfprint during deletion task */
++ fpi_ssm_set_data (self->task_ssm, delete_print, NULL);
++ fpi_ssm_start (self->task_ssm, egis_etu905_task_ssm_done);
++}
++
++static void
++egis_etu905_enroll_status_report (FpDevice *device,
++ EnrollPrint *enroll_print,
++ EnrollStatus status,
++ GError *error)
++{
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ switch (status)
++ {
++ case ENROLL_STATUS_DEVICE_FULL:
++ case ENROLL_STATUS_DUPLICATE:
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ break;
++
++ case ENROLL_STATUS_RETRY:
++ fpi_device_enroll_progress (device, enroll_print->stage, NULL, error);
++ break;
++
++ case ENROLL_STATUS_PARTIAL_OK:
++ enroll_print->stage++;
++ fp_info ("Partial capture successful. Please touch the sensor again (%d/%d)",
++ enroll_print->stage,
++ self->max_enroll_stages);
++ fpi_device_enroll_progress (device, enroll_print->stage, enroll_print->print, NULL);
++ break;
++
++ case ENROLL_STATUS_COMPLETE:
++ fp_info ("Enrollment was successful!");
++ fpi_device_enroll_complete (device, g_object_ref (enroll_print->print), NULL);
++ break;
++
++ default:
++ if (error)
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ else
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
++ "Unknown error"));
++ }
++}
++
++static void
++egis_etu905_read_capture_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ fp_dbg ("Read capture callback");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ EnrollPrint *enroll_print = fpi_ssm_get_data (self->task_ssm);
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ return;
++ }
++
++ /* Check that the read payload indicates "success" */
++ if (egis_etu905_validate_response_prefix (buffer_in,
++ length_in,
++ rsp_read_success_prefix,
++ rsp_read_success_prefix_len) &&
++ egis_etu905_validate_response_suffix (buffer_in,
++ length_in,
++ rsp_read_success_suffix,
++ rsp_read_success_suffix_len))
++ {
++ egis_etu905_enroll_status_report (device, enroll_print,
++ ENROLL_STATUS_PARTIAL_OK, NULL);
++ }
++ else
++ {
++ /* If not success then the sensor can either report "off center" or "sensor is dirty" */
++
++ /* "Off center" */
++ if (egis_etu905_validate_response_prefix (buffer_in,
++ length_in,
++ rsp_read_offcenter_prefix,
++ rsp_read_offcenter_prefix_len) &&
++ egis_etu905_validate_response_suffix (buffer_in,
++ length_in,
++ rsp_read_offcenter_suffix,
++ rsp_read_offcenter_suffix_len))
++ error = fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER);
++
++ /* "Sensor is dirty" */
++ else if (egis_etu905_validate_response_prefix (buffer_in,
++ length_in,
++ rsp_read_dirty_prefix,
++ rsp_read_dirty_prefix_len))
++ error = fpi_device_retry_new_msg (FP_DEVICE_RETRY_REMOVE_FINGER,
++ "Your device is having trouble recognizing you. "
++ "Make sure your sensor is clean.");
++
++ else
++ error = fpi_device_retry_new_msg (FP_DEVICE_RETRY_REMOVE_FINGER,
++ "Unknown failure trying to read your finger. "
++ "Please try again.");
++
++ egis_etu905_enroll_status_report (device, enroll_print, ENROLL_STATUS_RETRY, error);
++ }
++
++ if (enroll_print->stage == self->max_enroll_stages)
++ fpi_ssm_next_state (self->task_ssm);
++ else
++ fpi_ssm_jump_to_state (self->task_ssm, ENROLL_CAPTURE_SENSOR_RESET);
++}
++
++static void
++egis_etu905_enroll_duplicate_check_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ fp_dbg ("Task SSM enroll duplicate check callback");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ return;
++ }
++
++ /* Check that the read payload reports "not yet enrolled" */
++ if (egis_etu905_validate_response_suffix (buffer_in,
++ length_in,
++ rsp_check_not_yet_enrolled_suffix,
++ rsp_check_not_yet_enrolled_suffix_len))
++ fpi_ssm_jump_to_state (self->task_ssm, ENROLL_COMMIT_START);
++ else
++ egis_etu905_enroll_status_report (device, NULL, ENROLL_STATUS_DUPLICATE,
++ fpi_device_error_new (FP_DEVICE_ERROR_DATA_DUPLICATE));
++}
++
++static void
++egis_etu905_enroll_begin_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ fp_dbg ("Enroll begin callback");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ return;
++ }
++
++ FpiByteReader reader;
++
++ fpi_byte_reader_init (&reader, buffer_in, length_in);
++
++ fpi_byte_reader_set_pos (&reader, EGIS_ETU905_LIST_RESPONSE_PREFIX_SIZE);
++
++ const guint8 *data = NULL;
++
++ fpi_byte_reader_get_data (&reader, EGIS_ETU905_FINGERPRINT_DATA_SIZE,
++ &data);
++
++ if (data)
++ memcpy (self->sid, data, EGIS_ETU905_FINGERPRINT_DATA_SIZE);
++
++ fpi_ssm_next_state (self->task_ssm);
++}
++
++/*
++ * Builds the full "check" payload which includes identifiers for all
++ * fingerprints which currently should exist on the storage. This payload is
++ * used during both enrollment and verify actions.
++ */
++static guchar *
++egis_etu905_get_check_cmd (FpDevice *device,
++ gsize *length_out)
++{
++ fp_dbg ("Get check command");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ g_auto(FpiByteWriter) writer = {0};
++ g_autofree guchar *result = NULL;
++ gboolean written = TRUE;
++
++ /*
++ * The final command body should contain:
++ * 1) hard-coded 00 00
++ * 2) 2-byte size indiciator, 20*Number enrolled identifiers plus 9 in form of:
++ * (enrolled_ids->len + 1) * 0x20 + 0x09
++ * Since max prints can be higher than 7 then this goes up to 2 bytes
++ * (e9 + 9 = 109)
++ * 3) Hard-coded prefix (cmd_check_prefix)
++ * 4) 2-byte size indiciator, 20*Number of enrolled identifiers without plus 9
++ * ((enrolled_ids->len + 1) * 0x20)
++ * 5) Hard-coded 32 * 0x00 bytes
++ * 6) All of the currently registered prints in their 32-byte device identifiers
++ * (enrolled_list)
++ * 7) Hard-coded suffix (cmd_check_suffix)
++ */
++
++ g_assert (self->enrolled_ids);
++ const gsize body_length = sizeof (guchar) * self->enrolled_ids->len *
++ EGIS_ETU905_FINGERPRINT_DATA_SIZE;
++
++ /* prefix length can depend on the type */
++ const gsize check_prefix_length = (fpi_device_get_driver_data (device) &
++ EGIS_ETU905_DRIVER_CHECK_PREFIX_TYPE2) ?
++ cmd_check_prefix_type2_len :
++ cmd_check_prefix_type1_len;
++
++ /* total_length is the 6 various bytes plus all other prefixes/suffixes and
++ * the body payload */
++ const gsize total_length = (sizeof (guchar) * 6)
++ + check_prefix_length
++ + EGIS_ETU905_CMD_CHECK_SEPARATOR_LENGTH
++ + body_length
++ + cmd_check_suffix_len;
++
++ /* pre-fill entire payload with 00s */
++ fpi_byte_writer_init_with_size (&writer, total_length, TRUE);
++
++ /* start with 00 00 (just move starting offset up by 2) */
++ written &= fpi_byte_writer_set_pos (&writer, 2);
++
++ /* Size Counter bytes */
++ /* "easiest" way to handle 2-bytes size for counter is to hard-code logic for
++ * when we go to the 2nd byte
++ * note this will not work in case any model ever supports more than 14 prints
++ * (assumed max is 10) */
++ if (self->enrolled_ids->len > 6)
++ {
++ written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
++ written &= fpi_byte_writer_put_uint8 (&writer,
++ ((self->enrolled_ids->len - 7) * 0x20)
++ + 0x09);
++ }
++ else
++ {
++ /* first byte is 0x00, just skip it */
++ written &= fpi_byte_writer_change_pos (&writer, 1);
++ written &= fpi_byte_writer_put_uint8 (&writer,
++ ((self->enrolled_ids->len + 1) * 0x20) +
++ 0x09);
++ }
++
++ /* command prefix */
++ if (fpi_device_get_driver_data (device) & EGIS_ETU905_DRIVER_CHECK_PREFIX_TYPE2)
++ written &= fpi_byte_writer_put_data (&writer, cmd_check_prefix_type2,
++ cmd_check_prefix_type2_len);
++ else
++ written &= fpi_byte_writer_put_data (&writer, cmd_check_prefix_type1,
++ cmd_check_prefix_type1_len);
++
++ /* 2-bytes size logic for counter again */
++ if (self->enrolled_ids->len > 6)
++ {
++ written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
++ written &= fpi_byte_writer_put_uint8 (&writer,
++ (self->enrolled_ids->len - 7) * 0x20);
++ }
++ else
++ {
++ /* first byte is 0x00, just skip it */
++ written &= fpi_byte_writer_change_pos (&writer, 1);
++ written &= fpi_byte_writer_put_uint8 (&writer,
++ (self->enrolled_ids->len + 1) * 0x20);
++ }
++
++ /* add 00s "separator" to offset position */
++ written &= fpi_byte_writer_change_pos (&writer,
++ EGIS_ETU905_CMD_CHECK_SEPARATOR_LENGTH);
++
++ for (guint i = 0; i < self->enrolled_ids->len && written; i++)
++ {
++ written &= fpi_byte_writer_put_data (&writer,
++ g_ptr_array_index (self->enrolled_ids, i),
++ EGIS_ETU905_FINGERPRINT_DATA_SIZE);
++ }
++
++ /* command suffix */
++ written &= fpi_byte_writer_put_data (&writer, cmd_check_suffix,
++ cmd_check_suffix_len);
++ g_assert (written);
++
++ if (length_out)
++ *length_out = total_length;
++
++ return fpi_byte_writer_reset_and_get_data (&writer);
++}
++
++static void
++egis_etu905_enroll_run_state (FpiSsm *ssm,
++ FpDevice *device)
++{
++ g_auto(FpiByteWriter) writer = {0};
++ EgismocSidData sid_data = {0};
++ EnrollPrint *enroll_print = fpi_ssm_get_data (ssm);
++ g_autofree guchar *payload = NULL;
++ gsize payload_length = 0;
++ g_autofree gchar *device_print_id = NULL;
++ g_autofree gchar *user_id = NULL;
++
++ switch (fpi_ssm_get_cur_state (ssm))
++ {
++ case ENROLL_START:
++ egis_etu905_exec_cmd (device, cmd_enroll_starting, cmd_enroll_starting_len,
++ NULL, egis_etu905_enroll_begin_cb);
++ break;
++
++ case ENROLL_CAPTURE_SENSOR_RESET:
++ egis_etu905_exec_cmd (device, cmd_sensor_reset, cmd_sensor_reset_len,
++ NULL, egis_etu905_task_ssm_next_state_cb);
++ break;
++
++ case ENROLL_CAPTURE_SENSOR_START_CAPTURE:
++ egis_etu905_exec_cmd (device, cmd_sensor_start_capture, cmd_sensor_start_capture_len,
++ NULL,
++ egis_etu905_task_ssm_next_state_cb);
++ break;
++
++ case ENROLL_CAPTURE_WAIT_FINGER:
++ egis_etu905_wait_finger_on_sensor (ssm, device);
++ break;
++
++ case ENROLL_CAPTURE_READ_RESPONSE:
++ egis_etu905_exec_cmd (device, cmd_read_capture, cmd_read_capture_len,
++ NULL, egis_etu905_read_capture_cb);
++ break;
++
++ case ENROLL_DUPLICATE_CHECK:
++ egis_etu905_exec_cmd (device, cmd_duplicate_check, cmd_duplicate_check_len,
++ NULL, egis_etu905_enroll_duplicate_check_cb);
++ break;
++
++ case ENROLL_COMMIT_START:
++ egis_etu905_exec_cmd (device, cmd_commit_starting, cmd_commit_starting_len,
++ NULL, egis_etu905_commit_start_cb);
++ break;
++
++ case ENROLL_COMMIT:
++ user_id = fpi_print_generate_user_id (enroll_print->print);
++ fp_dbg ("New fingerprint ID: %s", user_id);
++
++ sid_data.reserve_para_1 = EGIS_ETU905_PARA_1_VALUE;
++ sid_data.reserve_para_2 = EGIS_ETU905_PARA_2_VALUE;
++ sid_data.reserve_para_3 = EGIS_ETU905_PARA_3_VALUE;
++ memcpy (sid_data.reserve_para_4, user_id, MIN (EGIS_ETU905_FINGERPRINT_DATA_SIZE, strlen (user_id)));
++ egis_etu905_set_print_data (enroll_print->print, (const gchar *) &sid_data.reserve_para_4, user_id);
++ fpi_byte_writer_init (&writer);
++ if (!fpi_byte_writer_put_data (&writer, cmd_new_print_prefix_type2,
++ cmd_new_print_prefix_type2_len))
++ {
++ fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
++ break;
++ }
++ if (!fpi_byte_writer_put_data (&writer, (guint8 *) &sid_data,
++ sizeof (EgismocSidData)))
++ {
++ fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
++ break;
++ }
++
++ payload_length = fpi_byte_writer_get_size (&writer);
++ egis_etu905_exec_cmd (device, fpi_byte_writer_reset_and_get_data (&writer),
++ payload_length,
++ g_free, egis_etu905_task_ssm_next_state_cb);
++ break;
++
++ case ENROLL_COMMIT_SENSOR_RESET:
++ egis_etu905_exec_cmd (device, cmd_sensor_reset, cmd_sensor_reset_len,
++ NULL, egis_etu905_task_ssm_next_state_cb);
++ break;
++
++ case ENROLL_COMPLETE:
++ egis_etu905_enroll_status_report (device, enroll_print, ENROLL_STATUS_COMPLETE, NULL);
++ fpi_ssm_next_state (ssm);
++ break;
++ }
++}
++
++static void
++egis_etu905_enroll (FpDevice *device)
++{
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ EnrollPrint *enroll_print = g_new0 (EnrollPrint, 1);
++
++ fp_dbg ("Enroll");
++
++ fpi_device_get_enroll_data (device, &enroll_print->print);
++ enroll_print->stage = 0;
++
++ g_assert (self->task_ssm == NULL);
++ self->task_ssm = fpi_ssm_new (device, egis_etu905_enroll_run_state, ENROLL_STATES);
++ fpi_ssm_set_data (self->task_ssm, g_steal_pointer (&enroll_print), g_free);
++ fpi_ssm_start (self->task_ssm, egis_etu905_task_ssm_done);
++}
++
++static void
++egis_etu905_identify_check_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ fp_dbg ("Identify check callback");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ gchar device_print_id[EGIS_ETU905_FINGERPRINT_DATA_SIZE];
++ FpPrint *print = NULL;
++ FpPrint *verify_print = NULL;
++ GPtrArray *prints;
++ gboolean found = FALSE;
++ guint index;
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ return;
++ }
++
++ /* Check that the read payload indicates "match" */
++ if (egis_etu905_validate_response_suffix (buffer_in,
++ length_in,
++ rsp_identify_match_suffix,
++ rsp_identify_match_suffix_len))
++ {
++ /*
++ On success, there is a 32 byte array of "something"(?) in chars 14-45
++ and then the 32 byte array ID of the matched print comes as chars 46-77
++ */
++ memcpy (device_print_id,
++ buffer_in + EGIS_ETU905_IDENTIFY_RESPONSE_PRINT_ID_OFFSET,
++ EGIS_ETU905_FINGERPRINT_DATA_SIZE);
++
++ /* Create a new print from this device_print_id and then see if it matches
++ * the one indicated
++ */
++ print = fp_print_new (device);
++ egis_etu905_set_print_data (print, device_print_id, NULL);
++
++ if (!print)
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_INVALID,
++ "Failed to build a print from "
++ "device response."));
++ return;
++ }
++
++ fp_info ("Identify successful for: %s", fp_print_get_description (print));
++
++ if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY)
++ {
++ fpi_device_get_identify_data (device, &prints);
++ found = g_ptr_array_find_with_equal_func (prints,
++ print,
++ (GEqualFunc) fp_print_equal,
++ &index);
++
++ if (found)
++ fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL);
++ else
++ fpi_device_identify_report (device, NULL, print, NULL);
++ }
++ else
++ {
++ fpi_device_get_verify_data (device, &verify_print);
++ fp_info ("Verifying against: %s", fp_print_get_description (verify_print));
++
++ if (fp_print_equal (verify_print, print))
++ fpi_device_verify_report (device, FPI_MATCH_SUCCESS, print, NULL);
++ else
++ fpi_device_verify_report (device, FPI_MATCH_FAIL, print, NULL);
++ }
++ }
++ /* If device was successfully read but it was a "not matched" */
++ else if (egis_etu905_validate_response_suffix (buffer_in,
++ length_in,
++ rsp_identify_notmatch_suffix,
++ rsp_identify_notmatch_suffix_len))
++ {
++ fp_info ("Print was not identified by the device");
++
++ if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
++ fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, NULL);
++ else
++ fpi_device_identify_report (device, NULL, NULL, NULL);
++ }
++ else
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "Unrecognized response from device."));
++ return;
++ }
++
++ fpi_ssm_next_state (self->task_ssm);
++}
++
++static void
++egis_etu905_identify_run_state (FpiSsm *ssm,
++ FpDevice *device)
++{
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ g_autofree guchar *payload = NULL;
++ gsize payload_length = 0;
++
++ switch (fpi_ssm_get_cur_state (ssm))
++ {
++ case IDENTIFY_GET_ENROLLED_IDS:
++ /* get enrolled_ids from device for use in check stages below */
++ egis_etu905_exec_cmd (device, cmd_list, cmd_list_len,
++ NULL, egis_etu905_list_fill_enrolled_ids_cb);
++ break;
++
++ case IDENTIFY_CHECK_ENROLLED_NUM:
++ if (self->enrolled_ids->len == 0)
++ {
++ fpi_ssm_mark_failed (g_steal_pointer (&self->task_ssm),
++ fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
++ return;
++ }
++ fpi_ssm_next_state (ssm);
++ break;
++
++ case IDENTIFY_SENSOR_RESET:
++ egis_etu905_exec_cmd (device, cmd_sensor_reset, cmd_sensor_reset_len,
++ NULL, egis_etu905_task_ssm_next_state_cb);
++ break;
++
++ case IDENTIFY_SENSOR_IDENTIFY:
++ egis_etu905_exec_cmd (device, cmd_sensor_identify, cmd_sensor_identify_len,
++ NULL, egis_etu905_task_ssm_next_state_cb);
++ break;
++
++ case IDENTIFY_WAIT_FINGER:
++ egis_etu905_wait_finger_on_sensor (ssm, device);
++ break;
++
++ case IDENTIFY_SENSOR_CHECK:
++ egis_etu905_exec_cmd (device, cmd_sensor_check, cmd_sensor_check_len,
++ NULL, egis_etu905_task_ssm_next_state_cb);
++ break;
++
++ case IDENTIFY_CHECK:
++ payload = egis_etu905_get_check_cmd (device, &payload_length);
++ egis_etu905_exec_cmd (device, g_steal_pointer (&payload), payload_length,
++ g_free, egis_etu905_identify_check_cb);
++ break;
++
++ case IDENTIFY_COMPLETE_SENSOR_RESET:
++ egis_etu905_exec_cmd (device, cmd_sensor_reset, cmd_sensor_reset_len,
++ NULL, egis_etu905_task_ssm_next_state_cb);
++ break;
++
++ /*
++ * In Windows, the driver seems at this point to then immediately take
++ * another read from the sensor; this is suspected to be an on-chip
++ * "verify". However, because the user's finger is still on the sensor from
++ * the identify, then it seems to always return positive. We will consider
++ * this extra step unnecessary and just skip it in this driver. This driver
++ * will instead handle matching of the FpPrint from the gallery in the
++ * "verify" case of the callback egis_etu905_identify_check_cb.
++ */
++ case IDENTIFY_COMPLETE:
++ if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY)
++ fpi_device_identify_complete (device, NULL);
++ else
++ fpi_device_verify_complete (device, NULL);
++
++ fpi_ssm_mark_completed (ssm);
++ break;
++ }
++}
++
++static void
++egis_etu905_identify_verify (FpDevice *device)
++{
++ fp_dbg ("Identify or Verify");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ g_assert (self->task_ssm == NULL);
++ self->task_ssm = fpi_ssm_new (device, egis_etu905_identify_run_state, IDENTIFY_STATES);
++ fpi_ssm_start (self->task_ssm, egis_etu905_task_ssm_done);
++}
++
++static void
++egis_etu905_fw_version_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ fp_dbg ("Firmware version callback");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ g_autofree gchar *fw_version = NULL;
++ gsize prefix_length;
++ guchar *fw_version_start;
++ gsize fw_version_length;
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ return;
++ }
++
++ /* Check that the read payload indicates "success" */
++ if (!egis_etu905_validate_response_suffix (buffer_in,
++ length_in,
++ rsp_fw_version_suffix,
++ rsp_fw_version_suffix_len))
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "Device firmware response "
++ "was not valid."));
++ return;
++ }
++
++ /*
++ * FW Version is 12 bytes: a carriage return (0x0d) plus the version string
++ * itself. Always skip [the read prefix] + [2 * check bytes] + [3 * 0x00] that
++ * come with every payload Then we will also skip the carriage return and take
++ * all but the last 2 bytes as the FW Version
++ */
++ prefix_length = egis_etu905_read_prefix_len + 2 + 3 + 1;
++ fw_version_start = buffer_in + prefix_length;
++ fw_version_length = length_in - prefix_length - rsp_fw_version_suffix_len;
++ fw_version = g_strndup ((gchar *) fw_version_start, fw_version_length);
++
++ fp_info ("Device firmware version is %s", fw_version);
++
++ fpi_ssm_next_state (self->task_ssm);
++}
++
++static void
++egis_etu905_cmd_init_cb (FpDevice *device,
++ guchar *buffer_in,
++ gsize length_in,
++ GError *error)
++{
++ fp_dbg ("cmd init callback");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ if (error)
++ {
++ fpi_ssm_mark_failed (self->task_ssm, error);
++ return;
++ }
++
++ /* Check that the read payload indicates "success" */
++ if (!egis_etu905_validate_response_suffix (buffer_in,
++ length_in,
++ rsp_fw_version_suffix,
++ rsp_fw_version_suffix_len))
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "cmd init response "
++ "was not valid."));
++ return;
++ }
++ fpi_ssm_next_state (self->task_ssm);
++}
++
++static void
++egis_etu905_dev_init_done (FpiSsm *ssm,
++ FpDevice *device,
++ GError *error)
++{
++ if (error)
++ {
++ g_usb_device_release_interface (
++ fpi_device_get_usb_device (device), 0, 0, NULL);
++ egis_etu905_task_ssm_done (ssm, device, error);
++ return;
++ }
++
++ egis_etu905_task_ssm_done (ssm, device, NULL);
++ fpi_device_open_complete (device, NULL);
++}
++
++static void
++egis_etu905_dev_init_handler (FpiSsm *ssm,
++ FpDevice *device)
++{
++ g_autoptr(FpiUsbTransfer) transfer = NULL;
++
++ switch (fpi_ssm_get_cur_state (ssm))
++ {
++ case DEV_GET_FW_VERSION:
++ egis_etu905_exec_cmd (device, cmd_fw_version, cmd_fw_version_len,
++ NULL, egis_etu905_fw_version_cb);
++ return;
++
++ case DEV_INIT_CONTROL:
++ egis_etu905_exec_cmd (device, cmd_init, cmd_init_len,
++ NULL, egis_etu905_cmd_init_cb);
++ return;
++
++ default:
++ g_assert_not_reached ();
++ }
++
++ transfer = fpi_usb_transfer_new (device);
++ transfer->ssm = ssm;
++ transfer->short_is_error = TRUE;
++ fpi_usb_transfer_submit (g_steal_pointer (&transfer),
++ EGIS_ETU905_USB_CONTROL_TIMEOUT,
++ fpi_device_get_cancellable (device),
++ fpi_ssm_usb_transfer_cb,
++ NULL);
++}
++
++static void
++egis_etu905_probe (FpDevice *device)
++{
++ GUsbDevice *usb_dev;
++ GError *error = NULL;
++ g_autofree gchar *serial = NULL;
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ fp_dbg ("%s enter --> ", G_STRFUNC);
++
++ /* Claim usb interface */
++ usb_dev = fpi_device_get_usb_device (device);
++ if (!g_usb_device_open (usb_dev, &error))
++ {
++ fp_dbg ("%s g_usb_device_open failed %s", G_STRFUNC, error->message);
++ fpi_device_probe_complete (device, NULL, NULL, error);
++ return;
++ }
++
++ if (!g_usb_device_reset (usb_dev, &error))
++ {
++ fp_dbg ("%s g_usb_device_reset failed %s", G_STRFUNC, error->message);
++ g_usb_device_close (usb_dev, NULL);
++ fpi_device_probe_complete (device, NULL, NULL, error);
++ return;
++ }
++
++ if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
++ {
++ fp_dbg ("%s g_usb_device_claim_interface failed %s", G_STRFUNC, error->message);
++ g_usb_device_close (usb_dev, NULL);
++ fpi_device_probe_complete (device, NULL, NULL, error);
++ return;
++ }
++
++ if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
++ serial = g_strdup ("emulated-device");
++ else
++ serial = g_usb_device_get_string_descriptor (usb_dev,
++ g_usb_device_get_serial_number_index (usb_dev),
++ &error);
++
++ if (error)
++ {
++ fp_dbg ("%s g_usb_device_get_string_descriptor failed %s", G_STRFUNC, error->message);
++ g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (device)),
++ 0, 0, NULL);
++ g_usb_device_close (usb_dev, NULL);
++ fpi_device_probe_complete (device, NULL, NULL, error);
++ return;
++ }
++
++ if (fpi_device_get_driver_data (device) & EGIS_ETU905_DRIVER_MAX_ENROLL_STAGES_20)
++ self->max_enroll_stages = 20;
++ else
++ self->max_enroll_stages = EGIS_ETU905_MAX_ENROLL_STAGES_DEFAULT;
++
++ fpi_device_set_nr_enroll_stages (device, self->max_enroll_stages);
++
++ g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (device)), 0, 0, NULL);
++ g_usb_device_close (usb_dev, NULL);
++
++ fpi_device_probe_complete (device, serial, NULL, error);
++}
++
++static void
++egis_etu905_open (FpDevice *device)
++{
++ fp_dbg ("Opening device");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ g_autoptr(GError) error = NULL;
++
++ if (!g_usb_device_reset (fpi_device_get_usb_device (device), &error))
++ {
++ fpi_device_open_complete (device, g_steal_pointer (&error));
++ return;
++ }
++
++ if (!g_usb_device_claim_interface (fpi_device_get_usb_device (device),
++ 0, 0, &error))
++ {
++ fpi_device_open_complete (device, g_steal_pointer (&error));
++ return;
++ }
++
++ g_assert (self->task_ssm == NULL);
++ self->task_ssm = fpi_ssm_new (device, egis_etu905_dev_init_handler, DEV_INIT_STATES);
++ fpi_ssm_start (self->task_ssm, egis_etu905_dev_init_done);
++}
++
++static void
++egis_etu905_cancel (FpDevice *device)
++{
++ fp_dbg ("Cancel");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++
++ g_cancellable_cancel (self->interrupt_cancellable);
++ g_clear_object (&self->interrupt_cancellable);
++ self->interrupt_cancellable = g_cancellable_new ();
++}
++
++static void
++egis_etu905_suspend (FpDevice *device)
++{
++ fp_dbg ("Suspend");
++
++ egis_etu905_cancel (device);
++ g_cancellable_cancel (fpi_device_get_cancellable (device));
++ fpi_device_suspend_complete (device, NULL);
++}
++
++static void
++egis_etu905_close (FpDevice *device)
++{
++ g_autoptr(GError) error = NULL;
++ fp_dbg ("Closing device");
++ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ GError *error = NULL;
++
++ egis_etu905_cancel (device);
++ g_clear_object (&self->interrupt_cancellable);
++
++ g_usb_device_release_interface (fpi_device_get_usb_device (device),
++ 0, 0, &error);
++ fpi_device_close_complete (device, g_steal_pointer (&error));
++}
++
++static void
++fpi_device_egis_etu905_init (FpiDeviceEgisEtu905 *self)
++{
++ G_DEBUG_HERE ();
++}
++
++static void
++fpi_device_egis_etu905_class_init (FpiDeviceEgisEtu905Class *klass)
++{
++ FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
++
++ dev_class->id = FP_COMPONENT;
++ dev_class->full_name = EGIS_ETU905_DRIVER_FULLNAME;
++
++ dev_class->type = FP_DEVICE_TYPE_USB;
++ dev_class->scan_type = FP_SCAN_TYPE_PRESS;
++ dev_class->id_table = egis_etu905_id_table;
++ dev_class->nr_enroll_stages = EGIS_ETU905_MAX_ENROLL_STAGES_DEFAULT;
++ dev_class->temp_hot_seconds = -1;
++
++ dev_class->probe = egis_etu905_probe;
++ dev_class->open = egis_etu905_open;
++ dev_class->cancel = egis_etu905_cancel;
++ dev_class->suspend = egis_etu905_suspend;
++ dev_class->close = egis_etu905_close;
++ dev_class->identify = egis_etu905_identify_verify;
++ dev_class->verify = egis_etu905_identify_verify;
++ dev_class->enroll = egis_etu905_enroll;
++ dev_class->delete = egis_etu905_delete;
++ dev_class->clear_storage = egis_etu905_clear_storage;
++ dev_class->list = egis_etu905_list;
++
++ fpi_device_class_auto_initialize_features (dev_class);
++ dev_class->features |= FP_DEVICE_FEATURE_DUPLICATES_CHECK;
++}
+diff --git a/libfprint/drivers/egismoc/egis_etu905.h b/libfprint/drivers/egismoc/egis_etu905.h
+new file mode 100644
+index 00000000..e931deca
+--- /dev/null
++++ b/libfprint/drivers/egismoc/egis_etu905.h
+@@ -0,0 +1,214 @@
++/*
++ * Driver for Egis Technology (LighTuning) Match-On-Chip sensors
++ *
++ * This library is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU Lesser General Public
++ * License as published by the Free Software Foundation; either
++ * version 2.1 of the License, or (at your option) any later version.
++ *
++ * This library is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public
++ * License along with this library; if not, write to the Free Software
++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++ */
++
++#pragma once
++
++#include "fpi-device.h"
++#include "fpi-ssm.h"
++
++G_DECLARE_FINAL_TYPE (FpiDeviceEgisEtu905, fpi_device_egis_etu905, FPI, DEVICE_EGIS_ETU905, FpDevice)
++
++#define EGIS_ETU905_DRIVER_FULLNAME "Egis Technology (LighTuning) Match-on-Chip"
++
++#define EGIS_ETU905_DRIVER_CHECK_PREFIX_TYPE1 (1 << 0)
++#define EGIS_ETU905_DRIVER_CHECK_PREFIX_TYPE2 (1 << 1)
++#define EGIS_ETU905_DRIVER_MAX_ENROLL_STAGES_20 (1 << 2)
++
++#define EGIS_ETU905_EP_CMD_OUT (0x02 | FPI_USB_ENDPOINT_OUT)
++#define EGIS_ETU905_EP_CMD_IN (0x81 | FPI_USB_ENDPOINT_IN)
++#define EGIS_ETU905_EP_CMD_INTERRUPT_IN 0x83
++
++#define EGIS_ETU905_USB_CONTROL_TIMEOUT 5000
++#define EGIS_ETU905_USB_SEND_TIMEOUT 5000
++#define EGIS_ETU905_USB_RECV_TIMEOUT 5000
++#define EGIS_ETU905_USB_INTERRUPT_TIMEOUT 0 /* No timeout for waiting for finger down */
++
++#define EGIS_ETU905_USB_IN_RECV_LENGTH 4096
++#define EGIS_ETU905_USB_INTERRUPT_IN_RECV_LENGTH 64
++
++#define EGIS_ETU905_MAX_ENROLL_STAGES_DEFAULT 12
++#define EGIS_ETU905_MAX_ENROLL_NUM 12
++#define EGIS_ETU905_FINGERPRINT_DATA_SIZE 32
++#define EGIS_ETU905_LIST_RESPONSE_PREFIX_SIZE 14
++#define EGIS_ETU905_LIST_RESPONSE_SUFFIX_SIZE 2
++
++#define EGIS_ETU905_PARA_4_SIZE 68
++
++#define EGIS_ETU905_PARA_1_VALUE 0
++#define EGIS_ETU905_PARA_2_VALUE 0
++#define EGIS_ETU905_PARA_3_VALUE 32
++
++#pragma pack(push, 1)
++typedef struct
++{
++ guchar reserve_para_1;
++ gushort reserve_para_2;
++ gushort reserve_para_3;
++ guchar reserve_para_4[EGIS_ETU905_PARA_4_SIZE];
++} EgismocSidData;
++#pragma pack(pop)
++
++/* standard prefixes for all read/writes */
++
++static guchar egis_etu905_write_prefix[] = {'E', 'G', 'I', 'S', 0x00, 0x00, 0x00, 0x01};
++static gsize egis_etu905_write_prefix_len = sizeof (egis_etu905_write_prefix) / sizeof (egis_etu905_write_prefix[0]);
++
++static guchar egis_etu905_read_prefix[] = {'S', 'I', 'G', 'E', 0x00, 0x00, 0x00, 0x01};
++static gsize egis_etu905_read_prefix_len = sizeof (egis_etu905_read_prefix) / sizeof (egis_etu905_read_prefix[0]);
++
++
++/* hard-coded command payloads */
++
++static guchar cmd_fw_version[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x0c};
++static gsize cmd_fw_version_len = sizeof (cmd_fw_version) / sizeof (cmd_fw_version[0]);
++static guchar rsp_fw_version_suffix[] = {0x90, 0x00};
++static gsize rsp_fw_version_suffix_len = sizeof (rsp_fw_version_suffix) / sizeof (rsp_fw_version_suffix[0]);
++
++static guchar cmd_init[] = {0x00, 0x00, 0x00, 0x29, 0x50, 0x81, 0x80, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
++ 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x12, 0x00, 0x45, 0x67, 0x69, 0x73,
++ 0x46, 0x50, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x51, 0xc6, 0xbd, 0x71};
++static gsize cmd_init_len = sizeof (cmd_init) / sizeof (cmd_init[0]);
++
++static guchar cmd_list[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x19, 0x04, 0x00, 0x00, 0x01, 0x40};
++static gsize cmd_list_len = sizeof (cmd_list) / sizeof (cmd_list[0]);
++
++static guchar cmd_sensor_reset[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x1a, 0x00, 0x00};
++static gsize cmd_sensor_reset_len = sizeof (cmd_sensor_reset) / sizeof (cmd_sensor_reset[0]);
++
++static guchar cmd_sensor_check[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x17, 0x02, 0x00};
++static gsize cmd_sensor_check_len = sizeof (cmd_sensor_check) / sizeof (cmd_sensor_check[0]);
++
++static guchar cmd_sensor_identify[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x17, 0x01, 0x01};
++static gsize cmd_sensor_identify_len = sizeof (cmd_sensor_identify) / sizeof (cmd_sensor_identify[0]);
++
++static guchar rsp_identify_match_suffix[] = {0x90, 0x00};
++static gsize rsp_identify_match_suffix_len = sizeof (rsp_identify_match_suffix) / sizeof (rsp_identify_match_suffix[0]);
++
++static guchar rsp_identify_notmatch_suffix[] = {0x90, 0x04};
++static gsize rsp_identify_notmatch_suffix_len = sizeof (rsp_identify_notmatch_suffix) / sizeof (rsp_identify_notmatch_suffix[0]);
++
++static guchar cmd_enroll_starting[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x16, 0x01, 0x00, 0x00, 0x00, 0x20};
++static gsize cmd_enroll_starting_len = sizeof (cmd_enroll_starting) / sizeof (cmd_enroll_starting[0]);
++
++static guchar cmd_sensor_start_capture[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x16, 0x02, 0x01};
++static gsize cmd_sensor_start_capture_len = sizeof (cmd_sensor_start_capture) / sizeof (cmd_sensor_start_capture[0]);
++
++static guchar cmd_read_capture[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x16, 0x02, 0x02, 0x00, 0x00, 0x02};
++static gsize cmd_read_capture_len = sizeof (cmd_read_capture) / sizeof (cmd_read_capture[0]);
++
++static guchar cmd_duplicate_check[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x16, 0x05, 0x00};
++static gsize cmd_duplicate_check_len = sizeof (cmd_duplicate_check) / sizeof (cmd_duplicate_check[0]);
++
++static guchar rsp_read_success_prefix[] = {0x00, 0x00, 0x00, 0x04};
++static gsize rsp_read_success_prefix_len = sizeof (rsp_read_success_prefix) / sizeof (rsp_read_success_prefix[0]);
++static guchar rsp_read_success_suffix[] = {0x90, 0x00};
++static gsize rsp_read_success_suffix_len = sizeof (rsp_read_success_suffix) / sizeof (rsp_read_success_suffix[0]);
++static guchar rsp_read_offcenter_prefix[] = {0x00, 0x00, 0x00, 0x04};
++static gsize rsp_read_offcenter_prefix_len = sizeof (rsp_read_offcenter_prefix) / sizeof (rsp_read_offcenter_prefix[0]);
++static guchar rsp_read_offcenter_suffix[] = {0x64, 0x91};
++static gsize rsp_read_offcenter_suffix_len = sizeof (rsp_read_offcenter_suffix) / sizeof (rsp_read_offcenter_suffix[0]);
++static guchar rsp_read_dirty_prefix[] = {0x00, 0x00, 0x00, 0x02, 0x64};
++static gsize rsp_read_dirty_prefix_len = sizeof (rsp_read_dirty_prefix) / sizeof (rsp_read_dirty_prefix[0]);
++
++static guchar cmd_commit_starting[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x16, 0x05, 0x00, 0x00, 0x00, 0x20};
++static gsize cmd_commit_starting_len = sizeof (cmd_commit_starting) / sizeof (cmd_commit_starting[0]);
++
++/* prefixes/suffixes and other things for dynamically created command payloads */
++
++#define EGIS_ETU905_CHECK_BYTES_LENGTH 2
++#define EGIS_ETU905_IDENTIFY_RESPONSE_PRINT_ID_OFFSET 46
++#define EGIS_ETU905_CMD_CHECK_SEPARATOR_LENGTH 32
++
++static guchar cmd_new_print_prefix_type2[] = {0x00, 0x00, 0x00, 0x50, 0x50, 0x16, 0x03, 0x00, 0x00, 0x00, 0x49};
++static gsize cmd_new_print_prefix_type2_len = sizeof (cmd_new_print_prefix_type2) / sizeof (cmd_new_print_prefix_type2[0]);
++
++static guchar cmd_delete_prefix[] = {0x50, 0x18, 0x04, 0x00, 0x00};
++static gsize cmd_delete_prefix_len = sizeof (cmd_delete_prefix) / sizeof (cmd_delete_prefix[0]);
++static guchar rsp_delete_success_prefix[] = {0x00, 0x00, 0x00, 0x02, 0x90, 0x00};
++static gsize rsp_delete_success_prefix_len = sizeof (rsp_delete_success_prefix) / sizeof (rsp_delete_success_prefix[0]);
++
++static guchar cmd_check_prefix_type1[] = {0x50, 0x17, 0x03, 0x00, 0x00};
++static gsize cmd_check_prefix_type1_len = sizeof (cmd_check_prefix_type1) / sizeof (cmd_check_prefix_type1[0]);
++static guchar cmd_check_prefix_type2[] = {0x50, 0x17, 0x03, 0x80, 0x00};
++static gsize cmd_check_prefix_type2_len = sizeof (cmd_check_prefix_type2) / sizeof (cmd_check_prefix_type2[0]);
++static guchar cmd_check_suffix[] = {0x00, 0x40};
++static gsize cmd_check_suffix_len = sizeof (cmd_check_suffix) / sizeof (cmd_check_suffix[0]);
++static guchar rsp_check_not_yet_enrolled_suffix[] = {0x90, 0x04};
++static gsize rsp_check_not_yet_enrolled_suffix_len = sizeof (rsp_check_not_yet_enrolled_suffix) / sizeof (rsp_check_not_yet_enrolled_suffix[0]);
++
++
++/* SSM task states and various status enums */
++
++typedef enum {
++ CMD_SEND,
++ CMD_GET,
++ CMD_STATES,
++} CommandStates;
++
++typedef enum {
++ DEV_GET_FW_VERSION,
++ DEV_INIT_CONTROL,
++ DEV_INIT_STATES,
++} DeviceInitStates;
++
++typedef enum {
++ IDENTIFY_GET_ENROLLED_IDS,
++ IDENTIFY_CHECK_ENROLLED_NUM,
++ IDENTIFY_SENSOR_RESET,
++ IDENTIFY_SENSOR_IDENTIFY,
++ IDENTIFY_WAIT_FINGER,
++ IDENTIFY_SENSOR_CHECK,
++ IDENTIFY_CHECK,
++ IDENTIFY_COMPLETE_SENSOR_RESET,
++ IDENTIFY_COMPLETE,
++ IDENTIFY_STATES,
++} IdentifyStates;
++
++typedef enum {
++ ENROLL_START,
++ ENROLL_CAPTURE_SENSOR_RESET,
++ ENROLL_CAPTURE_SENSOR_START_CAPTURE,
++ ENROLL_CAPTURE_WAIT_FINGER,
++ ENROLL_CAPTURE_READ_RESPONSE,
++ ENROLL_DUPLICATE_CHECK,
++ ENROLL_COMMIT_START,
++ ENROLL_COMMIT,
++ ENROLL_COMMIT_SENSOR_RESET,
++ ENROLL_COMPLETE,
++ ENROLL_STATES,
++} EnrollStates;
++
++typedef enum {
++ ENROLL_STATUS_DEVICE_FULL,
++ ENROLL_STATUS_DUPLICATE,
++ ENROLL_STATUS_PARTIAL_OK,
++ ENROLL_STATUS_RETRY,
++ ENROLL_STATUS_COMPLETE,
++} EnrollStatus;
++
++typedef enum {
++ LIST_GET_ENROLLED_IDS,
++ LIST_RETURN_ENROLLED_PRINTS,
++ LIST_STATES,
++} ListStates;
++
++typedef enum {
++ DELETE_GET_ENROLLED_IDS,
++ DELETE_DELETE,
++ DELETE_STATES,
++} DeleteStates;
+diff --git a/libfprint/meson.build b/libfprint/meson.build
+index ae0f6e24..081b18de 100644
+--- a/libfprint/meson.build
++++ b/libfprint/meson.build
+@@ -127,6 +127,8 @@ driver_sources = {
+ [ 'drivers/egis0570.c' ],
+ 'egismoc' :
+ [ 'drivers/egismoc/egismoc.c' ],
++ 'egis_etu905' :
++ [ 'drivers/egismoc/egis_etu905.c' ],
+ 'vfs0050' :
+ [ 'drivers/vfs0050.c' ],
+ 'elan' :
+diff --git a/meson.build b/meson.build
+index 14fb11f2..02b43e4f 100644
+--- a/meson.build
++++ b/meson.build
+@@ -131,6 +131,7 @@ default_drivers = [
+ 'etes603',
+ 'egis0570',
+ 'egismoc',
++ 'egis_etu905',
+ 'vcom5s',
+ 'synaptics',
+ 'elan',
+@@ -165,6 +166,7 @@ endian_independent_drivers = virtual_drivers + [
+ 'aes4000',
+ 'egis0570',
+ 'egismoc',
++ 'egis_etu905',
+ 'elanmoc',
+ 'etes603',
+ 'focaltech_moc',
+diff --git a/tests/egis_etu905/custom.pcapng b/tests/egis_etu905/custom.pcapng
+new file mode 100644
+index 0000000000000000000000000000000000000000..b21c4622a1b5b44f25065882cff3d3e2687d76d1
+GIT binary patch
+literal 33644
+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
+
+literal 0
+HcmV?d00001
+
+diff --git a/tests/egis_etu905/custom.py b/tests/egis_etu905/custom.py
+new file mode 100644
+index 00000000..a842f26e
+--- /dev/null
++++ b/tests/egis_etu905/custom.py
+@@ -0,0 +1,109 @@
++#!/usr/bin/python3
++import traceback
++
++import sys
++import gi
++
++gi.require_version('FPrint', '2.0')
++from gi.repository import FPrint, GLib
++
++# Exit with error on any exception, included those happening in async callbacks
++sys.excepthook = lambda *args: (traceback.print_exception(*args), sys.exit(1))
++
++ctx = GLib.main_context_default()
++
++c = FPrint.Context()
++c.enumerate()
++devices = c.get_devices()
++
++d = devices[0]
++del devices
++
++assert d.get_driver() == "egis_etu905"
++assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
++assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
++assert d.has_feature(FPrint.DeviceFeature.VERIFY)
++assert d.has_feature(FPrint.DeviceFeature.STORAGE)
++assert d.has_feature(FPrint.DeviceFeature.STORAGE_LIST)
++assert d.has_feature(FPrint.DeviceFeature.STORAGE_DELETE)
++assert d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
++
++d.open_sync()
++
++def enroll_progress(*args):
++ assert d.get_finger_status() == FPrint.FingerStatusFlags.PRESENT
++ print("enroll progress stage: " + str(args[1]))
++
++def identify_done(dev, res):
++ global identified
++ identified = True
++ identify_match, identify_print = dev.identify_finish(res)
++ print("MATCH FOUND!" if identify_match else "NO MATCH FOUND")
++ assert identify_match.equal(identify_print)
++
++# List
++print("--- LISTING ---")
++stored = d.list_prints_sync()
++prints1 = len(stored)
++print(f"--- LIST DONE: Found {prints1} prints before enroll---")
++
++# Enroll
++print("--- ENROLLING ---")
++template = FPrint.Print.new(d)
++
++assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
++p = d.enroll_sync(template, None, enroll_progress, None)
++assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
++print("--- ENROLL DONE ---")
++del template
++
++# List
++print("--- LISTING ---")
++stored = d.list_prints_sync()
++prints2 = len(stored)
++print(f"--- LIST DONE: Found {prints2} prints after enroll---")
++assert (prints2 - prints1) == 1
++
++# Verify
++print("--- VERIFYING ---")
++assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
++verify_res, verify_print = d.verify_sync(p)
++assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
++print(f"--- VERIFY DONE: Result {verify_res} ---")
++
++# Identify
++print("--- ASYNC IDENTIFYING ---")
++identified = False
++deserialized_prints = []
++for p in stored:
++ deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
++ assert deserialized_prints[-1].equal(p)
++
++d.identify(deserialized_prints, callback=identify_done)
++del deserialized_prints
++
++while not identified:
++ ctx.iteration(True)
++print("--- IDENTIFY DONE ---")
++
++# Delete
++print("--- DELETING ---")
++p_to_delete = next((sp for sp in stored if sp.equal(p)), None)
++if p_to_delete:
++ d.delete_print_sync(p_to_delete)
++ print("--- DELETE DONE ---")
++del p_to_delete
++del p
++
++# List
++print("--- LISTING ---")
++stored = d.list_prints_sync()
++prints3 = len(stored)
++print(f"--- LIST DONE: Found {prints3} prints after deleting---")
++assert (prints2 - prints3) == 1
++del stored
++
++d.close_sync()
++
++del d
++del c
+diff --git a/tests/egis_etu905/device b/tests/egis_etu905/device
+new file mode 100644
+index 00000000..4b750a79
+--- /dev/null
++++ b/tests/egis_etu905/device
+@@ -0,0 +1,348 @@
++P: /devices/pci0000:00/0000:00:08.1/0000:05:00.4/usb3/3-3
++N: bus/usb/003/002=12010002FF0000407A1CAE0542530102030109022700010100A0320904000003FFFFFF00070581024000000705020240000007058303400001
++E: BUSNUM=003
++E: DEVNAME=/dev/bus/usb/003/002
++E: DEVNUM=002
++E: DEVTYPE=usb_device
++E: DRIVER=usb
++E: ID_BUS=usb
++E: ID_MODEL=ETU905Axx-E
++E: ID_MODEL_ENC=ETU905Axx-E
++E: ID_MODEL_ID=05ae
++E: ID_PATH=pci-0000:05:00.4-usb-0:3
++E: ID_PATH_TAG=pci-0000_05_00_4-usb-0_3
++E: ID_PATH_WITH_USB_REVISION=pci-0000:05:00.4-usbv2-0:3
++E: ID_REVISION=5342
++E: ID_SERIAL=EGIS_ETU905Axx-E_0A8606PNA357
++E: ID_SERIAL_SHORT=0A8606PNA357
++E: ID_USB_INTERFACES=:ffffff:
++E: ID_USB_MODEL=ETU905Axx-E
++E: ID_USB_MODEL_ENC=ETU905Axx-E
++E: ID_USB_MODEL_ID=05ae
++E: ID_USB_REVISION=5342
++E: ID_USB_SERIAL=EGIS_ETU905Axx-E_0A8606PNA357
++E: ID_USB_SERIAL_SHORT=0A8606PNA357
++E: ID_USB_VENDOR=EGIS
++E: ID_USB_VENDOR_ENC=EGIS
++E: ID_USB_VENDOR_ID=1c7a
++E: ID_VENDOR=EGIS
++E: ID_VENDOR_ENC=EGIS
++E: ID_VENDOR_FROM_DATABASE=LighTuning Technology Inc.
++E: ID_VENDOR_ID=1c7a
++E: MAJOR=189
++E: MINOR=257
++E: PRODUCT=1c7a/5ae/5342
++E: SUBSYSTEM=usb
++E: TYPE=255/0/0
++A: authorized=1\n
++A: avoid_reset_quirk=0\n
++A: bConfigurationValue=1\n
++A: bDeviceClass=ff\n
++A: bDeviceProtocol=00\n
++A: bDeviceSubClass=00\n
++A: bMaxPacketSize0=64\n
++A: bMaxPower=100mA\n
++A: bNumConfigurations=1\n
++A: bNumInterfaces= 1\n
++A: bcdDevice=5342\n
++A: bmAttributes=a0\n
++A: busnum=3\n
++A: configuration=
++H: descriptors=12010002FF0000407A1CAE0542530102030109022700010100A0320904000003FFFFFF00070581024000000705020240000007058303400001
++A: dev=189:257\n
++A: devnum=2\n
++A: devpath=3\n
++L: driver=../../../../../../bus/usb/drivers/usb
++L: firmware_node=../../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:0c/device:1b/device:1c/device:1f
++A: idProduct=05ae\n
++A: idVendor=1c7a\n
++A: ltm_capable=no\n
++A: manufacturer=EGIS\n
++A: maxchild=0\n
++A: physical_location/dock=no\n
++A: physical_location/horizontal_position=left\n
++A: physical_location/lid=no\n
++A: physical_location/panel=top\n
++A: physical_location/vertical_position=upper\n
++L: port=../3-0:1.0/usb3-port3
++A: power/active_duration=93136758\n
++A: power/async=enabled\n
++A: power/autosuspend=2\n
++A: power/autosuspend_delay_ms=2000\n
++A: power/connected_duration=93139621\n
++A: power/control=on\n
++A: power/level=on\n
++A: power/persist=1\n
++A: power/runtime_active_kids=0\n
++A: power/runtime_active_time=93138826\n
++A: power/runtime_enabled=forbidden\n
++A: power/runtime_status=active\n
++A: power/runtime_suspended_time=0\n
++A: power/runtime_usage=1\n
++A: power/wakeup=disabled\n
++A: power/wakeup_abort_count=\n
++A: power/wakeup_active=\n
++A: power/wakeup_active_count=\n
++A: power/wakeup_count=\n
++A: power/wakeup_expire_count=\n
++A: power/wakeup_last_time_ms=\n
++A: power/wakeup_max_time_ms=\n
++A: power/wakeup_total_time_ms=\n
++A: product=ETU905Axx-E\n
++A: quirks=0x0\n
++A: removable=fixed\n
++A: rx_lanes=1\n
++A: serial=0A8606PNA357\n
++A: speed=12\n
++A: tx_lanes=1\n
++A: urbnum=5855\n
++A: version= 2.00\n
++
++P: /devices/pci0000:00/0000:00:08.1/0000:05:00.4/usb3
++N: bus/usb/003/001=12010002090001406B1D020014060302010109021900010100E0000904000001090000000705810304000C
++E: BUSNUM=003
++E: CURRENT_TAGS=:seat:
++E: DEVNAME=/dev/bus/usb/003/001
++E: DEVNUM=001
++E: DEVTYPE=usb_device
++E: DRIVER=usb
++E: ID_AUTOSUSPEND=1
++E: ID_BUS=usb
++E: ID_FOR_SEAT=usb-pci-0000_05_00_4
++E: ID_MODEL=xHCI_Host_Controller
++E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
++E: ID_MODEL_FROM_DATABASE=2.0 root hub
++E: ID_MODEL_ID=0002
++E: ID_PATH=pci-0000:05:00.4
++E: ID_PATH_TAG=pci-0000_05_00_4
++E: ID_REVISION=0614
++E: ID_SERIAL=Linux_6.14.0-37-generic_xhci-hcd_xHCI_Host_Controller_0000:05:00.4
++E: ID_SERIAL_SHORT=0000:05:00.4
++E: ID_USB_INTERFACES=:090000:
++E: ID_USB_MODEL=xHCI_Host_Controller
++E: ID_USB_MODEL_ENC=xHCI\x20Host\x20Controller
++E: ID_USB_MODEL_ID=0002
++E: ID_USB_REVISION=0614
++E: ID_USB_SERIAL=Linux_6.14.0-37-generic_xhci-hcd_xHCI_Host_Controller_0000:05:00.4
++E: ID_USB_SERIAL_SHORT=0000:05:00.4
++E: ID_USB_VENDOR=Linux_6.14.0-37-generic_xhci-hcd
++E: ID_USB_VENDOR_ENC=Linux\x206.14.0-37-generic\x20xhci-hcd
++E: ID_USB_VENDOR_ID=1d6b
++E: ID_VENDOR=Linux_6.14.0-37-generic_xhci-hcd
++E: ID_VENDOR_ENC=Linux\x206.14.0-37-generic\x20xhci-hcd
++E: ID_VENDOR_FROM_DATABASE=Linux Foundation
++E: ID_VENDOR_ID=1d6b
++E: MAJOR=189
++E: MINOR=256
++E: PRODUCT=1d6b/2/614
++E: SUBSYSTEM=usb
++E: TAGS=:seat:
++E: TYPE=9/0/1
++A: authorized=1\n
++A: authorized_default=1\n
++A: avoid_reset_quirk=0\n
++A: bConfigurationValue=1\n
++A: bDeviceClass=09\n
++A: bDeviceProtocol=01\n
++A: bDeviceSubClass=00\n
++A: bMaxPacketSize0=64\n
++A: bMaxPower=0mA\n
++A: bNumConfigurations=1\n
++A: bNumInterfaces= 1\n
++A: bcdDevice=0614\n
++A: bmAttributes=e0\n
++A: busnum=3\n
++A: configuration=
++H: descriptors=12010002090001406B1D020014060302010109021900010100E0000904000001090000000705810304000C
++A: dev=189:256\n
++A: devnum=1\n
++A: devpath=0\n
++L: driver=../../../../../bus/usb/drivers/usb
++L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:0c/device:1b/device:1c
++A: idProduct=0002\n
++A: idVendor=1d6b\n
++A: interface_authorized_default=1\n
++A: ltm_capable=no\n
++A: manufacturer=Linux 6.14.0-37-generic xhci-hcd\n
++A: maxchild=4\n
++A: power/active_duration=93137993\n
++A: power/async=enabled\n
++A: power/autosuspend=0\n
++A: power/autosuspend_delay_ms=0\n
++A: power/connected_duration=93139758\n
++A: power/control=auto\n
++A: power/level=auto\n
++A: power/runtime_active_kids=1\n
++A: power/runtime_active_time=93139206\n
++A: power/runtime_enabled=enabled\n
++A: power/runtime_status=active\n
++A: power/runtime_suspended_time=0\n
++A: power/runtime_usage=0\n
++A: power/wakeup=disabled\n
++A: power/wakeup_abort_count=\n
++A: power/wakeup_active=\n
++A: power/wakeup_active_count=\n
++A: power/wakeup_count=\n
++A: power/wakeup_expire_count=\n
++A: power/wakeup_last_time_ms=\n
++A: power/wakeup_max_time_ms=\n
++A: power/wakeup_total_time_ms=\n
++A: product=xHCI Host Controller\n
++A: quirks=0x0\n
++A: removable=unknown\n
++A: rx_lanes=1\n
++A: serial=0000:05:00.4\n
++A: speed=480\n
++A: tx_lanes=1\n
++A: urbnum=989\n
++A: version= 2.00\n
++
++P: /devices/pci0000:00/0000:00:08.1/0000:05:00.4
++E: DRIVER=xhci_hcd
++E: ID_MODEL_FROM_DATABASE=Renoir/Cezanne USB 3.1
++E: ID_PATH=pci-0000:05:00.4
++E: ID_PATH_TAG=pci-0000_05_00_4
++E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
++E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
++E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
++E: ID_VENDOR_FROM_DATABASE=Advanced Micro Devices, Inc. [AMD]
++E: MODALIAS=pci:v00001022d00001639sv000017AAsd0000382Fbc0Csc03i30
++E: PCI_CLASS=C0330
++E: PCI_ID=1022:1639
++E: PCI_SLOT_NAME=0000:05:00.4
++E: PCI_SUBSYS_ID=17AA:382F
++E: SUBSYSTEM=pci
++A: ari_enabled=0\n
++A: broken_parity_status=0\n
++A: class=0x0c0330\n
++H: config=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
++A: consistent_dma_mask_bits=64\n
++A: current_link_speed=8.0 GT/s PCIe\n
++A: current_link_width=16\n
++A: d3cold_allowed=1\n
++A: dbc=disabled\n
++A: dbc_bInterfaceProtocol=01\n
++A: dbc_bcdDevice=0010\n
++A: dbc_idProduct=0010\n
++A: dbc_idVendor=1d6b\n
++A: dbc_poll_interval_ms=64\n
++A: device=0x1639\n
++A: dma_mask_bits=64\n
++L: driver=../../../../bus/pci/drivers/xhci_hcd
++A: driver_override=(null)\n
++A: enable=1\n
++L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:0c/device:1b
++L: iommu=../../0000:00:00.2/iommu/ivhd0
++L: iommu_group=../../../../kernel/iommu_groups/20
++A: irq=44\n
++A: link/l0s_aspm=0\n
++A: link/l1_aspm=0\n
++A: local_cpulist=0-11\n
++A: local_cpus=fff\n
++A: max_link_speed=8.0 GT/s PCIe\n
++A: max_link_width=16\n
++A: modalias=pci:v00001022d00001639sv000017AAsd0000382Fbc0Csc03i30\n
++A: msi_bus=1\n
++A: msi_irqs/45=msix\n
++A: msi_irqs/46=msix\n
++A: msi_irqs/47=msix\n
++A: msi_irqs/48=msix\n
++A: msi_irqs/49=msix\n
++A: msi_irqs/50=msix\n
++A: msi_irqs/51=msix\n
++A: msi_irqs/52=msix\n
++A: numa_node=-1\n
++A: pools=poolinfo - 0.1\nbuffer-2048 0 0 2048 0\nbuffer-512 0 0 512 0\nbuffer-128 0 0 128 0\nbuffer-32 0 0 32 0\nxHCI 1KB stream ctx arrays 0 0 1024 0\nxHCI 256 byte stream ctx arrays 0 0 256 0\nxHCI input/output contexts 4 5 2112 5\nxHCI ring segments 23 23 4096 23\nbuffer-2048 0 0 2048 0\nbuffer-512 0 0 512 0\nbuffer-128 0 0 128 0\nbuffer-32 0 0 32 0\n
++A: power/async=enabled\n
++A: power/control=on\n
++A: power/runtime_active_kids=1\n
++A: power/runtime_active_time=93139523\n
++A: power/runtime_enabled=forbidden\n
++A: power/runtime_status=active\n
++A: power/runtime_suspended_time=0\n
++A: power/runtime_usage=1\n
++A: power/wakeup=enabled\n
++A: power/wakeup_abort_count=0\n
++A: power/wakeup_active=0\n
++A: power/wakeup_active_count=0\n
++A: power/wakeup_count=0\n
++A: power/wakeup_expire_count=0\n
++A: power/wakeup_last_time_ms=0\n
++A: power/wakeup_max_time_ms=0\n
++A: power/wakeup_total_time_ms=0\n
++A: power_state=D0\n
++A: reset_method=pm\n
++A: resource=0x00000000d0400000 0x00000000d04fffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
++A: revision=0x00\n
++A: subsystem_device=0x382f\n
++A: subsystem_vendor=0x17aa\n
++A: vendor=0x1022\n
++
++P: /devices/pci0000:00/0000:00:08.1
++E: DRIVER=pcieport
++E: ID_MODEL_FROM_DATABASE=Renoir Internal PCIe GPP Bridge to Bus
++E: ID_PATH=pci-0000:00:08.1
++E: ID_PATH_TAG=pci-0000_00_08_1
++E: ID_PCI_CLASS_FROM_DATABASE=Bridge
++E: ID_PCI_INTERFACE_FROM_DATABASE=Normal decode
++E: ID_PCI_SUBCLASS_FROM_DATABASE=PCI bridge
++E: ID_VENDOR_FROM_DATABASE=Advanced Micro Devices, Inc. [AMD]
++E: MODALIAS=pci:v00001022d00001635sv00001022sd00001635bc06sc04i00
++E: PCI_CLASS=60400
++E: PCI_ID=1022:1635
++E: PCI_SLOT_NAME=0000:00:08.1
++E: PCI_SUBSYS_ID=1022:1635
++E: SUBSYSTEM=pci
++A: ari_enabled=0\n
++A: broken_parity_status=0\n
++A: class=0x060400\n
++H: config=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
++A: consistent_dma_mask_bits=32\n
++A: current_link_speed=8.0 GT/s PCIe\n
++A: current_link_width=16\n
++A: d3cold_allowed=1\n
++A: device=0x1635\n
++A: dma_mask_bits=32\n
++L: driver=../../../bus/pci/drivers/pcieport
++A: driver_override=(null)\n
++A: enable=2\n
++L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:0c
++L: iommu=../0000:00:00.2/iommu/ivhd0
++L: iommu_group=../../../kernel/iommu_groups/8
++A: irq=33\n
++A: local_cpulist=0-11\n
++A: local_cpus=fff\n
++A: max_link_speed=8.0 GT/s PCIe\n
++A: max_link_width=16\n
++A: modalias=pci:v00001022d00001635sv00001022sd00001635bc06sc04i00\n
++A: msi_bus=1\n
++A: msi_irqs/33=msi\n
++A: numa_node=-1\n
++A: power/async=enabled\n
++A: power/autosuspend_delay_ms=100\n
++A: power/control=auto\n
++A: power/runtime_active_kids=5\n
++A: power/runtime_active_time=93139537\n
++A: power/runtime_enabled=enabled\n
++A: power/runtime_status=active\n
++A: power/runtime_suspended_time=0\n
++A: power/runtime_usage=0\n
++A: power/wakeup=disabled\n
++A: power/wakeup_abort_count=\n
++A: power/wakeup_active=\n
++A: power/wakeup_active_count=\n
++A: power/wakeup_count=\n
++A: power/wakeup_expire_count=\n
++A: power/wakeup_last_time_ms=\n
++A: power/wakeup_max_time_ms=\n
++A: power/wakeup_total_time_ms=\n
++A: power_state=D0\n
++A: reset_method=pm\n
++A: resource=0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000001000 0x0000000000001fff 0x0000000000000101\n0x00000000d0300000 0x00000000d06fffff 0x0000000000000200\n0x000000fce0000000 0x000000fcf01fffff 0x0000000000102201\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
++A: revision=0x00\n
++A: secondary_bus_number=5\n
++A: subordinate_bus_number=5\n
++A: subsystem_device=0x1635\n
++A: subsystem_vendor=0x1022\n
++A: vendor=0x1022\n
++
+diff --git a/tests/meson.build b/tests/meson.build
+index 07c924be..b6e8bf95 100644
+--- a/tests/meson.build
++++ b/tests/meson.build
+@@ -52,6 +52,7 @@ drivers_tests = [
+ 'nb1010',
+ 'egis0570',
+ 'egismoc',
++ 'egis_etu905',
+ 'egismoc-05a1',
+ 'egismoc-0586',
+ 'egismoc-0587',
+--
+GitLab
+
+
+From c216f04dd1fd1cfe21a71d26bf6e17fc1a37983a Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Tue, 9 Jun 2026 14:19:17 +0200
+Subject: [PATCH 02/13] egis_etu905: Do not leak the transfer buffer
+
+The buffer is now owned by the data, so we should not steal it when
+passing it around or we'll leak.
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 6 ++++--
+ 1 file changed, 4 insertions(+), 2 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index be0c6e05..f91f0472 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -207,7 +207,8 @@ egis_etu905_cmd_receive_cb (FpiUsbTransfer *transfer,
+ fpi_ssm_mark_failed (transfer->ssm, error);
+ return;
+ }
+- if (data == NULL || transfer->actual_length < egis_etu905_read_prefix_len)
++
++ if (transfer->actual_length < egis_etu905_read_prefix_len)
+ {
+ fpi_ssm_mark_failed (transfer->ssm,
+ fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+@@ -216,6 +217,7 @@ egis_etu905_cmd_receive_cb (FpiUsbTransfer *transfer,
+
+ /* Store the response data and let the cmd_ssm_done callback invoke
+ * the actual callback with the stored data */
++ g_assert (data != NULL);
+ data->buffer_in = g_steal_pointer (&transfer->buffer);
+ data->length_in = transfer->actual_length;
+
+@@ -282,7 +284,7 @@ egis_etu905_cmd_ssm_done (FpiSsm *ssm,
+ if (data && data->callback)
+ {
+ data->callback (device,
+- g_steal_pointer (&data->buffer_in),
++ data->buffer_in,
+ data->length_in,
+ g_steal_pointer (&local_error));
+ }
+--
+GitLab
+
+
+From fdbc9ee6558a54dc393a5dfa04f626be8393116c Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Tue, 9 Jun 2026 13:51:28 +0200
+Subject: [PATCH 03/13] egis_etu905: Remove unused transfer
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 11 -----------
+ 1 file changed, 11 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index f91f0472..0bb9a6ba 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -1445,8 +1445,6 @@ static void
+ egis_etu905_dev_init_handler (FpiSsm *ssm,
+ FpDevice *device)
+ {
+- g_autoptr(FpiUsbTransfer) transfer = NULL;
+-
+ switch (fpi_ssm_get_cur_state (ssm))
+ {
+ case DEV_GET_FW_VERSION:
+@@ -1462,15 +1460,6 @@ egis_etu905_dev_init_handler (FpiSsm *ssm,
+ default:
+ g_assert_not_reached ();
+ }
+-
+- transfer = fpi_usb_transfer_new (device);
+- transfer->ssm = ssm;
+- transfer->short_is_error = TRUE;
+- fpi_usb_transfer_submit (g_steal_pointer (&transfer),
+- EGIS_ETU905_USB_CONTROL_TIMEOUT,
+- fpi_device_get_cancellable (device),
+- fpi_ssm_usb_transfer_cb,
+- NULL);
+ }
+
+ static void
+--
+GitLab
+
+
+From f5806825de803a7becd02b49a3f4a6a8e32579ff Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Tue, 9 Jun 2026 13:56:02 +0200
+Subject: [PATCH 04/13] egis_etu905: Remove unused variable
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 1 -
+ 1 file changed, 1 deletion(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index 0bb9a6ba..3d52bf89 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -943,7 +943,6 @@ egis_etu905_get_check_cmd (FpDevice *device,
+ fp_dbg ("Get check command");
+ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
+ g_auto(FpiByteWriter) writer = {0};
+- g_autofree guchar *result = NULL;
+ gboolean written = TRUE;
+
+ /*
+--
+GitLab
+
+
+From 12af25d43b890077cc13a0597b772c9401ca6273 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 13:28:50 +0200
+Subject: [PATCH 05/13] egis_etu905: Set short error using function
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index 3d52bf89..4e58515c 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -97,7 +97,7 @@ egis_etu905_wait_finger_on_sensor (FpiSsm *ssm,
+ EGIS_ETU905_USB_INTERRUPT_IN_RECV_LENGTH);
+ transfer->ssm = ssm;
+ /* Interrupt on this device always returns 1 byte short; this is expected */
+- transfer->short_is_error = FALSE;
++ fpi_usb_transfer_set_short_error (transfer, FALSE);
+
+ fpi_device_report_finger_status (device, FP_FINGER_STATUS_NEEDED);
+
+@@ -382,7 +382,7 @@ egis_etu905_exec_cmd (FpDevice *device,
+ }
+
+ transfer = fpi_usb_transfer_new (device);
+- transfer->short_is_error = TRUE;
++ fpi_usb_transfer_set_short_error (transfer, TRUE);
+ transfer->ssm = self->cmd_ssm;
+
+ fpi_usb_transfer_fill_bulk_full (transfer,
+--
+GitLab
+
+
+From 42f0b96c103195a6a7fa6b45258b72e393c90793 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 13:31:58 +0200
+Subject: [PATCH 06/13] egis_etu905: Rely on default device cancellable for all
+ the actions
+
+I don't see a reason why we should rely on a different cancellable for
+interrupts, but happy to learn more about this
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 33 +------------------------
+ 1 file changed, 1 insertion(+), 32 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index 4e58515c..3c1dcf73 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -33,7 +33,6 @@ struct _FpiDeviceEgisEtu905
+ FpiSsm *task_ssm;
+ FpiSsm *cmd_ssm;
+ FpiUsbTransfer *cmd_transfer;
+- GCancellable *interrupt_cancellable;
+ GPtrArray *enrolled_ids;
+ gint max_enroll_stages;
+ guint8 sid[EGIS_ETU905_FINGERPRINT_DATA_SIZE];
+@@ -89,8 +88,6 @@ egis_etu905_wait_finger_on_sensor (FpiSsm *ssm,
+ FpDevice *device)
+ {
+ fp_dbg ("Wait for finger on sensor");
+- FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
+-
+ g_autoptr(FpiUsbTransfer) transfer = fpi_usb_transfer_new (device);
+
+ fpi_usb_transfer_fill_interrupt (transfer, EGIS_ETU905_EP_CMD_INTERRUPT_IN,
+@@ -103,7 +100,7 @@ egis_etu905_wait_finger_on_sensor (FpiSsm *ssm,
+
+ fpi_usb_transfer_submit (g_steal_pointer (&transfer),
+ EGIS_ETU905_USB_INTERRUPT_TIMEOUT,
+- self->interrupt_cancellable,
++ fpi_device_get_cancellable (device),
+ egis_etu905_finger_on_sensor_cb,
+ NULL);
+ }
+@@ -1551,37 +1548,11 @@ egis_etu905_open (FpDevice *device)
+ fpi_ssm_start (self->task_ssm, egis_etu905_dev_init_done);
+ }
+
+-static void
+-egis_etu905_cancel (FpDevice *device)
+-{
+- fp_dbg ("Cancel");
+- FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
+-
+- g_cancellable_cancel (self->interrupt_cancellable);
+- g_clear_object (&self->interrupt_cancellable);
+- self->interrupt_cancellable = g_cancellable_new ();
+-}
+-
+-static void
+-egis_etu905_suspend (FpDevice *device)
+-{
+- fp_dbg ("Suspend");
+-
+- egis_etu905_cancel (device);
+- g_cancellable_cancel (fpi_device_get_cancellable (device));
+- fpi_device_suspend_complete (device, NULL);
+-}
+-
+ static void
+ egis_etu905_close (FpDevice *device)
+ {
+ g_autoptr(GError) error = NULL;
+ fp_dbg ("Closing device");
+- FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
+- GError *error = NULL;
+-
+- egis_etu905_cancel (device);
+- g_clear_object (&self->interrupt_cancellable);
+
+ g_usb_device_release_interface (fpi_device_get_usb_device (device),
+ 0, 0, &error);
+@@ -1610,8 +1581,6 @@ fpi_device_egis_etu905_class_init (FpiDeviceEgisEtu905Class *klass)
+
+ dev_class->probe = egis_etu905_probe;
+ dev_class->open = egis_etu905_open;
+- dev_class->cancel = egis_etu905_cancel;
+- dev_class->suspend = egis_etu905_suspend;
+ dev_class->close = egis_etu905_close;
+ dev_class->identify = egis_etu905_identify_verify;
+ dev_class->verify = egis_etu905_identify_verify;
+--
+GitLab
+
+
+From 4b8f46f1f9ce3d2b2ce96d0b87fdb464f9e67abe Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 13:32:51 +0200
+Subject: [PATCH 07/13] egis_etu905: Use fpi-bytes-reader to get the firmware
+ string
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 37 +++++++++++++++++++------
+ 1 file changed, 29 insertions(+), 8 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index 3c1dcf73..c4d4093d 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -1348,12 +1348,14 @@ egis_etu905_fw_version_cb (FpDevice *device,
+ gsize length_in,
+ GError *error)
+ {
+- fp_dbg ("Firmware version callback");
+ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
+- g_autofree gchar *fw_version = NULL;
+- gsize prefix_length;
+- guchar *fw_version_start;
++ FpiByteReader reader;
++ const guint8 *fw_version_data = NULL;
++ const guint prefix_length = egis_etu905_read_prefix_len + 2 + 3 + 1;
+ gsize fw_version_length;
++ g_autofree gchar *fw_version = NULL;
++
++ fp_dbg ("Firmware version callback");
+
+ if (error)
+ {
+@@ -1380,10 +1382,29 @@ egis_etu905_fw_version_cb (FpDevice *device,
+ * come with every payload Then we will also skip the carriage return and take
+ * all but the last 2 bytes as the FW Version
+ */
+- prefix_length = egis_etu905_read_prefix_len + 2 + 3 + 1;
+- fw_version_start = buffer_in + prefix_length;
+- fw_version_length = length_in - prefix_length - rsp_fw_version_suffix_len;
+- fw_version = g_strndup ((gchar *) fw_version_start, fw_version_length);
++ fpi_byte_reader_init (&reader, buffer_in, length_in);
++
++ if (!fpi_byte_reader_set_pos (&reader, prefix_length))
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "Device firmware response "
++ "too short for prefix."));
++ return;
++ }
++
++ fw_version_length = fpi_byte_reader_get_remaining (&reader) - rsp_fw_version_suffix_len;
++
++ if (!fpi_byte_reader_get_data (&reader, fw_version_length, &fw_version_data))
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "Device firmware response "
++ "too short for version string."));
++ return;
++ }
++
++ fw_version = g_strndup ((gchar *) fw_version_data, fw_version_length);
+
+ fp_info ("Device firmware version is %s", fw_version);
+
+--
+GitLab
+
+
+From c6f9f094afec2a1bf53e6a6132dbde130650b9ee Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 13:39:34 +0200
+Subject: [PATCH 08/13] egis_etu905: drop unused sid field
+
+We read it but we never use it
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 15 ---------------
+ 1 file changed, 15 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index c4d4093d..418b43a3 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -35,7 +35,6 @@ struct _FpiDeviceEgisEtu905
+ FpiUsbTransfer *cmd_transfer;
+ GPtrArray *enrolled_ids;
+ gint max_enroll_stages;
+- guint8 sid[EGIS_ETU905_FINGERPRINT_DATA_SIZE];
+ };
+
+ G_DEFINE_TYPE (FpiDeviceEgisEtu905, fpi_device_egis_etu905, FP_TYPE_DEVICE);
+@@ -911,20 +910,6 @@ egis_etu905_enroll_begin_cb (FpDevice *device,
+ return;
+ }
+
+- FpiByteReader reader;
+-
+- fpi_byte_reader_init (&reader, buffer_in, length_in);
+-
+- fpi_byte_reader_set_pos (&reader, EGIS_ETU905_LIST_RESPONSE_PREFIX_SIZE);
+-
+- const guint8 *data = NULL;
+-
+- fpi_byte_reader_get_data (&reader, EGIS_ETU905_FINGERPRINT_DATA_SIZE,
+- &data);
+-
+- if (data)
+- memcpy (self->sid, data, EGIS_ETU905_FINGERPRINT_DATA_SIZE);
+-
+ fpi_ssm_next_state (self->task_ssm);
+ }
+
+--
+GitLab
+
+
+From 65c3dcb1eb35ec0bd14b17bedf33de6c621f9ef3 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 13:44:13 +0200
+Subject: [PATCH 09/13] egis_etu905: Avoid potential wrong memory accesses
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 53 ++++++++++++++++++-------
+ 1 file changed, 38 insertions(+), 15 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index 418b43a3..c9b9ab3a 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -110,11 +110,21 @@ egis_etu905_validate_response_prefix (const guchar *buffer_in,
+ const guchar *valid_prefix,
+ const gsize valid_prefix_len)
+ {
+- const gboolean result = memcmp (buffer_in +
+- (egis_etu905_read_prefix_len +
+- EGIS_ETU905_CHECK_BYTES_LENGTH),
+- valid_prefix,
+- valid_prefix_len) == 0;
++ FpiByteReader reader;
++ const guint8 *data = NULL;
++ gboolean result;
++
++ fpi_byte_reader_init (&reader, buffer_in, buffer_in_len);
++
++ if (!fpi_byte_reader_set_pos (&reader, egis_etu905_read_prefix_len +
++ EGIS_ETU905_CHECK_BYTES_LENGTH) ||
++ !fpi_byte_reader_get_data (&reader, valid_prefix_len, &data))
++ {
++ fp_dbg ("Response too short for prefix validation");
++ return FALSE;
++ }
++
++ result = memcmp (data, valid_prefix, valid_prefix_len) == 0;
+
+ fp_dbg ("Response prefix valid: %s", result ? "yes" : "NO");
+ return result;
+@@ -126,9 +136,22 @@ egis_etu905_validate_response_suffix (const guchar *buffer_in,
+ const guchar *valid_suffix,
+ const gsize valid_suffix_len)
+ {
+- const gboolean result = memcmp (buffer_in + (buffer_in_len - valid_suffix_len),
+- valid_suffix,
+- valid_suffix_len) == 0;
++ FpiByteReader reader;
++ const guint8 *data = NULL;
++ gboolean result;
++
++ fpi_byte_reader_init (&reader, buffer_in, buffer_in_len);
++
++ /* Guard against unsigned underflow before computing the suffix position. */
++ if (valid_suffix_len > buffer_in_len ||
++ !fpi_byte_reader_set_pos (&reader, buffer_in_len - valid_suffix_len) ||
++ !fpi_byte_reader_get_data (&reader, valid_suffix_len, &data))
++ {
++ fp_dbg ("Response too short for suffix validation");
++ return FALSE;
++ }
++
++ result = memcmp (data, valid_suffix, valid_suffix_len) == 0;
+
+ fp_dbg ("Response suffix valid: %s", result ? "yes" : "NO");
+ return result;
+@@ -1467,10 +1490,10 @@ egis_etu905_dev_init_handler (FpiSsm *ssm,
+ static void
+ egis_etu905_probe (FpDevice *device)
+ {
+- GUsbDevice *usb_dev;
+- GError *error = NULL;
++ g_autoptr(GError) error = NULL;
+ g_autofree gchar *serial = NULL;
+ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
++ GUsbDevice *usb_dev;
+
+ fp_dbg ("%s enter --> ", G_STRFUNC);
+
+@@ -1479,7 +1502,7 @@ egis_etu905_probe (FpDevice *device)
+ if (!g_usb_device_open (usb_dev, &error))
+ {
+ fp_dbg ("%s g_usb_device_open failed %s", G_STRFUNC, error->message);
+- fpi_device_probe_complete (device, NULL, NULL, error);
++ fpi_device_probe_complete (device, NULL, NULL, g_steal_pointer (&error));
+ return;
+ }
+
+@@ -1487,7 +1510,7 @@ egis_etu905_probe (FpDevice *device)
+ {
+ fp_dbg ("%s g_usb_device_reset failed %s", G_STRFUNC, error->message);
+ g_usb_device_close (usb_dev, NULL);
+- fpi_device_probe_complete (device, NULL, NULL, error);
++ fpi_device_probe_complete (device, NULL, NULL, g_steal_pointer (&error));
+ return;
+ }
+
+@@ -1495,7 +1518,7 @@ egis_etu905_probe (FpDevice *device)
+ {
+ fp_dbg ("%s g_usb_device_claim_interface failed %s", G_STRFUNC, error->message);
+ g_usb_device_close (usb_dev, NULL);
+- fpi_device_probe_complete (device, NULL, NULL, error);
++ fpi_device_probe_complete (device, NULL, NULL, g_steal_pointer (&error));
+ return;
+ }
+
+@@ -1512,7 +1535,7 @@ egis_etu905_probe (FpDevice *device)
+ g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (device)),
+ 0, 0, NULL);
+ g_usb_device_close (usb_dev, NULL);
+- fpi_device_probe_complete (device, NULL, NULL, error);
++ fpi_device_probe_complete (device, NULL, NULL, g_steal_pointer (&error));
+ return;
+ }
+
+@@ -1526,7 +1549,7 @@ egis_etu905_probe (FpDevice *device)
+ g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (device)), 0, 0, NULL);
+ g_usb_device_close (usb_dev, NULL);
+
+- fpi_device_probe_complete (device, serial, NULL, error);
++ fpi_device_probe_complete (device, serial, NULL, NULL);
+ }
+
+ static void
+--
+GitLab
+
+
+From 5b51f9c8ccf33424636e4e32cb6205204e816940 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 13:47:41 +0200
+Subject: [PATCH 10/13] egis_etu905: Sanitize print data parsing
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 23 ++++++++++++++++-------
+ 1 file changed, 16 insertions(+), 7 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index c9b9ab3a..0a5655f1 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -318,7 +318,7 @@ static guint16
+ egis_etu905_get_check_bytes (FpiByteReader *reader)
+ {
+ fp_dbg ("Get check bytes");
+- size_t sum_values = 0;
++ guint64 sum_values = 0;
+ guint16 val;
+
+ fpi_byte_reader_set_pos (reader, 0);
+@@ -562,8 +562,6 @@ egis_etu905_get_delete_cmd (FpDevice *device,
+ const guchar *print_data_id = NULL;
+ gsize print_data_id_len = 0;
+ g_autofree gchar *print_description = NULL;
+- g_autofree guchar *enrolled_print_id = NULL;
+- g_autofree guchar *result = NULL;
+ gboolean written = TRUE;
+
+ /*
+@@ -639,7 +637,8 @@ egis_etu905_get_delete_cmd (FpDevice *device,
+ g_object_get (delete_print, "description", &print_description, NULL);
+ g_object_get (delete_print, "fpi-data", &print_data, NULL);
+
+- if (!g_variant_check_format_string (print_data, "(@ay)", FALSE))
++ if (!print_data ||
++ !g_variant_check_format_string (print_data, "(@ay)", FALSE))
+ {
+ fpi_ssm_mark_failed (self->task_ssm,
+ fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
+@@ -650,11 +649,21 @@ egis_etu905_get_delete_cmd (FpDevice *device,
+ print_data_id = g_variant_get_fixed_array (print_data_id_var,
+ &print_data_id_len, sizeof (guchar));
+
+- if (!g_str_has_prefix (print_description, "FP"))
++ if (print_data_id_len != EGIS_ETU905_FINGERPRINT_DATA_SIZE)
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_INVALID,
++ "Stored print id has "
++ "unexpected length %zu",
++ print_data_id_len));
++ return NULL;
++ }
++
++ if (!print_description || !g_str_has_prefix (print_description, "FP"))
+ fp_dbg ("Fingerprint '%s' was not created by libfprint; deleting anyway.",
+- print_description);
++ print_description ? print_description : "(null)");
+
+- fp_info ("Delete fingerprint %s", print_description);
++ fp_info ("Delete fingerprint %s", print_description ? print_description : "(null)");
+
+ written &= fpi_byte_writer_put_data (&writer, print_data_id,
+ EGIS_ETU905_FINGERPRINT_DATA_SIZE);
+--
+GitLab
+
+
+From c0a98110531e74beb5876ef084da3ed8901128c2 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 13:48:00 +0200
+Subject: [PATCH 11/13] egis_etu905: Do not try to continue a failed SSM
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index 0a5655f1..d45b46e2 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -755,6 +755,10 @@ egis_etu905_delete_run_state (FpiSsm *ssm,
+ else
+ payload = egis_etu905_get_delete_cmd (device, NULL, &payload_length);
+
++ /* get_delete_cmd already marked task_ssm as failed */
++ if (!payload)
++ return;
++
+ egis_etu905_exec_cmd (device, g_steal_pointer (&payload), payload_length,
+ g_free, egis_etu905_delete_cb);
+ break;
+--
+GitLab
+
+
+From 06ad44bc1da732598f82a7c11eb0bbc29850ac13 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Mon, 8 Jun 2026 15:19:54 +0200
+Subject: [PATCH 12/13] egis_etu905: Improve the identify callback data reading
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 41 ++++++++++++++-----------
+ 1 file changed, 23 insertions(+), 18 deletions(-)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index d45b46e2..7de306b4 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -496,11 +496,10 @@ egis_etu905_list_fill_enrolled_ids_cb (FpDevice *device,
+ */
+ while (read)
+ {
+- const guint8 *data;
++ const guint8 data[EGIS_ETU905_FINGERPRINT_DATA_SIZE];
+ g_autofree gchar *print_id = NULL;
+
+- read &= fpi_byte_reader_get_data (&reader, EGIS_ETU905_FINGERPRINT_DATA_SIZE,
+- &data);
++ read &= fpi_byte_reader_get_data_static (&reader, data);
+ if (!read)
+ break;
+
+@@ -1182,15 +1181,16 @@ egis_etu905_identify_check_cb (FpDevice *device,
+ gsize length_in,
+ GError *error)
+ {
+- fp_dbg ("Identify check callback");
+ FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device);
+- gchar device_print_id[EGIS_ETU905_FINGERPRINT_DATA_SIZE];
++ guint8 device_print_id[EGIS_ETU905_FINGERPRINT_DATA_SIZE];
+ FpPrint *print = NULL;
+ FpPrint *verify_print = NULL;
+ GPtrArray *prints;
+ gboolean found = FALSE;
+ guint index;
+
++ fp_dbg ("Identify check callback");
++
+ if (error)
+ {
+ fpi_ssm_mark_failed (self->task_ssm, error);
+@@ -1203,29 +1203,34 @@ egis_etu905_identify_check_cb (FpDevice *device,
+ rsp_identify_match_suffix,
+ rsp_identify_match_suffix_len))
+ {
++ FpiByteReader reader;
++
+ /*
+ On success, there is a 32 byte array of "something"(?) in chars 14-45
+ and then the 32 byte array ID of the matched print comes as chars 46-77
+ */
+- memcpy (device_print_id,
+- buffer_in + EGIS_ETU905_IDENTIFY_RESPONSE_PRINT_ID_OFFSET,
+- EGIS_ETU905_FINGERPRINT_DATA_SIZE);
+-
+- /* Create a new print from this device_print_id and then see if it matches
+- * the one indicated
+- */
+- print = fp_print_new (device);
+- egis_etu905_set_print_data (print, device_print_id, NULL);
++ fpi_byte_reader_init (&reader, buffer_in, length_in);
+
+- if (!print)
++ if (!fpi_byte_reader_set_pos (&reader,
++ EGIS_ETU905_IDENTIFY_RESPONSE_PRINT_ID_OFFSET) ||
++ !fpi_byte_reader_get_data_static (&reader, device_print_id))
+ {
+ fpi_ssm_mark_failed (self->task_ssm,
+- fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_INVALID,
+- "Failed to build a print from "
+- "device response."));
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "Identify response too "
++ "short for matched print "
++ "id."));
+ return;
+ }
+
++ fp_dbg ("Device-reported matched print id: %s", device_print_id);
++
++ /* Create a new print from this device_print_id and then see if it matches
++ * the one indicated
++ */
++ print = fp_print_new (device);
++ egis_etu905_set_print_data (print, (const char *) device_print_id, NULL);
++
+ fp_info ("Identify successful for: %s", fp_print_get_description (print));
+
+ if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY)
+--
+GitLab
+
+
+From 6a71e039a12ead2b3120ad4789b93a44193045ec Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
+Date: Tue, 9 Jun 2026 13:56:24 +0200
+Subject: [PATCH 13/13] egis_etu905: Double-check that the identified ID is
+ part of the enrolled list
+
+---
+ libfprint/drivers/egismoc/egis_etu905.c | 27 +++++++++++++++++++++++++
+ 1 file changed, 27 insertions(+)
+
+diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c
+index 7de306b4..dcd71ff6 100644
+--- a/libfprint/drivers/egismoc/egis_etu905.c
++++ b/libfprint/drivers/egismoc/egis_etu905.c
+@@ -1203,6 +1203,7 @@ egis_etu905_identify_check_cb (FpDevice *device,
+ rsp_identify_match_suffix,
+ rsp_identify_match_suffix_len))
+ {
++ gboolean id_known = FALSE;
+ FpiByteReader reader;
+
+ /*
+@@ -1225,6 +1226,32 @@ egis_etu905_identify_check_cb (FpDevice *device,
+
+ fp_dbg ("Device-reported matched print id: %s", device_print_id);
+
++ /* While the returned ID should indeed be part of the enrolled list, since
++ * we got it, let's double check that this is really the case.
++ */
++ if (self->enrolled_ids)
++ {
++ for (guint i = 0; i < self->enrolled_ids->len; i++)
++ {
++ if (memcmp (g_ptr_array_index (self->enrolled_ids, i),
++ device_print_id,
++ EGIS_ETU905_FINGERPRINT_DATA_SIZE) == 0)
++ {
++ id_known = TRUE;
++ break;
++ }
++ }
++ }
++
++ if (!id_known)
++ {
++ fpi_ssm_mark_failed (self->task_ssm,
++ fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
++ "Device reported a match "
++ "for an unknown print id."));
++ return;
++ }
++
+ /* Create a new print from this device_print_id and then see if it matches
+ * the one indicated
+ */
+--
+GitLab
+
diff --git a/libfprint.spec b/libfprint.spec
index fbffea7..96a9cb2 100644
--- a/libfprint.spec
+++ b/libfprint.spec
@@ -14,6 +14,17 @@ Source0: https://gitlab.freedesktop.org/libfprint/libfprint/-/archive/v%{
# Backport from upstream
Patch00001: https://gitlab.freedesktop.org/libfprint/libfprint/-/commit/2c7842c905147a2d127c1b168b2e9d43.patch
+# the updates for the fpi
+Patch10001: 0001-doc-Include-Binary-buffer-I-O-section-for-the-byte-r.patch
+Patch10002: 0002-fpi-byte-writer-Add-APIs-to-write-and-get-GBytes.patch
+Patch10003: 0003-fpi-byte-reader-Add-support-to-read-and-get-peek-GBy.patch
+Patch10004: 0004-fpi-byte-reader-Add-support-to-read-to-a-static-buff.patch
+Patch10005: 0005-fpi-usb-transfer-Add-missing-definition-of-set_short.patch
+Patch10006: 0006-fpi-usb-transfer-Wrap-g_error_new-arguments.patch
+# Add EGIS readers
+# https://gitlab.freedesktop.org/libfprint/libfprint/-/merge_requests/561
+Patch10007: egis_reader.patch
+
BuildRequires: meson
BuildRequires: gcc
BuildRequires: gcc-c++
reply other threads:[~2026-06-26 7:19 UTC|newest]
Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=178245836253.1.9282662469454704043.rpms-libfprint-f99efa9929b2@fedoraproject.org \
--to=hpa@redhat.com \
--cc=git-commits@fedoraproject.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox