Release 1.94.8

Signed-off-by: huan_huang <huan_huang@realsil.com.cn>

.gitlab-ci.yml

@@ -6,37 +6,52 @@ include:
     file: '/templates/fedora.yml'
   - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/master/flatpak/flatpak_ci_initiative.yml'
 
+default:
+  # Auto-retry jobs in case of infra failures
+  retry:
+    max: 1
+    when:
+      - 'runner_system_failure'
+      - 'stuck_or_timeout_failure'
+      - 'scheduler_failure'
+      - 'api_failure'
+
 variables:
   extends: .libfprint_common_variables
   FDO_DISTRIBUTION_TAG: $LIBFPRINT_IMAGE_TAG
   FDO_DISTRIBUTION_VERSION: rawhide
   FDO_UPSTREAM_REPO: "libfprint/$CI_PROJECT_NAME"
   FEDORA_IMAGE: "$CI_REGISTRY/libfprint/$CI_PROJECT_NAME/fedora/$FDO_DISTRIBUTION_VERSION:$FDO_DISTRIBUTION_TAG"
-  BUNDLE: "org.freedesktop.libfprint.Demo.flatpak"
   LAST_ABI_BREAK: "056ea541ddc97f5806cffbd99a12dc87e4da3546"
 
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == 'merge_request_event'
+    - if: $CI_PIPELINE_SOURCE == 'push'
+
 stages:
   - image-build
   - check-source
   - build
   - test
   - flatpak
+  - deploy
 
 image: $FEDORA_IMAGE
 
 .build_one_driver_template: &build_one_driver
   script:
     # Build with a driver that doesn't need imaging, or nss
-    - meson --werror -Ddrivers=$driver . _build
+    - meson setup _build --werror -Ddrivers=$driver
-    - ninja -C _build
+    - meson compile -C _build
     - rm -rf _build/
 
 .build_template: &build
   script:
     # And build with everything
-    - meson --werror -Ddrivers=all . _build
+    - meson setup _build --werror -Ddrivers=all
-    - ninja -C _build
+    - meson compile -C _build
-    - ninja -C _build install
+    - meson install -C _build
 
 .build_template: &check_abi
   script:
@@ -65,11 +80,10 @@ test:
     variables:
       - $CI_PIPELINE_SOURCE == "schedule"
   script:
-    - meson --werror -Ddrivers=all -Db_coverage=true . _build
+    - meson setup _build --werror -Ddrivers=all -Db_coverage=true
-    - ninja -C _build
     - meson test -C _build --print-errorlogs --no-stdsplit --timeout-multiplier 3
     - ninja -C _build coverage
-    - cat _build/meson-logs/coverage.txt
+    - cat _build/meson-logs/coverage.txt || true
   artifacts:
     reports:
       junit: "_build/meson-logs/testlog.junit.xml"
@@ -90,12 +104,12 @@ test_valgrind:
     variables:
       - $CI_PIPELINE_SOURCE == "schedule"
   script:
-    - meson -Ddrivers=all . _build
+    - meson setup _build -Ddrivers=all
-    - ninja -C _build
+    - meson compile -C _build
     - meson test -C _build --print-errorlogs --no-stdsplit --setup=valgrind
   artifacts:
     reports:
-      junit: "_build/meson-logs/testlog.junit.xml"
+      junit: "_build/meson-logs/testlog-valgrind.junit.xml"
     expose_as: 'Valgrind test logs'
     when: always
     paths:
@@ -103,6 +117,29 @@ test_valgrind:
       - _build/meson-logs/testlog-valgrind.txt
     expire_in: 1 week
 
+test_installed:
+  stage: test
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
+  script:
+    - meson setup _build --prefix=/usr -Ddrivers=all
+    - meson install -C _build
+    - mv _build _build_dir
+    - rm -rf tests
+    - gnome-desktop-testing-runner --list libfprint-2
+    - gnome-desktop-testing-runner libfprint-2
+        --report-directory=_installed-tests-report/failed/
+        --log-directory=_installed-tests-report/logs/
+        --parallel=0
+  artifacts:
+    expose_as: 'GNOME Tests Runner logs'
+    when: always
+    paths:
+      - _build_dir/meson-logs
+      - _installed-tests-report
+    expire_in: 1 week
+
 
 test_scan_build:
   stage: test
@@ -111,10 +148,12 @@ test_scan_build:
       - $CI_PIPELINE_SOURCE == "schedule"
   allow_failure: true
   script:
-    - meson -Ddrivers=all . _build
+    - meson setup _build -Ddrivers=all
     # Wrapper to add --status-bugs and disable malloc checker
-    - SCANBUILD=$CI_PROJECT_DIR/.gitlab-ci/scan-build ninja -C _build scan-build
+    - SCANBUILD=$CI_PROJECT_DIR/.gitlab-ci/scan-build
+      ninja -C _build scan-build
   artifacts:
+    when: on_failure
     paths:
       - _build/meson-logs
     expire_in: 1 week
@@ -140,27 +179,35 @@ test_unsupported_list:
 
 flatpak:
   stage: flatpak
-  extends: .flatpak
+  extends: .flatpak@x86_64
-  # From https://gitlab.gnome.org/GNOME/gnome-runtime-images/container_registry
-  image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:42
   variables:
     MANIFEST_PATH: "demo/org.freedesktop.libfprint.Demo.json"
     FLATPAK_MODULE: "libfprint"
     APP_ID: "org.freedesktop.libfprint.Demo"
+    BUNDLE: "org.freedesktop.libfprint.Demo.flatpak"
+    RUNTIME_REPO: "https://nightly.gnome.org/gnome-nightly.flatpakrepo"
+  # Build with any builder
+  tags: []
   rules:
     - if: '$CI_PROJECT_PATH != "libfprint/libfprint"'
-      when: never
+      when: manual
+      allow_failure: true
     - if: '$CI_PIPELINE_SOURCE == "schedule"'
       when: never
     - if: '$CI_COMMIT_BRANCH == "master"'
+      allow_failure: true
       when: always
     - if: '$CI_COMMIT_TAG'
+      allow_failure: true
       when: always
     # For any other (commit), allow manual run.
     # This excludes MRs which would create a duplicate pipeline
     - if: '$CI_COMMIT_BRANCH'
       when: manual
       allow_failure: true
+    - if: '$CI_MERGE_REQUEST_ID'
+      when: manual
+      allow_failure: true
 
 # CONTAINERS creation stage
 .container_fedora_build_base:
@@ -171,7 +218,6 @@ flatpak:
       - $CI_PIPELINE_SOURCE == "never"
   variables:
     GIT_STRATEGY: none # no need to pull the whole tree for rebuilding the image
-    FDO_FORCE_REBUILD: 1
     # a list of packages to install
     FDO_DISTRIBUTION_PACKAGES:
       $LIBFPRINT_DEPENDENCIES
@@ -181,14 +227,22 @@ flatpak:
     FDO_DISTRIBUTION_EXEC: |
       $LIBFPRINT_EXEC
 
+.container_fedora_build_forced:
+  variables:
+    FDO_FORCE_REBUILD: 1
+
 container_fedora_build_schedule:
-  extends: .container_fedora_build_base
+  extends:
+    - .container_fedora_build_base
+    - .container_fedora_build_forced
   only:
     variables:
       - $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
 
 container_fedora_build_manual:
-  extends: .container_fedora_build_base
+  extends:
+    - .container_fedora_build_base
+    - .container_fedora_build_forced
   only:
     variables:
       - $LIBFPRINT_CI_ACTION == "build-image"
@@ -203,3 +257,18 @@ container_fedora_build_on_deps_changed:
       - merge_requests
     changes:
       - .gitlab-ci/libfprint-image-variables.yaml
+
+pages:
+  image: alpine:latest
+  stage: deploy
+  needs:
+    - job: test
+      artifacts: true
+  script:
+    - mkdir public
+    - mv _build/meson-logs/coveragereport public/coverage
+  artifacts:
+    paths:
+      - public
+  rules:
+    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH

.gitlab-ci/libfprint-image-variables.yaml

@@ -1,2 +1,2 @@
 variables:
-  LIBFPRINT_IMAGE_TAG: v2
+  LIBFPRINT_IMAGE_TAG: v3

.gitlab-ci/libfprint-templates.yaml

@@ -13,6 +13,7 @@
     glib2-devel
     glibc-devel
     gobject-introspection-devel
+    gnome-desktop-testing
     gtk-doc
     gtk3-devel
     libabigail
@@ -33,7 +34,8 @@
     diffutils
 
   LIBFPRINT_EXEC: |
-    dnf debuginfo-install -y \
+    dnf -y install dnf-utils
+    debuginfo-install -y \
       glib2 \
       glibc \
       libgusb \

NEWS

@@ -1,6 +1,50 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
+2024-09-03: v1.94.8 release
+
+Highlights:
+ * build: Support building in non-linux unix environments (tested in FreeBSD)
+ * egismoc: New PIDs 0x0583, 0x0586, 0x0587.
+ * elanmoc: New PID 0x0C9F.
+ * fpcmoc: New PIDs 0x9524, 0x9544.
+ * goodixmoc: New PIDs 0x609A, 0x650A, 0x650C, 0x6512.
+ * realtek: New PID 0x5816.
+ * synaptics: New PIDs 0x00C4, 0x019D, 0x00C6.
+ * fpcmoc: fix incorrect immobile handling during enrollment.
+ * fpcmoc: fixed jumping to wrong state at end of custom enroll.
+ * egismoc: various code cleanups.
+
+2024-02-20: v1.94.7 release
+
+Highlights:
+ * synaptics: fix enroll identify problem after user reset database.
+ * synaptics: New PIDs 0x0173, 0x0106, 0x0124.
+ * goodixmoc: New PID 0x6582.
+ * build: Do not require bash to build, only posix sh.
+ * fp-image: Simplify minutiae detection tasks.
+ * GLib 2.68 is now required to build libfprint.
+
+New drivers:
+ * realtek (PID 0x5813).
+ * focaltech_moc (PIDs 0x9E48, 0xD979, 0xA959).
+ * egismoc (PIDs 0x0582, 0x05a1).
+
+2023-08-17: v1.94.6 release
+
+Highlights:
+ * goodixmoc: New PIDs 0x60A4, 0x60BC, 0x6092, 0x633C and 0x6304.
+ * goodixmoc: Fix missing "enroll create" state.
+ * elanmoc: New PID 0x0C99.
+ * upektc: Improve compatibility with sensors 147e:2016.
+ * aes4000: Actually support 08FF:5501 devices.
+ * virtual-device-listener: Fix failing tests with GLib 2.76
+ * tests: Add installed tests
+
+Bugs fixed:
+ * #526 libfprint: fpcmoc: use after free if enrollment or identification is
+   cancelled (Vasily Khoruzhick)
+
 2022-10-13: v1.94.5 release
 
 Highlights:
@@ -342,7 +386,7 @@ tests of the drivers using umockdev.
   - Mark fp_dscv_print functions as deprecated
 
 * Udev rules:
-  - Add some unsupported devices to the whitelist
+  - Add some unsupported devices to the allowlist
 
 2017-05-14: v0.7.0 release
 * Drivers:
@@ -392,7 +436,7 @@ tests of the drivers using umockdev.
   - Fix possible race condition, and cancellation in uru4000 driver
 
 * Udev rules:
-  - Add Microsoft keyboard to the suspend blacklist
+  - Add Microsoft keyboard to the suspend denylist
 
 * Plenty of build fixes
 

README.md

@@ -46,6 +46,12 @@ We include **Bozorth3** from the **[US Export Controlled]**
 distribution, which we have determined to be fine
 being shipped in an open source project.
 
+## Get in *touch*
+
+ - [IRC] - `#fprint` @ `irc.oftc.net`
+ - [Matrix] - `#fprint:matrix.org` bridged to the IRC channel
+ - [MailingList] - low traffic, not much used these days
+
 <br/>
 
 <div align="right">
@@ -62,6 +68,9 @@ being shipped in an open source project.
 [Unsupported]: https://gitlab.freedesktop.org/libfprint/wiki/-/wikis/Unsupported-Devices
 [Supported]: https://fprint.freedesktop.org/supported-devices.html
 [Website]: https://fprint.freedesktop.org/
+[MailingList]: https://lists.freedesktop.org/mailman/listinfo/fprint
+[IRC]: ircs://irc.oftc.net:6697/#fprint
+[Matrix]: https://matrix.to/#/#fprint:matrix.org
 
 [Contribute]: ./HACKING.md
 [License]: ./COPYING

data/autosuspend.hwdb

@@ -67,7 +67,7 @@ usb:v08FFp5731*
  ID_PERSIST=0
 
 # Supported by libfprint driver aes4000
-usb:v5501p08FF*
+usb:v08FFp5501*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -77,6 +77,15 @@ usb:v1C7Ap0571*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
+# Supported by libfprint driver egismoc
+usb:v1C7Ap0582*
+usb:v1C7Ap0583*
+usb:v1C7Ap0586*
+usb:v1C7Ap0587*
+usb:v1C7Ap05A1*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
 # Supported by libfprint driver elan
 usb:v04F3p0903*
 usb:v04F3p0907*
@@ -149,6 +158,8 @@ usb:v04F3p0C82*
 usb:v04F3p0C88*
 usb:v04F3p0C8C*
 usb:v04F3p0C8D*
+usb:v04F3p0C99*
+usb:v04F3p0C9F*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -157,22 +168,37 @@ usb:v1C7Ap0603*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
+# Supported by libfprint driver focaltech_moc
+usb:v2808p9E48*
+usb:v2808pD979*
+usb:v2808pA959*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
 # Supported by libfprint driver fpcmoc
 usb:v10A5pFFE0*
 usb:v10A5pA305*
 usb:v10A5pDA04*
 usb:v10A5pD805*
 usb:v10A5pD205*
+usb:v10A5p9524*
+usb:v10A5p9544*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
 # Supported by libfprint driver goodixmoc
 usb:v27C6p5840*
 usb:v27C6p6014*
+usb:v27C6p6092*
 usb:v27C6p6094*
+usb:v27C6p609A*
 usb:v27C6p609C*
 usb:v27C6p60A2*
+usb:v27C6p60A4*
+usb:v27C6p60BC*
+usb:v27C6p6304*
 usb:v27C6p631C*
+usb:v27C6p633C*
 usb:v27C6p634C*
 usb:v27C6p6384*
 usb:v27C6p639C*
@@ -180,6 +206,9 @@ usb:v27C6p63AC*
 usb:v27C6p63BC*
 usb:v27C6p63CC*
 usb:v27C6p6496*
+usb:v27C6p650A*
+usb:v27C6p650C*
+usb:v27C6p6582*
 usb:v27C6p6584*
 usb:v27C6p658C*
 usb:v27C6p6592*
@@ -187,6 +216,7 @@ usb:v27C6p6594*
 usb:v27C6p659A*
 usb:v27C6p659C*
 usb:v27C6p6A94*
+usb:v27C6p6512*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -195,21 +225,33 @@ usb:v298Dp1010*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
+# Supported by libfprint driver realtek
+usb:v0BDAp5813*
+usb:v0BDAp5816*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
 # Supported by libfprint driver synaptics
 usb:v06CBp00BD*
 usb:v06CBp00DF*
 usb:v06CBp00F9*
 usb:v06CBp00FC*
 usb:v06CBp00C2*
+usb:v06CBp00C4*
 usb:v06CBp0100*
 usb:v06CBp00F0*
 usb:v06CBp0103*
 usb:v06CBp0123*
+usb:v06CBp0124*
 usb:v06CBp0126*
 usb:v06CBp0129*
 usb:v06CBp0168*
 usb:v06CBp015F*
 usb:v06CBp0104*
+usb:v06CBp0173*
+usb:v06CBp0106*
+usb:v06CBp019D*
+usb:v06CBp00C6*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -278,6 +320,7 @@ usb:v138Ap0091*
  ID_PERSIST=0
 
 # Known unsupported devices
+usb:v047Dp00F2*
 usb:v04E8p730B*
 usb:v04F3p036B*
 usb:v04F3p0C00*
@@ -285,12 +328,16 @@ usb:v04F3p0C4C*
 usb:v04F3p0C57*
 usb:v04F3p0C5E*
 usb:v04F3p0C5A*
+usb:v04F3p0C6C*
 usb:v04F3p0C70*
 usb:v04F3p0C72*
+usb:v04F3p0C77*
 usb:v04F3p2706*
+usb:v04F3p3032*
 usb:v04F3p3057*
 usb:v04F3p3104*
 usb:v04F3p310D*
+usb:v04F3p3128*
 usb:v06CBp0081*
 usb:v06CBp0088*
 usb:v06CBp008A*
@@ -301,7 +348,6 @@ usb:v06CBp00A8*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
 usb:v06CBp00BE*
-usb:v06CBp00C4*
 usb:v06CBp00CB*
 usb:v06CBp00C9*
 usb:v06CBp00D8*
@@ -320,10 +366,17 @@ usb:v0A5Cp5842*
 usb:v0A5Cp5843*
 usb:v0A5Cp5844*
 usb:v0A5Cp5845*
+usb:v0A5Cp5860*
+usb:v0A5Cp5863*
+usb:v0A5Cp5864*
+usb:v0A5Cp5865*
+usb:v0A5Cp5866*
+usb:v0A5Cp5867*
 usb:v0BDAp5812*
 usb:v10A5p0007*
 usb:v10A5p9200*
 usb:v10A5p9800*
+usb:v10A5pE340*
 usb:v1188p9545*
 usb:v138Ap0007*
 usb:v138Ap003A*
@@ -336,12 +389,14 @@ usb:v138Ap0094*
 usb:v138Ap0097*
 usb:v138Ap009D*
 usb:v138Ap00AB*
+usb:v138Ap00A6*
 usb:v147Ep1002*
 usb:v1491p0088*
 usb:v16D1p1027*
 usb:v1C7Ap0300*
 usb:v1C7Ap0575*
 usb:v1C7Ap0576*
+usb:v1C7Ap0577*
 usb:v27C6p5042*
 usb:v27C6p5110*
 usb:v27C6p5117*
@@ -369,6 +424,8 @@ usb:v27C6p55B4*
 usb:v27C6p5740*
 usb:v27C6p5E0A*
 usb:v27C6p581A*
+usb:v27C6p589A*
+usb:v27C6p6382*
 usb:v2808p9338*
 usb:v2808p93A9*
 usb:v298Dp2020*

demo/gtk-libfprint-test.c

@@ -102,9 +102,9 @@ plot_minutiae (unsigned char *rgbdata,
   int i;
 
 #define write_pixel(num) do { \
-      rgbdata[((num) * 3)] = 0xff; \
+            rgbdata[((num) * 3)] = 0xff; \
-      rgbdata[((num) * 3) + 1] = 0; \
+            rgbdata[((num) * 3) + 1] = 0; \
-      rgbdata[((num) * 3) + 2] = 0; \
+            rgbdata[((num) * 3) + 2] = 0; \
   } while(0)
 
   for (i = 0; i < minutiae->len; i++)

demo/org.freedesktop.libfprint.Demo.json

@@ -1,7 +1,7 @@
 {
     "app-id": "org.freedesktop.libfprint.Demo",
     "runtime": "org.gnome.Platform",
-    "runtime-version": "42",
+    "runtime-version": "master",
     "sdk": "org.gnome.Sdk",
     "command": "gtk-libfprint-test",
     "finish-args": [
@@ -38,24 +38,24 @@
         {
             "name": "libgusb",
             "buildsystem": "meson",
-            "config-opts": [ "-Dtests=false", "-Dvapi=false", "-Ddocs=false", "-Dintrospection=false" ],
+            "config-opts": [ "-Dtests=false", "-Dvapi=false", "-Ddocs=false" ],
             "sources": [
                 {
                     "type": "archive",
-                    "url": "https://github.com/hughsie/libgusb/archive/0.3.0.tar.gz",
+                    "url": "https://github.com/hughsie/libgusb/releases/download/0.4.6/libgusb-0.4.6.tar.xz",
-                    "sha256": "b36310f8405d5fd68f6caf4a829f7ab4c627b38fd3d02a139d411fce0f3a49f1"
+                    "sha256": "1b0422bdcd72183272ac42eec9398c5a0bc48a02f618fa3242c468cbbd003049"
                 }
             ]
         },
         {
             "name": "gudev",
             "buildsystem": "meson",
-            "config-opts": [ "-Dtests=disabled", "-Dintrospection=disabled" ],
+            "config-opts": [ "-Dtests=disabled", "-Dintrospection=disabled", "-Dvapi=disabled" ],
             "sources": [
                 {
                     "type": "archive",
-                    "url": "https://download.gnome.org/sources/libgudev/236/libgudev-236.tar.xz",
+                    "url": "https://download.gnome.org/sources/libgudev/238/libgudev-238.tar.xz",
-                    "sha256": "e50369d06d594bae615eb7aeb787de304ebaad07a26d1043cef8e9c7ab7c9524"
+                    "sha256": "61266ab1afc9d73dbc60a8b2af73e99d2fdff47d99544d085760e4fa667b5dd1"
                 }
             ]
         },

doc/meson.build

@@ -19,13 +19,13 @@ content_files = [
 
 expand_content_files = content_files
 
-glib_prefix = dependency('glib-2.0').get_pkgconfig_variable('prefix')
+glib_prefix = dependency('glib-2.0').get_variable(pkgconfig: 'prefix')
 glib_docpath = join_paths(glib_prefix, 'share', 'gtk-doc', 'html')
 docpath = join_paths(get_option('datadir'), 'gtk-doc', 'html')
 
 gnome.gtkdoc(versioned_libname,
     main_xml: 'libfprint-docs.xml',
-    src_dir: join_paths(meson.source_root(), 'libfprint'),
+    src_dir: join_paths(meson.project_source_root(), 'libfprint'),
     include_directories: include_directories('../libfprint'),
     dependencies: libfprint_dep,
     content_files: content_files,

examples/meson.build

@@ -21,3 +21,8 @@ executable('cpp-test',
     'cpp-test.cpp',
     dependencies: libfprint_dep,
 )
+
+if installed_tests
+    install_subdir('prints',
+        install_dir: installed_tests_testdir)
+endif

libfprint/drivers/aes4000.c

@@ -124,7 +124,7 @@ G_DEFINE_TYPE (FpiDeviceAes4000, fpi_device_aes4000, FPI_TYPE_DEVICE_AES3K);
 
 
 static const FpIdEntry id_table[] = {
-  { .pid = 0x08ff, .vid = 0x5501 },
+  { .vid = 0x08ff, .pid = 0x5501 },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };
 

libfprint/drivers/egismoc/egismoc.h

@@ -0,0 +1,223 @@
+/*
+ * Driver for Egis Technology (LighTuning) Match-On-Chip sensors
+ * Originally authored 2023 by Joshua Grisham <josh@joshuagrisham.com>
+ *
+ * Portions of code and logic inspired from the elanmoc libfprint driver
+ * which is copyright (C) 2021 Elan Microelectronics Inc (see elanmoc.c)
+ *
+ * Based on original reverse-engineering work by Joshua Grisham. The protocol has
+ * been reverse-engineered from captures of the official Windows driver, and by
+ * testing commands on the sensor with a multiplatform Python prototype driver:
+ * https://github.com/joshuagrisham/galaxy-book2-pro-linux/tree/main/fingerprint/
+ *
+ * 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 (FpiDeviceEgisMoc, fpi_device_egismoc, FPI, DEVICE_EGISMOC, FpDevice)
+
+#define EGISMOC_DRIVER_FULLNAME "Egis Technology (LighTuning) Match-on-Chip"
+
+#define EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 (1 << 0)
+#define EGISMOC_DRIVER_CHECK_PREFIX_TYPE2 (1 << 1)
+#define EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 (1 << 2)
+
+#define EGISMOC_EP_CMD_OUT (0x02 | FPI_USB_ENDPOINT_OUT)
+#define EGISMOC_EP_CMD_IN (0x81 | FPI_USB_ENDPOINT_IN)
+#define EGISMOC_EP_CMD_INTERRUPT_IN 0x83
+
+#define EGISMOC_USB_CONTROL_TIMEOUT 5000
+#define EGISMOC_USB_SEND_TIMEOUT 5000
+#define EGISMOC_USB_RECV_TIMEOUT 5000
+#define EGISMOC_USB_INTERRUPT_TIMEOUT 60000
+
+#define EGISMOC_USB_IN_RECV_LENGTH 4096
+#define EGISMOC_USB_INTERRUPT_IN_RECV_LENGTH 64
+
+#define EGISMOC_MAX_ENROLL_STAGES_DEFAULT 10
+#define EGISMOC_MAX_ENROLL_NUM 10
+#define EGISMOC_FINGERPRINT_DATA_SIZE 32
+#define EGISMOC_LIST_RESPONSE_PREFIX_SIZE 14
+#define EGISMOC_LIST_RESPONSE_SUFFIX_SIZE 2
+
+/* standard prefixes for all read/writes */
+
+static guchar egismoc_write_prefix[] = {'E', 'G', 'I', 'S', 0x00, 0x00, 0x00, 0x01};
+static gsize egismoc_write_prefix_len = sizeof (egismoc_write_prefix) / sizeof (egismoc_write_prefix[0]);
+
+static guchar egismoc_read_prefix[] = {'S', 'I', 'G', 'E', 0x00, 0x00, 0x00, 0x01};
+static gsize egismoc_read_prefix_len = sizeof (egismoc_read_prefix) / sizeof (egismoc_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_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_sensor_enroll[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x17, 0x01, 0x00};
+static gsize cmd_sensor_enroll_len = sizeof (cmd_sensor_enroll) / sizeof (cmd_sensor_enroll[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 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]);
+
+
+/* commands which exist on the device but are currently not used */
+/*
+   static guchar cmd_sensor_cancel[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x16, 0x04, 0x00};
+   static gsize cmd_sensor_cancel_len = sizeof(cmd_sensor_cancel) / sizeof(cmd_sensor_cancel[0]);
+
+   static guchar cmd_sensor_verify[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x04, 0x01, 0x00};
+   static gsize cmd_sensor_verify_len = sizeof(cmd_sensor_verify) / sizeof(cmd_sensor_verify[0]);
+
+   static guchar cmd_read_verify[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x04, 0x02, 0x00};
+   static gsize cmd_read_verify_len = sizeof(cmd_read_verify) / sizeof(cmd_read_verify[0]);
+ */
+
+
+/* prefixes/suffixes and other things for dynamically created command payloads */
+
+#define EGISMOC_CHECK_BYTES_LENGTH 2
+#define EGISMOC_IDENTIFY_RESPONSE_PRINT_ID_OFFSET 46
+#define EGISMOC_CMD_CHECK_SEPARATOR_LENGTH 32
+
+static guchar cmd_new_print_prefix[] = {0x00, 0x00, 0x00, 0x27, 0x50, 0x16, 0x03, 0x00, 0x00, 0x00, 0x20};
+static gsize cmd_new_print_prefix_len = sizeof (cmd_new_print_prefix) / sizeof (cmd_new_print_prefix[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_INIT_CONTROL1,
+  DEV_INIT_CONTROL2,
+  DEV_INIT_CONTROL3,
+  DEV_INIT_CONTROL4,
+  DEV_INIT_CONTROL5,
+  DEV_GET_FW_VERSION,
+  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_GET_ENROLLED_IDS,
+  ENROLL_CHECK_ENROLLED_NUM,
+  ENROLL_SENSOR_RESET,
+  ENROLL_SENSOR_ENROLL,
+  ENROLL_WAIT_FINGER,
+  ENROLL_SENSOR_CHECK,
+  ENROLL_CHECK,
+  ENROLL_START,
+  ENROLL_CAPTURE_SENSOR_RESET,
+  ENROLL_CAPTURE_SENSOR_START_CAPTURE,
+  ENROLL_CAPTURE_WAIT_FINGER,
+  ENROLL_CAPTURE_READ_RESPONSE,
+  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;

libfprint/drivers/elanmoc/elanmoc.c

@@ -31,6 +31,8 @@ static const FpIdEntry id_table[] = {
   { .vid = 0x04f3,  .pid = 0x0c88,  },
   { .vid = 0x04f3,  .pid = 0x0c8c,  },
   { .vid = 0x04f3,  .pid = 0x0c8d,  },
+  { .vid = 0x04f3,  .pid = 0x0c99,  },
+  { .vid = 0x04f3,  .pid = 0x0c9f,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -49,9 +51,9 @@ elanmoc_compose_cmd (
   const struct elanmoc_cmd *cmd_info
                     )
 {
-  g_autofree char *cmd_buf = NULL;
+  g_autofree uint8_t *cmd_buf = NULL;
 
-  cmd_buf = g_malloc0 (cmd_info->cmd_len);
+  cmd_buf = g_new0 (uint8_t, cmd_info->cmd_len);
   if(cmd_info->cmd_len < ELAN_MAX_HDR_LEN)
     memcpy (cmd_buf, &cmd_info->cmd_header, cmd_info->cmd_len);
   else
@@ -1086,6 +1088,10 @@ elanmoc_open (FpDevice *device)
       self->max_moc_enroll_time = 11;
       break;
 
+    case 0x0c99:
+      self->max_moc_enroll_time = 14;
+      break;
+
     case 0x0c8d:
       self->max_moc_enroll_time = 17;
       break;

libfprint/drivers/focaltech_moc/focaltech_moc.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2021 Focaltech Microelectronics
+ *
+ * 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"
+#include <libusb.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+G_DECLARE_FINAL_TYPE (FpiDeviceFocaltechMoc, fpi_device_focaltech_moc, FPI, DEVICE_FOCALTECH_MOC, FpDevice)
+
+#define FOCALTECH_MOC_DRIVER_FULLNAME "Focaltech MOC Sensors"
+
+#define FOCALTECH_MOC_CMD_TIMEOUT 1000
+#define FOCALTECH_MOC_MAX_FINGERS 10
+#define FOCALTECH_MOC_UID_PREFIX_LENGTH 8
+#define FOCALTECH_MOC_USER_ID_LENGTH 64
+
+typedef void (*FocaltechCmdMsgCallback) (FpiDeviceFocaltechMoc *self,
+                                         GError                *error);
+
+struct _FpiDeviceFocaltechMoc
+{
+  FpDevice        parent;
+  FpiSsm         *task_ssm;
+  FpiSsm         *cmd_ssm;
+  FpiUsbTransfer *cmd_transfer;
+  gboolean        cmd_cancelable;
+  gsize           cmd_len_in;
+  int             num_frames;
+  int             delete_slot;
+  guint8          bulk_in_ep;
+  guint8          bulk_out_ep;
+};

libfprint/drivers/fpcmoc/fpc.c

@@ -21,7 +21,7 @@
 
 #define FP_COMPONENT "fpcmoc"
 #define MAX_ENROLL_SAMPLES (25)
-#define CTRL_TIMEOUT (1000)
+#define CTRL_TIMEOUT (2000)
 #define DATA_TIMEOUT (5000)
 
 /* Usb port setting */
@@ -68,6 +68,8 @@ static const FpIdEntry id_table[] = {
   { .vid = 0x10A5,  .pid = 0xDA04,  },
   { .vid = 0x10A5,  .pid = 0xD805,  },
   { .vid = 0x10A5,  .pid = 0xD205,  },
+  { .vid = 0x10A5,  .pid = 0x9524,  },
+  { .vid = 0x10A5,  .pid = 0x9544,  },
   /* terminating entry */
   { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };
@@ -132,7 +134,11 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
     }
 
   ssm_state = fpi_ssm_get_cur_state (transfer->ssm);
-  fp_dbg ("%s current ssm state: %d", G_STRFUNC, ssm_state);
+  fp_dbg ("%s current ssm request: %d state: %d", G_STRFUNC, data->request, ssm_state);
+
+  /* clean cmd_ssm except capture command for suspend/resume case */
+  if (ssm_state != FP_CMD_SEND || data->request != FPC_CMD_ARM)
+    self->cmd_ssm = NULL;
 
   if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE)
     {
@@ -265,6 +271,7 @@ fpc_cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
   FpiDeviceFpcMoc *self = FPI_DEVICE_FPCMOC (dev);
   CommandData *data = fpi_ssm_get_data (ssm);
 
+  self->cmd_ssm = NULL;
   /* Notify about the SSM failure from here instead. */
   if (error)
     {
@@ -272,8 +279,6 @@ fpc_cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
       if (data->callback)
         data->callback (self, NULL, error);
     }
-
-  self->cmd_ssm = NULL;
 }
 
 static void
@@ -358,6 +363,7 @@ fpc_sensor_cmd (FpiDeviceFpcMoc *self,
       g_clear_object (&self->interrupt_cancellable);
     }
 
+  g_assert (self->cmd_ssm == NULL);
   self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                                fpc_cmd_run_state,
                                FP_CMD_NUM_STATES);
@@ -383,7 +389,7 @@ fpc_dev_release_interface (FpiDeviceFpcMoc *self,
     }
 
   /* Notify close complete */
-  fpi_device_close_complete (FP_DEVICE (self), release_error);
+  fpi_device_close_complete (FP_DEVICE (self), g_steal_pointer (&release_error));
 }
 
 static gboolean
@@ -441,10 +447,16 @@ fpc_evt_cb (FpiDeviceFpcMoc *self,
       break;
 
     case FPC_EVT_FINGER_DWN:
-      fp_dbg ("%s Got finger down event", G_STRFUNC);
+      fp_dbg ("%s Got finger down event (%d)", G_STRFUNC, presp->evt_hdr.status);
       fpi_device_report_finger_status_changes (FP_DEVICE (self),
                                                FP_FINGER_STATUS_PRESENT,
                                                FP_FINGER_STATUS_NONE);
+      if (presp->evt_hdr.status != 0)
+        {
+          /* Redo the current task state if capture failed */
+          fpi_ssm_jump_to_state (self->task_ssm, fpi_ssm_get_cur_state (self->task_ssm));
+          return;
+        }
       break;
 
     case FPC_EVT_IMG:
@@ -737,15 +749,22 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
       /* here should tips remove finger and try again */
       if (self->max_immobile_stage)
         {
-          if (self->immobile_stage >= self->max_immobile_stage)
+          self->immobile_stage++;
+          if (self->immobile_stage > self->max_immobile_stage)
             {
               fp_dbg ("Skip similar handle due to customer enrollment %d(%d)",
                       self->immobile_stage, self->max_immobile_stage);
               /* Skip too similar handle, treat as normal enroll progress. */
-              fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROL_STATUS_PROGRESS);
+              self->enroll_stage++;
+              fpi_device_enroll_progress (FP_DEVICE (self), self->enroll_stage, NULL, NULL);
+              /* Used for customer enrollment scheme */
+              if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage))
+                {
+                  fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+                  return;
+                }
               break;
             }
-          self->immobile_stage++;
         }
       fpi_device_enroll_progress (FP_DEVICE (self),
                                   self->enroll_stage,
@@ -758,7 +777,10 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
       fpi_device_enroll_progress (FP_DEVICE (self), self->enroll_stage, NULL, NULL);
       /* Used for customer enrollment scheme */
       if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage))
-        fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+        {
+          fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+          return;
+        }
       break;
 
     case FPC_ENROL_STATUS_IMAGE_LOW_COVERAGE:
@@ -1149,12 +1171,9 @@ fpc_enroll_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
 
   fp_info ("Enrollment complete!");
 
-  if (fpi_ssm_get_error (ssm))
-    error = fpi_ssm_get_error (ssm);
-
   if (error)
     {
-      fpi_device_enroll_complete (dev, NULL, error);
+      fpi_device_enroll_complete (dev, NULL, g_steal_pointer (&error));
       self->task_ssm = NULL;
       return;
     }
@@ -1336,9 +1355,6 @@ fpc_verify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
 
   fp_info ("Verify_identify complete!");
 
-  if (fpi_ssm_get_error (ssm))
-    error = fpi_ssm_get_error (ssm);
-
   if (error && error->domain == FP_DEVICE_RETRY)
     {
       if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY)
@@ -1348,9 +1364,9 @@ fpc_verify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
     }
 
   if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY)
-    fpi_device_verify_complete (dev, error);
+    fpi_device_verify_complete (dev, g_steal_pointer (&error));
   else
-    fpi_device_identify_complete (dev, error);
+    fpi_device_identify_complete (dev, g_steal_pointer (&error));
 
   self->task_ssm = NULL;
 }
@@ -1448,10 +1464,7 @@ fpc_clear_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
 
   fp_info ("Clear Storage complete!");
 
-  if (fpi_ssm_get_error (ssm))
+  fpi_device_clear_storage_complete (dev, g_steal_pointer (&error));
-    error = fpi_ssm_get_error (ssm);
-
-  fpi_device_clear_storage_complete (dev, error);
   self->task_ssm = NULL;
 }
 
@@ -1555,10 +1568,7 @@ fpc_init_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
   FpiDeviceFpcMoc *self = FPI_DEVICE_FPCMOC (dev);
 
-  if (fpi_ssm_get_error (ssm))
+  fpi_device_open_complete (dev, g_steal_pointer (&error));
-    error = fpi_ssm_get_error (ssm);
-
-  fpi_device_open_complete (dev, error);
   self->task_ssm = NULL;
 }
 
@@ -1630,6 +1640,8 @@ fpc_dev_probe (FpDevice *device)
     case 0xD805:
     case 0xDA04:
     case 0xD205:
+    case 0x9524:
+    case 0x9544:
       self->max_enroll_stage = MAX_ENROLL_SAMPLES;
       break;
 

libfprint/drivers/goodixmoc/goodix.c

@@ -631,20 +631,20 @@ fp_enroll_enum_cb (FpiDeviceGoodixMoc  *self,
       return;
     }
 
-  fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+  fpi_ssm_next_state (self->task_ssm);
 }
 
 static void
-fp_enroll_init_cb (FpiDeviceGoodixMoc  *self,
+fp_enroll_create_cb (FpiDeviceGoodixMoc  *self,
-                   gxfp_cmd_response_t *resp,
+                     gxfp_cmd_response_t *resp,
-                   GError              *error)
+                     GError              *error)
 {
   if (error)
     {
       fpi_ssm_mark_failed (self->task_ssm, error);
       return;
     }
-  memcpy (self->template_id, resp->enroll_init.tid, TEMPLATE_ID_SIZE);
+  memcpy (self->template_id, resp->enroll_create.tid, TEMPLATE_ID_SIZE);
   fpi_ssm_next_state (self->task_ssm);
 }
 
@@ -837,16 +837,6 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_ENROLL_ENUM:
-      {
-        goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
-                           false,
-                           (const guint8 *) &dummy,
-                           1,
-                           fp_enroll_enum_cb);
-      }
-      break;
-
     case FP_ENROLL_PWR_BTN_SHIELD_ON:
       {
         goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
@@ -857,13 +847,23 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
+    case FP_ENROLL_ENUM:
+      {
+        goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
+                           false,
+                           (const guint8 *) &dummy,
+                           1,
+                           fp_enroll_enum_cb);
+      }
+      break;
+
     case FP_ENROLL_CREATE:
       {
         goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT,
                            false,
                            (const guint8 *) &dummy,
                            1,
-                           fp_enroll_init_cb);
+                           fp_enroll_create_cb);
       }
       break;
 
@@ -1359,16 +1359,25 @@ gx_fp_probe (FpDevice *device)
     {
     case 0x6496:
     case 0x60A2:
+    case 0x60A4:
     case 0x6014:
+    case 0x6092:
     case 0x6094:
+    case 0x609A:
     case 0x609C:
+    case 0x60BC:
+    case 0x6304:
     case 0x631C:
+    case 0x633C:
     case 0x634C:
     case 0x6384:
     case 0x639C:
     case 0x63AC:
     case 0x63BC:
     case 0x63CC:
+    case 0x650A:
+    case 0x650C:
+    case 0x6582:
     case 0x6A94:
     case 0x659A:
       self->max_enroll_stage = 12;
@@ -1602,10 +1611,16 @@ fpi_device_goodixmoc_init (FpiDeviceGoodixMoc *self)
 static const FpIdEntry id_table[] = {
   { .vid = 0x27c6,  .pid = 0x5840,  },
   { .vid = 0x27c6,  .pid = 0x6014,  },
+  { .vid = 0x27c6,  .pid = 0x6092,  },
   { .vid = 0x27c6,  .pid = 0x6094,  },
+  { .vid = 0x27c6,  .pid = 0x609A,  },
   { .vid = 0x27c6,  .pid = 0x609C,  },
   { .vid = 0x27c6,  .pid = 0x60A2,  },
+  { .vid = 0x27c6,  .pid = 0x60A4,  },
+  { .vid = 0x27c6,  .pid = 0x60BC,  },
+  { .vid = 0x27c6,  .pid = 0x6304,  },
   { .vid = 0x27c6,  .pid = 0x631C,  },
+  { .vid = 0x27c6,  .pid = 0x633C,  },
   { .vid = 0x27c6,  .pid = 0x634C,  },
   { .vid = 0x27c6,  .pid = 0x6384,  },
   { .vid = 0x27c6,  .pid = 0x639C,  },
@@ -1613,6 +1628,9 @@ static const FpIdEntry id_table[] = {
   { .vid = 0x27c6,  .pid = 0x63BC,  },
   { .vid = 0x27c6,  .pid = 0x63CC,  },
   { .vid = 0x27c6,  .pid = 0x6496,  },
+  { .vid = 0x27c6,  .pid = 0x650A,  },
+  { .vid = 0x27c6,  .pid = 0x650C,  },
+  { .vid = 0x27c6,  .pid = 0x6582,  },
   { .vid = 0x27c6,  .pid = 0x6584,  },
   { .vid = 0x27c6,  .pid = 0x658C,  },
   { .vid = 0x27c6,  .pid = 0x6592,  },
@@ -1620,6 +1638,7 @@ static const FpIdEntry id_table[] = {
   { .vid = 0x27c6,  .pid = 0x659A,  },
   { .vid = 0x27c6,  .pid = 0x659C,  },
   { .vid = 0x27c6,  .pid = 0x6A94,  },
+  { .vid = 0x27c6,  .pid = 0x6512,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 

libfprint/drivers/goodixmoc/goodix.h

@@ -44,7 +44,6 @@ typedef enum {
 typedef enum {
   FP_ENROLL_PWR_BTN_SHIELD_ON = 0,
   FP_ENROLL_ENUM,
-  FP_ENROLL_IDENTIFY,
   FP_ENROLL_CREATE,
   FP_ENROLL_CAPTURE,
   FP_ENROLL_UPDATE,

libfprint/drivers/goodixmoc/goodix_proto.c

@@ -343,10 +343,10 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
       break;
 
     case MOC_CMD0_ENROLL_INIT:
-      if (buffer_len < sizeof (gxfp_enroll_init_t) + 1)
+      if (buffer_len < sizeof (gxfp_enroll_create_t) + 1)
         return -1;
       if (presp->result == GX_SUCCESS)
-        memcpy (&presp->enroll_init.tid, &buffer[1], TEMPLATE_ID_SIZE);
+        memcpy (&presp->enroll_create.tid, &buffer[1], TEMPLATE_ID_SIZE);
       break;
 
     case MOC_CMD0_ENROLL:
@@ -465,4 +465,4 @@ gx_proto_init_sensor_config (pgxfp_sensor_cfg_t pconfig)
   memcpy (pconfig->crc_value, &crc32_calc, PACKAGE_CRC_SIZE);
 
   return 0;
-}
+}

libfprint/drivers/goodixmoc/goodix_proto.h

@@ -105,10 +105,10 @@ typedef struct _gxfp_parse_msg
 } gxfp_parse_msg_t, *pgxfp_parse_msg_t;
 
 
-typedef struct _gxfp_enroll_init
+typedef struct _gxfp_enroll_create
 {
   uint8_t tid[TEMPLATE_ID_SIZE];
-} gxfp_enroll_init_t, *pgxfp_enroll_init_t;
+} gxfp_enroll_create_t, *pgxfp_enroll_create_t;
 
 #pragma pack(push, 1)
 typedef struct _template_format
@@ -192,7 +192,7 @@ typedef struct _fp_cmd_response
   {
     gxfp_parse_msg_t       parse_msg;
     gxfp_verify_t          verify;
-    gxfp_enroll_init_t     enroll_init;
+    gxfp_enroll_create_t   enroll_create;
     gxfp_capturedata_t     capture_data_resp;
     gxfp_check_duplicate_t check_duplicate_resp;
     gxfp_enroll_commit_t   enroll_commit;

libfprint/drivers/realtek/realtek.h

@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2022-2023 Realtek Corp.
+ *
+ * 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"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#define EP_IN (2 | FPI_USB_ENDPOINT_IN)
+#define EP_OUT (1 | FPI_USB_ENDPOINT_OUT)
+
+#define EP_IN_MAX_BUF_SIZE 2048
+
+#define FP_RTK_CMD_BULK_TOTAL_LEN 12
+#define FP_RTK_CMD_BULK_LEN 2
+#define FP_RTK_CMD_BULK_PARAM_LEN 4
+#define FP_RTK_CMD_BULK_ADDR_LEN 4
+#define FP_RTK_CMD_BULK_DATA_LEN 2
+
+#define TEMPLATE_LEN_COMMON 35
+
+#define SUBFACTOR_OFFSET 2
+#define UID_OFFSET 3
+#define UID_PAYLOAD_LEN_DEFAULT 32
+
+/* Command transfer timeout :ms*/
+#define CMD_TIMEOUT 1000
+#define DATA_TIMEOUT 5000
+#define STATUS_TIMEOUT 2000
+
+#define MAX_ENROLL_SAMPLES 8
+#define DEFAULT_UID_LEN 28
+#define SUB_FINGER_01 0xFF
+
+#define GET_BULK_CMD_TYPE(val)              ((val & 0xC0) >> 6)
+#define GET_TRANS_DATA_LEN(len_h, len_l)    ((len_h << 8) | len_l)
+#define GET_LEN_L(total_data_len)           ((total_data_len) & 0xff)
+#define GET_LEN_H(total_data_len)           ((total_data_len) >> 8)
+
+G_DECLARE_FINAL_TYPE (FpiDeviceRealtek, fpi_device_realtek, FPI, DEVICE_REALTEK, FpDevice)
+
+typedef void (*SynCmdMsgCallback) (FpiDeviceRealtek *self,
+                                   uint8_t          *buffer_in,
+                                   GError           *error);
+
+typedef struct
+{
+  SynCmdMsgCallback callback;
+} CommandData;
+
+typedef enum {
+  FP_RTK_CMD_BULK_ONLY = 0,
+  FP_RTK_CMD_BULK_READ,
+  FP_RTK_CMD_BULK_WRITE,
+} FpRtkCmdType;
+
+typedef enum {
+  FP_RTK_MSG_DEFAULT = 0,
+  FP_RTK_MSG_NO_STATUS,
+} FpRtkMsgType;
+
+typedef enum {
+  FP_RTK_PURPOSE_VERIFY   = 0x01,
+  FP_RTK_PURPOSE_IDENTIFY = 0x02,
+  FP_RTK_PURPOSE_ENROLL   = 0x04,
+} FpRtkPurpose;
+
+typedef enum {
+  FP_RTK_SUCCESS = 0x0,
+  FP_RTK_TOO_HIGH,
+  FP_RTK_TOO_LOW,
+  FP_RTK_TOO_LEFT,
+  FP_RTK_TOO_RIGHT,
+  FP_RTK_TOO_FAST,
+  FP_RTK_TOO_SLOW,
+  FP_RTK_POOR_QUALITY,
+  FP_RTK_TOO_SKEWED,
+  FP_RTK_TOO_SHORT,
+  FP_RTK_MERGE_FAILURE,
+  FP_RTK_MATCH_FAIL,
+  FP_RTK_CMD_ERR,
+} FpRtkInStatus;
+
+typedef enum {
+  FP_RTK_ENROLL_GET_TEMPLATE = 0,
+  FP_RTK_ENROLL_BEGIN_POS,
+  FP_RTK_ENROLL_CAPTURE,
+  FP_RTK_ENROLL_FINISH_CAPTURE,
+  FP_RTK_ENROLL_ACCEPT_SAMPLE,
+  FP_RTK_ENROLL_CHECK_DUPLICATE,
+  FP_RTK_ENROLL_COMMIT,
+  FP_RTK_ENROLL_CANCEL_CAPTURE,
+  FP_RTK_ENROLL_NUM_STATES,
+} FpRtkEnrollState;
+
+typedef enum {
+  FP_RTK_VERIFY_GET_TEMPLATE = 0,
+  FP_RTK_VERIFY_CAPTURE,
+  FP_RTK_VERIFY_FINISH_CAPTURE,
+  FP_RTK_VERIFY_ACCEPT_SAMPLE,
+  FP_RTK_VERIFY_INDENTIFY_FEATURE,
+  FP_RTK_VERIFY_UPDATE_TEMPLATE,
+  FP_RTK_VERIFY_CANCEL_CAPTURE,
+  FP_RTK_VERIFY_NUM_STATES,
+} FpRtkVerifyState;
+
+typedef enum {
+  FP_RTK_DELETE_GET_POS = 0,
+  FP_RTK_DELETE_PRINT,
+  FP_RTK_DELETE_NUM_STATES,
+} FpRtkDeleteState;
+
+typedef enum {
+  FP_RTK_INIT_GET_DEVICE_INFO = 0,
+  FP_RTK_INIT_SELECT_OS,
+  FP_RTK_INIT_GET_ENROLL_NUM,
+  FP_RTK_INIT_NUM_STATES,
+} FpRtkInitState;
+
+typedef enum {
+  FP_RTK_CMD_SEND = 0,
+  FP_RTK_CMD_TRANS_DATA,
+  FP_RTK_CMD_GET_STATUS,
+  FP_RTK_CMD_NUM_STATES,
+} FpRtkCmdState;
+
+struct _FpiDeviceRealtek
+{
+  FpDevice        parent;
+  FpiSsm         *task_ssm;
+  FpiSsm         *cmd_ssm;
+  FpiUsbTransfer *cmd_transfer;
+  FpiUsbTransfer *data_transfer;
+  gint            cmd_type;
+  FpRtkMsgType    message_type;
+  gboolean        cmd_cancellable;
+  gint            enroll_stage;
+  gint            max_enroll_stage;
+  guchar         *read_data;
+  gsize           trans_data_len;
+  FpRtkPurpose    fp_purpose;
+  gint            pos_index;
+  gint            template_num;
+  gint            template_len;
+};
+
+struct rtk_cmd_bulk
+{
+  uint8_t cmd[FP_RTK_CMD_BULK_LEN];
+  uint8_t param[FP_RTK_CMD_BULK_PARAM_LEN];
+  uint8_t addr[FP_RTK_CMD_BULK_ADDR_LEN];
+  uint8_t data_len[FP_RTK_CMD_BULK_DATA_LEN];
+};
+
+struct rtk_cmd_ctrl
+{
+  int      direction;
+  uint8_t  request;
+  uint16_t value;
+  uint16_t index;
+  uint16_t len;
+};
+
+static struct rtk_cmd_ctrl get_device_info = {
+  .direction = G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
+  .request = 0x07,
+  .value = 0x000D,
+  .index = 0x0000,
+  .len = 0x0008,
+};
+
+static struct rtk_cmd_bulk co_start_capture = {
+  .cmd = {0x05, 0x05},
+};
+
+static struct rtk_cmd_bulk co_finish_capture = {
+  .cmd = {0x45, 0x06},
+  .data_len = {0x05},
+};
+
+static struct rtk_cmd_bulk co_accept_sample = {
+  .cmd = {0x45, 0x08},
+  .data_len = {0x09},
+};
+
+static struct rtk_cmd_bulk nor_identify_feature = {
+  .cmd = {0x45, 0x22},
+  .data_len = {0x2A},
+};
+
+static struct rtk_cmd_bulk co_get_enroll_num = {
+  .cmd = {0x45, 0x0d},
+  .data_len = {0x02},
+};
+
+static struct rtk_cmd_bulk co_get_template = {
+  .cmd = {0x45, 0x0E},
+};
+
+static struct rtk_cmd_bulk nor_enroll_begin = {
+  .cmd = {0x05, 0x20},
+};
+
+static struct rtk_cmd_bulk co_check_duplicate = {
+  .cmd = {0x45, 0x10},
+  .data_len = {0x22},
+};
+
+static struct rtk_cmd_bulk nor_enroll_commit = {
+  .cmd = {0x85, 0x21},
+};
+
+static struct rtk_cmd_bulk co_update_template = {
+  .cmd = {0x05, 0x11},
+};
+
+static struct rtk_cmd_bulk co_delete_record = {
+  .cmd = {0x05, 0x0F},
+};
+
+static struct rtk_cmd_bulk co_select_system = {
+  .cmd = {0x05, 0x13},
+};
+
+static struct rtk_cmd_bulk co_cancel_capture = {
+  .cmd = {0x05, 0x07},
+};

libfprint/drivers/synaptics/synaptics.c

@@ -36,15 +36,21 @@ static const FpIdEntry id_table[] = {
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C2,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C4,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0103,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0123,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0124,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0126,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0129,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0168,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x015F,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0104,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0173,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0106,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019D,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C6,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -106,7 +112,11 @@ cmd_receive_cb (FpiUsbTransfer *transfer,
 
           if (self->cmd_complete_on_removal)
             {
-              fpi_ssm_mark_completed (transfer->ssm);
+              if (self->delay_error)
+                fpi_ssm_mark_failed (transfer->ssm,
+                                     g_steal_pointer (&self->delay_error));
+              else
+                fpi_ssm_mark_completed (transfer->ssm);
               return;
             }
         }
@@ -641,18 +651,21 @@ verify (FpDevice *device)
 }
 
 static void
-identify_complete_after_finger_removal (FpiDeviceSynaptics *self)
+identify_complete_after_finger_removal (FpiDeviceSynaptics *self, GError *error)
 {
   FpDevice *device = FP_DEVICE (self);
 
   if (self->finger_on_sensor)
     {
       fp_dbg ("delaying identify report until after finger removal!");
+      if (error)
+        g_propagate_error (&self->delay_error, error);
+
       self->cmd_complete_on_removal = TRUE;
     }
   else
     {
-      fpi_device_identify_complete (device, NULL);
+      fpi_device_identify_complete (device, error);
     }
 }
 
@@ -702,19 +715,18 @@ identify_msg_cb (FpiDeviceSynaptics *self,
           fp_info ("Match error occurred");
           fpi_device_identify_report (device, NULL, NULL,
                                       fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
-          identify_complete_after_finger_removal (self);
+          identify_complete_after_finger_removal (self, NULL);
         }
       else if (resp->result == BMKT_FP_NO_MATCH)
         {
           fp_info ("Print didn't match");
           fpi_device_identify_report (device, NULL, NULL, NULL);
-          identify_complete_after_finger_removal (self);
+          identify_complete_after_finger_removal (self, NULL);
         }
-      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS)
+      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS || resp->result == BMKT_FP_DATABASE_EMPTY)
         {
           fp_info ("Print is not in database");
-          fpi_device_identify_complete (device,
+          identify_complete_after_finger_removal (self, fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
-                                        fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
         }
       else
         {
@@ -750,7 +762,7 @@ identify_msg_cb (FpiDeviceSynaptics *self,
         else
           fpi_device_identify_report (device, NULL, print, NULL);
 
-        identify_complete_after_finger_removal (self);
+        identify_complete_after_finger_removal (self, NULL);
       }
     }
 }

libfprint/drivers/synaptics/synaptics.h

@@ -127,4 +127,5 @@ struct _FpiDeviceSynaptics
 
   struct syna_enroll_resp_data enroll_resp_data;
   syna_state_t                 state;
+  GError                      *delay_error;
 };

libfprint/drivers/upeksonly.c

@@ -74,26 +74,26 @@ struct _FpiDeviceUpeksonly
   FpiSsm       *loopsm;
 
   /* Do we really need multiple concurrent transfers? */
-  GCancellable                    *img_cancellable;
+  GCancellable  *img_cancellable;
-  GPtrArray                       *img_transfers;
+  GPtrArray     *img_transfers;
-  int                              num_flying;
+  int            num_flying;
 
-  GSList                          *rows;
+  GSList        *rows;
-  unsigned                         num_rows;
+  unsigned       num_rows;
-  unsigned char                   *rowbuf;
+  unsigned char *rowbuf;
-  int                              rowbuf_offset;
+  int            rowbuf_offset;
 
-  int                              wraparounds;
+  int            wraparounds;
-  int                              num_blank;
+  int            num_blank;
-  int                              num_nonblank;
+  int            num_nonblank;
-  enum sonly_fs                    finger_state;
+  enum sonly_fs finger_state;
-  int                              last_seqnum;
+  int            last_seqnum;
 
   enum sonly_kill_transfers_action killing_transfers;
-  GError                          *kill_error;
+  GError                   *kill_error;
-  FpiSsm                          *kill_ssm;
+  FpiSsm                   *kill_ssm;
 
-  struct fpi_line_asmbl_ctx        assembling_ctx;
+  struct fpi_line_asmbl_ctx assembling_ctx;
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceUpeksonly, fpi_device_upeksonly, FPI,
                       DEVICE_UPEKSONLY, FpImageDevice);

libfprint/drivers/upektc_img.c

@@ -31,10 +31,6 @@ static void start_deactivation (FpImageDevice *dev);
 #define CTRL_TIMEOUT 4000
 #define BULK_TIMEOUT 4000
 
-#define IMAGE_WIDTH 144
-#define IMAGE_HEIGHT 384
-#define IMAGE_SIZE (IMAGE_WIDTH * IMAGE_HEIGHT)
-
 #define MAX_CMD_SIZE 64
 #define MAX_RESPONSE_SIZE 2052
 #define SHORT_RESPONSE_SIZE 64
@@ -47,8 +43,10 @@ struct _FpiDeviceUpektcImg
   unsigned char  response[MAX_RESPONSE_SIZE];
   unsigned char *image_bits;
   unsigned char  seq;
+  size_t         expected_image_size;
   size_t         image_size;
   size_t         response_rest;
+  gboolean       area_sensor;
   gboolean       deactivating;
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceUpektcImg, fpi_device_upektc_img, FPI,
@@ -180,6 +178,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                       gpointer user_data, GError *error)
 {
   FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_GET_CLASS (dev);
   FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
   unsigned char *data = self->response;
   FpImage *img;
@@ -247,8 +246,30 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                                      CAPTURE_ACK_00_28);
               break;
 
+            case 0x13:
+              /* finger is present keep your finger on reader */
+              fpi_device_report_finger_status_changes (device,
+                                                       FP_FINGER_STATUS_NEEDED,
+                                                       FP_FINGER_STATUS_NONE);
+              fpi_ssm_jump_to_state (transfer->ssm,
+                                     self->area_sensor ?
+                                     CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM);
+              break;
+
             case 0x00:
               /* finger is present! */
+              fpi_device_report_finger_status_changes (device,
+                                                       FP_FINGER_STATUS_PRESENT,
+                                                       FP_FINGER_STATUS_NONE);
+              fpi_ssm_jump_to_state (transfer->ssm,
+                                     CAPTURE_ACK_00_28);
+              break;
+
+            case 0x01:
+              /* no finger! */
+              fpi_device_report_finger_status_changes (device,
+                                                       FP_FINGER_STATUS_NONE,
+                                                       FP_FINGER_STATUS_PRESENT);
               fpi_ssm_jump_to_state (transfer->ssm,
                                      CAPTURE_ACK_00_28);
               break;
@@ -261,18 +282,20 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
               fpi_image_device_report_finger_status (dev,
                                                      FALSE);
               fpi_ssm_jump_to_state (transfer->ssm,
-                                     CAPTURE_ACK_00_28_TERM);
+                                     self->area_sensor ?
+                                     CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM);
               break;
 
             case 0x1d:
-              /* too much horisontal movement */
+              /* too much horizontal movement */
-              fp_err ("too much horisontal movement, aborting");
+              fp_err ("too much horizontal movement, aborting");
               fpi_image_device_retry_scan (dev,
                                            FP_DEVICE_RETRY_CENTER_FINGER);
               fpi_image_device_report_finger_status (dev,
                                                      FALSE);
               fpi_ssm_jump_to_state (transfer->ssm,
-                                     CAPTURE_ACK_00_28_TERM);
+                                     self->area_sensor ?
+                                     CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM);
               break;
 
             default:
@@ -283,7 +306,8 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
               fpi_image_device_report_finger_status (dev,
                                                      FALSE);
               fpi_ssm_jump_to_state (transfer->ssm,
-                                     CAPTURE_ACK_00_28_TERM);
+                                     self->area_sensor ?
+                                     CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM);
               break;
             }
           break;
@@ -307,13 +331,13 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
           self->image_size +=
             upektc_img_process_image_frame (self->image_bits + self->image_size,
                                             data);
-          BUG_ON (self->image_size != IMAGE_SIZE);
+          BUG_ON (self->image_size != self->expected_image_size);
           fp_dbg ("Image size is %lu",
                   (gulong) self->image_size);
-          img = fp_image_new (IMAGE_WIDTH, IMAGE_HEIGHT);
+          img = fp_image_new (img_class->img_width, img_class->img_height);
           img->flags |= FPI_IMAGE_PARTIAL;
           memcpy (img->data, self->image_bits,
-                  IMAGE_SIZE);
+                  self->image_size);
           fpi_image_device_image_captured (dev, img);
           fpi_image_device_report_finger_status (dev,
                                                  FALSE);
@@ -346,8 +370,12 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev)
   switch (fpi_ssm_get_cur_state (ssm))
     {
     case CAPTURE_INIT_CAPTURE:
-      upektc_img_submit_req (ssm, dev, upek2020_init_capture, sizeof (upek2020_init_capture),
+      if (self->area_sensor)
-                             self->seq, capture_reqs_cb);
+        upektc_img_submit_req (ssm, dev, upek2020_init_capture_press, sizeof (upek2020_init_capture_press),
+                               self->seq, capture_reqs_cb);
+      else
+        upektc_img_submit_req (ssm, dev, upek2020_init_capture, sizeof (upek2020_init_capture),
+                               self->seq, capture_reqs_cb);
       self->seq++;
       break;
 
@@ -513,15 +541,81 @@ init_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device,
     fpi_ssm_mark_failed (transfer->ssm, error);
 }
 
-/* TODO: process response properly */
 static void
 init_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                    gpointer user_data, GError *error)
 {
-  if (!error)
+  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
-    fpi_ssm_next_state (transfer->ssm);
+  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
-  else
+  unsigned char *data = self->response;
-    fpi_ssm_mark_failed (transfer->ssm, error);
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+
+  if (data[12] == 0x06 && data[13] == 0x14)  /* if get_info */
+    {
+      FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_GET_CLASS (dev);
+      uint16_t width = (data[51] << 8) | data[50];
+      uint16_t height = (data[53] << 8) | data[52];
+
+      self->area_sensor = !(data[49] & 0x80);
+
+      switch (width)
+        {
+        case 256:
+          fp_dbg ("Sensor type : TCS1x, width x height: %hu x %hu", width, height); /* 360x256 --- 270x192 must be set */
+          BUG_ON (height != 360);
+          img_class->img_width = 192;
+          img_class->img_height = 270;
+          break;
+
+        case 208:
+          fp_dbg ("Sensor type : TCS2, width x height: %hu x %hu", width, height); /* 288x208 --- 216x156 must be set */
+          BUG_ON (height != 288);
+          img_class->img_width = 156;
+          img_class->img_height = 216;
+          break;
+
+        case 248:
+          fp_dbg ("Sensor type : TCS3, width x height: %hu x %hu", width, height); /* 360x248 --- 270x186 must be set */
+          BUG_ON (height != 360);
+          img_class->img_width = 186;
+          img_class->img_height = 270;
+          break;
+
+        case 192:
+          fp_dbg ("Sensor type : TCS4x, width x height: %hu x %hu", width, height); /* 512x192 --- 384x144 must be set */
+          BUG_ON (height != 512);
+          img_class->img_width = 144;
+          img_class->img_height = 384;
+          break;
+
+        case 144:
+          fp_dbg ("Sensor type : TCS5x, width x height: %hu x %hu", width, height); /* 512x144 --- 384x108 must be set */
+          BUG_ON (height != 512);
+          img_class->img_width = 108;
+          img_class->img_height = 384;
+          break;
+
+        default:
+          fp_dbg ("Sensor type : Unknown");
+
+          fpi_ssm_mark_failed (transfer->ssm,
+                               fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                         "Unknown sensor type (reported size %dx%d)",
+                                                         width, height));
+
+          return;
+        }
+
+      self->expected_image_size = img_class->img_width * img_class->img_height;
+      self->image_bits = g_malloc0 (self->expected_image_size * 2);
+    }
+
+  fpi_ssm_next_state (transfer->ssm);
 }
 
 static void
@@ -616,7 +710,6 @@ dev_deactivate (FpImageDevice *dev)
 static void
 dev_init (FpImageDevice *dev)
 {
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
   GError *error = NULL;
 
   /* TODO check that device has endpoints we're using */
@@ -627,7 +720,6 @@ dev_init (FpImageDevice *dev)
       return;
     }
 
-  self->image_bits = g_malloc0 (IMAGE_SIZE * 2);
   fpi_image_device_open_complete (dev, NULL);
 }
 
@@ -687,6 +779,6 @@ fpi_device_upektc_img_class_init (FpiDeviceUpektcImgClass *klass)
 
   img_class->bz3_threshold = 20;
 
-  img_class->img_width = IMAGE_WIDTH;
+  img_class->img_width = -1;
-  img_class->img_height = IMAGE_HEIGHT;
+  img_class->img_height = -1;
 }

libfprint/drivers/upektc_img.h

@@ -75,6 +75,22 @@ static const unsigned char upek2020_init_capture[] = {
   0x02,
   0x00, /* Wait for acceptable finger */
   0x02,
+  0x25, 0xa9 /* CRC */
+};
+
+static const unsigned char upek2020_init_capture_press[] = {
+  'C', 'i', 'a', 'o',
+  0x00,
+  0x00, 0x0e, /* Seq = 7, len = 0x00e */
+  0x28, /* CMD = 0x28 */
+  0x0b, 0x00, /* Inner len = 0x000b */
+  0x00, 0x00,
+  0x0e, /* SUBCMD = 0x0e */
+  0x02,
+  0xfe, 0xff, 0xff, 0xff, /* timeout = -2 = 0xfffffffe = infinite time */
+  0x02,
+  0x01, /* Wait for finger */
+  0x02,
   0x14, 0x9a /* CRC */
 };
 

libfprint/drivers/vfs101.c

@@ -162,9 +162,9 @@ enum {
 
 /* Dump buffer for debug */
 #define dump_buffer(buf) \
-  fp_dbg ("%02x %02x %02x %02x %02x %02x %02x %02x", \
+        fp_dbg ("%02x %02x %02x %02x %02x %02x %02x %02x", \
-          buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13] \
+                buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13] \
-         )
+               )
 
 /* Callback of asynchronous send */
 static void

libfprint/drivers/vfs301_proto.c

@@ -157,7 +157,7 @@ vfs301_proto_generate_0B (int subtype, gssize *len)
 }
 
 #define HEX_TO_INT(c) \
-  (((c) >= '0' && (c) <= '9') ? ((c) - '0') : ((c) - 'A' + 10))
+        (((c) >= '0' && (c) <= '9') ? ((c) - '0') : ((c) - 'A' + 10))
 
 static guint8 *
 translate_str (const char **srcL, gssize *len)
@@ -422,15 +422,15 @@ img_process_data (int first_block, FpDeviceVfs301 *dev, const guint8 *buf, int l
 /************************** PROTOCOL STUFF ************************************/
 
 #define USB_RECV(from, len) \
-  usb_recv (dev, from, len, NULL, NULL)
+        usb_recv (dev, from, len, NULL, NULL)
 
 #define USB_SEND(type, subtype) \
-  { \
+        { \
-    const guint8 *data; \
+          const guint8 *data; \
-    gssize len; \
+          gssize len; \
-    data = vfs301_proto_generate (type, subtype, &len); \
+          data = vfs301_proto_generate (type, subtype, &len); \
-    usb_send (dev, data, len, NULL); \
+          usb_send (dev, data, len, NULL); \
-  }
+        }
 
 #define RAW_DATA(x) g_memdup2 (x, sizeof (x)), sizeof (x)
 
@@ -489,13 +489,13 @@ vfs301_proto_peek_event (FpDeviceVfs301 *dev)
  *      we will run into timeouts randomly and need to then try again.
  */
 #define PARALLEL_RECEIVE(e1, l1, e2, l2) \
-  { \
+        { \
-    g_autoptr(GError) error = NULL; \
+          g_autoptr(GError) error = NULL; \
-    usb_recv (dev, e1, l1, NULL, &error); \
+          usb_recv (dev, e1, l1, NULL, &error); \
-    usb_recv (dev, e2, l2, NULL, NULL); \
+          usb_recv (dev, e2, l2, NULL, NULL); \
-    if (g_error_matches (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_TIMED_OUT)) \
+          if (g_error_matches (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_TIMED_OUT)) \
-    usb_recv (dev, e1, l1, NULL, NULL); \
+          usb_recv (dev, e1, l1, NULL, NULL); \
-  }
+        }
 
 static void
 vfs301_proto_process_event_cb (FpiUsbTransfer *transfer,

libfprint/drivers/vfs5011.c

@@ -41,30 +41,30 @@ struct usb_action
 };
 
 #define SEND(ENDPOINT, COMMAND) \
-  { \
+        { \
-    .type = ACTION_SEND, \
+          .type = ACTION_SEND, \
-    .endpoint = ENDPOINT, \
+          .endpoint = ENDPOINT, \
-    .name = #COMMAND, \
+          .name = #COMMAND, \
-    .size = sizeof (COMMAND), \
+          .size = sizeof (COMMAND), \
-    .data = COMMAND \
+          .data = COMMAND \
-  },
+        },
 
 #define RECV(ENDPOINT, SIZE) \
-  { \
+        { \
-    .type = ACTION_RECEIVE, \
+          .type = ACTION_RECEIVE, \
-    .endpoint = ENDPOINT, \
+          .endpoint = ENDPOINT, \
-    .size = SIZE, \
+          .size = SIZE, \
-    .data = NULL \
+          .data = NULL \
-  },
+        },
 
 #define RECV_CHECK(ENDPOINT, SIZE, EXPECTED) \
-  { \
+        { \
-    .type = ACTION_RECEIVE, \
+          .type = ACTION_RECEIVE, \
-    .endpoint = ENDPOINT, \
+          .endpoint = ENDPOINT, \
-    .size = SIZE, \
+          .size = SIZE, \
-    .data = EXPECTED, \
+          .data = EXPECTED, \
-    .correct_reply_size = sizeof (EXPECTED) \
+          .correct_reply_size = sizeof (EXPECTED) \
-  },
+        },
 
 struct usbexchange_data
 {

libfprint/drivers/vfs7552.c

@@ -51,39 +51,39 @@ struct usb_action
 };
 
 #define SEND(ENDPOINT, COMMAND) \
-  {                             \
+        {                             \
-    .type = ACTION_SEND,        \
+          .type = ACTION_SEND,        \
-    .endpoint = ENDPOINT,       \
+          .endpoint = ENDPOINT,       \
-    .name = #COMMAND,           \
+          .name = #COMMAND,           \
-    .size = sizeof (COMMAND),   \
+          .size = sizeof (COMMAND),   \
-    .data = COMMAND             \
+          .data = COMMAND             \
-  },
+        },
 
 #define RECV(ENDPOINT, SIZE)  \
-  {                           \
+        {                           \
-    .type = ACTION_RECEIVE,   \
+          .type = ACTION_RECEIVE,   \
-    .endpoint = ENDPOINT,     \
+          .endpoint = ENDPOINT,     \
-    .size = SIZE,             \
+          .size = SIZE,             \
-    .data = NULL              \
+          .data = NULL              \
-  },
+        },
 
 #define RECV_CHECK(ENDPOINT, SIZE, EXPECTED) \
-  {                                          \
+        {                                          \
-    .type = ACTION_RECEIVE,                  \
+          .type = ACTION_RECEIVE,                  \
-    .endpoint = ENDPOINT,                    \
+          .endpoint = ENDPOINT,                    \
-    .size = SIZE,                            \
+          .size = SIZE,                            \
-    .data = EXPECTED,                        \
+          .data = EXPECTED,                        \
-    .correct_reply_size = sizeof (EXPECTED)  \
+          .correct_reply_size = sizeof (EXPECTED)  \
-  },
+        },
 
 #define RECV_CHECK_SIZE(ENDPOINT, SIZE, EXPECTED) \
-  {                                               \
+        {                                               \
-    .type = ACTION_RECEIVE,                       \
+          .type = ACTION_RECEIVE,                       \
-    .endpoint = ENDPOINT,                         \
+          .endpoint = ENDPOINT,                         \
-    .size = SIZE,                                 \
+          .size = SIZE,                                 \
-    .data = NULL,                                 \
+          .data = NULL,                                 \
-    .correct_reply_size = sizeof (EXPECTED)       \
+          .correct_reply_size = sizeof (EXPECTED)       \
-  },
+        },
 
 struct usbexchange_data
 {

libfprint/drivers/virtual-device-listener.c

@@ -273,7 +273,8 @@ on_stream_read_cb (GObject      *source_object,
         }
       else
         {
-          // g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Got empty data");
+          g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
+                                   "Got empty data");
           return;
         }
     }

libfprint/drivers/virtual-device.c

@@ -733,7 +733,13 @@ dev_deinit (FpDevice *dev)
     }
 
   if (!self->keep_alive)
-    stop_listener (self);
+    {
+      stop_listener (self);
+      self->supports_cancellation = TRUE;
+    }
+
+  self->enroll_stages_passed = 0;
+  self->match_reported = FALSE;
 
   fpi_device_close_complete (dev, NULL);
 }

libfprint/fp-context.c

@@ -67,32 +67,26 @@ enum {
 static guint signals[LAST_SIGNAL] = { 0 };
 
 static const char *
-get_drivers_whitelist_env (void)
+get_drivers_allowlist_env (void)
 {
-  return g_getenv ("FP_DRIVERS_WHITELIST");
+  return g_getenv ("FP_DRIVERS_ALLOWLIST");
 }
 
 static gboolean
 is_driver_allowed (const gchar *driver)
 {
-  g_auto(GStrv) whitelisted_drivers = NULL;
+  g_auto(GStrv) allowlisted_drivers = NULL;
-  const char *fp_drivers_whitelist_env;
+  const char *fp_drivers_allowlist_env;
-  int i;
 
   g_return_val_if_fail (driver, TRUE);
 
-  fp_drivers_whitelist_env = get_drivers_whitelist_env ();
+  fp_drivers_allowlist_env = get_drivers_allowlist_env ();
 
-  if (!fp_drivers_whitelist_env)
+  if (!fp_drivers_allowlist_env)
     return TRUE;
 
-  whitelisted_drivers = g_strsplit (fp_drivers_whitelist_env, ":", -1);
+  allowlisted_drivers = g_strsplit (fp_drivers_allowlist_env, ":", -1);
-
+  return g_strv_contains ((const gchar * const *) allowlisted_drivers, driver);
-  for (i = 0; whitelisted_drivers[i]; ++i)
-    if (g_strcmp0 (driver, whitelisted_drivers[i]) == 0)
-      return TRUE;
-
-  return FALSE;
 }
 
 typedef struct
@@ -364,7 +358,7 @@ fp_context_init (FpContext *self)
 
   priv->drivers = fpi_get_driver_types ();
 
-  if (get_drivers_whitelist_env ())
+  if (get_drivers_allowlist_env ())
     {
       for (i = 0; i < priv->drivers->len;)
         {

libfprint/fp-device-private.h

@@ -44,7 +44,7 @@ typedef struct
   FpDeviceType type;
 
   GUsbDevice  *usb_device;
-  const gchar *virtual_env;
+  gchar       *virtual_env;
   struct
   {
     gchar *spidev_path;
@@ -111,8 +111,6 @@ typedef struct
   GDestroyNotify   enroll_progress_destroy;
 } FpEnrollData;
 
-void enroll_data_free (FpEnrollData *enroll_data);
-
 typedef struct
 {
   FpPrint       *enrolled_print;   /* verify */
@@ -128,7 +126,6 @@ typedef struct
   GDestroyNotify match_destroy;
 } FpMatchData;
 
-void match_data_free (FpMatchData *match_data);
 
 void fpi_device_suspend (FpDevice *device);
 void fpi_device_resume (FpDevice *device);

libfprint/fp-device.c

@@ -292,14 +292,14 @@ fp_device_get_property (GObject    *object,
 
     case PROP_FPI_UDEV_DATA_SPIDEV:
       if (cls->type == FP_DEVICE_TYPE_UDEV)
-        g_value_set_string (value, g_strdup (priv->udev_data.spidev_path));
+        g_value_set_string (value, priv->udev_data.spidev_path);
       else
         g_value_set_string (value, NULL);
       break;
 
     case PROP_FPI_UDEV_DATA_HIDRAW:
       if (cls->type == FP_DEVICE_TYPE_UDEV)
-        g_value_set_string (value, g_strdup (priv->udev_data.hidraw_path));
+        g_value_set_string (value, priv->udev_data.hidraw_path);
       else
         g_value_set_string (value, NULL);
       break;
@@ -1088,6 +1088,15 @@ fp_device_resume_finish (FpDevice     *device,
   return g_task_propagate_boolean (G_TASK (result), error);
 }
 
+static void
+enroll_data_free (FpEnrollData *data)
+{
+  if (data->enroll_progress_destroy)
+    data->enroll_progress_destroy (data->enroll_progress_data);
+  data->enroll_progress_data = NULL;
+  g_clear_object (&data->print);
+  g_free (data);
+}
 
 /**
  * fp_device_enroll:
@@ -1217,6 +1226,23 @@ fp_device_enroll_finish (FpDevice     *device,
   return g_task_propagate_pointer (G_TASK (result), error);
 }
 
+static void
+match_data_free (FpMatchData *data)
+{
+  g_clear_object (&data->print);
+  g_clear_object (&data->match);
+  g_clear_error (&data->error);
+
+  if (data->match_destroy)
+    data->match_destroy (data->match_data);
+  data->match_data = NULL;
+
+  g_clear_object (&data->enrolled_print);
+  g_clear_pointer (&data->gallery, g_ptr_array_unref);
+
+  g_free (data);
+}
+
 /**
  * fp_device_verify:
  * @device: a #FpDevice

libfprint/fp-image.c

@@ -24,6 +24,7 @@
 #include "fpi-image.h"
 #include "fpi-log.h"
 
+#include <config.h>
 #include <nbis.h>
 
 /**
@@ -159,60 +160,65 @@ fp_image_init (FpImage *self)
 
 typedef struct
 {
-  GAsyncReadyCallback user_cb;
   struct fp_minutiae *minutiae;
-  gint                width, height;
-  gdouble             ppmm;
-  FpiImageFlags       flags;
-  guchar             *image;
   guchar             *binarized;
-} DetectMinutiaeData;
+  FpiImageFlags       flags;
+  unsigned char      *image;
+  gboolean            image_changed;
+} DetectMinutiaeNbisData;
 
 static void
-fp_image_detect_minutiae_free (DetectMinutiaeData *data)
+fp_image_detect_minutiae_free (DetectMinutiaeNbisData *data)
 {
-  g_clear_pointer (&data->image, g_free);
   g_clear_pointer (&data->minutiae, free_minutiae);
   g_clear_pointer (&data->binarized, g_free);
+
+  if (data->image_changed)
+    g_clear_pointer (&data->image, g_free);
+
   g_free (data);
 }
 
-static void
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (DetectMinutiaeNbisData, fp_image_detect_minutiae_free)
-fp_image_detect_minutiae_cb (GObject      *source_object,
+
-                             GAsyncResult *res,
+
-                             gpointer      user_data)
+static gboolean
+fp_image_detect_minutiae_nbis_finish (FpImage *self,
+                                      GTask   *task,
+                                      GError **error)
 {
-  GTask *task = G_TASK (res);
+  g_autoptr(DetectMinutiaeNbisData) data = NULL;
-  FpImage *image;
-  DetectMinutiaeData *data = g_task_get_task_data (task);
 
-  if (!g_task_had_error (task))
+  data = g_task_propagate_pointer (task, error);
+
+  if (data != NULL)
     {
-      gint i;
+      self->flags = data->flags;
-      image = FP_IMAGE (source_object);
 
-      image->flags = data->flags;
+      if (data->image_changed)
+        {
+          g_clear_pointer (&self->data, g_free);
+          self->data = g_steal_pointer (&data->image);
+        }
 
-      g_clear_pointer (&image->data, g_free);
+      g_clear_pointer (&self->binarized, g_free);
-      image->data = g_steal_pointer (&data->image);
+      self->binarized = g_steal_pointer (&data->binarized);
 
-      g_clear_pointer (&image->binarized, g_free);
+      g_clear_pointer (&self->minutiae, g_ptr_array_unref);
-      image->binarized = g_steal_pointer (&data->binarized);
+      self->minutiae = g_ptr_array_new_full (data->minutiae->num,
+                                             (GDestroyNotify) free_minutia);
 
-      g_clear_pointer (&image->minutiae, g_ptr_array_unref);
+      for (int i = 0; i < data->minutiae->num; i++)
-      image->minutiae = g_ptr_array_new_full (data->minutiae->num,
+        g_ptr_array_add (self->minutiae,
-                                              (GDestroyNotify) free_minutia);
-
-      for (i = 0; i < data->minutiae->num; i++)
-        g_ptr_array_add (image->minutiae,
                          g_steal_pointer (&data->minutiae->list[i]));
 
-      /* Don't let it delete anything. */
+      /* Don't let free_minutiae delete the minutiae that we now own. */
       data->minutiae->num = 0;
+
+      return TRUE;
     }
 
-  if (data->user_cb)
+  return FALSE;
-    data->user_cb (source_object, res, user_data);
 }
 
 static void
@@ -265,70 +271,83 @@ invert_colors (guint8 *data, gint width, gint height)
 }
 
 static void
-fp_image_detect_minutiae_thread_func (GTask        *task,
+fp_image_detect_minutiae_nbis_thread_func (GTask        *task,
-                                      gpointer      source_object,
+                                           gpointer      source_object,
-                                      gpointer      task_data,
+                                           gpointer      task_data,
-                                      GCancellable *cancellable)
+                                           GCancellable *cancellable)
 {
   g_autoptr(GTimer) timer = NULL;
-  DetectMinutiaeData *data = task_data;
+  g_autoptr(DetectMinutiaeNbisData) ret_data = NULL;
-  struct fp_minutiae *minutiae = NULL;
+  g_autoptr(GTask) thread_task = g_steal_pointer (&task);
   g_autofree gint *direction_map = NULL;
   g_autofree gint *low_contrast_map = NULL;
   g_autofree gint *low_flow_map = NULL;
   g_autofree gint *high_curve_map = NULL;
   g_autofree gint *quality_map = NULL;
-  g_autofree guchar *bdata = NULL;
+  g_autofree LFSPARMS *lfsparms = NULL;
+  FpImage *self = source_object;
+  FpiImageFlags minutiae_flags;
+  unsigned char *image;
   gint map_w, map_h;
   gint bw, bh, bd;
   gint r;
-  g_autofree LFSPARMS *lfsparms = NULL;
+
+  image = self->data;
+  minutiae_flags = self->flags & ~(FPI_IMAGE_H_FLIPPED |
+                                   FPI_IMAGE_V_FLIPPED |
+                                   FPI_IMAGE_COLORS_INVERTED);
+
+  if (minutiae_flags != FPI_IMAGE_NONE)
+    image = g_memdup2 (self->data, self->width * self->height);
+
+  ret_data = g_new0 (DetectMinutiaeNbisData, 1);
+  ret_data->flags = minutiae_flags;
+  ret_data->image = image;
+  ret_data->image_changed = image != self->data;
 
   /* Normalize the image first */
-  if (data->flags & FPI_IMAGE_H_FLIPPED)
+  if (self->flags & FPI_IMAGE_H_FLIPPED)
-    hflip (data->image, data->width, data->height);
+    hflip (image, self->width, self->height);
 
-  if (data->flags & FPI_IMAGE_V_FLIPPED)
+  if (self->flags & FPI_IMAGE_V_FLIPPED)
-    vflip (data->image, data->width, data->height);
+    vflip (image, self->width, self->height);
 
-  if (data->flags & FPI_IMAGE_COLORS_INVERTED)
+  if (self->flags & FPI_IMAGE_COLORS_INVERTED)
-    invert_colors (data->image, data->width, data->height);
+    invert_colors (image, self->width, self->height);
-
-  data->flags &= ~(FPI_IMAGE_H_FLIPPED | FPI_IMAGE_V_FLIPPED | FPI_IMAGE_COLORS_INVERTED);
 
   lfsparms = g_memdup2 (&g_lfsparms_V2, sizeof (LFSPARMS));
-  lfsparms->remove_perimeter_pts = data->flags & FPI_IMAGE_PARTIAL ? TRUE : FALSE;
+  lfsparms->remove_perimeter_pts = minutiae_flags & FPI_IMAGE_PARTIAL ? TRUE : FALSE;
 
   timer = g_timer_new ();
-  r = get_minutiae (&minutiae, &quality_map, &direction_map,
+  r = get_minutiae (&ret_data->minutiae, &quality_map, &direction_map,
                     &low_contrast_map, &low_flow_map, &high_curve_map,
-                    &map_w, &map_h, &bdata, &bw, &bh, &bd,
+                    &map_w, &map_h, &ret_data->binarized, &bw, &bh, &bd,
-                    data->image, data->width, data->height, 8,
+                    image, self->width, self->height, 8,
-                    data->ppmm, lfsparms);
+                    self->ppmm, lfsparms);
   g_timer_stop (timer);
   fp_dbg ("Minutiae scan completed in %f secs", g_timer_elapsed (timer, NULL));
 
-  data->binarized = g_steal_pointer (&bdata);
+  if (g_task_had_error (thread_task))
-  data->minutiae = minutiae;
+    return;
 
   if (r)
     {
       fp_err ("get minutiae failed, code %d", r);
-      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "Minutiae scan failed with code %d", r);
+      g_task_return_new_error (thread_task, G_IO_ERROR,
-      g_object_unref (task);
+                               G_IO_ERROR_FAILED,
+                               "Minutiae scan failed with code %d", r);
       return;
     }
 
-  if (!data->minutiae || data->minutiae->num == 0)
+  if (!ret_data->minutiae || ret_data->minutiae->num == 0)
     {
-      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
+      g_task_return_new_error (thread_task, G_IO_ERROR, G_IO_ERROR_FAILED,
                                "No minutiae found");
-      g_object_unref (task);
       return;
     }
 
-  g_task_return_boolean (task, TRUE);
+  g_task_return_pointer (thread_task, g_steal_pointer (&ret_data),
-  g_object_unref (task);
+                         (GDestroyNotify) fp_image_detect_minutiae_free);
 }
 
 /**
@@ -444,21 +463,25 @@ fp_image_detect_minutiae (FpImage            *self,
                           GAsyncReadyCallback callback,
                           gpointer            user_data)
 {
-  GTask *task;
+  g_autoptr(GTask) task = NULL;
-  DetectMinutiaeData *data = g_new0 (DetectMinutiaeData, 1);
 
-  task = g_task_new (self, cancellable, fp_image_detect_minutiae_cb, user_data);
+  g_return_if_fail (FP_IS_IMAGE (self));
+  g_return_if_fail (callback != NULL);
 
-  data->image = g_malloc (self->width * self->height);
+  task = g_task_new (self, cancellable, callback, user_data);
-  memcpy (data->image, self->data, self->width * self->height);
+  g_task_set_source_tag (task, fp_image_detect_minutiae);
-  data->flags = self->flags;
+  g_task_set_check_cancellable (task, TRUE);
-  data->width = self->width;
-  data->height = self->height;
-  data->ppmm = self->ppmm;
-  data->user_cb = callback;
 
-  g_task_set_task_data (task, data, (GDestroyNotify) fp_image_detect_minutiae_free);
+  if (!g_atomic_int_compare_and_exchange (&self->detection_in_progress,
-  g_task_run_in_thread (task, fp_image_detect_minutiae_thread_func);
+                                          FALSE, TRUE))
+    {
+      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE,
+                               "Minutiae detection is already in progress");
+      return;
+    }
+
+  g_task_run_in_thread (g_steal_pointer (&task),
+                        fp_image_detect_minutiae_nbis_thread_func);
 }
 
 /**
@@ -476,7 +499,27 @@ fp_image_detect_minutiae_finish (FpImage      *self,
                                  GAsyncResult *result,
                                  GError      **error)
 {
-  return g_task_propagate_boolean (G_TASK (result), error);
+  GTask *task;
+  gboolean changed;
+
+  g_return_val_if_fail (FP_IS_IMAGE (self), FALSE);
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+  g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) ==
+                        fp_image_detect_minutiae, FALSE);
+
+  task = G_TASK (result);
+  changed = g_atomic_int_compare_and_exchange (&self->detection_in_progress,
+                                               TRUE, FALSE);
+  g_assert (changed);
+
+  if (g_task_had_error (task))
+    {
+      gpointer data = g_task_propagate_pointer (task, error);
+      g_assert (data == NULL);
+      return FALSE;
+    }
+
+  return fp_image_detect_minutiae_nbis_finish (self, task, error);
 }
 
 /**

libfprint/fp-print.c

@@ -721,13 +721,12 @@ fp_print_serialize (FpPrint *print,
 
   result = g_variant_builder_end (&builder);
 
-  if (G_BYTE_ORDER == G_BIG_ENDIAN)
+#if (G_BYTE_ORDER == G_BIG_ENDIAN)
-    {
+  GVariant *tmp;
-      GVariant *tmp;
+  tmp = g_variant_byteswap (result);
-      tmp = g_variant_byteswap (result);
+  g_variant_unref (result);
-      g_variant_unref (result);
+  result = tmp;
-      result = tmp;
+#endif
-    }
 
   len = g_variant_get_size (result);
   /* Add 3 bytes of header */
@@ -800,10 +799,11 @@ fp_print_deserialize (const guchar *data,
   if (!raw_value)
     goto invalid_format;
 
-  if (G_BYTE_ORDER == G_BIG_ENDIAN)
+#if (G_BYTE_ORDER == G_BIG_ENDIAN)
-    value = g_variant_byteswap (raw_value);
+  value = g_variant_byteswap (raw_value);
-  else
+#else
-    value = g_variant_get_normal_form (raw_value);
+  value = g_variant_get_normal_form (raw_value);
+#endif
 
   g_variant_get (value,
                  "(i&s&sbymsmsi@a{sv}v)",

libfprint/fp-print.h

@@ -29,7 +29,7 @@ G_BEGIN_DECLS
 G_DECLARE_FINAL_TYPE (FpPrint, fp_print, FP, PRINT, GInitiallyUnowned)
 
 #define FP_FINGER_IS_VALID(finger) \
-  ((finger) >= FP_FINGER_FIRST && (finger) <= FP_FINGER_LAST)
+        ((finger) >= FP_FINGER_FIRST && (finger) <= FP_FINGER_LAST)
 
 #include "fp-device.h"
 

libfprint/fpi-byte-reader.h

@@ -675,4 +675,6 @@ fpi_byte_reader_skip_inline (FpiByteReader * reader, guint nbytes)
 
 #endif /* FPI_BYTE_READER_DISABLE_INLINES */
 
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiByteReader, fpi_byte_reader_free);
+
 G_END_DECLS

libfprint/fpi-byte-writer.c

@@ -75,7 +75,8 @@ fpi_byte_writer_new_with_size (guint size, gboolean fixed)
   FpiByteWriter *ret = fpi_byte_writer_new ();
 
   ret->alloc_size = size;
-  ret->parent.data = g_malloc (ret->alloc_size);
+  ret->parent.data = g_malloc0 (ret->alloc_size);
+  ret->parent.size = size;
   ret->fixed = fixed;
   ret->owned = TRUE;
 
@@ -142,7 +143,8 @@ fpi_byte_writer_init_with_size (FpiByteWriter * writer, guint size,
 
   fpi_byte_writer_init (writer);
 
-  writer->parent.data = g_malloc (size);
+  writer->parent.data = g_malloc0 (size);
+  writer->parent.size = size;
   writer->alloc_size = size;
   writer->fixed = fixed;
   writer->owned = TRUE;
@@ -209,10 +211,9 @@ fpi_byte_writer_reset_and_get_data (FpiByteWriter * writer)
 
   g_return_val_if_fail (writer != NULL, NULL);
 
-  data = (guint8 *) writer->parent.data;
+  data = (guint8 *) g_steal_pointer (&writer->parent.data);
   if (!writer->owned)
     data = g_memdup2 (data, writer->parent.size);
-  writer->parent.data = NULL;
   fpi_byte_writer_reset (writer);
 
   return data;

libfprint/fpi-byte-writer.h

@@ -111,6 +111,17 @@ fpi_byte_writer_set_pos (FpiByteWriter *writer, guint pos)
   return fpi_byte_reader_set_pos (FPI_BYTE_READER (writer), pos);
 }
 
+static inline gboolean
+fpi_byte_writer_change_pos (FpiByteWriter *writer, gint pos)
+{
+  pos = fpi_byte_writer_get_pos (writer) + pos;
+
+  if (pos < 0)
+    return FALSE;
+
+  return fpi_byte_reader_set_pos (FPI_BYTE_READER (writer), pos);
+}
+
 static inline guint
 fpi_byte_writer_get_size (const FpiByteWriter *writer)
 {
@@ -407,4 +418,7 @@ fpi_byte_writer_fill_inline (FpiByteWriter * writer, guint8 value, guint size)
 
 #endif
 
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiByteWriter, fpi_byte_writer_free);
+G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (FpiByteWriter, fpi_byte_writer_reset);
+
 G_END_DECLS

libfprint/fpi-compat.h

@@ -20,36 +20,6 @@
 
 #include <glib-object.h>
 
-#if !GLIB_CHECK_VERSION (2, 57, 0)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (GTypeClass, g_type_class_unref);
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (GEnumClass, g_type_class_unref);
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (GFlagsClass, g_type_class_unref);
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (GParamSpec, g_param_spec_unref);
-#else
-/* Re-define G_SOURCE_FUNC as we are technically not allowed to use it with
- * the version we depend on currently. */
-#undef G_SOURCE_FUNC
-#endif
-
-#define G_SOURCE_FUNC(f) ((GSourceFunc) (void (*)(void))(f))
-
-#if !GLIB_CHECK_VERSION (2, 63, 3)
-typedef struct _FpDeviceClass FpDeviceClass;
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpDeviceClass, g_type_class_unref);
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (GDate, g_date_free);
-#endif
-
-#if !GLIB_CHECK_VERSION (2, 68, 0)
-#define g_memdup2(data, size) g_memdup ((data), (size))
-#else
-#define g_memdup2(data, size)        \
-  (G_GNUC_EXTENSION ({               \
-    G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
-      g_memdup2 ((data), (size));    \
-    G_GNUC_END_IGNORE_DEPRECATIONS   \
-  }))
-#endif
-
 #if  __GNUC__ > 10 || (__GNUC__ == 10 && __GNUC_MINOR__ >= 1)
 #define FP_GNUC_ACCESS(m, p, s) __attribute__((access (m, p, s)))
 #else

libfprint/fpi-device.c

@@ -522,33 +522,6 @@ fpi_device_get_driver_data (FpDevice *device)
   return priv->driver_data;
 }
 
-void
-enroll_data_free (FpEnrollData *data)
-{
-  if (data->enroll_progress_destroy)
-    data->enroll_progress_destroy (data->enroll_progress_data);
-  data->enroll_progress_data = NULL;
-  g_clear_object (&data->print);
-  g_free (data);
-}
-
-void
-match_data_free (FpMatchData *data)
-{
-  g_clear_object (&data->print);
-  g_clear_object (&data->match);
-  g_clear_error (&data->error);
-
-  if (data->match_destroy)
-    data->match_destroy (data->match_data);
-  data->match_data = NULL;
-
-  g_clear_object (&data->enrolled_print);
-  g_clear_pointer (&data->gallery, g_ptr_array_unref);
-
-  g_free (data);
-}
-
 /**
  * fpi_device_get_enroll_data:
  * @device: The #FpDevice
@@ -1069,34 +1042,41 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
 static void
 fpi_device_task_return_data_free (FpDeviceTaskReturnData *data)
 {
-  if (data->result)
+  switch (data->type)
     {
-      switch (data->type)
+    case FP_DEVICE_TASK_RETURN_INT:
-        {
+    case FP_DEVICE_TASK_RETURN_BOOL:
-        case FP_DEVICE_TASK_RETURN_INT:
+      break;
-        case FP_DEVICE_TASK_RETURN_BOOL:
-          break;
 
-        case FP_DEVICE_TASK_RETURN_OBJECT:
+    case FP_DEVICE_TASK_RETURN_OBJECT:
-          g_clear_object ((GObject **) &data->result);
+      g_clear_object ((GObject **) &data->result);
-          break;
+      break;
 
-        case FP_DEVICE_TASK_RETURN_PTR_ARRAY:
+    case FP_DEVICE_TASK_RETURN_PTR_ARRAY:
-          g_clear_pointer ((GPtrArray **) &data->result, g_ptr_array_unref);
+      g_clear_pointer ((GPtrArray **) &data->result, g_ptr_array_unref);
-          break;
+      break;
 
-        case FP_DEVICE_TASK_RETURN_ERROR:
+    case FP_DEVICE_TASK_RETURN_ERROR:
-          g_clear_error ((GError **) &data->result);
+      g_clear_error ((GError **) &data->result);
-          break;
+      break;
 
-        default:
+    default:
-          g_assert_not_reached ();
+      g_assert_not_reached ();
-        }
     }
+
   g_object_unref (data->device);
   g_free (data);
 }
 
+/**
+ * fpi_device_return_task_in_idle:
+ * @device: The #FpDevice
+ * @return_type: The #FpDeviceTaskReturnType of @return_data
+ * @return_data: (nullable) (transfer full): The data to return.
+ *
+ * Completes a #FpDevice task in an idle source, stealing the ownership of
+ * the passed @returned_data.
+ */
 static void
 fpi_device_return_task_in_idle (FpDevice              *device,
                                 FpDeviceTaskReturnType return_type,
@@ -1128,7 +1108,7 @@ fpi_device_return_task_in_idle (FpDevice              *device,
  * @device: The #FpDevice
  * @device_id: Unique ID for the device or %NULL
  * @device_name: Human readable name or %NULL for driver name
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing probe operation. If error is %NULL success is assumed.
  */
@@ -1174,7 +1154,7 @@ fpi_device_probe_complete (FpDevice    *device,
 /**
  * fpi_device_open_complete:
  * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing open operation. If error is %NULL success is assumed.
  */
@@ -1201,7 +1181,7 @@ fpi_device_open_complete (FpDevice *device, GError *error)
 /**
  * fpi_device_close_complete:
  * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing close operation. If error is %NULL success is assumed.
  */
@@ -1253,7 +1233,7 @@ fpi_device_close_complete (FpDevice *device, GError *error)
  * fpi_device_enroll_complete:
  * @device: The #FpDevice
  * @print: (nullable) (transfer full): The #FpPrint or %NULL on failure
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing enroll operation. The #FpPrint can be stored by the
  * caller for later verification.
@@ -1382,7 +1362,7 @@ fpi_device_verify_complete (FpDevice *device,
 /**
  * fpi_device_identify_complete:
  * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing identify operation.
  *
@@ -1448,7 +1428,7 @@ fpi_device_identify_complete (FpDevice *device,
  * fpi_device_capture_complete:
  * @device: The #FpDevice
  * @image: The #FpImage, or %NULL on error
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing capture operation.
  */
@@ -1495,7 +1475,7 @@ fpi_device_capture_complete (FpDevice *device,
 /**
  * fpi_device_delete_complete:
  * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing delete operation.
  */
@@ -1524,7 +1504,7 @@ fpi_device_delete_complete (FpDevice *device,
  * fpi_device_list_complete:
  * @device: The #FpDevice
  * @prints: (element-type FpPrint) (transfer container): Possibly empty array of prints or %NULL on error
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing list operation.
  *
@@ -1802,7 +1782,7 @@ fpi_device_suspend_completed (FpDevice *device)
 /**
  * fpi_device_suspend_complete:
  * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish a suspend request. Only return a %NULL error if suspend has been
  * correctly configured and the current action as returned by
@@ -1853,7 +1833,7 @@ fpi_device_suspend_complete (FpDevice *device,
 /**
  * fpi_device_resume_complete:
  * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish a resume request.
  */
@@ -1881,7 +1861,7 @@ fpi_device_resume_complete (FpDevice *device,
 /**
  * fpi_device_clear_storage_complete:
  * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Finish an ongoing clear_storage operation.
  */
@@ -1912,7 +1892,7 @@ fpi_device_clear_storage_complete (FpDevice *device,
  * @device: The #FpDevice
  * @completed_stages: The number of stages that are completed at this point
  * @print: (transfer floating): The #FpPrint for the newly completed stage or %NULL on failure
- * @error: (transfer full): The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Notify about the progress of the enroll operation. This is important for UI interaction.
  * The passed error may be used if a scan needs to be retried, use fpi_device_retry_new().

libfprint/fpi-image-device.c

@@ -565,7 +565,7 @@ fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry)
 /**
  * fpi_image_device_session_error:
  * @self: a #FpImageDevice imaging fingerprint device
- * @error: The #GError to report
+ * @error: (nullable) (transfer full): The #GError to report.
  *
  * Report an error while interacting with the device. This effectively
  * aborts the current ongoing action. Note that doing so will result in
@@ -624,7 +624,7 @@ fpi_image_device_session_error (FpImageDevice *self, GError *error)
 /**
  * fpi_image_device_activate_complete:
  * @self: a #FpImageDevice imaging fingerprint device
- * @error: A #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Reports completion of device activation.
  */
@@ -663,7 +663,7 @@ fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
 /**
  * fpi_image_device_deactivate_complete:
  * @self: a #FpImageDevice imaging fingerprint device
- * @error: A #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Reports completion of device deactivation.
  */
@@ -690,7 +690,7 @@ fpi_image_device_deactivate_complete (FpImageDevice *self, GError *error)
 /**
  * fpi_image_device_open_complete:
  * @self: a #FpImageDevice imaging fingerprint device
- * @error: A #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Reports completion of open operation.
  */
@@ -718,7 +718,7 @@ fpi_image_device_open_complete (FpImageDevice *self, GError *error)
 /**
  * fpi_image_device_close_complete:
  * @self: a #FpImageDevice imaging fingerprint device
- * @error: A #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
  *
  * Reports completion of close operation.
  */

libfprint/fpi-image.c

@@ -24,8 +24,9 @@
 #include "fpi-log.h"
 
 #include <nbis.h>
+#include <config.h>
 
-#if HAVE_PIXMAN
+#ifdef HAVE_PIXMAN
 #include <pixman.h>
 #endif
 
@@ -107,12 +108,12 @@ fpi_mean_sq_diff_norm (const guint8 *buf1,
   return res / size;
 }
 
-#if HAVE_PIXMAN
 FpImage *
 fpi_image_resize (FpImage *orig_img,
                   guint    w_factor,
                   guint    h_factor)
 {
+#ifdef HAVE_PIXMAN
   int new_width = orig_img->width * w_factor;
   int new_height = orig_img->height * h_factor;
   pixman_image_t *orig, *resized;
@@ -145,5 +146,9 @@ fpi_image_resize (FpImage *orig_img,
   pixman_image_unref (resized);
 
   return newimg;
-}
+#else
+  fp_err ("Libfprint compiled without pixman support, impossible to resize");
+
+  return g_object_ref (orig_img);
 #endif
+}

libfprint/fpi-image.h

@@ -20,7 +20,6 @@
 
 #pragma once
 
-#include <config.h>
 #include "fp-image.h"
 
 /**
@@ -34,6 +33,7 @@
  * rely on the image to be normalized by libfprint before further processing.
  */
 typedef enum {
+  FPI_IMAGE_NONE            = 0,
   FPI_IMAGE_V_FLIPPED       = 1 << 0,
   FPI_IMAGE_H_FLIPPED       = 1 << 1,
   FPI_IMAGE_COLORS_INVERTED = 1 << 2,
@@ -68,7 +68,8 @@ struct _FpImage
   guint8    *binarized;
 
   GPtrArray *minutiae;
-  guint      ref_count;
+
+  gboolean   detection_in_progress;
 };
 
 gint fpi_std_sq_dev (const guint8 *buf,
@@ -77,8 +78,6 @@ gint fpi_mean_sq_diff_norm (const guint8 *buf1,
                             const guint8 *buf2,
                             gint          size);
 
-#if HAVE_PIXMAN
 FpImage *fpi_image_resize (FpImage *orig,
                            guint    w_factor,
                            guint    h_factor);
-#endif

libfprint/fpi-log.h

@@ -80,12 +80,12 @@
  * Uses fp_err() to print an error if the @condition is true.
  */
 #define BUG_ON(condition) G_STMT_START          \
-  if (condition) {                        \
+        if (condition) {                        \
-      char *s;                        \
+            char *s;                        \
-      s = g_strconcat ("BUG: (", #condition, ")", NULL); \
+            s = g_strconcat ("BUG: (", #condition, ")", NULL); \
-      fp_err ("%s: %s() %s:%d", s, G_STRFUNC, __FILE__, __LINE__); \
+            fp_err ("%s: %s() %s:%d", s, G_STRFUNC, __FILE__, __LINE__); \
-      g_free (s);                     \
+            g_free (s);                     \
-    } G_STMT_END
+          } G_STMT_END
 
 /**
  * BUG:

libfprint/fpi-ssm.c

@@ -73,7 +73,7 @@
 struct _FpiSsm
 {
   FpDevice               *dev;
-  const char             *name;
+  char                   *name;
   FpiSsm                 *parentsm;
   gpointer                ssm_data;
   GDestroyNotify          ssm_data_destroy;

libfprint/fpi-ssm.h

@@ -60,7 +60,7 @@ typedef void (*FpiSsmHandlerCallback)(FpiSsm   *ssm,
 
 /* for library and drivers */
 #define fpi_ssm_new(dev, handler, nr_states) \
-  fpi_ssm_new_full (dev, handler, nr_states, nr_states, #nr_states)
+        fpi_ssm_new_full (dev, handler, nr_states, nr_states, #nr_states)
 FpiSsm *fpi_ssm_new_full (FpDevice             *dev,
                           FpiSsmHandlerCallback handler,
                           int                   nr_states,

libfprint/fprint-list-supported-devices.c

@@ -110,7 +110,7 @@ main (int argc, char **argv)
 
   printed = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 
-  g_print ("%% lifprint — Supported Devices\n");
+  g_print ("%% libfprint — Supported Devices\n");
   g_print ("%% Bastien Nocera, Daniel Drake\n");
   g_print ("%% 2018\n");
   g_print ("\n");
@@ -132,7 +132,7 @@ main (int argc, char **argv)
     g_print ("%s", (char *) l->data);
   g_print ("\n");
 
-  g_list_free_full (usb_list, g_free);
+  g_list_free_full (g_steal_pointer (&usb_list), g_free);
 
   g_print ("## SPI devices\n");
   g_print ("\n");
@@ -146,7 +146,7 @@ main (int argc, char **argv)
     g_print ("%s", (char *) l->data);
   g_print ("\n");
 
-  g_list_free_full (usb_list, g_free);
+  g_list_free_full (g_steal_pointer (&spi_list), g_free);
 
 
   g_hash_table_destroy (printed);

libfprint/fprint-list-udev-hwdb.c

@@ -24,11 +24,12 @@
 #include "fpi-context.h"
 #include "fpi-device.h"
 
-static const FpIdEntry whitelist_id_table[] = {
+static const FpIdEntry allowlist_id_table[] = {
   /* Currently known and unsupported devices.
    * You can generate this list from the wiki page using e.g.:
    *   gio cat https://gitlab.freedesktop.org/libfprint/wiki/-/wikis/Unsupported-Devices.md | sed -n 's!|.*\([0-9a-fA-F]\{4\}\):\([0-9a-fA-F]\{4\}\).*|.*!  { .vid = 0x\1, .pid = 0x\2 },!p'
    */
+  { .vid = 0x047d, .pid = 0x00f2 },
   { .vid = 0x04e8, .pid = 0x730b },
   { .vid = 0x04f3, .pid = 0x036b },
   { .vid = 0x04f3, .pid = 0x0c00 },
@@ -36,12 +37,16 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x04f3, .pid = 0x0c57 },
   { .vid = 0x04f3, .pid = 0x0c5e },
   { .vid = 0x04f3, .pid = 0x0c5a },
+  { .vid = 0x04f3, .pid = 0x0c6c },
   { .vid = 0x04f3, .pid = 0x0c70 },
   { .vid = 0x04f3, .pid = 0x0c72 },
+  { .vid = 0x04f3, .pid = 0x0c77 },
   { .vid = 0x04f3, .pid = 0x2706 },
+  { .vid = 0x04f3, .pid = 0x3032 },
   { .vid = 0x04f3, .pid = 0x3057 },
   { .vid = 0x04f3, .pid = 0x3104 },
   { .vid = 0x04f3, .pid = 0x310d },
+  { .vid = 0x04f3, .pid = 0x3128 },
   { .vid = 0x06cb, .pid = 0x0081 },
   { .vid = 0x06cb, .pid = 0x0088 },
   { .vid = 0x06cb, .pid = 0x008a },
@@ -52,7 +57,6 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x06cb, .pid = 0x00b7 },
   { .vid = 0x06cb, .pid = 0x00bb },
   { .vid = 0x06cb, .pid = 0x00be },
-  { .vid = 0x06cb, .pid = 0x00c4 },
   { .vid = 0x06cb, .pid = 0x00cb },
   { .vid = 0x06cb, .pid = 0x00c9 },
   { .vid = 0x06cb, .pid = 0x00d8 },
@@ -71,10 +75,17 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x0a5c, .pid = 0x5843 },
   { .vid = 0x0a5c, .pid = 0x5844 },
   { .vid = 0x0a5c, .pid = 0x5845 },
+  { .vid = 0x0a5c, .pid = 0x5860 },
+  { .vid = 0x0a5c, .pid = 0x5863 },
+  { .vid = 0x0a5c, .pid = 0x5864 },
+  { .vid = 0x0a5c, .pid = 0x5865 },
+  { .vid = 0x0a5c, .pid = 0x5866 },
+  { .vid = 0x0a5c, .pid = 0x5867 },
   { .vid = 0x0bda, .pid = 0x5812 },
   { .vid = 0x10a5, .pid = 0x0007 },
   { .vid = 0x10a5, .pid = 0x9200 },
   { .vid = 0x10a5, .pid = 0x9800 },
+  { .vid = 0x10a5, .pid = 0xe340 },
   { .vid = 0x1188, .pid = 0x9545 },
   { .vid = 0x138a, .pid = 0x0007 },
   { .vid = 0x138a, .pid = 0x003a },
@@ -87,12 +98,14 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x138a, .pid = 0x0097 },
   { .vid = 0x138a, .pid = 0x009d },
   { .vid = 0x138a, .pid = 0x00ab },
+  { .vid = 0x138a, .pid = 0x00a6 },
   { .vid = 0x147e, .pid = 0x1002 },
   { .vid = 0x1491, .pid = 0x0088 },
   { .vid = 0x16d1, .pid = 0x1027 },
   { .vid = 0x1c7a, .pid = 0x0300 },
   { .vid = 0x1c7a, .pid = 0x0575 },
   { .vid = 0x1c7a, .pid = 0x0576 },
+  { .vid = 0x1c7a, .pid = 0x0577 },
   { .vid = 0x27c6, .pid = 0x5042 },
   { .vid = 0x27c6, .pid = 0x5110 },
   { .vid = 0x27c6, .pid = 0x5117 },
@@ -120,6 +133,8 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x27c6, .pid = 0x5740 },
   { .vid = 0x27c6, .pid = 0x5e0a },
   { .vid = 0x27c6, .pid = 0x581a },
+  { .vid = 0x27c6, .pid = 0x589a },
+  { .vid = 0x27c6, .pid = 0x6382 },
   { .vid = 0x2808, .pid = 0x9338 },
   { .vid = 0x2808, .pid = 0x93a9 },
   { .vid = 0x298d, .pid = 0x2020 },
@@ -128,18 +143,18 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0 },
 };
 
-static const FpIdEntry blacklist_id_table[] = {
+static const FpIdEntry denylist_id_table[] = {
   { .vid = 0x0483, .pid = 0x2016 },
   /* https://bugs.freedesktop.org/show_bug.cgi?id=66659 */
   { .vid = 0x045e, .pid = 0x00bb },
   { .vid = 0 },
 };
 
-static const FpDeviceClass whitelist = {
+static const FpDeviceClass allowlist = {
   .type = FP_DEVICE_TYPE_USB,
-  .id_table = whitelist_id_table,
+  .id_table = allowlist_id_table,
-  .id = "whitelist",
+  .id = "allowlist",
-  .full_name = "Hardcoded whitelist"
+  .full_name = "Hardcoded allowlist"
 };
 
 GHashTable *printed = NULL;
@@ -158,7 +173,7 @@ print_driver (const FpDeviceClass *cls)
       const FpIdEntry *bl_entry;
       char *key;
 
-      for (bl_entry = blacklist_id_table; bl_entry->vid != 0; bl_entry++)
+      for (bl_entry = denylist_id_table; bl_entry->vid != 0; bl_entry++)
         if (entry->vid == bl_entry->vid && entry->pid == bl_entry->pid)
           break;
 
@@ -169,7 +184,7 @@ print_driver (const FpDeviceClass *cls)
 
       if (g_hash_table_lookup (printed, key) != NULL)
         {
-          if (cls == &whitelist)
+          if (cls == &allowlist)
             g_warning ("%s implemented by driver %s",
                        key, (const char *) g_hash_table_lookup (printed, key));
           g_free (key);
@@ -180,7 +195,7 @@ print_driver (const FpDeviceClass *cls)
 
       if (num_printed == 0)
         {
-          if (cls != &whitelist)
+          if (cls != &allowlist)
             g_print ("\n# Supported by libfprint driver %s\n", cls->id);
           else
             g_print ("\n# Known unsupported devices\n");
@@ -234,7 +249,7 @@ main (int argc, char **argv)
       print_driver (cls);
     }
 
-  print_driver (&whitelist);
+  print_driver (&allowlist);
 
   g_hash_table_destroy (printed);
 

libfprint/meson.build

@@ -1,3 +1,11 @@
+spi_sources = []
+spi_headers = []
+
+if enabled_spi_drivers.length() > 0
+  spi_headers = ['fpi-spi-transfer.h']
+  spi_sources = ['fpi-spi-transfer.c']
+endif
+
 libfprint_sources = [
     'fp-context.c',
     'fp-device.c',
@@ -16,7 +24,7 @@ libfprint_private_sources = [
     'fpi-print.c',
     'fpi-ssm.c',
     'fpi-usb-transfer.c',
-    'fpi-spi-transfer.c',
+    spi_sources,
 ]
 
 libfprint_public_headers = [
@@ -41,7 +49,7 @@ libfprint_private_headers = [
     'fpi-minutiae.h',
     'fpi-print.h',
     'fpi-usb-transfer.h',
-    'fpi-spi-transfer.h',
+    spi_headers,
     'fpi-ssm.h',
 ]
 
@@ -119,6 +127,8 @@ driver_sources = {
         [ 'drivers/etes603.c' ],
     'egis0570' :
         [ 'drivers/egis0570.c' ],
+    'egismoc' :
+        [ 'drivers/egismoc/egismoc.c' ],
     'vfs0050' :
         [ 'drivers/vfs0050.c' ],
     'elan' :
@@ -141,6 +151,10 @@ driver_sources = {
         [ 'drivers/goodixmoc/goodix.c', 'drivers/goodixmoc/goodix_proto.c' ],
     'fpcmoc' :
         [ 'drivers/fpcmoc/fpc.c' ],
+    'realtek' :
+        [ 'drivers/realtek/realtek.c' ],
+    'focaltech_moc' :
+        [ 'drivers/focaltech_moc/focaltech_moc.c' ],
 }
 
 helper_sources = {
@@ -263,7 +277,7 @@ libfprint_drivers = static_library('fprint-drivers',
     install: false)
 
 mapfile = files('libfprint.ver')
-vflag = '-Wl,--version-script,@0@/@1@'.format(meson.source_root(), mapfile[0])
+vflag = '-Wl,--version-script,@0@/@1@'.format(meson.project_source_root(), mapfile[0])
 
 libfprint = shared_library(versioned_libname.split('lib')[1],
     sources: [
@@ -339,7 +353,7 @@ sync_udev_udb = custom_target('sync-udev-hwdb',
     command: [
         'cp', '-v',
         udev_hwdb_generator.full_path(),
-        meson.source_root() / 'data'
+        meson.project_source_root() / 'data'
     ]
 )
 

meson.build

@@ -1,22 +1,27 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.94.4',
+    version: '1.94.8',
     license: 'LGPLv2.1+',
     default_options: [
         'buildtype=debugoptimized',
         'warning_level=1',
         'c_std=gnu99',
     ],
-    meson_version: '>= 0.49.0')
+    meson_version: '>= 0.56.0')
 
 gnome = import('gnome')
 
 libfprint_conf = configuration_data()
 libfprint_conf.set_quoted('LIBFPRINT_VERSION', meson.project_version())
 
+prefix = get_option('prefix')
+libdir = prefix / get_option('libdir')
+libexecdir = prefix / get_option('libexecdir')
+datadir = prefix / get_option('datadir')
+
 cc = meson.get_compiler('c')
 cpp = meson.get_compiler('cpp')
 host_system = host_machine.system()
-glib_min_version = '2.56'
+glib_min_version = '2.68'
 
 glib_version_def = 'GLIB_VERSION_@0@_@1@'.format(
     glib_min_version.split('.')[0], glib_min_version.split('.')[1])
@@ -86,11 +91,15 @@ gusb_dep = dependency('gusb', version: '>= 0.2.0')
 mathlib_dep = cc.find_library('m', required: false)
 
 # The following dependencies are only used for tests
+sh = find_program('sh', required: true)
 cairo_dep = dependency('cairo', required: false)
 
 # introspection scanning and Gio-2.0.gir
 gobject_introspection = dependency('gobject-introspection-1.0', required: get_option('introspection'))
 
+# SPI
+have_spi = host_machine.system() == 'linux'
+
 # Drivers
 drivers = get_option('drivers').split(',')
 virtual_drivers = [
@@ -115,6 +124,7 @@ default_drivers = [
     'vfs0050',
     'etes603',
     'egis0570',
+    'egismoc',
     'vcom5s',
     'synaptics',
     'elan',
@@ -126,16 +136,42 @@ default_drivers = [
     'goodixmoc',
     'nb1010',
     'fpcmoc',
-
+    'realtek',
-    # SPI
+    'focaltech_moc',
-    'elanspi',
 ]
 
+spi_drivers = [
+    'elanspi'
+]
+
+if have_spi
+    default_drivers += spi_drivers
+endif
+
 # FIXME: All the drivers should be fixed by adjusting the byte order.
 # See https://gitlab.freedesktop.org/libfprint/libfprint/-/issues/236
 endian_independent_drivers = virtual_drivers + [
+    'aes1610',
+    'aes1660',
+    'aes2550',
+    'aes2660',
     'aes3500',
+    'aes4000',
+    'egis0570',
+    'egismoc',
+    'elanmoc',
+    'etes603',
+    'focaltech_moc',
+    'nb1010',
+    'realtek',
     'synaptics',
+    'upeksonly',
+    'upektc',
+    'upektc_img',
+    'upekts',
+    'vcom5s',
+    'vfs101',
+    'vfs7552',
 ]
 
 all_drivers = default_drivers + virtual_drivers
@@ -148,6 +184,17 @@ if drivers == [ 'default' ]
     drivers = default_drivers
 endif
 
+enabled_spi_drivers = []
+foreach driver : spi_drivers
+    if driver in drivers
+        enabled_spi_drivers += driver
+    endif
+endforeach
+
+if enabled_spi_drivers.length() > 0 and not have_spi
+    error('SPI drivers @0@ are not supported'.format(enabled_spi_drivers))
+endif
+
 driver_helper_mapping = {
     'aes1610' : [ 'aeslib' ],
     'aes1660' : [ 'aeslib', 'aesx660' ],
@@ -242,7 +289,7 @@ if install_udev_rules
     udev_rules_dir = get_option('udev_rules_dir')
     if udev_rules_dir == 'auto'
         udev_dep = dependency('udev')
-        udev_rules_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/rules.d'
+        udev_rules_dir = udev_dep.get_variable(pkgconfig: 'udevdir') + '/rules.d'
     endif
 endif
 
@@ -279,15 +326,13 @@ if not udev_hwdb.disabled()
 
     if udev_hwdb_dir == 'auto'
         udev_dep = dependency('udev')
-        udev_hwdb_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/hwdb.d'
+        udev_hwdb_dir = udev_dep.get_variable(pkgconfig: 'udevdir') + '/hwdb.d'
     endif
 else
     udev_hwdb_dir = ''
 endif
 
 if get_option('gtk-examples')
-    gnome = import('gnome')
-
     gtk_dep = dependency('gtk+-3.0', required: false)
     if not gtk_dep.found()
         error('GTK+ 3.x is required for GTK+ examples')
@@ -299,9 +344,7 @@ subdir('libfprint')
 
 configure_file(output: 'config.h', configuration: libfprint_conf)
 
-subdir('examples')
 if get_option('doc')
-    gnome = import('gnome')
     subdir('doc')
 endif
 if get_option('gtk-examples')
@@ -311,6 +354,8 @@ endif
 subdir('data')
 subdir('tests')
 
+subdir('examples')
+
 pkgconfig = import('pkgconfig')
 pkgconfig.generate(
     name: versioned_libname,
@@ -321,3 +366,5 @@ pkgconfig.generate(
     subdirs: versioned_libname,
     filebase: versioned_libname,
 )
+
+summary({'Drivers': drivers, }, section: 'Drivers')

meson_options.txt

@@ -30,3 +30,7 @@ option('doc',
        description: 'Whether to build the API documentation',
        type: 'boolean',
        value: true)
+option('installed-tests',
+       description: 'Whether to install the installed tests',
+       type: 'boolean',
+       value: true)

tests/create-driver-test.py.in

@@ -44,7 +44,7 @@ if len(sys.argv) > 3:
     sys.exit(1)
 
 driver_name = sys.argv[1]
-os.environ['FP_DRIVERS_WHITELIST'] = driver_name
+os.environ['FP_DRIVERS_ALLOWLIST'] = driver_name
 
 test_variant = None
 if len(sys.argv) == 3:

tests/driver.test.in

@@ -0,0 +1,5 @@
+[Test]
+Type=session
+# We can't use TestEnvironment as per
+#  https://gitlab.gnome.org/GNOME/gnome-desktop-testing/-/issues/1
+Exec=env @driver_env@ @installed_tests_execdir@/@umockdev_test_name@ @installed_tests_testdir@/@driver_test@

tests/egis0570/device

@@ -24,7 +24,7 @@ E: ID_USB_INTERFACES=:ff0000:
 E: ID_VENDOR_FROM_DATABASE=LighTuning Technology Inc.
 E: ID_PATH=pci-0000:00:14.0-usb-0:9
 E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_9
-E: LIBFPRINT_DRIVER=Hardcoded whitelist
+E: LIBFPRINT_DRIVER=Hardcoded allowlist
 A: authorized=1\n
 A: avoid_reset_quirk=0\n
 A: bConfigurationValue=1\n

tests/egismoc-0586/custom.py

@@ -0,0 +1,156 @@
+#!/usr/bin/python3
+
+import traceback
+import sys
+import time
+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
+
+d.open_sync()
+
+assert d.get_driver() == "egismoc"
+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.DUPLICATES_CHECK)
+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)
+
+def enroll_progress(*args):
+    print("finger status: ", d.get_finger_status())
+    print('enroll progress: ' + str(args))
+
+def identify_done(dev, res):
+    global identified
+    identified = True
+    identify_match, identify_print = dev.identify_finish(res)
+    print('indentification_done: ', identify_match, identify_print)
+    assert identify_match.equal(identify_print)
+
+# Beginning with list and clear assumes you begin with >0 prints enrolled before capturing
+
+print("listing - device should have prints")
+stored = d.list_prints_sync()
+assert len(stored) > 0
+del stored
+
+print("clear device storage")
+d.clear_storage_sync()
+print("clear done")
+
+print("listing - device should be empty")
+stored = d.list_prints_sync()
+assert len(stored) == 0
+del stored
+
+print("enrolling")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.LEFT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+p1 = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("enroll done")
+del template
+
+print("listing - device should have 1 print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p1)
+
+print("verifying")
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+verify_res, verify_print = d.verify_sync(p1)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("verify done")
+assert verify_res == True
+
+identified = False
+deserialized_prints = []
+for p in stored:
+    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
+    assert deserialized_prints[-1].equal(p)
+del stored
+
+print('async identifying')
+d.identify(deserialized_prints, callback=identify_done)
+del deserialized_prints
+
+while not identified:
+    ctx.iteration(True)
+
+print("try to enroll duplicate")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.RIGHT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+try:
+    d.enroll_sync(template, None, enroll_progress, None)
+except GLib.Error as error:
+    assert error.matches(FPrint.DeviceError.quark(),
+                         FPrint.DeviceError.DATA_DUPLICATE)
+except Exception as exc:
+    raise
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("duplicate enroll attempt done")
+
+print("listing - device should still only have 1 print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p1)
+del stored
+
+print("enroll new finger")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.RIGHT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+p2 = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("enroll new finger done")
+del template
+
+print("listing - device should have 2 prints")
+stored = d.list_prints_sync()
+assert len(stored) == 2
+assert (stored[0].equal(p1) and stored[1].equal(p2)) or (stored[0].equal(p2) and stored[1].equal(p1))
+del stored
+
+print("deleting first print")
+d.delete_print_sync(p1)
+print("delete done")
+del p1
+
+print("listing - device should only have second print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p2)
+del stored
+del p2
+
+print("clear device storage")
+d.clear_storage_sync()
+print("clear done")
+
+print("listing - device should be empty")
+stored = d.list_prints_sync()
+assert len(stored) == 0
+del stored
+
+d.close_sync()
+
+del d
+del c

tests/egismoc-0586/device

@@ -0,0 +1,255 @@
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-7
+N: bus/usb/001/021=12010002FF0000407A1C860556620102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
+E: BUSNUM=001
+E: DEVNAME=/dev/bus/usb/001/021
+E: DEVNUM=021
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: ID_AUTOSUSPEND=1
+E: ID_BUS=usb
+E: ID_MODEL=ETU905A88-E
+E: ID_MODEL_ENC=ETU905A88-E
+E: ID_MODEL_ID=0586
+E: ID_PATH=pci-0000:00:14.0-usb-0:7
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_7
+E: ID_PATH_WITH_USB_REVISION=pci-0000:00:14.0-usbv2-0:7
+E: ID_PERSIST=0
+E: ID_REVISION=6256
+E: ID_SERIAL=EGIS_ETU905A88-E_0A5743PCU834
+E: ID_SERIAL_SHORT=0A5743PCU834
+E: ID_USB_INTERFACES=:ff0000:
+E: ID_USB_MODEL=ETU905A88-E
+E: ID_USB_MODEL_ENC=ETU905A88-E
+E: ID_USB_MODEL_ID=0586
+E: ID_USB_REVISION=6256
+E: ID_USB_SERIAL=EGIS_ETU905A88-E_0A5743PCU834
+E: ID_USB_SERIAL_SHORT=0A5743PCU834
+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=20
+E: PRODUCT=1c7a/586/6256
+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=6256\n
+A: bmAttributes=a0\n
+A: busnum=1\n
+A: configuration=
+H: descriptors=12010002FF0000407A1C860556620102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
+A: dev=189:20\n
+A: devnum=21\n
+A: devpath=7\n
+L: driver=../../../../../bus/usb/drivers/usb
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4e/device:4f/device:56
+A: idProduct=0586\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=center\n
+A: physical_location/lid=no\n
+A: physical_location/panel=front\n
+A: physical_location/vertical_position=center\n
+L: port=../1-0:1.0/usb1-port7
+A: power/active_duration=12644\n
+A: power/autosuspend=2\n
+A: power/autosuspend_delay_ms=2000\n
+A: power/connected_duration=230907\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/persist=0\n
+A: power/runtime_active_time=12929\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=217715\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=ETU905A88-E\n
+A: quirks=0x0\n
+A: removable=fixed\n
+A: rx_lanes=1\n
+A: serial=0A5743PCU834\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=18\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0/usb1
+N: bus/usb/001/001=12010002090001406B1D020008060302010109021900010100E0000904000001090000000705810304000C
+E: BUSNUM=001
+E: CURRENT_TAGS=:seat:
+E: DEVNAME=/dev/bus/usb/001/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_00_14_0
+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:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+E: ID_REVISION=0608
+E: ID_SERIAL=Linux_6.8.5-arch1-1_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL_SHORT=0000:00:14.0
+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=0608
+E: ID_USB_SERIAL=Linux_6.8.5-arch1-1_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_USB_SERIAL_SHORT=0000:00:14.0
+E: ID_USB_VENDOR=Linux_6.8.5-arch1-1_xhci-hcd
+E: ID_USB_VENDOR_ENC=Linux\x206.8.5-arch1-1\x20xhci-hcd
+E: ID_USB_VENDOR_ID=1d6b
+E: ID_VENDOR=Linux_6.8.5-arch1-1_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x206.8.5-arch1-1\x20xhci-hcd
+E: ID_VENDOR_FROM_DATABASE=Linux Foundation
+E: ID_VENDOR_ID=1d6b
+E: MAJOR=189
+E: MINOR=0
+E: PRODUCT=1d6b/2/608
+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=0608\n
+A: bmAttributes=e0\n
+A: busnum=1\n
+A: configuration=
+H: descriptors=12010002090001406B1D020008060302010109021900010100E0000904000001090000000705810304000C
+A: dev=189:0\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:4e/device:4f
+A: idProduct=0002\n
+A: idVendor=1d6b\n
+A: interface_authorized_default=1\n
+A: ltm_capable=no\n
+A: manufacturer=Linux 6.8.5-arch1-1 xhci-hcd\n
+A: maxchild=12\n
+A: power/active_duration=73066477\n
+A: power/autosuspend=0\n
+A: power/autosuspend_delay_ms=0\n
+A: power/connected_duration=73071614\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/runtime_active_time=73070027\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=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:00:14.0\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=1111\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0
+E: DRIVER=xhci_hcd
+E: ID_AUTOSUSPEND=1
+E: ID_MODEL_FROM_DATABASE=Alder Lake PCH USB 3.2 xHCI Host Controller
+E: ID_PATH=pci-0000:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+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=Intel Corporation
+E: MODALIAS=pci:v00008086d000051EDsv00001043sd0000201Fbc0Csc03i30
+E: PCI_CLASS=C0330
+E: PCI_ID=8086:51ED
+E: PCI_SLOT_NAME=0000:00:14.0
+E: PCI_SUBSYS_ID=1043:201F
+E: SUBSYSTEM=pci
+A: ari_enabled=0\n
+A: broken_parity_status=0\n
+A: class=0x0c0330\n
+H: config=8680ED51060490020130030C000080000400220560000000000000000000000000000000000000000000000043101F20000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C10800000000000000000000000590B7001805E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F110112000000
+A: consistent_dma_mask_bits=64\n
+A: d3cold_allowed=1\n
+A: device=0x51ed\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:4e
+A: irq=143\n
+A: local_cpulist=0-15\n
+A: local_cpus=ffff\n
+A: modalias=pci:v00008086d000051EDsv00001043sd0000201Fbc0Csc03i30\n
+A: msi_bus=1\n
+A: msi_irqs/143=msi\n
+A: msi_irqs/144=msi\n
+A: msi_irqs/145=msi\n
+A: msi_irqs/146=msi\n
+A: msi_irqs/147=msi\n
+A: msi_irqs/148=msi\n
+A: msi_irqs/149=msi\n
+A: msi_irqs/150=msi\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    8    9 2112  9\nxHCI ring segments   43   53 4096 53\nbuffer-2048         0   16 2048  8\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0  128   32  1\n
+A: power/control=auto\n
+A: power/runtime_active_time=73070690\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=0\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: resource=0x0000006005220000 0x000000600522ffff 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=0x01\n
+A: subsystem_device=0x201f\n
+A: subsystem_vendor=0x1043\n
+A: vendor=0x8086\n

tests/egismoc-0587/custom.py

@@ -0,0 +1,156 @@
+#!/usr/bin/python3
+
+import traceback
+import sys
+import time
+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
+
+d.open_sync()
+
+assert d.get_driver() == "egismoc"
+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.DUPLICATES_CHECK)
+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)
+
+def enroll_progress(*args):
+    print("finger status: ", d.get_finger_status())
+    print('enroll progress: ' + str(args))
+
+def identify_done(dev, res):
+    global identified
+    identified = True
+    identify_match, identify_print = dev.identify_finish(res)
+    print('indentification_done: ', identify_match, identify_print)
+    assert identify_match.equal(identify_print)
+
+# Beginning with list and clear assumes you begin with >0 prints enrolled before capturing
+
+print("listing - device should have prints")
+stored = d.list_prints_sync()
+assert len(stored) > 0
+del stored
+
+print("clear device storage")
+d.clear_storage_sync()
+print("clear done")
+
+print("listing - device should be empty")
+stored = d.list_prints_sync()
+assert len(stored) == 0
+del stored
+
+print("enrolling")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.LEFT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+p1 = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("enroll done")
+del template
+
+print("listing - device should have 1 print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p1)
+
+print("verifying")
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+verify_res, verify_print = d.verify_sync(p1)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("verify done")
+assert verify_res == True
+
+identified = False
+deserialized_prints = []
+for p in stored:
+    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
+    assert deserialized_prints[-1].equal(p)
+del stored
+
+print('async identifying')
+d.identify(deserialized_prints, callback=identify_done)
+del deserialized_prints
+
+while not identified:
+    ctx.iteration(True)
+
+print("try to enroll duplicate")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.RIGHT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+try:
+    d.enroll_sync(template, None, enroll_progress, None)
+except GLib.Error as error:
+    assert error.matches(FPrint.DeviceError.quark(),
+                         FPrint.DeviceError.DATA_DUPLICATE)
+except Exception as exc:
+    raise
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("duplicate enroll attempt done")
+
+print("listing - device should still only have 1 print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p1)
+del stored
+
+print("enroll new finger")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.RIGHT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+p2 = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("enroll new finger done")
+del template
+
+print("listing - device should have 2 prints")
+stored = d.list_prints_sync()
+assert len(stored) == 2
+assert (stored[0].equal(p1) and stored[1].equal(p2)) or (stored[0].equal(p2) and stored[1].equal(p1))
+del stored
+
+print("deleting first print")
+d.delete_print_sync(p1)
+print("delete done")
+del p1
+
+print("listing - device should only have second print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p2)
+del stored
+del p2
+
+print("clear device storage")
+d.clear_storage_sync()
+print("clear done")
+
+print("listing - device should be empty")
+stored = d.list_prints_sync()
+assert len(stored) == 0
+del stored
+
+d.close_sync()
+
+del d
+del c

tests/egismoc-0587/device

@@ -0,0 +1,270 @@
+P: /devices/pci0000:00/0000:00:14.0/usb3/3-5
+N: bus/usb/003/009=12010002FF0000407A1C870567640102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
+E: BUSNUM=003
+E: DEVNAME=/dev/bus/usb/003/009
+E: DEVNUM=009
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: ID_AUTOSUSPEND=1
+E: ID_BUS=usb
+E: ID_MODEL=ETU905A88-E
+E: ID_MODEL_ENC=ETU905A88-E
+E: ID_MODEL_ID=0587
+E: ID_PATH=pci-0000:00:14.0-usb-0:5
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_5
+E: ID_PATH_WITH_USB_REVISION=pci-0000:00:14.0-usbv2-0:5
+E: ID_PERSIST=0
+E: ID_REVISION=6467
+E: ID_SERIAL=EGIS_ETU905A88-E_198427PCU834
+E: ID_SERIAL_SHORT=198427PCU834
+E: ID_USB_INTERFACES=:ff0000:
+E: ID_USB_MODEL=ETU905A88-E
+E: ID_USB_MODEL_ENC=ETU905A88-E
+E: ID_USB_MODEL_ID=0587
+E: ID_USB_REVISION=6467
+E: ID_USB_SERIAL=EGIS_ETU905A88-E_198427PCU834
+E: ID_USB_SERIAL_SHORT=198427PCU834
+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=264
+E: PRODUCT=1c7a/587/6467
+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=6467\n
+A: bmAttributes=a0\n
+A: busnum=3\n
+A: configuration=
+H: descriptors=12010002FF0000407A1C870567640102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
+A: dev=189:264\n
+A: devnum=9\n
+A: devpath=5\n
+L: driver=../../../../../bus/usb/drivers/usb
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4e/device:4f/device:54
+A: idProduct=0587\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-port5
+A: power/active_duration=58096\n
+A: power/async=enabled\n
+A: power/autosuspend=2\n
+A: power/autosuspend_delay_ms=2000\n
+A: power/connected_duration=183928\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/persist=0\n
+A: power/runtime_active_kids=0\n
+A: power/runtime_active_time=58510\n
+A: power/runtime_enabled=enabled\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=125136\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=ETU905A88-E\n
+A: quirks=0x0\n
+A: removable=fixed\n
+A: rx_lanes=1\n
+A: serial=198427PCU834\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=547\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0/usb3
+N: bus/usb/003/001=12010002090001406B1D020006060302010109021900010100E0000904000001090000000705810304000C
+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_00_14_0
+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:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+E: ID_REVISION=0606
+E: ID_SERIAL=Linux_6.6.0-14-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL_SHORT=0000:00:14.0
+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=0606
+E: ID_USB_SERIAL=Linux_6.6.0-14-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_USB_SERIAL_SHORT=0000:00:14.0
+E: ID_USB_VENDOR=Linux_6.6.0-14-generic_xhci-hcd
+E: ID_USB_VENDOR_ENC=Linux\x206.6.0-14-generic\x20xhci-hcd
+E: ID_USB_VENDOR_ID=1d6b
+E: ID_VENDOR=Linux_6.6.0-14-generic_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x206.6.0-14-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/606
+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=0606\n
+A: bmAttributes=e0\n
+A: busnum=3\n
+A: configuration=
+H: descriptors=12010002090001406B1D020006060302010109021900010100E0000904000001090000000705810304000C
+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:4e/device:4f
+A: idProduct=0002\n
+A: idVendor=1d6b\n
+A: interface_authorized_default=1\n
+A: ltm_capable=no\n
+A: manufacturer=Linux 6.6.0-14-generic xhci-hcd\n
+A: maxchild=12\n
+A: power/active_duration=5145268\n
+A: power/async=enabled\n
+A: power/autosuspend=0\n
+A: power/autosuspend_delay_ms=0\n
+A: power/connected_duration=5191200\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/runtime_active_kids=2\n
+A: power/runtime_active_time=5145262\n
+A: power/runtime_enabled=enabled\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=45937\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:00:14.0\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=637\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0
+E: DRIVER=xhci_hcd
+E: ID_AUTOSUSPEND=1
+E: ID_MODEL_FROM_DATABASE=Alder Lake PCH USB 3.2 xHCI Host Controller
+E: ID_PATH=pci-0000:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+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=Intel Corporation
+E: MODALIAS=pci:v00008086d000051EDsv00001043sd0000201Fbc0Csc03i30
+E: PCI_CLASS=C0330
+E: PCI_ID=8086:51ED
+E: PCI_SLOT_NAME=0000:00:14.0
+E: PCI_SUBSYS_ID=1043:201F
+E: SUBSYSTEM=pci
+A: ari_enabled=0\n
+A: broken_parity_status=0\n
+A: class=0x0c0330\n
+H: config=8680ED51060490020130030C000080000400262F62000000000000000000000000000000000000000000000043101F20000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C1080000000000000000000000059087001805E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F110112000000
+A: consistent_dma_mask_bits=64\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: device=0x51ed\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:4e
+A: index=10\n
+L: iommu=../../virtual/iommu/dmar1
+L: iommu_group=../../../kernel/iommu_groups/11
+A: irq=145\n
+A: label=Onboard - Other\n
+A: local_cpulist=0-19\n
+A: local_cpus=fffff\n
+A: modalias=pci:v00008086d000051EDsv00001043sd0000201Fbc0Csc03i30\n
+A: msi_bus=1\n
+A: msi_irqs/145=msi\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          1   32  128  1\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   10   11 2112 11\nxHCI ring segments   38   38 4096 38\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          6   32  128  1\nbuffer-32           0    0   32  0\n
+A: power/async=enabled\n
+A: power/control=auto\n
+A: power/runtime_active_kids=2\n
+A: power/runtime_active_time=5192072\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=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: resource=0x000000622f260000 0x000000622f26ffff 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=0x01\n
+A: subsystem_device=0x201f\n
+A: subsystem_vendor=0x1043\n
+A: vendor=0x8086\n
+

tests/egismoc-05a1/custom.py

@@ -0,0 +1,156 @@
+#!/usr/bin/python3
+
+import traceback
+import sys
+import time
+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
+
+d.open_sync()
+
+assert d.get_driver() == "egismoc"
+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.DUPLICATES_CHECK)
+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)
+
+def enroll_progress(*args):
+    print("finger status: ", d.get_finger_status())
+    print('enroll progress: ' + str(args))
+
+def identify_done(dev, res):
+    global identified
+    identified = True
+    identify_match, identify_print = dev.identify_finish(res)
+    print('indentification_done: ', identify_match, identify_print)
+    assert identify_match.equal(identify_print)
+
+# Beginning with list and clear assumes you begin with >0 prints enrolled before capturing
+
+print("listing - device should have prints")
+stored = d.list_prints_sync()
+assert len(stored) > 0
+del stored
+
+print("clear device storage")
+d.clear_storage_sync()
+print("clear done")
+
+print("listing - device should be empty")
+stored = d.list_prints_sync()
+assert len(stored) == 0
+del stored
+
+print("enrolling")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.LEFT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+p1 = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("enroll done")
+del template
+
+print("listing - device should have 1 print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p1)
+
+print("verifying")
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+verify_res, verify_print = d.verify_sync(p1)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("verify done")
+assert verify_res == True
+
+identified = False
+deserialized_prints = []
+for p in stored:
+    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
+    assert deserialized_prints[-1].equal(p)
+del stored
+
+print('async identifying')
+d.identify(deserialized_prints, callback=identify_done)
+del deserialized_prints
+
+while not identified:
+    ctx.iteration(True)
+
+print("try to enroll duplicate")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.RIGHT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+try:
+    d.enroll_sync(template, None, enroll_progress, None)
+except GLib.Error as error:
+    assert error.matches(FPrint.DeviceError.quark(),
+                         FPrint.DeviceError.DATA_DUPLICATE)
+except Exception as exc:
+    raise
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("duplicate enroll attempt done")
+
+print("listing - device should still only have 1 print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p1)
+del stored
+
+print("enroll new finger")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.RIGHT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+p2 = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("enroll new finger done")
+del template
+
+print("listing - device should have 2 prints")
+stored = d.list_prints_sync()
+assert len(stored) == 2
+assert (stored[0].equal(p1) and stored[1].equal(p2)) or (stored[0].equal(p2) and stored[1].equal(p1))
+del stored
+
+print("deleting first print")
+d.delete_print_sync(p1)
+print("delete done")
+del p1
+
+print("listing - device should only have second print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p2)
+del stored
+del p2
+
+print("clear device storage")
+d.clear_storage_sync()
+print("clear done")
+
+print("listing - device should be empty")
+stored = d.list_prints_sync()
+assert len(stored) == 0
+del stored
+
+d.close_sync()
+
+del d
+del c

tests/egismoc-05a1/device

@@ -0,0 +1,262 @@
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-5
+N: bus/usb/001/003=12010002FF0000407A1CA10513120102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
+E: BUSNUM=001
+E: DEVNAME=/dev/bus/usb/001/003
+E: DEVNUM=003
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: ID_BUS=usb
+E: ID_MODEL=ETU905A80-E
+E: ID_MODEL_ENC=ETU905A80-E
+E: ID_MODEL_ID=05a1
+E: ID_REVISION=1213
+E: ID_SERIAL=EGIS_ETU905A80-E_0C5A44PCU833
+E: ID_SERIAL_SHORT=0C5A44PCU833
+E: ID_USB_INTERFACES=:ff0000:
+E: ID_USB_MODEL=ETU905A80-E
+E: ID_USB_MODEL_ENC=ETU905A80-E
+E: ID_USB_MODEL_ID=05a1
+E: ID_USB_REVISION=1213
+E: ID_USB_SERIAL=EGIS_ETU905A80-E_0C5A44PCU833
+E: ID_USB_SERIAL_SHORT=0C5A44PCU833
+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=2
+E: PRODUCT=1c7a/5a1/1213
+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=1213\n
+A: bmAttributes=a0\n
+A: busnum=1\n
+A: configuration=
+H: descriptors=12010002FF0000407A1CA10513120102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
+A: dev=189:2\n
+A: devnum=3\n
+A: devpath=5\n
+L: driver=../../../../../bus/usb/drivers/usb
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:51/device:52/device:57
+A: idProduct=05a1\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=center\n
+A: physical_location/lid=no\n
+A: physical_location/panel=unknown\n
+A: physical_location/vertical_position=center\n
+L: port=../1-0:1.0/usb1-port5
+A: power/active_duration=955612\n
+A: power/async=enabled\n
+A: power/autosuspend=2\n
+A: power/autosuspend_delay_ms=2000\n
+A: power/connected_duration=955612\n
+A: power/control=on\n
+A: power/level=on\n
+A: power/persist=0\n
+A: power/runtime_active_kids=0\n
+A: power/runtime_active_time=955338\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=ETU905A80-E\n
+A: quirks=0x0\n
+A: removable=fixed\n
+A: rx_lanes=1\n
+A: serial=0C5A44PCU833\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=491\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0/usb1
+N: bus/usb/001/001=12010002090001406B1D020005060302010109021900010100E0000904000001090000000705810304000C
+E: BUSNUM=001
+E: CURRENT_TAGS=:seat:
+E: DEVNAME=/dev/bus/usb/001/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_00_14_0
+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:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+E: ID_REVISION=0605
+E: ID_SERIAL=Linux_6.5.0-9-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL_SHORT=0000:00:14.0
+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=0605
+E: ID_USB_SERIAL=Linux_6.5.0-9-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_USB_SERIAL_SHORT=0000:00:14.0
+E: ID_USB_VENDOR=Linux_6.5.0-9-generic_xhci-hcd
+E: ID_USB_VENDOR_ENC=Linux\x206.5.0-9-generic\x20xhci-hcd
+E: ID_USB_VENDOR_ID=1d6b
+E: ID_VENDOR=Linux_6.5.0-9-generic_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x206.5.0-9-generic\x20xhci-hcd
+E: ID_VENDOR_FROM_DATABASE=Linux Foundation
+E: ID_VENDOR_ID=1d6b
+E: MAJOR=189
+E: MINOR=0
+E: PRODUCT=1d6b/2/605
+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=0605\n
+A: bmAttributes=e0\n
+A: busnum=1\n
+A: configuration=
+H: descriptors=12010002090001406B1D020005060302010109021900010100E0000904000001090000000705810304000C
+A: dev=189:0\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:51/device:52
+A: idProduct=0002\n
+A: idVendor=1d6b\n
+A: interface_authorized_default=1\n
+A: ltm_capable=no\n
+A: manufacturer=Linux 6.5.0-9-generic xhci-hcd\n
+A: maxchild=12\n
+A: power/active_duration=956044\n
+A: power/async=enabled\n
+A: power/autosuspend=0\n
+A: power/autosuspend_delay_ms=0\n
+A: power/connected_duration=956044\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/runtime_active_kids=2\n
+A: power/runtime_active_time=956041\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:00:14.0\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=181\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0
+E: DRIVER=xhci_hcd
+E: ID_MODEL_FROM_DATABASE=Alder Lake PCH USB 3.2 xHCI Host Controller
+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=Intel Corporation
+E: MODALIAS=pci:v00008086d000051EDsv0000144Dsd0000C1CAbc0Csc03i30
+E: PCI_CLASS=C0330
+E: PCI_ID=8086:51ED
+E: PCI_SLOT_NAME=0000:00:14.0
+E: PCI_SUBSYS_ID=144D:C1CA
+E: SUBSYSTEM=pci
+A: ari_enabled=0\n
+A: broken_parity_status=0\n
+A: class=0x0c0330\n
+H: config=8680ED51060490020130030C0000800004001A3E6000000000000000000000000000000000000000000000004D14CAC1000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C108000000000000000000000005908700D804E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F110112000000
+A: consistent_dma_mask_bits=64\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: device=0x51ed\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:51
+A: index=9\n
+L: iommu=../../virtual/iommu/dmar2
+L: iommu_group=../../../kernel/iommu_groups/11
+A: irq=142\n
+A: label=Onboard - Other\n
+A: local_cpulist=0-15\n
+A: local_cpus=ffff\n
+A: modalias=pci:v00008086d000051EDsv0000144Dsd0000C1CAbc0Csc03i30\n
+A: msi_bus=1\n
+A: msi_irqs/142=msi\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    6    7 2112  7\nxHCI ring segments   28   28 4096 28\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          1   32  128  1\nbuffer-32           0    0   32  0\n
+A: power/async=enabled\n
+A: power/control=auto\n
+A: power/runtime_active_kids=1\n
+A: power/runtime_active_time=957198\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=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: resource=0x000000603e1a0000 0x000000603e1affff 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=0x01\n
+A: subsystem_device=0xc1ca\n
+A: subsystem_vendor=0x144d\n
+A: vendor=0x8086\n
+

tests/egismoc/custom.py

@@ -0,0 +1,156 @@
+#!/usr/bin/python3
+
+import traceback
+import sys
+import time
+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
+
+d.open_sync()
+
+assert d.get_driver() == "egismoc"
+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.DUPLICATES_CHECK)
+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)
+
+def enroll_progress(*args):
+    print("finger status: ", d.get_finger_status())
+    print('enroll progress: ' + str(args))
+
+def identify_done(dev, res):
+    global identified
+    identified = True
+    identify_match, identify_print = dev.identify_finish(res)
+    print('indentification_done: ', identify_match, identify_print)
+    assert identify_match.equal(identify_print)
+
+# Beginning with list and clear assumes you begin with >0 prints enrolled before capturing
+
+print("listing - device should have prints")
+stored = d.list_prints_sync()
+assert len(stored) > 0
+del stored
+
+print("clear device storage")
+d.clear_storage_sync()
+print("clear done")
+
+print("listing - device should be empty")
+stored = d.list_prints_sync()
+assert len(stored) == 0
+del stored
+
+print("enrolling")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.LEFT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+p1 = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("enroll done")
+del template
+
+print("listing - device should have 1 print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p1)
+
+print("verifying")
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+verify_res, verify_print = d.verify_sync(p1)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("verify done")
+assert verify_res == True
+
+identified = False
+deserialized_prints = []
+for p in stored:
+    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
+    assert deserialized_prints[-1].equal(p)
+del stored
+
+print('async identifying')
+d.identify(deserialized_prints, callback=identify_done)
+del deserialized_prints
+
+while not identified:
+    ctx.iteration(True)
+
+print("try to enroll duplicate")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.RIGHT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+try:
+    d.enroll_sync(template, None, enroll_progress, None)
+except GLib.Error as error:
+    assert error.matches(FPrint.DeviceError.quark(),
+                         FPrint.DeviceError.DATA_DUPLICATE)
+except Exception as exc:
+    raise
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("duplicate enroll attempt done")
+
+print("listing - device should still only have 1 print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p1)
+del stored
+
+print("enroll new finger")
+template = FPrint.Print.new(d)
+template.set_finger(FPrint.Finger.RIGHT_INDEX)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+p2 = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+print("enroll new finger done")
+del template
+
+print("listing - device should have 2 prints")
+stored = d.list_prints_sync()
+assert len(stored) == 2
+assert (stored[0].equal(p1) and stored[1].equal(p2)) or (stored[0].equal(p2) and stored[1].equal(p1))
+del stored
+
+print("deleting first print")
+d.delete_print_sync(p1)
+print("delete done")
+del p1
+
+print("listing - device should only have second print")
+stored = d.list_prints_sync()
+assert len(stored) == 1
+assert stored[0].equal(p2)
+del stored
+del p2
+
+print("clear device storage")
+d.clear_storage_sync()
+print("clear done")
+
+print("listing - device should be empty")
+stored = d.list_prints_sync()
+assert len(stored) == 0
+del stored
+
+d.close_sync()
+
+del d
+del c

tests/egismoc/device

@@ -0,0 +1,262 @@
+P: /devices/pci0000:00/0000:00:14.0/usb3/3-5
+N: bus/usb/003/012=12010002FF0000407A1C820581110102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
+E: BUSNUM=003
+E: CURRENT_TAGS=:snap_cups_ippeveprinter:snap_cups_cupsd:
+E: DEVNAME=/dev/bus/usb/003/012
+E: DEVNUM=012
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: ID_BUS=usb
+E: ID_MODEL=ETU905A80-E
+E: ID_MODEL_ENC=ETU905A80-E
+E: ID_MODEL_ID=0582
+E: ID_PATH=pci-0000:00:14.0-usb-0:5
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_5
+E: ID_REVISION=1181
+E: ID_SERIAL=EGIS_ETU905A80-E_0E7828PBS393
+E: ID_SERIAL_SHORT=0E7828PBS393
+E: ID_USB_INTERFACES=:ff0000:
+E: ID_USB_MODEL=ETU905A80-E
+E: ID_USB_MODEL_ENC=ETU905A80-E
+E: ID_USB_MODEL_ID=0582
+E: ID_USB_REVISION=1181
+E: ID_USB_SERIAL=EGIS_ETU905A80-E_0E7828PBS393
+E: ID_USB_SERIAL_SHORT=0E7828PBS393
+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=267
+E: PRODUCT=1c7a/582/1181
+E: SUBSYSTEM=usb
+E: TAGS=:snap_cups_ippeveprinter:snap_cups_cupsd:
+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=1181\n
+A: bmAttributes=a0\n
+A: busnum=3\n
+A: configuration=
+H: descriptors=12010002FF0000407A1C820581110102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
+A: dev=189:267\n
+A: devnum=12\n
+A: devpath=5\n
+L: driver=../../../../../bus/usb/drivers/usb
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:51/device:52/device:57
+A: idProduct=0582\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=center\n
+A: physical_location/lid=no\n
+A: physical_location/panel=unknown\n
+A: physical_location/vertical_position=center\n
+L: port=../3-0:1.0/usb3-port5
+A: power/active_duration=1425996\n
+A: power/async=enabled\n
+A: power/autosuspend=2\n
+A: power/autosuspend_delay_ms=2000\n
+A: power/connected_duration=1426656\n
+A: power/control=on\n
+A: power/level=on\n
+A: power/persist=0\n
+A: power/runtime_active_kids=0\n
+A: power/runtime_active_time=1426124\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=ETU905A80-E\n
+A: quirks=0x0\n
+A: removable=fixed\n
+A: rx_lanes=1\n
+A: serial=0E7828PBS393\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=2803\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0/usb3
+N: bus/usb/003/001=12010002090001406B1D020002060302010109021900010100E0000904000001090000000705810304000C
+E: BUSNUM=003
+E: CURRENT_TAGS=:seat:snap_cups_cupsd:snap_cups_ippeveprinter:
+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_00_14_0
+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:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+E: ID_REVISION=0602
+E: ID_SERIAL=Linux_6.2.0-34-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL_SHORT=0000:00:14.0
+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=0602
+E: ID_USB_SERIAL=Linux_6.2.0-34-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_USB_SERIAL_SHORT=0000:00:14.0
+E: ID_USB_VENDOR=Linux_6.2.0-34-generic_xhci-hcd
+E: ID_USB_VENDOR_ENC=Linux\x206.2.0-34-generic\x20xhci-hcd
+E: ID_USB_VENDOR_ID=1d6b
+E: ID_VENDOR=Linux_6.2.0-34-generic_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x206.2.0-34-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/602
+E: SUBSYSTEM=usb
+E: TAGS=:snap_cups_cupsd:seat:snap_cups_ippeveprinter:
+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=0602\n
+A: bmAttributes=e0\n
+A: busnum=3\n
+A: configuration=
+H: descriptors=12010002090001406B1D020002060302010109021900010100E0000904000001090000000705810304000C
+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:51/device:52
+A: idProduct=0002\n
+A: idVendor=1d6b\n
+A: interface_authorized_default=1\n
+A: ltm_capable=no\n
+A: manufacturer=Linux 6.2.0-34-generic xhci-hcd\n
+A: maxchild=12\n
+A: power/active_duration=337953872\n
+A: power/async=enabled\n
+A: power/autosuspend=0\n
+A: power/autosuspend_delay_ms=0\n
+A: power/connected_duration=337978524\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/runtime_active_kids=1\n
+A: power/runtime_active_time=337962424\n
+A: power/runtime_enabled=enabled\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=616\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:00:14.0\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=4969\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0
+E: DRIVER=xhci_hcd
+E: ID_MODEL_FROM_DATABASE=Alder Lake PCH USB 3.2 xHCI Host Controller
+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=Intel Corporation
+E: MODALIAS=pci:v00008086d000051EDsv0000144Dsd0000C870bc0Csc03i30
+E: PCI_CLASS=C0330
+E: PCI_ID=8086:51ED
+E: PCI_SLOT_NAME=0000:00:14.0
+E: PCI_SUBSYS_ID=144D:C870
+E: SUBSYSTEM=pci
+A: ari_enabled=0\n
+A: broken_parity_status=0\n
+A: class=0x0c0330\n
+H: config=8680ED51060490020130030C000080000400161D6000000000000000000000000000000000000000000000004D1470C8000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C1080000000000000000000000059087007805E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F010112000000
+A: consistent_dma_mask_bits=64\n
+A: d3cold_allowed=1\n
+A: dbc=disabled\n
+A: device=0x51ed\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:51
+A: index=7\n
+L: iommu=../../virtual/iommu/dmar1
+L: iommu_group=../../../kernel/iommu_groups/8
+A: irq=145\n
+A: label=Onboard - Other\n
+A: local_cpulist=0-15\n
+A: local_cpus=ffff\n
+A: modalias=pci:v00008086d000051EDsv0000144Dsd0000C870bc0Csc03i30\n
+A: msi_bus=1\n
+A: msi_irqs/145=msi\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    6    9 2112  9\nxHCI ring segments   26   34 4096 34\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0   32  128  1\nbuffer-32           0    0   32  0\n
+A: power/async=enabled\n
+A: power/control=auto\n
+A: power/runtime_active_kids=1\n
+A: power/runtime_active_time=337964621\n
+A: power/runtime_enabled=enabled\n
+A: power/runtime_status=active\n
+A: power/runtime_suspended_time=438\n
+A: power/runtime_usage=0\n
+A: power/wakeup=enabled\n
+A: power/wakeup_abort_count=0\n
+A: power/wakeup_active=0\n
+A: power/wakeup_active_count=7\n
+A: power/wakeup_count=0\n
+A: power/wakeup_expire_count=7\n
+A: power/wakeup_last_time_ms=336554844\n
+A: power/wakeup_max_time_ms=105\n
+A: power/wakeup_total_time_ms=721\n
+A: power_state=D0\n
+A: resource=0x000000601d160000 0x000000601d16ffff 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=0x01\n
+A: subsystem_device=0xc870\n
+A: subsystem_vendor=0x144d\n
+A: vendor=0x8086\n
+

tests/focaltech_moc/custom.py

@@ -0,0 +1,89 @@
+#!/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() == "focaltech_moc"
+assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
+assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
+assert d.has_feature(FPrint.DeviceFeature.VERIFY)
+assert not d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
+assert d.has_feature(FPrint.DeviceFeature.STORAGE)
+assert d.has_feature(FPrint.DeviceFeature.STORAGE_LIST)
+assert d.has_feature(FPrint.DeviceFeature.STORAGE_DELETE)
+assert not d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
+
+d.open_sync()
+
+template = FPrint.Print.new(d)
+
+def enroll_progress(*args):
+    #assert d.get_finger_status() == FPrint.FingerStatusFlags.NEEDED
+    print("finger status: ", d.get_finger_status())
+    print('enroll progress: ' + str(args))
+
+def identify_done(dev, res):
+    global identified
+    identified = True
+    identify_match, identify_print = dev.identify_finish(res)
+    print('indentification_done: ', identify_match, identify_print)
+    assert identify_match.equal(identify_print)
+
+# List, enroll, list, verify, identify, delete
+print("enrolling")
+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")
+
+print("listing")
+stored = d.list_prints_sync()
+print("listing done")
+assert len(stored) == 1
+assert stored[0].equal(p)
+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("verify done")
+del p
+assert verify_res == True
+
+identified = False
+deserialized_prints = []
+for p in stored:
+    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
+    assert deserialized_prints[-1].equal(p)
+del stored
+
+print('async identifying')
+d.identify(deserialized_prints, callback=identify_done)
+del deserialized_prints
+
+while not identified:
+    ctx.iteration(True)
+
+print("deleting")
+d.delete_print_sync(p)
+print("delete done")
+
+d.close_sync()
+
+del d
+del c

tests/goodixmoc/device

@@ -1,31 +1,30 @@
-P: /devices/pci0000:00/0000:00:14.0/usb1/1-3
+P: /devices/pci0000:00/0000:00:14.0/usb3/3-9
-N: bus/usb/001/023=12010002EF000040C627966400010102030109022000010103A0320904000002FF0000040705830240000007050102400000
+N: bus/usb/003/004=12010002EF000040C627AC6300010102030109022000010103A0320904000002FF0000040705830240000007050102400000
-E: DEVNAME=/dev/bus/usb/001/023
+E: DEVNAME=/dev/bus/usb/003/004
 E: DEVTYPE=usb_device
 E: DRIVER=usb
-E: PRODUCT=27c6/6496/100
+E: PRODUCT=27c6/63ac/100
 E: TYPE=239/0/0
-E: BUSNUM=001
+E: BUSNUM=003
-E: DEVNUM=023
+E: DEVNUM=004
 E: MAJOR=189
-E: MINOR=22
+E: MINOR=259
 E: SUBSYSTEM=usb
 E: ID_VENDOR=Goodix_Technology_Co.__Ltd.
 E: ID_VENDOR_ENC=Goodix\x20Technology\x20Co.\x2c\x20Ltd.
 E: ID_VENDOR_ID=27c6
 E: ID_MODEL=Goodix_USB2.0_MISC
 E: ID_MODEL_ENC=Goodix\x20USB2.0\x20MISC
-E: ID_MODEL_ID=6496
+E: ID_MODEL_ID=63ac
 E: ID_REVISION=0100
-E: ID_SERIAL=Goodix_Technology_Co.__Ltd._Goodix_USB2.0_MISC_XXXX_MOC_B0
+E: ID_SERIAL=Goodix_Technology_Co.__Ltd._Goodix_USB2.0_MISC_UID4C77C784_XXXX_MOC_B0
-E: ID_SERIAL_SHORT=XXXX_MOC_B0
+E: ID_SERIAL_SHORT=UID4C77C784_XXXX_MOC_B0
 E: ID_BUS=usb
 E: ID_USB_INTERFACES=:ff0000:
 E: ID_VENDOR_FROM_DATABASE=Shenzhen Goodix Technology Co.,Ltd.
 E: ID_AUTOSUSPEND=1
-E: ID_PERSIST=0
+E: ID_PATH=pci-0000:00:14.0-usb-0:9
-E: ID_PATH=pci-0000:00:14.0-usb-0:3
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_9
-E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_3
 A: authorized=1\n
 A: avoid_reset_quirk=0\n
 A: bConfigurationValue=1\n
@@ -38,30 +37,34 @@ A: bNumConfigurations=1\n
 A: bNumInterfaces= 1\n
 A: bcdDevice=0100\n
 A: bmAttributes=a0\n
-A: busnum=1\n
+A: busnum=3\n
-A: configuration=XXXX_MOC_B0\n
+A: configuration=UID4C77C784_XXXX_MOC_B0\n
-H: descriptors=12010002EF000040C627966400010102030109022000010103A0320904000002FF0000040705830240000007050102400000
+H: descriptors=12010002EF000040C627AC6300010102030109022000010103A0320904000002FF0000040705830240000007050102400000
-A: dev=189:22\n
+A: dev=189:259\n
-A: devnum=23\n
+A: devnum=4\n
-A: devpath=3\n
+A: devpath=9\n
 L: driver=../../../../../bus/usb/drivers/usb
-L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:1c/device:1d/device:20
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:13/device:14/device:1f
-A: idProduct=6496\n
+A: idProduct=63ac\n
 A: idVendor=27c6\n
 A: ltm_capable=no\n
 A: manufacturer=Goodix Technology Co., Ltd.\n
 A: maxchild=0\n
-L: port=../1-0:1.0/usb1-port3
+L: port=../3-0:1.0/usb3-port9
-A: power/active_duration=22667\n
+A: power/active_duration=702588\n
+A: power/async=enabled\n
 A: power/autosuspend=2\n
 A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=917616\n
+A: power/connected_duration=78973756\n
 A: power/control=auto\n
 A: power/level=auto\n
 A: power/persist=1\n
-A: power/runtime_active_time=22809\n
+A: power/runtime_active_kids=0\n
+A: power/runtime_active_time=707156\n
+A: power/runtime_enabled=enabled\n
 A: power/runtime_status=active\n
-A: power/runtime_suspended_time=894564\n
+A: power/runtime_suspended_time=78265226\n
+A: power/runtime_usage=0\n
 A: power/wakeup=disabled\n
 A: power/wakeup_abort_count=\n
 A: power/wakeup_active=\n
@@ -73,34 +76,34 @@ A: power/wakeup_max_time_ms=\n
 A: power/wakeup_total_time_ms=\n
 A: product=Goodix USB2.0 MISC\n
 A: quirks=0x0\n
-A: removable=removable\n
+A: removable=fixed\n
 A: rx_lanes=1\n
-A: serial=XXXX_MOC_B0\n
+A: serial=UID4C77C784_XXXX_MOC_B0\n
 A: speed=12\n
 A: tx_lanes=1\n
-A: urbnum=298\n
+A: urbnum=5759\n
 A: version= 2.00\n
 
-P: /devices/pci0000:00/0000:00:14.0/usb1
+P: /devices/pci0000:00/0000:00:14.0/usb3
-N: bus/usb/001/001=12010002090001406B1D020017050302010109021900010100E0000904000001090000000705810304000C
+N: bus/usb/003/001=12010002090001406B1D020015050302010109021900010100E0000904000001090000000705810304000C
-E: DEVNAME=/dev/bus/usb/001/001
+E: DEVNAME=/dev/bus/usb/003/001
 E: DEVTYPE=usb_device
 E: DRIVER=usb
-E: PRODUCT=1d6b/2/517
+E: PRODUCT=1d6b/2/515
 E: TYPE=9/0/1
-E: BUSNUM=001
+E: BUSNUM=003
 E: DEVNUM=001
 E: MAJOR=189
-E: MINOR=0
+E: MINOR=256
 E: SUBSYSTEM=usb
-E: ID_VENDOR=Linux_5.17.12-300.fc36.x86_64_xhci-hcd
+E: ID_VENDOR=Linux_5.15.0-57-generic_xhci-hcd
-E: ID_VENDOR_ENC=Linux\x205.17.12-300.fc36.x86_64\x20xhci-hcd
+E: ID_VENDOR_ENC=Linux\x205.15.0-57-generic\x20xhci-hcd
 E: ID_VENDOR_ID=1d6b
 E: ID_MODEL=xHCI_Host_Controller
 E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
 E: ID_MODEL_ID=0002
-E: ID_REVISION=0517
+E: ID_REVISION=0515
-E: ID_SERIAL=Linux_5.17.12-300.fc36.x86_64_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL=Linux_5.15.0-57-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
 E: ID_SERIAL_SHORT=0000:00:14.0
 E: ID_BUS=usb
 E: ID_USB_INTERFACES=:090000:
@@ -123,31 +126,35 @@ A: bMaxPacketSize0=64\n
 A: bMaxPower=0mA\n
 A: bNumConfigurations=1\n
 A: bNumInterfaces= 1\n
-A: bcdDevice=0517\n
+A: bcdDevice=0515\n
 A: bmAttributes=e0\n
-A: busnum=1\n
+A: busnum=3\n
-A: configuration=\n
+A: configuration=
-H: descriptors=12010002090001406B1D020017050302010109021900010100E0000904000001090000000705810304000C
+H: descriptors=12010002090001406B1D020015050302010109021900010100E0000904000001090000000705810304000C
-A: dev=189:0\n
+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:1c/device:1d
+L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:13/device:14
 A: idProduct=0002\n
 A: idVendor=1d6b\n
 A: interface_authorized_default=1\n
 A: ltm_capable=no\n
-A: manufacturer=Linux 5.17.12-300.fc36.x86_64 xhci-hcd\n
+A: manufacturer=Linux 5.15.0-57-generic xhci-hcd\n
 A: maxchild=12\n
-A: power/active_duration=164289796\n
+A: power/active_duration=78971960\n
+A: power/async=enabled\n
 A: power/autosuspend=0\n
 A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=164360220\n
+A: power/connected_duration=78974992\n
 A: power/control=auto\n
 A: power/level=auto\n
-A: power/runtime_active_time=164331876\n
+A: power/runtime_active_kids=2\n
+A: power/runtime_active_time=78973899\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
@@ -164,48 +171,52 @@ A: rx_lanes=1\n
 A: serial=0000:00:14.0\n
 A: speed=480\n
 A: tx_lanes=1\n
-A: urbnum=2097\n
+A: urbnum=1824\n
 A: version= 2.00\n
 
 P: /devices/pci0000:00/0000:00:14.0
 E: DRIVER=xhci_hcd
 E: PCI_CLASS=C0330
-E: PCI_ID=8086:9DED
+E: PCI_ID=8086:51ED
-E: PCI_SUBSYS_ID=17AA:2292
+E: PCI_SUBSYS_ID=1028:0B00
 E: PCI_SLOT_NAME=0000:00:14.0
-E: MODALIAS=pci:v00008086d00009DEDsv000017AAsd00002292bc0Csc03i30
+E: MODALIAS=pci:v00008086d000051EDsv00001028sd00000B00bc0Csc03i30
 E: SUBSYSTEM=pci
 E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
 E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
 E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
 E: ID_VENDOR_FROM_DATABASE=Intel Corporation
-E: ID_AUTOSUSPEND=1
-E: ID_MODEL_FROM_DATABASE=Cannon Point-LP USB 3.1 xHCI Controller
 A: ari_enabled=0\n
 A: broken_parity_status=0\n
 A: class=0x0c0330\n
-H: config=8680ED9D060490021130030C00008000040022EA000000000000000000000000000000000000000000000000AA179222000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F00000000F507312600000000316000000000000000000000000000000180C2C1080000000000000000000000059087001803E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000000000000000000008000000040000000000000000000000000000000000000000000000000000000800000004000000000000000000000000000000000000000000000000000000B50F320112000000
+H: config=8680ED51060490020130030C0000800004002A8F6200000000000000000000000000000000000000000000002810000B000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C1080000000000000000000000059087003808E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F100112000000
 A: consistent_dma_mask_bits=64\n
 A: d3cold_allowed=1\n
 A: dbc=disabled\n
-A: device=0x9ded\n
+A: device=0x51ed\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:1c
+L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:13
-A: irq=128\n
+L: iommu=../../virtual/iommu/dmar1
-A: local_cpulist=0-7\n
+L: iommu_group=../../../kernel/iommu_groups/13
-A: local_cpus=ff\n
+A: irq=167\n
-A: modalias=pci:v00008086d00009DEDsv000017AAsd00002292bc0Csc03i30\n
+A: local_cpulist=0-19\n
+A: local_cpus=fffff\n
+A: modalias=pci:v00008086d000051EDsv00001028sd00000B00bc0Csc03i30\n
 A: msi_bus=1\n
-A: msi_irqs/128=msi\n
+A: msi_irqs/167=msi\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   11   12 2112 12\nxHCI ring segments   46   50 4096 50\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          6   32  128  1\nbuffer-32           0    0   32  0\n
+A: pools=poolinfo - 0.1\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts   13   14 2112 14\nxHCI ring segments   38   42 4096 42\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          3   32  128  1\nbuffer-32           0    0   32  0\n
+A: power/async=enabled\n
 A: power/control=auto\n
-A: power/runtime_active_time=164332777\n
+A: power/runtime_active_kids=1\n
+A: power/runtime_active_time=78974886\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=enabled\n
 A: power/wakeup_abort_count=0\n
 A: power/wakeup_active=0\n
@@ -216,9 +227,9 @@ 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: resource=0x00000000ea220000 0x00000000ea22ffff 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: resource=0x000000628f2a0000 0x000000628f2affff 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=0x11\n
+A: revision=0x01\n
-A: subsystem_device=0x2292\n
+A: subsystem_device=0x0b00\n
-A: subsystem_vendor=0x17aa\n
+A: subsystem_vendor=0x1028\n
 A: vendor=0x8086\n
 

tests/libfprint.supp

@@ -17,3 +17,10 @@
    ...
 }
 
+{
+   <ignore-g-thread-new-leak>
+   Memcheck:Leak
+   fun:calloc
+   ...
+   fun:g_thread_new
+}

tests/meson.build

@@ -4,23 +4,34 @@ envs.set('G_DEBUG', 'fatal-warnings')
 envs.set('G_MESSAGES_DEBUG', 'all')
 
 # Setup paths
-envs.set('MESON_SOURCE_ROOT', meson.source_root())
+envs.set('MESON_SOURCE_ROOT', meson.project_source_root())
-envs.set('MESON_BUILD_ROOT', meson.build_root())
+envs.set('MESON_BUILD_ROOT', meson.project_build_root())
-envs.prepend('LD_LIBRARY_PATH', join_paths(meson.build_root(), 'libfprint'))
+envs.set('G_TEST_SRCDIR', meson.current_source_dir())
+envs.set('G_TEST_BUILDDIR', meson.current_build_dir())
+envs.prepend('LD_LIBRARY_PATH', meson.project_build_root() / 'libfprint')
 
 # Set FP_DEVICE_EMULATION so that drivers can adapt (e.g. to use fixed
 # random numbers rather than proper ones)
 envs.set('FP_DEVICE_EMULATION', '1')
 
 # Set a colon-separated list of native drivers we enable in tests
-envs.set('FP_DRIVERS_WHITELIST', ':'.join([
+envs.set('FP_DRIVERS_ALLOWLIST', ':'.join([
     'virtual_image',
     'virtual_device',
     'virtual_device_storage',
 ]))
 
+envs.set('FP_PRINTS_PATH', meson.project_source_root() / 'examples' / 'prints')
+
 envs.set('NO_AT_BRIDGE', '1')
 
+python3 = find_program('python3')
+
+installed_tests = get_option('installed-tests')
+installed_tests_execdir = libexecdir / 'installed-tests' / versioned_libname
+installed_tests_testdir = datadir / 'installed-tests' / versioned_libname
+installed_tests_libdir = libdir
+
 drivers_tests = [
     'aes2501',
     'aes3500',
@@ -30,6 +41,7 @@ drivers_tests = [
     'elanspi',
     'synaptics',
     'upektc_img',
+    'upektc_img-tcs1s',
     'uru4000-msv2',
     'uru4000-4500',
     'vfs0050',
@@ -39,28 +51,51 @@ drivers_tests = [
     'goodixmoc',
     'nb1010',
     'egis0570',
+    'egismoc',
+    'egismoc-05a1',
+    'egismoc-0586',
+    'egismoc-0587',
     'fpcmoc',
+	'realtek',
+	'realtek-5816',
+    'focaltech_moc',
 ]
 
 if get_option('introspection')
   conf = configuration_data()
-  conf.set('SRCDIR', meson.source_root())
+  conf.set('SRCDIR', meson.project_source_root())
-  conf.set('BUILDDIR', meson.build_root())
+  conf.set('BUILDDIR', meson.project_build_root())
   configure_file(configuration: conf,
       input: 'create-driver-test.py.in',
       output: 'create-driver-test.py')
 endif
 
+env_parser_cmd = '''
+import os;
+print(" ".join([f"{k}={v}" for k, v in os.environ.items()
+    if k.startswith("FP_") or k.startswith("G_")]))
+'''
+
+envs_str = run_command(python3, '-c', env_parser_cmd,
+    env: envs,
+    check: installed_tests).stdout().strip()
+
+envs_str = ' '.join([
+    envs_str,
+    'G_TEST_SRCDIR=' + installed_tests_testdir,
+    'G_TEST_BUILDDIR=' + installed_tests_execdir,
+])
+
 if get_option('introspection')
-    envs.prepend('GI_TYPELIB_PATH', join_paths(meson.build_root(), 'libfprint'))
+    envs.prepend('GI_TYPELIB_PATH', meson.project_build_root() / 'libfprint')
     virtual_devices_tests = [
         'virtual-image',
         'virtual-device',
     ]
 
-    python3 = find_program('python3')
     unittest_inspector = find_program('unittest_inspector.py')
-    umockdev_test = find_program('umockdev-test.py')
+    umockdev_test_name = 'umockdev-test.py'
+    umockdev_test = find_program(umockdev_test_name)
 
     foreach vdtest: virtual_devices_tests
         driver_name = '_'.join(vdtest.split('-'))
@@ -68,11 +103,17 @@ if get_option('introspection')
             base_args = files(vdtest + '.py')
             suite = ['virtual-driver']
 
-            r = run_command(unittest_inspector, files(vdtest + '.py'), check: true)
+            r = run_command(unittest_inspector, files(vdtest + '.py'), check: false)
             unit_tests = r.stdout().strip().split('\n')
 
             if r.returncode() == 0 and unit_tests.length() > 0
                 suite += vdtest
+            elif r.returncode() == 77
+                test(vdtest,
+                    sh,
+                    args: ['-c', 'exit 77']
+                )
+                continue
             else
                 unit_tests = [vdtest]
             endif
@@ -92,21 +133,48 @@ if get_option('introspection')
                     env: envs,
                 )
             endforeach
+
+            if installed_tests
+                install_data(base_args,
+                    install_dir: installed_tests_execdir,
+                    install_mode: 'rwxr-xr-x',
+                )
+
+                configure_file(
+                    input: 'test.in',
+                    output: vdtest + '.test',
+                    install_dir: installed_tests_testdir,
+                    configuration: {
+                        # FIXME: use fs.name() on meson 0.58
+                        'exec': installed_tests_execdir / '@0@'.format(base_args[0]).split('/')[-1],
+                        'env': ' '.join([
+                            envs_str,
+                            'LD_LIBRARY_PATH=' + installed_tests_libdir,
+                            'FP_PRINTS_PATH=' + installed_tests_testdir / 'prints',
+                            # FIXME: Adding this requires gnome-desktop-testing!12
+                            # 'GI_TYPELIB_PATH=' + installed_tests_libdir / 'girepository-1.0',
+                        ]),
+                        'extra_content': '',
+                    },
+                )
+            endif
         else
             test(vdtest,
-                find_program('sh'),
+                sh,
                 args: ['-c', 'exit 77']
             )
         endif
     endforeach
 
+    driver_tests_enabled = false
     foreach driver_test: drivers_tests
         driver_name = driver_test.split('-')[0]
         driver_envs = envs
-        driver_envs.set('FP_DRIVERS_WHITELIST', driver_name)
+        driver_envs.set('FP_DRIVERS_ALLOWLIST', driver_name)
 
         if (driver_name in supported_drivers and
             gusb_dep.version().version_compare('>= 0.3.0'))
+            driver_tests_enabled = true
             test(driver_test,
                 python3,
                 args: [
@@ -118,23 +186,60 @@ if get_option('introspection')
                 timeout: 15,
                 depends: libfprint_typelib,
             )
+
+            if installed_tests
+                driver_envs_str = run_command(python3, '-c', env_parser_cmd,
+                    env: driver_envs,
+                    check: true).stdout().strip()
+
+                configure_file(
+                    input: 'driver.test.in',
+                    output: 'driver-' + driver_test + '.test',
+                    install_dir: installed_tests_testdir,
+                    configuration: {
+                        'installed_tests_execdir': installed_tests_execdir,
+                        'installed_tests_testdir': installed_tests_testdir,
+                        'umockdev_test_name': umockdev_test_name,
+                        'driver_test': driver_test,
+                        'driver_env': ' '.join([
+                            driver_envs_str,
+                            'LD_LIBRARY_PATH=' + installed_tests_libdir,
+                            # FIXME: Adding this requires gnome-desktop-testing!12
+                            # 'GI_TYPELIB_PATH=' + installed_tests_libdir / 'girepository-1.0',
+                        ]),
+                    },
+                )
+
+                install_subdir(driver_test, install_dir: installed_tests_testdir)
+            endif
         else
             test(driver_test,
-                find_program('sh'),
+                sh,
                 args: ['-c', 'exit 77']
             )
         endif
     endforeach
+
+    if  installed_tests and driver_tests_enabled
+        install_data(umockdev_test.full_path(),
+            install_dir: installed_tests_execdir,
+            install_mode: 'rwxr-xr-x',
+        )
+        install_data('capture.py',
+            install_dir: installed_tests_execdir,
+            install_mode: 'rwxr-xr-x',
+        )
+    endif
 else
     warning('Skipping all driver tests as introspection bindings are missing')
     test('virtual-image',
-        find_program('sh'),
+        sh,
         args: ['-c', 'exit 77']
     )
 
     foreach driver_test: drivers_tests
         test(driver_test,
-            find_program('sh'),
+            sh,
             args: ['-c', 'exit 77']
         )
     endforeach
@@ -163,10 +268,6 @@ endif
 
 unit_tests_deps = { 'fpi-assembling' : [cairo_dep] }
 
-test_config = configuration_data()
-test_config.set_quoted('SOURCE_ROOT', meson.source_root())
-test_config_h = configure_file(output: 'test-config.h', configuration: test_config)
-
 foreach test_name: unit_tests
     if unit_tests_deps.has_key(test_name)
         missing_deps = false
@@ -181,7 +282,7 @@ foreach test_name: unit_tests
             # Create a dummy test that always skips instead
             warning('Test @0@ cannot be compiled due to missing dependencies'.format(test_name))
             test(test_name,
-                find_program('sh'),
+                sh,
                 suite: ['unit-tests'],
                 args: ['-c', 'exit 77'],
             )
@@ -194,16 +295,31 @@ foreach test_name: unit_tests
 
     basename = 'test-' + test_name
     test_exe = executable(basename,
-        sources: [basename + '.c', test_config_h],
+        sources: basename + '.c',
         dependencies: [ libfprint_private_dep ] + extra_deps,
         c_args: common_cflags,
-        link_with: test_utils,
+        link_whole: test_utils,
+        install: installed_tests,
+        install_dir: installed_tests_execdir,
     )
     test(test_name,
         test_exe,
         suite: ['unit-tests'],
         env: envs,
     )
+
+    configure_file(
+        input: 'test.in',
+        output: test_name + '.test',
+        install: installed_tests,
+        install_dir: installed_tests_testdir,
+        configuration: {
+            'exec': installed_tests_execdir / basename,
+            'env': envs_str,
+            'extra_content': 'TestEnvironment=LD_LIBRARY_PATH=' +
+                installed_tests_libdir,
+        },
+    )
 endforeach
 
 # Run udev rule generator with fatal warnings
@@ -217,7 +333,7 @@ test('udev-hwdb',
 gdb = find_program('gdb', required: false)
 if gdb.found()
     libfprint_wrapper = [
-        gdb.path(),
+        gdb.full_path(),
         '-batch',
         '-ex', 'run',
         '--args',
@@ -232,14 +348,14 @@ endif
 
 valgrind = find_program('valgrind', required: false)
 if valgrind.found()
-    glib_share = glib_dep.get_pkgconfig_variable('prefix') / 'share' / glib_dep.name()
+    glib_share = glib_dep.get_variable(pkgconfig: 'prefix') / 'share' / glib_dep.name()
     glib_suppressions = glib_share + '/valgrind/glib.supp'
-    libfprint_suppressions = '@0@/@1@'.format(meson.source_root(),
+    libfprint_suppressions = '@0@/@1@'.format(meson.project_source_root(),
         files('libfprint.supp')[0])
-    python_suppressions = '@0@/@1@'.format(meson.source_root(),
+    python_suppressions = '@0@/@1@'.format(meson.project_source_root(),
         files('valgrind-python.supp')[0])
     libfprint_wrapper = [
-        valgrind.path(),
+        valgrind.full_path(),
         '--tool=memcheck',
         '--leak-check=full',
         '--leak-resolution=high',
@@ -248,6 +364,7 @@ if valgrind.found()
         '--track-origins=yes',
         '--show-leak-kinds=definite,possible',
         '--show-error-list=yes',
+        '--gen-suppressions=all',
         '--suppressions=' + libfprint_suppressions,
         '--suppressions=' + glib_suppressions,
         '--suppressions=' + python_suppressions,

tests/realtek-5816/custom.py

@@ -0,0 +1,110 @@
+#!/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() == "realtek"
+assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
+assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
+assert d.has_feature(FPrint.DeviceFeature.VERIFY)
+assert not d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
+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()
+
+# 1. verify clear storage command, 2. make sure later asserts are good
+d.clear_storage_sync()
+
+template = FPrint.Print.new(d)
+
+def enroll_progress(*args):
+    # assert d.get_finger_status() & FPrint.FingerStatusFlags.NEEDED
+    print('enroll progress: ' + str(args))
+
+def identify_done(dev, res):
+    global identified
+    identified = True
+    try:
+        identify_match, identify_print = dev.identify_finish(res)
+    except gi.repository.GLib.GError as e:
+        print("Please try again")
+    else:
+        print('indentification_done: ', identify_match, identify_print)
+        assert identify_match.equal(identify_print)
+
+def start_identify_async(prints):
+    global identified
+    print('async identifying')
+    d.identify(prints, callback=identify_done)
+    del prints
+
+    while not identified:
+        ctx.iteration(True)
+
+    identified = False
+
+# List, enroll, list, verify, identify, delete
+print("enrolling")
+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")
+
+print("listing")
+stored = d.list_prints_sync()
+print("listing done")
+assert len(stored) == 1
+assert stored[0].equal(p)
+print("verifying")
+try:
+    assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+    verify_res, verify_print = d.verify_sync(p)
+    assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+except gi.repository.GLib.GError as e:
+    print("Please try again")
+else:
+    print("verify done")
+    del p
+    assert verify_res == True
+
+identified = False
+deserialized_prints = []
+for p in stored:
+    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
+    assert deserialized_prints[-1].equal(p)
+del stored
+
+print('async identifying')
+d.identify(deserialized_prints, callback=identify_done)
+del deserialized_prints
+
+while not identified:
+    ctx.iteration(True)
+
+print("deleting")
+d.delete_print_sync(p)
+print("delete done")
+
+d.close_sync()
+
+del d
+del c

tests/realtek-5816/device

@@ -0,0 +1,250 @@
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-6
+N: bus/usb/001/006=12010102EF020140DA0B165800000301020109022E00010104A0FA0904000004FF02000507050102000200070583034000080705840340000807058202000200
+E: DEVNAME=/dev/bus/usb/001/006
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=bda/5816/0
+E: TYPE=239/2/1
+E: BUSNUM=001
+E: DEVNUM=006
+E: MAJOR=189
+E: MINOR=5
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Generic
+E: ID_VENDOR_ENC=Generic
+E: ID_VENDOR_ID=0bda
+E: ID_MODEL=Realtek_USB2.0_Finger_Print_Bridge
+E: ID_MODEL_ENC=Realtek\x20USB2.0\x20Finger\x20Print\x20Bridge
+E: ID_MODEL_ID=5816
+E: ID_REVISION=0000
+E: ID_SERIAL=Generic_Realtek_USB2.0_Finger_Print_Bridge_201801010001
+E: ID_SERIAL_SHORT=201801010001
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:ff0200:
+E: ID_VENDOR_FROM_DATABASE=Realtek Semiconductor Corp.
+E: ID_PATH=pci-0000:00:14.0-usb-0:6
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_6
+A: authorized=1\n
+A: avoid_reset_quirk=0\n
+A: bConfigurationValue=1\n
+A: bDeviceClass=ef\n
+A: bDeviceProtocol=01\n
+A: bDeviceSubClass=02\n
+A: bMaxPacketSize0=64\n
+A: bMaxPower=500mA\n
+A: bNumConfigurations=1\n
+A: bNumInterfaces= 1\n
+A: bcdDevice=0000\n
+A: bmAttributes=a0\n
+A: busnum=1\n
+A: configuration=Realtek USB2.0 Finger Print Bridge\n
+H: descriptors=12010102EF020140DA0B165800000301020109022E00010104A0FA0904000004FF02000507050102000200070583034000080705840340000807058202000200
+A: dev=189:5\n
+A: devnum=6\n
+A: devpath=6\n
+L: driver=../../../../../bus/usb/drivers/usb
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4b/device:4c/device:52
+A: idProduct=5816\n
+A: idVendor=0bda\n
+A: ltm_capable=no\n
+A: manufacturer=Generic\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=../1-0:1.0/usb1-port6
+A: power/active_duration=37699\n
+A: power/async=enabled\n
+A: power/autosuspend=2\n
+A: power/autosuspend_delay_ms=2000\n
+A: power/connected_duration=37699\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=37457\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=Realtek USB2.0 Finger Print Bridge\n
+A: quirks=0x0\n
+A: removable=removable\n
+A: rx_lanes=1\n
+A: serial=201801010001\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=22\n
+A: version= 2.01\n
+
+P: /devices/pci0000:00/0000:00:14.0/usb1
+N: bus/usb/001/001=12010002090001406B1D020008060302010109021900010100E0000904000001090000000705810304000C
+E: DEVNAME=/dev/bus/usb/001/001
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=1d6b/2/608
+E: TYPE=9/0/1
+E: BUSNUM=001
+E: DEVNUM=001
+E: MAJOR=189
+E: MINOR=0
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Linux_6.8.0-40-generic_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x206.8.0-40-generic\x20xhci-hcd
+E: ID_VENDOR_ID=1d6b
+E: ID_MODEL=xHCI_Host_Controller
+E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
+E: ID_MODEL_ID=0002
+E: ID_REVISION=0608
+E: ID_SERIAL=Linux_6.8.0-40-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL_SHORT=0000:00:14.0
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:090000:
+E: ID_VENDOR_FROM_DATABASE=Linux Foundation
+E: ID_AUTOSUSPEND=1
+E: ID_MODEL_FROM_DATABASE=2.0 root hub
+E: ID_PATH=pci-0000:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+E: ID_FOR_SEAT=usb-pci-0000_00_14_0
+E: TAGS=:seat:
+E: CURRENT_TAGS=:seat:
+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=0608\n
+A: bmAttributes=e0\n
+A: busnum=1\n
+A: configuration=
+H: descriptors=12010002090001406B1D020008060302010109021900010100E0000904000001090000000705810304000C
+A: dev=189:0\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:4b/device:4c
+A: idProduct=0002\n
+A: idVendor=1d6b\n
+A: interface_authorized_default=1\n
+A: ltm_capable=no\n
+A: manufacturer=Linux 6.8.0-40-generic xhci-hcd\n
+A: maxchild=16\n
+A: power/active_duration=1096259\n
+A: power/async=enabled\n
+A: power/autosuspend=0\n
+A: power/autosuspend_delay_ms=0\n
+A: power/connected_duration=1096259\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/runtime_active_kids=3\n
+A: power/runtime_active_time=1096256\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:00:14.0\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=229\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0
+E: DRIVER=xhci_hcd
+E: PCI_CLASS=C0330
+E: PCI_ID=8086:A36D
+E: PCI_SUBSYS_ID=1028:085C
+E: PCI_SLOT_NAME=0000:00:14.0
+E: MODALIAS=pci:v00008086d0000A36Dsv00001028sd0000085Cbc0Csc03i30
+E: SUBSYSTEM=pci
+E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
+E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
+E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
+E: ID_VENDOR_FROM_DATABASE=Intel Corporation
+E: ID_MODEL_FROM_DATABASE=Cannon Lake PCH USB 3.1 xHCI Host Controller
+A: ari_enabled=0\n
+A: broken_parity_status=0\n
+A: class=0x0c0330\n
+H: config=86806DA3060590021030030C00008000040030D200000000000000000000000000000000000000000000000028105C08000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F000000005B17C10300000000316000000000000000000000000000000180C2C10800000000000000000000000590B7001803E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000030000000C00000000000000C000000000000000000100003000000000000000030000000C0000000000000000000000000000000000000000000000000000000000000000000000B50F120112000000
+A: consistent_dma_mask_bits=64\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: device=0xa36d\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:4b
+A: index=4\n
+L: iommu=../../virtual/iommu/dmar1
+L: iommu_group=../../../kernel/iommu_groups/4
+A: irq=125\n
+A: label=Onboard - Other\n
+A: local_cpulist=0-3\n
+A: local_cpus=f\n
+A: modalias=pci:v00008086d0000A36Dsv00001028sd0000085Cbc0Csc03i30\n
+A: msi_bus=1\n
+A: msi_irqs/125=msi\n
+A: msi_irqs/126=msi\n
+A: msi_irqs/127=msi\n
+A: msi_irqs/128=msi\n
+A: msi_irqs/129=msi\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    6    7 2112  7\nxHCI ring segments   25   25 4096 25\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128         12   32  128  1\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=1096935\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: resource=0x00000000d2300000 0x00000000d230ffff 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=0x10\n
+A: subsystem_device=0x085c\n
+A: subsystem_vendor=0x1028\n
+A: vendor=0x8086\n
+

tests/realtek/custom.py

@@ -0,0 +1,110 @@
+#!/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() == "realtek"
+assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
+assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
+assert d.has_feature(FPrint.DeviceFeature.VERIFY)
+assert not d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
+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()
+
+# 1. verify clear storage command, 2. make sure later asserts are good
+d.clear_storage_sync()
+
+template = FPrint.Print.new(d)
+
+def enroll_progress(*args):
+    # assert d.get_finger_status() & FPrint.FingerStatusFlags.NEEDED
+    print('enroll progress: ' + str(args))
+
+def identify_done(dev, res):
+    global identified
+    identified = True
+    try:
+        identify_match, identify_print = dev.identify_finish(res)
+    except gi.repository.GLib.GError as e:
+        print("Please try again")
+    else:
+        print('indentification_done: ', identify_match, identify_print)
+        assert identify_match.equal(identify_print)
+
+def start_identify_async(prints):
+    global identified
+    print('async identifying')
+    d.identify(prints, callback=identify_done)
+    del prints
+
+    while not identified:
+        ctx.iteration(True)
+
+    identified = False
+
+# List, enroll, list, verify, identify, delete
+print("enrolling")
+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")
+
+print("listing")
+stored = d.list_prints_sync()
+print("listing done")
+assert len(stored) == 1
+assert stored[0].equal(p)
+print("verifying")
+try:
+    assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+    verify_res, verify_print = d.verify_sync(p)
+    assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+except gi.repository.GLib.GError as e:
+    print("Please try again")
+else:
+    print("verify done")
+    del p
+    assert verify_res == True
+
+identified = False
+deserialized_prints = []
+for p in stored:
+    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
+    assert deserialized_prints[-1].equal(p)
+del stored
+
+print('async identifying')
+d.identify(deserialized_prints, callback=identify_done)
+del deserialized_prints
+
+while not identified:
+    ctx.iteration(True)
+
+print("deleting")
+d.delete_print_sync(p)
+print("delete done")
+
+d.close_sync()
+
+del d
+del c

tests/realtek/device

@@ -0,0 +1,244 @@
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-8
+N: bus/usb/001/025=12010102EF020140DA0B135801210301020109022E00010104A0FA0904000004FF02000507050102000200070583031000080705840310000807058202000200
+E: DEVNAME=/dev/bus/usb/001/025
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=bda/5813/2101
+E: TYPE=239/2/1
+E: BUSNUM=001
+E: DEVNUM=025
+E: MAJOR=189
+E: MINOR=24
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Generic
+E: ID_VENDOR_ENC=Generic
+E: ID_VENDOR_ID=0bda
+E: ID_MODEL=Realtek_USB2.0_Finger_Print_Bridge
+E: ID_MODEL_ENC=Realtek\x20USB2.0\x20Finger\x20Print\x20Bridge
+E: ID_MODEL_ID=5813
+E: ID_REVISION=2101
+E: ID_SERIAL=Generic_Realtek_USB2.0_Finger_Print_Bridge_201801010001
+E: ID_SERIAL_SHORT=201801010001
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:ff0200:
+E: ID_VENDOR_FROM_DATABASE=Realtek Semiconductor Corp.
+E: ID_PATH=pci-0000:00:14.0-usb-0:8
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_8
+A: authorized=1\n
+A: avoid_reset_quirk=0\n
+A: bConfigurationValue=1\n
+A: bDeviceClass=ef\n
+A: bDeviceProtocol=01\n
+A: bDeviceSubClass=02\n
+A: bMaxPacketSize0=64\n
+A: bMaxPower=500mA\n
+A: bNumConfigurations=1\n
+A: bNumInterfaces= 1\n
+A: bcdDevice=2101\n
+A: bmAttributes=a0\n
+A: busnum=1\n
+A: configuration=Realtek USB2.0 Finger Print Bridge\n
+H: descriptors=12010102EF020140DA0B135801210301020109022E00010104A0FA0904000004FF02000507050102000200070583031000080705840310000807058202000200
+A: dev=189:24\n
+A: devnum=25\n
+A: devpath=8\n
+L: driver=../../../../../bus/usb/drivers/usb
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4b/device:4c/device:54
+A: idProduct=5813\n
+A: idVendor=0bda\n
+A: ltm_capable=no\n
+A: manufacturer=Generic\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=../1-0:1.0/usb1-port8
+A: power/active_duration=271844\n
+A: power/async=enabled\n
+A: power/autosuspend=2\n
+A: power/autosuspend_delay_ms=2000\n
+A: power/connected_duration=271844\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=271564\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=Realtek USB2.0 Finger Print Bridge\n
+A: quirks=0x0\n
+A: removable=removable\n
+A: rx_lanes=1\n
+A: serial=201801010001\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=297176\n
+A: version= 2.01\n
+
+P: /devices/pci0000:00/0000:00:14.0/usb1
+N: bus/usb/001/001=12010002090001406B1D020005060302010109021900010100E0000904000001090000000705810304000C
+E: DEVNAME=/dev/bus/usb/001/001
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=1d6b/2/605
+E: TYPE=9/0/1
+E: BUSNUM=001
+E: DEVNUM=001
+E: MAJOR=189
+E: MINOR=0
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Linux_6.5.0-18-generic_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x206.5.0-18-generic\x20xhci-hcd
+E: ID_VENDOR_ID=1d6b
+E: ID_MODEL=xHCI_Host_Controller
+E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
+E: ID_MODEL_ID=0002
+E: ID_REVISION=0605
+E: ID_SERIAL=Linux_6.5.0-18-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL_SHORT=0000:00:14.0
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:090000:
+E: ID_VENDOR_FROM_DATABASE=Linux Foundation
+E: ID_AUTOSUSPEND=1
+E: ID_MODEL_FROM_DATABASE=2.0 root hub
+E: ID_PATH=pci-0000:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+E: ID_FOR_SEAT=usb-pci-0000_00_14_0
+E: TAGS=:seat:
+E: CURRENT_TAGS=:seat:
+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=0605\n
+A: bmAttributes=e0\n
+A: busnum=1\n
+A: configuration=
+H: descriptors=12010002090001406B1D020005060302010109021900010100E0000904000001090000000705810304000C
+A: dev=189:0\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:4b/device:4c
+A: idProduct=0002\n
+A: idVendor=1d6b\n
+A: interface_authorized_default=1\n
+A: ltm_capable=no\n
+A: manufacturer=Linux 6.5.0-18-generic xhci-hcd\n
+A: maxchild=16\n
+A: power/active_duration=351477916\n
+A: power/async=enabled\n
+A: power/autosuspend=0\n
+A: power/autosuspend_delay_ms=0\n
+A: power/connected_duration=351477916\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/runtime_active_kids=3\n
+A: power/runtime_active_time=351477912\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:00:14.0\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=2135\n
+A: version= 2.00\n
+
+P: /devices/pci0000:00/0000:00:14.0
+E: DRIVER=xhci_hcd
+E: PCI_CLASS=C0330
+E: PCI_ID=8086:A36D
+E: PCI_SUBSYS_ID=1028:085C
+E: PCI_SLOT_NAME=0000:00:14.0
+E: MODALIAS=pci:v00008086d0000A36Dsv00001028sd0000085Cbc0Csc03i30
+E: SUBSYSTEM=pci
+E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
+E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
+E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
+E: ID_VENDOR_FROM_DATABASE=Intel Corporation
+E: ID_MODEL_FROM_DATABASE=Cannon Lake PCH USB 3.1 xHCI Host Controller
+A: ari_enabled=0\n
+A: broken_parity_status=0\n
+A: class=0x0c0330\n
+H: config=86806DA3060590021030030C00008000040030D200000000000000000000000000000000000000000000000028105C08000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F000000004505531F00000000316000000000000000000000000000000180C2C108000000000000000000000005908700D802E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000030000000C00000000000000C000000000000000000100003000000000000000030000000C0000000000000000000000000000000000000000000000000000000000000000000000B50F120112000000
+A: consistent_dma_mask_bits=64\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: device=0xa36d\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:4b
+A: index=4\n
+A: irq=126\n
+A: label=Onboard - Other\n
+A: local_cpulist=0-3\n
+A: local_cpus=f\n
+A: modalias=pci:v00008086d0000A36Dsv00001028sd0000085Cbc0Csc03i30\n
+A: msi_bus=1\n
+A: msi_irqs/126=msi\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    6    7 2112  7\nxHCI ring segments   24   24 4096 24\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128         12   32  128  1\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=351478612\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: resource=0x00000000d2300000 0x00000000d230ffff 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=0x10\n
+A: subsystem_device=0x085c\n
+A: subsystem_vendor=0x1028\n
+A: vendor=0x8086\n
+

tests/test-device-fake.c

@@ -20,6 +20,7 @@
 
 #define FP_COMPONENT "fake_test_dev"
 
+#include "fpi-log.h"
 #include "test-device-fake.h"
 
 G_DEFINE_TYPE (FpiDeviceFake, fpi_device_fake, FP_TYPE_DEVICE)
@@ -29,12 +30,28 @@ static const FpIdEntry driver_ids[] = {
   { .virtual_envvar = NULL }
 };
 
+static void
+  (debug_action) (FpDevice * device,
+                  const gchar *func)
+{
+  g_autofree char *action_str = NULL;
+
+  action_str = g_enum_to_string (FPI_TYPE_DEVICE_ACTION,
+                                 fpi_device_get_current_action (device));
+
+  fp_dbg ("%s: Device %s in action %s\n",
+          func, fp_device_get_name (device), action_str);
+}
+
+#define debug_action(d) (debug_action) ((d), G_STRFUNC)
+
 static void
 fpi_device_fake_probe (FpDevice *device)
 {
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_probe;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_PROBE);
 
@@ -55,6 +72,7 @@ fpi_device_fake_open (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_open;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_OPEN);
 
@@ -72,6 +90,7 @@ fpi_device_fake_close (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_close;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_CLOSE);
 
@@ -90,6 +109,7 @@ fpi_device_fake_enroll (FpDevice *device)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *print = fake_dev->ret_print;
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_enroll;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_ENROLL);
 
@@ -118,6 +138,7 @@ fpi_device_fake_verify (FpDevice *device)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *print = fake_dev->ret_print;
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_verify;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_VERIFY);
 
@@ -149,6 +170,7 @@ fpi_device_fake_identify (FpDevice *device)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *match = fake_dev->ret_match;
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_identify;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_IDENTIFY);
 
@@ -197,6 +219,7 @@ fpi_device_fake_capture (FpDevice *device)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   gboolean wait_for_finger;
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_capture;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_CAPTURE);
 
@@ -216,6 +239,7 @@ fpi_device_fake_list (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_list;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_LIST);
 
@@ -233,6 +257,7 @@ fpi_device_fake_delete (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_delete;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_DELETE);
 
@@ -251,6 +276,7 @@ fpi_device_fake_clear_storage (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_clear_storage;
   g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_CLEAR_STORAGE);
 
@@ -268,6 +294,7 @@ fpi_device_fake_cancel (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_cancel;
   g_assert_cmpuint (fpi_device_get_current_action (device), !=, FPI_DEVICE_ACTION_NONE);
 }
@@ -277,6 +304,7 @@ fpi_device_fake_suspend (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_suspend;
 
   fpi_device_suspend_complete (device, g_steal_pointer (&fake_dev->ret_suspend));
@@ -287,6 +315,7 @@ fpi_device_fake_resume (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
+  debug_action (device);
   fake_dev->last_called_function = fpi_device_fake_resume;
 
   fpi_device_resume_complete (device, g_steal_pointer (&fake_dev->ret_resume));

tests/test-fpi-assembling.c

@@ -22,7 +22,6 @@
 #include <cairo.h>
 #include "fpi-assembling.h"
 #include "fpi-image.h"
-#include "test-config.h"
 
 typedef struct
 {
@@ -67,8 +66,7 @@ test_frame_assembling (void)
   g_autoptr(FpImage) fp_img = NULL;
   GSList *frames = NULL;
 
-  g_assert_false (SOURCE_ROOT == NULL);
+  path = g_test_build_filename (G_TEST_DIST, "vfs5011", "capture.png", NULL);
-  path = g_build_path (G_DIR_SEPARATOR_S, SOURCE_ROOT, "tests", "vfs5011", "capture.png", NULL);
 
   img = cairo_image_surface_create_from_png (path);
   data = cairo_image_surface_get_data (img);

tests/test-fpi-device.c

@@ -30,8 +30,10 @@
 #include "fp-print-private.h"
 
 /* gcc 12.0.1 is complaining about dangling pointers in the auto_close* functions */
+#if G_GNUC_CHECK_VERSION (12, 0)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdangling-pointer"
+#endif
 
 /* Utility functions */
 
@@ -69,7 +71,9 @@ auto_close_fake_device_free (FpAutoCloseDevice *device)
 }
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpAutoCloseDevice, auto_close_fake_device_free)
 
+#if G_GNUC_CHECK_VERSION (12, 0)
 #pragma GCC diagnostic pop
+#endif
 
 typedef FpDeviceClass FpAutoResetClass;
 static FpAutoResetClass default_fake_dev_class = {0};

tests/test-generated-hwdb.sh

@@ -1,13 +1,12 @@
-#!/usr/bin/env bash
+#!/bin/sh -e
-set -e
 
 if [ ! -x "$UDEV_HWDB" ]; then
     echo "E: UDEV_HWDB (${UDEV_HWDB}) unset or not executable."
     exit 1
 fi
 
-if [ "$UDEV_HWDB_CHECK_CONTENTS" == 1 ]; then
+if [ "$UDEV_HWDB_CHECK_CONTENTS" = 1 ]; then
-    generated_rules=$(mktemp "${TMPDIR:-/tmp}/libfprint-XXXXXX.hwdb")
+    generated_rules=$(mktemp "${TMPDIR:-/tmp}/libfprint.hwdb.XXXXXX")
 else
     generated_rules=/dev/null
 fi

tests/test.in

@@ -0,0 +1,6 @@
+[Test]
+Type=session
+# We can't use TestEnvironment as per
+#  https://gitlab.gnome.org/GNOME/gnome-desktop-testing/-/issues/1
+Exec=env @env@ @exec@
+@extra_content@

tests/valgrind-python.supp

@@ -40,6 +40,20 @@
    fun:_Py*
 }
 
+{
+   ignore__py_addr32
+   Memcheck:Addr32
+   ...
+   fun:_Py*
+}
+
+{
+   ignore__py_addr32
+   Memcheck:Addr32
+   ...
+   fun:Py*
+}
+
 {
    ignore_py_leaks
    Memcheck:Leak

tests/virtual-device.py

@@ -59,6 +59,17 @@ class GLibErrorMessage:
 
 class VirtualDeviceBase(unittest.TestCase):
 
+    DEFAULT_ENROLL_STEPS = 5
+    USE_CLASS_DEVICE = True
+
+    @classmethod
+    def get_device(cls, ctx):
+        for dev in ctx.get_devices():
+            # We might have a USB device in the test system that needs skipping
+            if dev.get_driver() == cls._driver_name:
+                return dev
+        return None
+
     @classmethod
     def setUpClass(cls):
         unittest.TestCase.setUpClass()
@@ -73,26 +84,28 @@ class VirtualDeviceBase(unittest.TestCase):
         cls.sockaddr = os.path.join(cls.tmpdir, '{}.socket'.format(sock_name))
         os.environ['FP_{}'.format(driver_name.upper())] = cls.sockaddr
 
-        cls.ctx = FPrint.Context()
+        cls._driver_name = driver_name
 
-        cls.dev = None
+        if cls.USE_CLASS_DEVICE:
-        for dev in cls.ctx.get_devices():
+            cls.ctx = FPrint.Context()
-            # We might have a USB device in the test system that needs skipping
+            cls.dev = cls.get_device(cls.ctx)
-            if dev.get_driver() == driver_name:
+            assert cls.dev is not None, "You need to compile with {} for testing".format(
-                cls.dev = dev
+                driver_name)
-                break
-
-        assert cls.dev is not None, "You need to compile with {} for testing".format(driver_name)
 
     @classmethod
     def tearDownClass(cls):
         shutil.rmtree(cls.tmpdir)
-        del cls.dev
+        if cls.USE_CLASS_DEVICE:
-        del cls.ctx
+            del cls.dev
+            del cls.ctx
         unittest.TestCase.tearDownClass()
 
     def setUp(self):
         super().setUp()
+        if not self.USE_CLASS_DEVICE:
+            self.ctx = FPrint.Context()
+            self.dev = self.get_device(self.ctx)
+            self.assertIsNotNone(self.dev)
         self._close_on_teardown = True
         self.assertFalse(self.dev.is_open())
         self.dev.open_sync()
@@ -101,8 +114,13 @@ class VirtualDeviceBase(unittest.TestCase):
     def tearDown(self):
         if self._close_on_teardown:
             self.assertTrue(self.dev.is_open())
+            self.set_keep_alive(False)
+            self.send_command('SET_ENROLL_STAGES', self.DEFAULT_ENROLL_STEPS)
             self.dev.close_sync()
         self.assertFalse(self.dev.is_open())
+        if not self.USE_CLASS_DEVICE:
+            del self.dev
+            del self.ctx
         super().tearDown()
 
     def wait_timeout(self, interval):
@@ -331,6 +349,107 @@ class VirtualDeviceBase(unittest.TestCase):
             self.assertEqual(self._verify_fp.props.fpi_data.get_string(), scan_nick)
 
 
+class VirtualDeviceUnplugging(VirtualDeviceBase):
+
+    driver_name = 'virtual_device'
+    USE_CLASS_DEVICE = False
+
+    def test_device_unplug(self):
+        self._close_on_teardown = False
+        notified_spec = None
+        def on_removed_notify(dev, spec):
+            nonlocal notified_spec
+            notified_spec = spec
+
+        removed = False
+        ctx_removed = False
+
+        def on_ctx_removed(ctx, dev):
+            nonlocal ctx_removed
+            ctx_removed = dev == self.dev
+            self.assertEqual(removed, ctx_removed)
+
+        def on_removed(dev):
+            nonlocal removed
+            removed = dev.props.removed
+            self.assertNotEqual(removed, ctx_removed)
+
+        self.assertFalse(self.dev.props.removed)
+
+        self.dev.connect('notify::removed', on_removed_notify)
+        self.ctx.connect('device-removed', on_ctx_removed)
+        self.dev.connect('removed', on_removed)
+        self.send_command('UNPLUG')
+        self.assertEqual(notified_spec.name, 'removed')
+        self.assertTrue(self.dev.props.removed)
+        self.assertIn(self.dev, self.ctx.get_devices())
+        self.assertTrue(removed)
+
+        with self.assertRaises(GLib.GError) as error:
+            self.dev.close_sync()
+        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
+                                                FPrint.DeviceError.REMOVED))
+
+        while not ctx_removed:
+            ctx.iteration(True)
+
+        self.assertNotIn(self.dev, self.ctx.get_devices())
+
+    def test_device_unplug_during_verify(self):
+        self._close_on_teardown = False
+        self._destroy_on_teardown = True
+
+        notified_spec = None
+        def on_removed_notify(dev, spec):
+            nonlocal notified_spec
+            notified_spec = spec
+
+        removed = False
+        ctx_removed = False
+
+        def on_ctx_removed(ctx, dev):
+            nonlocal ctx_removed
+            ctx_removed = dev == self.dev
+            self.assertEqual(removed, ctx_removed)
+
+        def on_removed(dev):
+            nonlocal removed
+            removed = dev.props.removed
+            self.assertNotEqual(removed, ctx_removed)
+
+        self.assertFalse(self.dev.props.removed)
+        self.dev.connect('notify::removed', on_removed_notify)
+        self.ctx.connect('device-removed', on_ctx_removed)
+        self.dev.connect('removed', on_removed)
+
+        self.start_verify(FPrint.Print.new(self.dev),
+            identify=self.dev.supports_identify())
+
+        self.send_command('UNPLUG')
+        self.assertEqual(notified_spec.name, 'removed')
+        self.assertTrue(self.dev.props.removed)
+        self.assertIn(self.dev, self.ctx.get_devices())
+        self.assertFalse(removed)
+
+        with self.assertRaises(GLib.GError) as error:
+            self.complete_verify()
+        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
+                                                FPrint.DeviceError.REMOVED))
+
+        self.assertTrue(removed)
+        self.assertIn(self.dev, self.ctx.get_devices())
+
+        with self.assertRaises(GLib.GError) as error:
+            self.dev.close_sync()
+        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
+                                                FPrint.DeviceError.REMOVED))
+
+        while not ctx_removed:
+            ctx.iteration(True)
+
+        self.assertNotIn(self.dev, self.ctx.get_devices())
+
+
 class VirtualDevice(VirtualDeviceBase):
 
     def test_device_properties(self):
@@ -339,7 +458,8 @@ class VirtualDevice(VirtualDeviceBase):
         self.assertEqual(self.dev.get_name(), 'Virtual device for debugging')
         self.assertTrue(self.dev.is_open())
         self.assertEqual(self.dev.get_scan_type(), FPrint.ScanType.SWIPE)
-        self.assertEqual(self.dev.get_nr_enroll_stages(), 5)
+        self.assertEqual(self.dev.get_nr_enroll_stages(),
+                         self.DEFAULT_ENROLL_STEPS)
         self.assertFalse(self.dev.supports_identify())
         self.assertFalse(self.dev.supports_capture())
         self.assertFalse(self.dev.has_storage())
@@ -700,69 +820,6 @@ class VirtualDevice(VirtualDeviceBase):
             self.assertEqual(self.dev.get_scan_type(), FPrint.ScanType.SWIPE)
             self.assertIsNone(notified_spec)
 
-    def test_device_unplug(self):
-        self._close_on_teardown = False
-        notified_spec = None
-        def on_removed_notify(dev, spec):
-            nonlocal notified_spec
-            notified_spec = spec
-
-        removed = False
-        def on_removed(dev):
-            nonlocal removed
-            removed = True
-
-        self.assertFalse(self.dev.props.removed)
-
-        self.dev.connect('notify::removed', on_removed_notify)
-        self.dev.connect('removed', on_removed)
-        self.send_command('UNPLUG')
-        self.assertEqual(notified_spec.name, 'removed')
-        self.assertTrue(self.dev.props.removed)
-        self.assertTrue(removed)
-
-        with self.assertRaises(GLib.GError) as error:
-            self.dev.close_sync()
-        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
-                                                FPrint.DeviceError.REMOVED))
-
-    def test_device_unplug_during_verify(self):
-        self._close_on_teardown = False
-
-        notified_spec = None
-        def on_removed_notify(dev, spec):
-            nonlocal notified_spec
-            notified_spec = spec
-
-        removed = False
-        def on_removed(dev):
-            nonlocal removed
-            removed = True
-
-        self.assertFalse(self.dev.props.removed)
-        self.dev.connect('notify::removed', on_removed_notify)
-        self.dev.connect('removed', on_removed)
-
-        self.start_verify(FPrint.Print.new(self.dev),
-            identify=self.dev.supports_identify())
-
-        self.send_command('UNPLUG')
-        self.assertEqual(notified_spec.name, 'removed')
-        self.assertTrue(self.dev.props.removed)
-        self.assertFalse(removed)
-
-        with self.assertRaises(GLib.GError) as error:
-            self.complete_verify()
-        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
-                                                FPrint.DeviceError.REMOVED))
-
-        self.assertTrue(removed)
-
-        with self.assertRaises(GLib.GError) as error:
-            self.dev.close_sync()
-        self.assertTrue(error.exception.matches(FPrint.DeviceError.quark(),
-                                                FPrint.DeviceError.REMOVED))
-
     def test_device_sleep(self):
         self.send_sleep(1500)
 

tests/virtual-image.py

@@ -46,12 +46,15 @@ def load_image(img):
 
     return img
 
-if hasattr(os.environ, 'MESON_SOURCE_ROOT'):
+if 'FP_PRINTS_PATH' in os.environ:
-    root = os.environ['MESON_SOURCE_ROOT']
+    prints_path = os.environ['FP_PRINTS_PATH']
 else:
-    root = os.path.join(os.path.dirname(__file__), '..')
+    if 'MESON_SOURCE_ROOT' in os.environ:
+        root = os.environ['MESON_SOURCE_ROOT']
+    else:
+        root = os.path.join(os.path.dirname(__file__), '..')
 
-imgdir = os.path.join(root, 'examples', 'prints')
+    prints_path = os.path.join(root, 'examples', 'prints')
 
 ctx = GLib.main_context_default()
 
@@ -76,10 +79,12 @@ class VirtualImage(unittest.TestCase):
         assert cls.dev is not None, "You need to compile with virtual_image for testing"
 
         cls.prints = {}
-        for f in glob.glob(os.path.join(imgdir, '*.png')):
+        for f in glob.glob(os.path.join(prints_path, '*.png')):
             n = os.path.basename(f)[:-4]
             cls.prints[n] = load_image(f)
 
+        assert cls.prints, "No prints found in " + prints_path
+
     @classmethod
     def tearDownClass(cls):
         shutil.rmtree(cls.tmpdir)