2026-05-08 22:08:43 +02:00
97 changed files with 897 additions and 10528 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -4,10 +4,9 @@ include:
  - project: 'freedesktop/ci-templates'
    ref: master
    file: '/templates/fedora.yml'
-  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/71e636e012ae0ab04c5e0fe40ca73ada91ae6bde/flatpak/flatpak_ci_initiative.yml'
+  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/master/flatpak/flatpak_ci_initiative.yml'
 default:
  interruptible: true
  # Auto-retry jobs in case of infra failures
  retry:
    max: 1
@ -23,14 +22,13 @@ variables:
  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'
    - if: $CI_PIPELINE_SOURCE == 'schedule'
    - if: $CI_PROJECT_NAMESPACE == 'libfprint' && $LIBFPRINT_CI_ACTION != ''
 stages:
  - image-build
@ -38,13 +36,12 @@ stages:
  - 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 openssl
+    # Build with a driver that doesn't need imaging, or nss
    - meson setup _build --werror -Ddrivers=$driver
    - meson compile -C _build
    - rm -rf _build/
@ -60,16 +57,11 @@ image: $FEDORA_IMAGE
  script:
    - ./.ci/check-abi ${LAST_ABI_BREAK} $(git rev-parse HEAD)
 .standard_job:
  rules:
    - when: on_success
    - if: $CI_PIPELINE_SOURCE == "schedule"
      when: never
 build:
  stage: build
-  extends:
+  except:
-    - .standard_job
+    variables:
      - $CI_PIPELINE_SOURCE == "schedule"
  variables:
    driver: virtual_image
  <<: *build_one_driver
@ -84,12 +76,13 @@ build:
 test:
  stage: test
-  extends:
+  except:
-    - .standard_job
+    variables:
      - $CI_PIPELINE_SOURCE == "schedule"
  script:
    - meson setup _build --werror -Ddrivers=all -Db_coverage=true
    - meson test -C _build --print-errorlogs --no-stdsplit --timeout-multiplier 3
-    - ninja -C _build coverage || true
+    - ninja -C _build coverage
    - cat _build/meson-logs/coverage.txt || true
  artifacts:
    reports:
@ -107,8 +100,9 @@ test:
 test_valgrind:
  stage: test
-  extends:
+  except:
-    - .standard_job
+    variables:
      - $CI_PIPELINE_SOURCE == "schedule"
  script:
    - meson setup _build -Ddrivers=all
    - meson compile -C _build
@ -123,50 +117,33 @@ test_valgrind:
      - _build/meson-logs/testlog-valgrind.txt
    expire_in: 1 week
 test_asan:
  stage: test
  extends:
    - .standard_job
  script:
    - meson setup _build -Ddrivers=all -Db_sanitize=address,undefined
    - meson test -C _build --print-errorlogs --no-stdsplit
  artifacts:
    reports:
      junit: "_build/meson-logs/testlog.junit.xml"
    expose_as: 'Sanitizers test logs'
    when: always
    paths:
      - _build/meson-logs
      - _build/meson-logs/testlog.txt
    expire_in: 1 week
 test_installed:
  stage: test
-  extends:
+  except:
-    - .standard_job
+    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/
+        --report-directory=_build/installed-tests-report/failed/
-        --log-directory=_installed-tests-report/logs/
+        --log-directory=_build/installed-tests-report/logs/
        --parallel=0
  artifacts:
    expose_as: 'GNOME Tests Runner logs'
    when: always
    paths:
-      - _build_dir/meson-logs
+      - _build/meson-logs
-      - _installed-tests-report
+      - _build/installed-tests-report
    expire_in: 1 week
 test_scan_build:
  stage: test
-  extends:
+  except:
-    - .standard_job
+    variables:
      - $CI_PIPELINE_SOURCE == "schedule"
  allow_failure: true
  script:
    - meson setup _build -Ddrivers=all
@ -174,70 +151,60 @@ test_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
 test_indent:
  stage: check-source
-  extends:
+  except:
-    - .standard_job
+    variables:
      - $CI_PIPELINE_SOURCE == "schedule"
  script:
    - scripts/uncrustify.sh
    - git diff
    - git diff-index --name-only --exit-code HEAD
  rules:
    - changes:
        compare_to: 'refs/heads/master'
        paths:
          - '**/*.c'
          - '**/*.h'
 test_unsupported_list:
  stage: check-source
-  extends:
+  except:
-    - .standard_job
+    variables:
      - $CI_PIPELINE_SOURCE == "schedule"
  allow_failure: true
  script:
    - tests/hwdb-check-unsupported.py
 flatpak:
  stage: flatpak
-  extends: .flatpak@x86_64
+  extends: .flatpak
  # 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: manual
+      when: never
-      allow_failure: true
+    - if: '$CI_PIPELINE_SOURCE == "schedule"'
    - 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:
  extends: .fdo.container-build@fedora
  stage: image-build
  only:
    variables:
      - $CI_PIPELINE_SOURCE == "never"
  variables:
    GIT_STRATEGY: none # no need to pull the whole tree for rebuilding the image
    # a list of packages to install
@ -248,8 +215,6 @@ flatpak:
      libudev-devel
    FDO_DISTRIBUTION_EXEC: |
      $LIBFPRINT_EXEC
  rules:
    - when: never
 .container_fedora_build_forced:
  variables:
@ -259,39 +224,25 @@ container_fedora_build_schedule:
  extends:
    - .container_fedora_build_base
    - .container_fedora_build_forced
-  rules:
+  only:
-    - if: $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
+    variables:
-      when: always
+      - $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
 container_fedora_build_manual:
  extends:
    - .container_fedora_build_base
    - .container_fedora_build_forced
-  rules:
+  only:
-    - if: $LIBFPRINT_CI_ACTION == "build-image"
+    variables:
-      when: always
+      - $LIBFPRINT_CI_ACTION == "build-image"
 container_fedora_build_on_deps_changed:
  extends: .container_fedora_build_base
-  rules:
+  only:
-    - if: $CI_PROJECT_NAMESPACE == "libfprint" && $CI_PIPELINE_SOURCE != "schedule"
+    variables:
-      changes:
+      - $CI_PROJECT_NAMESPACE == "libfprint" && $CI_PIPELINE_SOURCE != "schedule"
-        compare_to: 'refs/heads/master'
+    refs:
-        paths:
+      - branches
-          - '.gitlab-ci/libfprint-image-variables.yaml'
+      - merge_requests
-          - '.gitlab-ci/libfprint-templates.yaml'
+    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 && $CI_PIPELINE_SOURCE == "push"
--- a/.gitlab-ci/libfprint-image-variables.yaml
+++ b/.gitlab-ci/libfprint-image-variables.yaml
@ -1,2 +1,2 @@
 variables:
-  LIBFPRINT_IMAGE_TAG: v6
+  LIBFPRINT_IMAGE_TAG: v3
--- a/.gitlab-ci/libfprint-templates.yaml
+++ b/.gitlab-ci/libfprint-templates.yaml
@ -3,7 +3,6 @@
 .libfprint_common_variables:
  LIBFPRINT_DEPENDENCIES:
    appstream
    doxygen
    dnf-plugins-core
    flatpak-builder
@ -18,14 +17,12 @@
    gtk-doc
    gtk3-devel
    libabigail
    libasan
    libgusb-devel
    libgudev-devel
    libubsan
    libX11-devel
    libXv-devel
    meson
-    openssl-devel
+    nss-devel
    pixman-devel
    python3-cairo
    python3-gobject
@ -43,7 +40,10 @@
      glibc \
      libgusb \
      libusb \
-      openssl \
+      nss \
-      pixman \
+      pixman
-      python3-gobject \
+
-      python3-gobject-base
+    git clone https://github.com/martinpitt/umockdev.git && \
        cd umockdev && \
        meson _build --prefix=/usr && \
        ninja -C _build && ninja -C _build install
--- a/.gitlab-ci/scan-build
+++ b/.gitlab-ci/scan-build
@ -1,4 +1,4 @@
 #!/bin/sh
 # This wrapper just disables the malloc checker
-exec /usr/bin/scan-build --status-bugs -disable-checker unix.Malloc --exclude "_build/meson-private" "$@"
+exec /usr/bin/scan-build --status-bugs -disable-checker unix.Malloc "$@"
--- a/64
+++ b/64
@ -1,66 +1,6 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 2026-02-10: v1.94.10 release
 Highlights:
  * synaptics: Add USB reset in probe to recover stall condition
  * synaptics: New PIDs 0x0169, 0x019F, 0x00E9, 0x01A0, 0x0109, 0x010A
  * goodixmoc: New PID 0x66A9
  * goodixmoc: Fix crash in exit callback handler
  * fpcmoc: New PID 0xA306
  * fpcmoc: Fix interrupt cancellable leak
  * elanmoc: New PIDs 0x0CA7, 0x0CA8, 0x0CB0
  * egismoc: New PIDs 0x0584, 0x0588
  * focaltech_moc: New PIDs 0xA27A, 0x1579
  * realtek: New PID 0xFA03
  * fp-device: Clarify getter for open property
  * libfprint: Use fatal-warnings on g-i-scanner
 2025-02-20: v1.94.9 release
 Highlights:
  * uru4000: Use OpenSSL to perform AES-ECB encryption, as per this libfprint
    does not support on NSS, but on openssl (>= 3.0).
  * goodixmoc: New PIDs 0x60C2, 0x689A
  * synaptics: New PIDs 0x016C, 0x0174, 0x0107, 0x0108, 0x00C2, 0x00F0
  * fpcmoc: New PID 0xC844
  * focaltech_moc: New PIDs 0xA99A, 0xA57A, 0xA78A
  * elanmoc: New PIDs 0x0C98, 0x0C9D, 0x0CA3
  * elanspi: New PIDs 0x3128, 0x2766
  * fp-device: Add FP_DEVICE_RETRY_TOO_FAST retry error
  * data: AppStream meta info listing supported USB devices.
  * fixed various memory issues in multiple devices
 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:
@ -417,7 +357,7 @@ tests of the drivers using umockdev.
  - Mark fp_dscv_print functions as deprecated
 * Udev rules:
-  - Add some unsupported devices to the allowlist
+  - Add some unsupported devices to the whitelist
 2017-05-14: v0.7.0 release
 * Drivers:
@ -467,7 +407,7 @@ tests of the drivers using umockdev.
  - Fix possible race condition, and cancellation in uru4000 driver
 * Udev rules:
-  - Add Microsoft keyboard to the suspend denylist
+  - Add Microsoft keyboard to the suspend blacklist
 * Plenty of build fixes
--- a/README.md
+++ b/README.md
@ -46,12 +46,6 @@ 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">
@ -68,9 +62,6 @@ 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
--- a/data/autosuspend.hwdb
+++ b/data/autosuspend.hwdb
@ -77,17 +77,6 @@ usb:v1C7Ap0571*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
 # Supported by libfprint driver egismoc
 usb:v1C7Ap0582*
 usb:v1C7Ap0583*
 usb:v1C7Ap0584*
 usb:v1C7Ap0586*
 usb:v1C7Ap0587*
 usb:v1C7Ap0588*
 usb:v1C7Ap05A1*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
 # Supported by libfprint driver elan
 usb:v04F3p0903*
 usb:v04F3p0907*
@ -160,15 +149,7 @@ usb:v04F3p0C82*
 usb:v04F3p0C88*
 usb:v04F3p0C8C*
 usb:v04F3p0C8D*
 usb:v04F3p0C98*
 usb:v04F3p0C99*
 usb:v04F3p0C9D*
 usb:v04F3p0C9F*
 usb:v04F3p0CA3*
 usb:v04F3p0CA7*
 usb:v04F3p0CA8*
 usb:v04F3p0CB0*
 usb:v04F3p0CB2*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
@ -177,46 +158,24 @@ usb:v1C7Ap0603*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
 # Supported by libfprint driver focaltech_moc
 usb:v2808p9E48*
 usb:v2808pD979*
 usb:v2808pA27A*
 usb:v2808pA959*
 usb:v2808pA99A*
 usb:v2808pA57A*
 usb:v2808pA78A*
 usb:v2808p1579*
 usb:v2808p077A*
 usb:v2808p079A*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
 # Supported by libfprint driver fpcmoc
 usb:v10A5pFFE0*
 usb:v10A5pA305*
 usb:v10A5pA306*
 usb:v10A5pDA04*
 usb:v10A5pD805*
 usb:v10A5pD205*
 usb:v10A5p9524*
 usb:v10A5p9544*
 usb:v10A5pC844*
 usb:v10A5p9B24*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
 # Supported by libfprint driver goodixmoc
 usb:v27C6p5840*
 usb:v27C6p6014*
 usb:v27C6p6090*
 usb:v27C6p6092*
 usb:v27C6p6094*
 usb:v27C6p609A*
 usb:v27C6p609C*
 usb:v27C6p60A2*
 usb:v27C6p60A4*
 usb:v27C6p60BC*
 usb:v27C6p60C2*
 usb:v27C6p6304*
 usb:v27C6p631C*
 usb:v27C6p633C*
@ -227,9 +186,6 @@ usb:v27C6p63AC*
 usb:v27C6p63BC*
 usb:v27C6p63CC*
 usb:v27C6p6496*
 usb:v27C6p650A*
 usb:v27C6p650C*
 usb:v27C6p6582*
 usb:v27C6p6584*
 usb:v27C6p658C*
 usb:v27C6p6592*
@ -237,10 +193,6 @@ usb:v27C6p6594*
 usb:v27C6p659A*
 usb:v27C6p659C*
 usb:v27C6p6A94*
 usb:v27C6p6512*
 usb:v27C6p6890*
 usb:v27C6p689A*
 usb:v27C6p66A9*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
@ -249,44 +201,21 @@ usb:v298Dp1010*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
 # Supported by libfprint driver realtek
 usb:v0BDAp5813*
 usb:v0BDAp5816*
 usb:v2541pFA03*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
 # Supported by libfprint driver synaptics
 usb:v06CBp00BD*
 usb:v06CBp00C2*
 usb:v06CBp00C4*
 usb:v06CBp00C6*
 usb:v06CBp00DF*
 usb:v06CBp00E9*
 usb:v06CBp00F0*
 usb:v06CBp00F9*
 usb:v06CBp00FC*
 usb:v06CBp00C2*
 usb:v06CBp0100*
 usb:v06CBp00F0*
 usb:v06CBp0103*
 usb:v06CBp0104*
 usb:v06CBp0106*
 usb:v06CBp0107*
 usb:v06CBp0108*
 usb:v06CBp0109*
 usb:v06CBp010A*
 usb:v06CBp0123*
 usb:v06CBp0124*
 usb:v06CBp0126*
 usb:v06CBp0129*
 usb:v06CBp015F*
 usb:v06CBp0168*
-usb:v06CBp0169*
+usb:v06CBp015F*
-usb:v06CBp016C*
+usb:v06CBp0104*
 usb:v06CBp0173*
 usb:v06CBp0174*
 usb:v06CBp019D*
 usb:v06CBp019F*
 usb:v06CBp01A0*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
@ -355,10 +284,6 @@ usb:v138Ap0091*
 ID_PERSIST=0
 # Known unsupported devices
 usb:v0A5Cp5802*
 usb:v047Dp00F2*
 usb:v047Dp8054*
 usb:v047Dp8055*
 usb:v04E8p730B*
 usb:v04F3p036B*
 usb:v04F3p0C00*
@ -366,37 +291,23 @@ usb:v04F3p0C4C*
 usb:v04F3p0C57*
 usb:v04F3p0C5E*
 usb:v04F3p0C5A*
 usb:v04F3p0C60*
 usb:v04F3p0C6C*
 usb:v04F3p0C70*
 usb:v04F3p0C72*
 usb:v04F3p0C77*
 usb:v04F3p0C7C*
 usb:v04F3p0C7F*
 usb:v04F3p0C80*
 usb:v04F3p0C85*
 usb:v04F3p0C90*
 usb:v04F3p2706*
 usb:v04F3p3032*
 usb:v04F3p3057*
 usb:v04F3p3104*
 usb:v04F3p310D*
 usb:v04F3p3128*
 usb:v04F3p0C8A*
 usb:v05BAp000E*
 usb:v06CBp0051*
 usb:v06CBp0081*
 usb:v06CBp0088*
 usb:v06CBp008A*
 usb:v06CBp009A*
 usb:v06CBp009B*
 usb:v06CBp00A1*
 usb:v06CBp00A2*
 usb:v06CBp00A8*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
 usb:v06CBp00BC*
 usb:v06CBp00BE*
 usb:v06CBp00C4*
 usb:v06CBp00CB*
 usb:v06CBp00C9*
 usb:v06CBp00D8*
@ -404,8 +315,8 @@ usb:v06CBp00DA*
 usb:v06CBp00DC*
 usb:v06CBp00E4*
 usb:v06CBp00E7*
 usb:v06CBp00E9*
 usb:v06CBp00FD*
 usb:v06CBp00FF*
 usb:v0A5Cp5801*
 usb:v0A5Cp5805*
 usb:v0A5Cp5834*
@ -415,21 +326,10 @@ 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:v10A5p9201*
 usb:v10A5p9800*
 usb:v10A5pA120*
 usb:v10A5pA900*
 usb:v10A5pA921*
 usb:v10A5pE340*
 usb:v1188p9545*
 usb:v138Ap0007*
 usb:v138Ap003A*
@ -442,17 +342,12 @@ 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:v1C7Ap057E*
 usb:v2541p0236*
 usb:v2541p9711*
 usb:v27C6p5042*
 usb:v27C6p5110*
 usb:v27C6p5117*
@ -480,20 +375,10 @@ usb:v27C6p55B4*
 usb:v27C6p5740*
 usb:v27C6p5E0A*
 usb:v27C6p581A*
 usb:v27C6p589A*
 usb:v27C6p5F10*
 usb:v27C6p5F91*
 usb:v27C6p6382*
 usb:v2808p9338*
 usb:v2808p9348*
 usb:v2808p93A9*
 usb:v2808pA658*
 usb:v2808pC652*
 usb:v2808pA553*
 usb:v298Dp2020*
 usb:v298Dp2033*
 usb:v2DF0p0003*
 usb:v3274p8012*
 usb:v3538p0930*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
--- a/demo/gtk-libfprint-test.c
+++ b/demo/gtk-libfprint-test.c
@ -101,14 +101,11 @@ plot_minutiae (unsigned char *rgbdata,
 {
  int i;
-  #define write_pixel(num) \
+#define write_pixel(num) do { \
-    do \
+            rgbdata[((num) * 3)] = 0xff; \
-      { \
+            rgbdata[((num) * 3) + 1] = 0; \
-        rgbdata[((num) * 3)] = 0xff; \
+            rgbdata[((num) * 3) + 2] = 0; \
-        rgbdata[((num) * 3) + 1] = 0; \
+  } while(0)
        rgbdata[((num) * 3) + 2] = 0; \
      } \
    while(0)
  for (i = 0; i < minutiae->len; i++)
    {
--- a/demo/org.freedesktop.libfprint.Demo.json
+++ b/demo/org.freedesktop.libfprint.Demo.json
@ -1,7 +1,7 @@
 {
    "app-id": "org.freedesktop.libfprint.Demo",
    "runtime": "org.gnome.Platform",
-    "runtime-version": "master",
+    "runtime-version": "42",
    "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" ],
+            "config-opts": [ "-Dtests=false", "-Dvapi=false", "-Ddocs=false", "-Dintrospection=false" ],
            "sources": [
                {
                    "type": "archive",
-                    "url": "https://github.com/hughsie/libgusb/releases/download/0.4.6/libgusb-0.4.6.tar.xz",
+                    "url": "https://github.com/hughsie/libgusb/archive/0.3.0.tar.gz",
-                    "sha256": "1b0422bdcd72183272ac42eec9398c5a0bc48a02f618fa3242c468cbbd003049"
+                    "sha256": "b36310f8405d5fd68f6caf4a829f7ab4c627b38fd3d02a139d411fce0f3a49f1"
                }
            ]
        },
        {
            "name": "gudev",
            "buildsystem": "meson",
-            "config-opts": [ "-Dtests=disabled", "-Dintrospection=disabled", "-Dvapi=disabled" ],
+            "config-opts": [ "-Dtests=disabled", "-Dintrospection=disabled" ],
            "sources": [
                {
                    "type": "archive",
-                    "url": "https://download.gnome.org/sources/libgudev/238/libgudev-238.tar.xz",
+                    "url": "https://download.gnome.org/sources/libgudev/236/libgudev-236.tar.xz",
-                    "sha256": "61266ab1afc9d73dbc60a8b2af73e99d2fdff47d99544d085760e4fa667b5dd1"
+                    "sha256": "e50369d06d594bae615eb7aeb787de304ebaad07a26d1043cef8e9c7ab7c9524"
                }
            ]
        },
--- a/doc/meson.build
+++ b/doc/meson.build
@ -19,7 +19,7 @@ content_files = [
 expand_content_files = content_files
-glib_prefix = dependency('glib-2.0').get_variable(pkgconfig: 'prefix')
+glib_prefix = dependency('glib-2.0').get_pkgconfig_variable('prefix')
 glib_docpath = join_paths(glib_prefix, 'share', 'gtk-doc', 'html')
 docpath = join_paths(get_option('datadir'), 'gtk-doc', 'html')
--- a/examples/clear-storage.c
+++ b/examples/clear-storage.c
@ -1,208 +0,0 @@
 /*
 * Example storage clearing program, which deletes all the
 * fingers which have been previously enrolled to disk.
 * Copyright (C) 2020 Marco Trevisan <marco.trevisan@canonical.com>
 * Copyright (C) 2024 Abhinav Baid <abhinavbaid@gmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #define FP_COMPONENT "example-clear-storage"
 #include <stdlib.h>
 #include <stdio.h>
 #include <libfprint/fprint.h>
 #include <glib-unix.h>
 #include "storage.h"
 #include "utilities.h"
 typedef struct _ClearStorageData
 {
  GMainLoop    *loop;
  GCancellable *cancellable;
  unsigned int  sigint_handler;
  int           ret_value;
 } ClearStorageData;
 static void
 clear_storage_data_free (ClearStorageData *clear_storage_data)
 {
  g_clear_handle_id (&clear_storage_data->sigint_handler, g_source_remove);
  g_clear_object (&clear_storage_data->cancellable);
  g_main_loop_unref (clear_storage_data->loop);
  g_free (clear_storage_data);
 }
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClearStorageData, clear_storage_data_free)
 static void
 on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
 {
  g_autoptr(GError) error = NULL;
  ClearStorageData *clear_storage_data = user_data;
  fp_device_close_finish (dev, res, &error);
  if (error)
    g_warning ("Failed closing device %s", error->message);
  g_main_loop_quit (clear_storage_data->loop);
 }
 static void
 clear_storage_quit (FpDevice         *dev,
                    ClearStorageData *clear_storage_data)
 {
  if (!fp_device_is_open (dev))
    {
      g_main_loop_quit (clear_storage_data->loop);
      return;
    }
  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed,
                   clear_storage_data);
 }
 static void
 on_clear_storage_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
 {
  g_autoptr(GError) error = NULL;
  ClearStorageData *clear_storage_data = user_data;
  if (fp_device_clear_storage_finish (dev, res, &error))
    {
      if (!clear_saved_prints (dev, &error))
        {
          g_warning ("Clear saved prints from local storage failed: %s",
                     error->message);
          clear_storage_data->ret_value = EXIT_FAILURE;
        }
      else
        {
          g_print ("Clear storage successful!\n");
          clear_storage_data->ret_value = EXIT_SUCCESS;
        }
      clear_storage_quit (dev, clear_storage_data);
      return;
    }
  g_warning ("Failed to clear storage: %s", error->message);
  clear_storage_data->ret_value = EXIT_FAILURE;
  if (g_error_matches (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_NOT_SUPPORTED))
    {
      g_autoptr(GError) clear_error = NULL;
      if (clear_saved_prints (dev, &clear_error))
        clear_storage_data->ret_value = EXIT_SUCCESS;
      else
        g_warning ("Clear saved prints from local storage failed: %s",
                   clear_error->message);
    }
  clear_storage_quit (dev, clear_storage_data);
 }
 static void
 start_clear_storage (FpDevice *dev, ClearStorageData *clear_storage_data)
 {
  char buffer[20];
  g_print ("Clear device storage? [Y/n]? ");
  if (fgets (buffer, sizeof (buffer), stdin) &&
      (buffer[0] == 'Y' || buffer[0] == 'y'))
    {
      fp_device_clear_storage (dev, clear_storage_data->cancellable,
                               (GAsyncReadyCallback) on_clear_storage_completed,
                               clear_storage_data);
      return;
    }
  clear_storage_quit (dev, clear_storage_data);
 }
 static void
 on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
 {
  g_autoptr(GError) error = NULL;
  ClearStorageData *clear_storage_data = user_data;
  if (!fp_device_open_finish (dev, res, &error))
    {
      g_warning ("Failed to open device: %s", error->message);
      clear_storage_quit (dev, clear_storage_data);
      return;
    }
  g_print ("Opened device. ");
  start_clear_storage (dev, clear_storage_data);
 }
 static gboolean
 sigint_cb (void *user_data)
 {
  ClearStorageData *clear_storage_data = user_data;
  g_cancellable_cancel (clear_storage_data->cancellable);
  return G_SOURCE_CONTINUE;
 }
 int
 main (void)
 {
  g_autoptr(FpContext) ctx = NULL;
  g_autoptr(ClearStorageData) clear_storage_data = NULL;
  GPtrArray *devices;
  FpDevice *dev;
  setenv ("G_MESSAGES_DEBUG", "all", 0);
  setenv ("LIBUSB_DEBUG", "3", 0);
  ctx = fp_context_new ();
  devices = fp_context_get_devices (ctx);
  if (!devices)
    {
      g_warning ("Impossible to get devices");
      return EXIT_FAILURE;
    }
  dev = discover_device (devices);
  if (!dev)
    {
      g_warning ("No devices detected.");
      return EXIT_FAILURE;
    }
  clear_storage_data = g_new0 (ClearStorageData, 1);
  clear_storage_data->ret_value = EXIT_FAILURE;
  clear_storage_data->loop = g_main_loop_new (NULL, FALSE);
  clear_storage_data->cancellable = g_cancellable_new ();
  clear_storage_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
                                                               SIGINT,
                                                               sigint_cb,
                                                               clear_storage_data,
                                                               NULL);
  fp_device_open (dev, clear_storage_data->cancellable,
                  (GAsyncReadyCallback) on_device_opened,
                  clear_storage_data);
  g_main_loop_run (clear_storage_data->loop);
  return clear_storage_data->ret_value;
 }
--- a/examples/meson.build
+++ b/examples/meson.build
@ -5,7 +5,6 @@ examples = [
    'img-capture',
    'manage-prints',
    'verify',
    'clear-storage',
 ]
 foreach example: examples
--- a/examples/storage.c
+++ b/examples/storage.c
@ -26,7 +26,6 @@
 #include "storage.h"
 #include <errno.h>
 #include <glib/gstdio.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@ -56,18 +55,6 @@ get_print_data_descriptor (FpPrint *print, FpDevice *dev, FpFinger finger)
                          finger);
 }
 static char *
 get_print_prefix_for_device (FpDevice *dev)
 {
  const char *driver;
  const char *dev_id;
  driver = fp_device_get_driver (dev);
  dev_id = fp_device_get_device_id (dev);
  return g_strdup_printf ("%s/%s/", driver, dev_id);
 }
 static GVariantDict *
 load_data (void)
 {
@ -182,6 +169,8 @@ gallery_data_load (FpDevice *dev)
  g_autoptr(GVariant) dict_variant = NULL;
  g_autofree char *dev_prefix = NULL;
  GPtrArray *gallery;
  const char *driver;
  const char *dev_id;
  GVariantIter iter;
  GVariant *value;
  gchar *key;
@ -189,7 +178,9 @@ gallery_data_load (FpDevice *dev)
  gallery = g_ptr_array_new_with_free_func (g_object_unref);
  dict = load_data ();
  dict_variant = g_variant_dict_end (dict);
-  dev_prefix = get_print_prefix_for_device (dev);
+  driver = fp_device_get_driver (dev);
  dev_id = fp_device_get_device_id (dev);
  dev_prefix = g_strdup_printf ("%s/%s/", driver, dev_id);
  g_variant_iter_init (&iter, dict_variant);
  while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
@ -217,55 +208,6 @@ gallery_data_load (FpDevice *dev)
  return gallery;
 }
 gboolean
 clear_saved_prints (FpDevice *dev,
                    GError  **error)
 {
  g_autoptr(GVariantDict) dict = NULL;
  g_autoptr(GVariantDict) updated_dict = NULL;
  g_autoptr(GVariant) dict_variant = NULL;
  g_autofree char *dev_prefix = NULL;
  GPtrArray *print_keys;
  GVariantIter iter;
  GVariant *value;
  gchar *key;
  print_keys = g_ptr_array_new_with_free_func (g_free);
  dict = load_data ();
  dict_variant = g_variant_dict_end (dict);
  dev_prefix = get_print_prefix_for_device (dev);
  g_variant_iter_init (&iter, dict_variant);
  while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
    {
      if (!g_str_has_prefix (key, dev_prefix))
        continue;
      g_ptr_array_add (print_keys, g_strdup (key));
    }
  if (!print_keys->len)
    return TRUE;
  updated_dict = load_data ();
  for (guint i = 0; i < print_keys->len; ++i)
    {
      key = g_ptr_array_index (print_keys, i);
      if (!g_variant_dict_remove (updated_dict, key))
        {
          g_warning ("Print '%s' key not found!", key);
          continue;
        }
      g_debug ("Dropping print '%s' from gallery", key);
    }
  save_data (g_variant_dict_end (updated_dict));
  return TRUE;
 }
 FpPrint *
 print_create_template (FpDevice *dev, FpFinger finger, gboolean load_existing)
 {
--- a/examples/storage.h
+++ b/examples/storage.h
@ -20,17 +20,12 @@
 #pragma once
 #include <glib.h>
 #include <libfprint/fprint.h>
 int print_data_save (FpPrint *print,
                     FpFinger finger,
                     gboolean update_fingerprint);
 FpPrint * print_data_load (FpDevice *dev,
                           FpFinger  finger);
 GPtrArray * gallery_data_load (FpDevice *dev);
 gboolean clear_saved_prints (FpDevice *dev,
                             GError  **error);
 FpPrint * print_create_template (FpDevice      *dev,
                                 FpFinger       finger,
                                 const gboolean load_existing);
--- a/gcovr.cfg
+++ b/gcovr.cfg
@ -1 +0,0 @@
 gcov-ignore-parse-errors = suspicious_hits.warn
--- a/libfprint/drivers/egismoc/egismoc.c
+++ b/libfprint/drivers/egismoc/egismoc.c
--- a/libfprint/drivers/egismoc/egismoc.h
+++ b/libfprint/drivers/egismoc/egismoc.h
@ -1,223 +0,0 @@
 /*
 * 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;
--- a/libfprint/drivers/elanmoc/elanmoc.c
+++ b/libfprint/drivers/elanmoc/elanmoc.c
@ -31,15 +31,7 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x04f3,  .pid = 0x0c88,  },
  { .vid = 0x04f3,  .pid = 0x0c8c,  },
  { .vid = 0x04f3,  .pid = 0x0c8d,  },
  { .vid = 0x04f3,  .pid = 0x0c98,  },
  { .vid = 0x04f3,  .pid = 0x0c99,  },
  { .vid = 0x04f3,  .pid = 0x0c9d,  },
  { .vid = 0x04f3,  .pid = 0x0c9f,  },
  { .vid = 0x04f3,  .pid = 0x0ca3,  },
  { .vid = 0x04f3,  .pid = 0x0ca7,  },
  { .vid = 0x04f3,  .pid = 0x0ca8,  },
  { .vid = 0x04f3,  .pid = 0x0cb0,  },
  { .vid = 0x04f3,  .pid = 0x0cb2,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
@ -58,9 +50,9 @@ elanmoc_compose_cmd (
  const struct elanmoc_cmd *cmd_info
                    )
 {
-  g_autofree uint8_t *cmd_buf = NULL;
+  g_autofree char *cmd_buf = NULL;
-  cmd_buf = g_new0 (uint8_t, cmd_info->cmd_len);
+  cmd_buf = g_malloc0 (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
@ -136,10 +128,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
 }
 typedef enum {
-  ELAN_MOC_CMD_SEND = 0,
+  FP_CMD_SEND = 0,
-  ELAN_MOC_CMD_GET,
+  FP_CMD_GET,
-  ELAN_MOC_CMD_NUM_STATES,
+  FP_CMD_NUM_STATES,
-} ElanMocCmdState;
+} FpCmdState;
 static void
 fp_cmd_run_state (FpiSsm   *ssm,
@ -150,7 +142,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case ELAN_MOC_CMD_SEND:
+    case FP_CMD_SEND:
      if (self->cmd_transfer)
        {
          self->cmd_transfer->ssm = ssm;
@ -166,7 +158,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
        }
      break;
-    case ELAN_MOC_CMD_GET:
+    case FP_CMD_GET:
      if (self->cmd_len_in == 0)
        {
          CommandData *data = fpi_ssm_get_data (ssm);
@ -233,7 +225,7 @@ elanmoc_get_cmd (FpDevice *device, guint8 *buffer_out,
  self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                               fp_cmd_run_state,
-                               ELAN_MOC_CMD_NUM_STATES);
+                               FP_CMD_NUM_STATES);
  fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);
--- a/libfprint/drivers/elanspi.h
+++ b/libfprint/drivers/elanspi.h
@ -340,11 +340,9 @@ static const struct elanspi_regtable elanspi_calibration_table_new_page1 = {
 // using checkargs ACPI:HIDPID
 static const FpIdEntry elanspi_id_table[] = {
  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x2766}, .driver_data = ELANSPI_NO_ROTATE},
  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3057}, .driver_data = ELANSPI_180_ROTATE},
  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3087}, .driver_data = ELANSPI_180_ROTATE},
  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x30c6}, .driver_data = ELANSPI_180_ROTATE},
  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3128}, .driver_data = ELANSPI_90LEFT_ROTATE},
  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN70A1", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3134}, .driver_data = ELANSPI_90LEFT_ROTATE},
  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3148}, .driver_data = ELANSPI_180_ROTATE},
  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x30b2}, .driver_data = ELANSPI_NO_ROTATE},
--- a/libfprint/drivers/focaltech_moc/focaltech_moc.c
+++ b/libfprint/drivers/focaltech_moc/focaltech_moc.c
--- a/libfprint/drivers/focaltech_moc/focaltech_moc.h
+++ b/libfprint/drivers/focaltech_moc/focaltech_moc.h
@ -1,52 +0,0 @@
 /*
 * 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;
 };
--- a/libfprint/drivers/fpcmoc/fpc.c
+++ b/libfprint/drivers/fpcmoc/fpc.c
@ -21,7 +21,7 @@
 #define FP_COMPONENT "fpcmoc"
 #define MAX_ENROLL_SAMPLES (25)
-#define CTRL_TIMEOUT (2000)
+#define CTRL_TIMEOUT (1000)
 #define DATA_TIMEOUT (5000)
 /* Usb port setting */
@ -65,14 +65,9 @@ typedef struct
 static const FpIdEntry id_table[] = {
  { .vid = 0x10A5,  .pid = 0xFFE0,  },
  { .vid = 0x10A5,  .pid = 0xA305,  },
  { .vid = 0x10A5,  .pid = 0xA306,  },
  { .vid = 0x10A5,  .pid = 0xDA04,  },
  { .vid = 0x10A5,  .pid = 0xD805,  },
  { .vid = 0x10A5,  .pid = 0xD205,  },
  { .vid = 0x10A5,  .pid = 0x9524,  },
  { .vid = 0x10A5,  .pid = 0x9544,  },
  { .vid = 0x10A5,  .pid = 0xC844,  },
  { .vid = 0x10A5,  .pid = 0x9B24,  },
  /* terminating entry */
  { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };
@ -87,7 +82,7 @@ fpc_suspend_resume_cb (FpiUsbTransfer *transfer,
  fp_dbg ("%s current ssm state: %d", G_STRFUNC, ssm_state);
-  if (ssm_state == FPC_CMD_SUSPENDED)
+  if (ssm_state == FP_CMD_SUSPENDED)
    {
      if (error)
        fpi_ssm_mark_failed (transfer->ssm, error);
@ -95,12 +90,12 @@ fpc_suspend_resume_cb (FpiUsbTransfer *transfer,
      fpi_device_suspend_complete (device, error);
      /* The resume handler continues to the next state! */
    }
-  else if (ssm_state == FPC_CMD_RESUME)
+  else if (ssm_state == FP_CMD_RESUME)
    {
      if (error)
        fpi_ssm_mark_failed (transfer->ssm, error);
      else
-        fpi_ssm_jump_to_state (transfer->ssm, FPC_CMD_GET_DATA);
+        fpi_ssm_jump_to_state (transfer->ssm, FP_CMD_GET_DATA);
      fpi_device_resume_complete (device, error);
    }
@ -119,7 +114,7 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) && (self->cmd_suspended))
    {
      g_error_free (error);
-      fpi_ssm_jump_to_state (transfer->ssm, FPC_CMD_SUSPENDED);
+      fpi_ssm_jump_to_state (transfer->ssm, FP_CMD_SUSPENDED);
      return;
    }
@ -140,7 +135,7 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
  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 != FPC_CMD_SEND || data->request != FPC_CMD_ARM)
+  if (ssm_state != FP_CMD_SEND || data->request != FPC_CMD_ARM)
    self->cmd_ssm = NULL;
  if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE)
@ -154,13 +149,13 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
    }
  else if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE_EVTDATA)
    {
-      if (ssm_state == FPC_CMD_SEND)
+      if (ssm_state == FP_CMD_SEND)
        {
          fpi_ssm_next_state (transfer->ssm);
          return;
        }
-      if (ssm_state == FPC_CMD_GET_DATA)
+      if (ssm_state == FP_CMD_GET_DATA)
        {
          fpc_cmd_response_t evt_data = {0};
          fp_dbg ("%s recv evt data length: %ld", G_STRFUNC, transfer->actual_length);
@ -274,7 +269,6 @@ 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)
    {
@ -282,6 +276,8 @@ fpc_cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
      if (data->callback)
        data->callback (self, NULL, error);
    }
  self->cmd_ssm = NULL;
 }
 static void
@ -293,11 +289,11 @@ fpc_cmd_run_state (FpiSsm   *ssm,
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FPC_CMD_SEND:
+    case FP_CMD_SEND:
      fpc_send_ctrl_cmd (dev);
      break;
-    case FPC_CMD_GET_DATA:
+    case FP_CMD_GET_DATA:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@ -308,7 +304,7 @@ fpc_cmd_run_state (FpiSsm   *ssm,
                               fpi_ssm_get_data (ssm));
      break;
-    case FPC_CMD_SUSPENDED:
+    case FP_CMD_SUSPENDED:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_control (transfer,
@ -324,7 +320,7 @@ fpc_cmd_run_state (FpiSsm   *ssm,
                               fpc_suspend_resume_cb, NULL);
      break;
-    case FPC_CMD_RESUME:
+    case FP_CMD_RESUME:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_control (transfer,
@ -355,22 +351,21 @@ fpc_sensor_cmd (FpiDeviceFpcMoc *self,
  data = g_memdup2 (cmd_data, sizeof (CommandData));
  g_clear_object (&self->interrupt_cancellable);
  if (wait_data_delay)
    {
      self->cmd_data_timeout = 0;
-      self->interrupt_cancellable = g_cancellable_new ();
+      g_set_object (&self->interrupt_cancellable, g_cancellable_new ());
    }
  else
    {
      self->cmd_data_timeout = DATA_TIMEOUT;
      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,
-                               FPC_CMD_NUM_STATES);
+                               FP_CMD_NUM_STATES);
  fpi_ssm_set_data (self->cmd_ssm, data, g_free);
  fpi_ssm_start (self->cmd_ssm, fpc_cmd_ssm_done);
@ -393,7 +388,7 @@ fpc_dev_release_interface (FpiDeviceFpcMoc *self,
    }
  /* Notify close complete */
-  fpi_device_close_complete (FP_DEVICE (self), g_steal_pointer (&release_error));
+  fpi_device_close_complete (FP_DEVICE (self), release_error);
 }
 static gboolean
@ -451,16 +446,10 @@ fpc_evt_cb (FpiDeviceFpcMoc *self,
      break;
    case FPC_EVT_FINGER_DWN:
-      fp_dbg ("%s Got finger down event (%d)", G_STRFUNC, presp->evt_hdr.status);
+      fp_dbg ("%s Got finger down event", G_STRFUNC);
      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:
@ -745,7 +734,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
    case FPC_ENROL_STATUS_COMPLETED:
      self->enroll_stage++;
      fpi_device_enroll_progress (FP_DEVICE (self), self->enroll_stage, NULL, NULL);
-      fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_COMPLETE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
      return;
    case FPC_ENROL_STATUS_IMAGE_TOO_SIMILAR:
@ -753,22 +742,15 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
      /* here should tips remove finger and try again */
      if (self->max_immobile_stage)
        {
-          self->immobile_stage++;
+          if (self->immobile_stage >= self->max_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. */
-              self->enroll_stage++;
+              fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROL_STATUS_PROGRESS);
              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, FPC_ENROLL_COMPLETE);
                  return;
                }
              break;
            }
          self->immobile_stage++;
        }
      fpi_device_enroll_progress (FP_DEVICE (self),
                                  self->enroll_stage,
@ -781,10 +763,7 @@ 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, FPC_ENROLL_COMPLETE);
          return;
        }
      break;
    case FPC_ENROL_STATUS_IMAGE_LOW_COVERAGE:
@ -817,7 +796,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
    }
  else
    {
-      fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
    }
 }
@ -945,7 +924,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FPC_ENROLL_ENUM:
+    case FP_ENROLL_ENUM:
      {
        FPC_FID_DATA pquery_data = {0};
        gsize query_data_len = 0;
@ -970,7 +949,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_CREATE:
+    case FP_ENROLL_CREATE:
      {
        recv_data_len = sizeof (FPC_BEGIN_ENROL);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -985,7 +964,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_CAPTURE:
+    case FP_ENROLL_CAPTURE:
      {
        guint32 capture_id = FPC_CAPTUREID_RESERVED;
        fpi_device_report_finger_status_changes (device,
@ -1003,7 +982,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_GET_IMG:
+    case FP_ENROLL_GET_IMG:
      {
        cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
        cmd_data.request = FPC_CMD_GET_IMG;
@ -1017,7 +996,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_UPDATE:
+    case FP_ENROLL_UPDATE:
      {
        recv_data_len = sizeof (FPC_ENROL);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1032,7 +1011,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_COMPLETE:
+    case FP_ENROLL_COMPLETE:
      {
        recv_data_len = sizeof (FPC_END_ENROL);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1047,7 +1026,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_CHECK_DUPLICATE:
+    case FP_ENROLL_CHECK_DUPLICATE:
      {
        recv_data_len = sizeof (FPC_IDENTIFY);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1062,7 +1041,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_BINDID:
+    case FP_ENROLL_BINDID:
      {
        FPC_FID_DATA data = {0};
        gsize data_len = 0;
@ -1116,7 +1095,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_COMMIT:
+    case FP_ENROLL_COMMIT:
      {
        recv_data_len = sizeof (gint32);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1131,7 +1110,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_DICARD:
+    case FP_ENROLL_DICARD:
      {
        cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
        cmd_data.request = FPC_CMD_ABORT;
@ -1144,7 +1123,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_ENROLL_CLEANUP:
+    case FP_ENROLL_CLEANUP:
      {
        if (self->do_cleanup == TRUE)
          {
@ -1289,7 +1268,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FPC_VERIFY_CAPTURE:
+    case FP_VERIFY_CAPTURE:
      {
        guint32 capture_id = FPC_CAPTUREID_RESERVED;
        fpi_device_report_finger_status_changes (device,
@ -1307,7 +1286,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_VERIFY_GET_IMG:
+    case FP_VERIFY_GET_IMG:
      {
        cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
        cmd_data.request = FPC_CMD_GET_IMG;
@ -1321,7 +1300,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_VERIFY_IDENTIFY:
+    case FP_VERIFY_IDENTIFY:
      {
        gsize recv_data_len = sizeof (FPC_IDENTIFY);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1336,7 +1315,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_VERIFY_CANCEL:
+    case FP_VERIFY_CANCEL:
      {
        cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
        cmd_data.request = FPC_CMD_ABORT;
@ -1406,7 +1385,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FPC_CLEAR_DELETE_DB:
+    case FP_CLEAR_DELETE_DB:
      {
        if (self->dbid)
          {
@ -1433,7 +1412,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case FPC_CLEAR_CREATE_DB:
+    case FP_CLEAR_CREATE_DB:
      {
        if (self->dbid)
          {
@ -1538,7 +1517,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FPC_INIT:
+    case FP_INIT:
      cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
      cmd_data.request = FPC_CMD_INIT;
      cmd_data.value = 0x1;
@ -1550,7 +1529,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
      fpc_sensor_cmd (self, FALSE, &cmd_data);
      break;
-    case FPC_INIT_LOAD_DB:
+    case FP_LOAD_DB:
      {
        gsize recv_data_len = sizeof (FPC_LOAD_DB);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1641,13 +1620,9 @@ fpc_dev_probe (FpDevice *device)
    {
    case 0xFFE0:
    case 0xA305:
    case 0xA306:
    case 0xD805:
    case 0xDA04:
    case 0xD205:
    case 0x9524:
    case 0x9544:
    case 0xC844:
      self->max_enroll_stage = MAX_ENROLL_SAMPLES;
      break;
@ -1684,7 +1659,7 @@ fpc_dev_open (FpDevice *device)
    }
  self->task_ssm = fpi_ssm_new (device, fpc_init_sm_run_state,
-                                FPC_INIT_NUM_STATES);
+                                FP_INIT_NUM_STATES);
  fpi_ssm_start (self->task_ssm, fpc_init_ssm_done);
 }
@ -1696,7 +1671,6 @@ fpc_dev_close (FpDevice *device)
  fp_dbg ("%s enter -->", G_STRFUNC);
  g_clear_pointer (&self->dbid, g_free);
  g_cancellable_cancel (self->interrupt_cancellable);
  g_clear_object (&self->interrupt_cancellable);
  fpc_dev_release_interface (self, NULL);
 }
@ -1708,8 +1682,8 @@ fpc_dev_verify_identify (FpDevice *device)
  fp_dbg ("%s enter -->", G_STRFUNC);
  self->task_ssm = fpi_ssm_new_full (device, fpc_verify_sm_run_state,
-                                     FPC_VERIFY_NUM_STATES,
+                                     FP_VERIFY_NUM_STATES,
-                                     FPC_VERIFY_CANCEL,
+                                     FP_VERIFY_CANCEL,
                                     "verify_identify");
  fpi_ssm_start (self->task_ssm, fpc_verify_ssm_done);
@ -1725,8 +1699,8 @@ fpc_dev_enroll (FpDevice *device)
  self->enroll_stage = 0;
  self->immobile_stage = 0;
  self->task_ssm = fpi_ssm_new_full (device, fpc_enroll_sm_run_state,
-                                     FPC_ENROLL_NUM_STATES,
+                                     FP_ENROLL_NUM_STATES,
-                                     FPC_ENROLL_DICARD,
+                                     FP_ENROLL_DICARD,
                                     "enroll");
  fpi_ssm_start (self->task_ssm, fpc_enroll_ssm_done);
@ -1777,7 +1751,7 @@ fpc_dev_suspend (FpDevice *device)
    }
  g_assert (self->cmd_ssm);
-  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FPC_CMD_GET_DATA);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FP_CMD_GET_DATA);
  self->cmd_suspended = TRUE;
  g_cancellable_cancel (self->interrupt_cancellable);
 }
@ -1799,12 +1773,10 @@ fpc_dev_resume (FpDevice *device)
  g_assert (self->cmd_ssm);
  g_assert (self->cmd_suspended);
-  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FPC_CMD_SUSPENDED);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FP_CMD_SUSPENDED);
  self->cmd_suspended = FALSE;
-
+  g_set_object (&self->interrupt_cancellable, g_cancellable_new ());
-  g_clear_object (&self->interrupt_cancellable);
+  fpi_ssm_jump_to_state (self->cmd_ssm, FP_CMD_RESUME);
  self->interrupt_cancellable = g_cancellable_new ();
  fpi_ssm_jump_to_state (self->cmd_ssm, FPC_CMD_RESUME);
 }
 static void
@ -1868,8 +1840,8 @@ fpc_dev_clear_storage (FpDevice *device)
  fp_dbg ("%s enter -->", G_STRFUNC);
  self->task_ssm = fpi_ssm_new_full (device, fpc_clear_sm_run_state,
-                                     FPC_CLEAR_NUM_STATES,
+                                     FP_CLEAR_NUM_STATES,
-                                     FPC_CLEAR_NUM_STATES,
+                                     FP_CLEAR_NUM_STATES,
                                     "Clear storage");
  fpi_ssm_start (self->task_ssm, fpc_clear_ssm_done);
--- a/libfprint/drivers/fpcmoc/fpc.h
+++ b/libfprint/drivers/fpcmoc/fpc.h
@ -178,44 +178,44 @@ typedef enum {
 } FpcCmdType;
 typedef enum {
-  FPC_CMD_SEND = 0,
+  FP_CMD_SEND = 0,
-  FPC_CMD_GET_DATA,
+  FP_CMD_GET_DATA,
-  FPC_CMD_SUSPENDED,
+  FP_CMD_SUSPENDED,
-  FPC_CMD_RESUME,
+  FP_CMD_RESUME,
-  FPC_CMD_NUM_STATES,
+  FP_CMD_NUM_STATES,
-} FpcCmdState;
+} FpCmdState;
 typedef enum {
-  FPC_INIT = 0,
+  FP_INIT = 0,
-  FPC_INIT_LOAD_DB,
+  FP_LOAD_DB,
-  FPC_INIT_NUM_STATES,
+  FP_INIT_NUM_STATES,
-} FpcInitState;
+} FpInitState;
 typedef enum {
-  FPC_ENROLL_ENUM = 0,
+  FP_ENROLL_ENUM = 0,
-  FPC_ENROLL_CREATE,
+  FP_ENROLL_CREATE,
-  FPC_ENROLL_CAPTURE,
+  FP_ENROLL_CAPTURE,
-  FPC_ENROLL_GET_IMG,
+  FP_ENROLL_GET_IMG,
-  FPC_ENROLL_UPDATE,
+  FP_ENROLL_UPDATE,
-  FPC_ENROLL_COMPLETE,
+  FP_ENROLL_COMPLETE,
-  FPC_ENROLL_CHECK_DUPLICATE,
+  FP_ENROLL_CHECK_DUPLICATE,
-  FPC_ENROLL_BINDID,
+  FP_ENROLL_BINDID,
-  FPC_ENROLL_COMMIT,
+  FP_ENROLL_COMMIT,
-  FPC_ENROLL_DICARD,
+  FP_ENROLL_DICARD,
-  FPC_ENROLL_CLEANUP,
+  FP_ENROLL_CLEANUP,
-  FPC_ENROLL_NUM_STATES,
+  FP_ENROLL_NUM_STATES,
-} FpcEnrollState;
+} FpEnrollState;
 typedef enum {
-  FPC_VERIFY_CAPTURE = 0,
+  FP_VERIFY_CAPTURE = 0,
-  FPC_VERIFY_GET_IMG,
+  FP_VERIFY_GET_IMG,
-  FPC_VERIFY_IDENTIFY,
+  FP_VERIFY_IDENTIFY,
-  FPC_VERIFY_CANCEL,
+  FP_VERIFY_CANCEL,
-  FPC_VERIFY_NUM_STATES,
+  FP_VERIFY_NUM_STATES,
-} FpcVerifyState;
+} FpVerifyState;
 typedef enum {
-  FPC_CLEAR_DELETE_DB = 0,
+  FP_CLEAR_DELETE_DB = 0,
-  FPC_CLEAR_CREATE_DB,
+  FP_CLEAR_CREATE_DB,
-  FPC_CLEAR_NUM_STATES,
+  FP_CLEAR_NUM_STATES,
 } FpClearState;
--- a/libfprint/drivers/goodixmoc/goodix.c
+++ b/libfprint/drivers/goodixmoc/goodix.c
@ -128,13 +128,11 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
                   GError         *error)
 {
  FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
  FpiByteReader reader = {0};
  CommandData *data = user_data;
-  int ssm_state = 0;
+  int ret = -1, ssm_state = 0;
  gxfp_cmd_response_t cmd_reponse = {0, };
  pack_header header;
  guint32 crc32_calc = 0;
  guint32 crc32 = 0;
  guint16 cmd = 0;
  if (error)
@ -156,10 +154,8 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
      return;
    }
-  reader.data = transfer->buffer;
+  ret = gx_proto_parse_header (transfer->buffer, transfer->actual_length, &header);
-  reader.size = transfer->actual_length;
+  if (ret != 0)
  if (gx_proto_parse_header (&reader, &header) != 0)
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@ -167,17 +163,8 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
      return;
    }
  if (!fpi_byte_reader_set_pos (&reader, PACKAGE_HEADER_SIZE + header.len))
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
                                                     "Package crc read failed"));
    }
  gx_proto_crc32_calc (transfer->buffer, PACKAGE_HEADER_SIZE + header.len, (uint8_t *) &crc32_calc);
-
+  if(crc32_calc != GUINT32_FROM_LE (*(uint32_t *) (transfer->buffer + PACKAGE_HEADER_SIZE + header.len)))
  if (!fpi_byte_reader_get_uint32_le (&reader, &crc32) ||
      crc32_calc != crc32)
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@ -187,11 +174,8 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
  cmd = MAKE_CMD_EX (header.cmd0, header.cmd1);
-  fpi_byte_reader_set_pos (&reader, 0);
+  ret = gx_proto_parse_body (cmd, &transfer->buffer[PACKAGE_HEADER_SIZE], header.len, &cmd_reponse);
-  reader.data = &transfer->buffer[PACKAGE_HEADER_SIZE];
+  if (ret != 0)
  reader.size = header.len;
  if (gx_proto_parse_body (cmd, &reader, &cmd_reponse) != 0)
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@ -238,7 +222,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case GOODIX_CMD_SEND:
+    case FP_CMD_SEND:
      if (self->cmd_transfer)
        {
          self->cmd_transfer->ssm = ssm;
@ -254,7 +238,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
        }
      break;
-    case GOODIX_CMD_GET_ACK:
+    case FP_CMD_GET_ACK:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@ -266,7 +250,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
      break;
-    case GOODIX_CMD_GET_DATA:
+    case FP_CMD_GET_DATA:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@ -354,7 +338,7 @@ goodix_sensor_cmd (FpiDeviceGoodixMoc *self,
  self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                               fp_cmd_run_state,
-                               GOODIX_CMD_NUM_STATES);
+                               FP_CMD_NUM_STATES);
  fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);
@ -480,35 +464,6 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,
 }
 static void
 fp_verify_finger_mode_cb (FpiDeviceGoodixMoc  *self,
                          gxfp_cmd_response_t *resp,
                          GError              *error)
 {
  if (error)
    {
      fpi_ssm_mark_failed (self->task_ssm, error);
      return;
    }
  /* if reach max timeout(5sec) finger not up, try again */
  if (resp->finger_status.status == GX_ERROR_WAIT_FINGER_UP_TIMEOUT)
    {
      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_VERIFY_WAIT_FINGER_UP);
      return;
    }
  else if (resp->finger_status.status != GX_SUCCESS)
    {
      fpi_ssm_mark_failed (self->task_ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
                                                     "Switch finger mode failed"));
      return;
    }
  fpi_device_report_finger_status_changes (FP_DEVICE (self),
                                           FP_FINGER_STATUS_NONE,
                                           FP_FINGER_STATUS_PRESENT);
  fpi_ssm_next_state (self->task_ssm);
 }
 static void
 fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
 {
@ -522,7 +477,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case GOODIX_VERIFY_PWR_BTN_SHIELD_ON:
+    case FP_VERIFY_PWR_BTN_SHIELD_ON:
      goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
                         false,
                         NULL,
@ -530,7 +485,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_pwr_btn_shield_cb);
      break;
-    case GOODIX_VERIFY_CAPTURE:
+    case FP_VERIFY_CAPTURE:
      fpi_device_report_finger_status_changes (device,
                                               FP_FINGER_STATUS_NEEDED,
                                               FP_FINGER_STATUS_NONE);
@ -541,7 +496,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_verify_capture_cb);
      break;
-    case GOODIX_VERIFY_IDENTIFY:
+    case FP_VERIFY_IDENTIFY:
      goodix_sensor_cmd (self, MOC_CMD0_IDENTIFY, MOC_CMD1_DEFAULT,
                         false,
                         (const guint8 *) nonce,
@ -549,18 +504,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_verify_cb);
      break;
-    case GOODIX_VERIFY_WAIT_FINGER_UP:
+    case FP_VERIFY_PWR_BTN_SHIELD_OFF:
      {
        guint8 dummy = 0;
        goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP,
                           true,
                           &dummy,
                           1,
                           fp_verify_finger_mode_cb);
      }
      break;
    case GOODIX_VERIFY_PWR_BTN_SHIELD_OFF:
      goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
                         false,
                         NULL,
@ -722,7 +666,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
                                  self->enroll_stage,
                                  NULL,
                                  fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
-      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
      return;
    }
  fpi_device_report_finger_status_changes (FP_DEVICE (self),
@ -740,7 +684,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
                                  self->enroll_stage,
                                  NULL,
                                  fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER));
-      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
      return;
    }
  else
@ -786,7 +730,7 @@ fp_enroll_update_cb (FpiDeviceGoodixMoc  *self,
  /* if enroll complete, no need to wait finger up */
  if (self->enroll_stage >= self->max_enroll_stage)
    {
-      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CHECK_DUPLICATE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CHECK_DUPLICATE);
      return;
    }
@ -852,7 +796,7 @@ fp_finger_mode_cb (FpiDeviceGoodixMoc  *self,
  /* if reach max timeout(5sec) finger not up, switch to finger up again */
  if (resp->finger_status.status == GX_ERROR_WAIT_FINGER_UP_TIMEOUT)
    {
-      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_WAIT_FINGER_UP);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_WAIT_FINGER_UP);
      return;
    }
  else if (resp->finger_status.status != GX_SUCCESS)
@ -867,7 +811,7 @@ fp_finger_mode_cb (FpiDeviceGoodixMoc  *self,
                                           FP_FINGER_STATUS_PRESENT);
  if (self->enroll_stage < self->max_enroll_stage)
    {
-      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
      return;
    }
  fpi_ssm_next_state (self->task_ssm);
@ -893,7 +837,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case GOODIX_ENROLL_PWR_BTN_SHIELD_ON:
+    case FP_ENROLL_PWR_BTN_SHIELD_ON:
      {
        goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
                           false,
@ -903,7 +847,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case GOODIX_ENROLL_ENUM:
+    case FP_ENROLL_ENUM:
      {
        goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
                           false,
@ -913,7 +857,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case GOODIX_ENROLL_CREATE:
+    case FP_ENROLL_CREATE:
      {
        goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT,
                           false,
@ -923,7 +867,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case GOODIX_ENROLL_CAPTURE:
+    case FP_ENROLL_CAPTURE:
      fpi_device_report_finger_status_changes (device,
                                               FP_FINGER_STATUS_NEEDED,
                                               FP_FINGER_STATUS_NONE);
@ -934,7 +878,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_enroll_capture_cb);
      break;
-    case GOODIX_ENROLL_UPDATE:
+    case FP_ENROLL_UPDATE:
      dummy[0] = 1;
      dummy[1] = self->sensorcfg->config[2];
      dummy[2] = self->sensorcfg->config[3];
@ -945,7 +889,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_enroll_update_cb);
      break;
-    case GOODIX_ENROLL_WAIT_FINGER_UP:
+    case FP_ENROLL_WAIT_FINGER_UP:
      dummy[0] = 0;
      goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP,
                         true,
@ -954,7 +898,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_finger_mode_cb);
      break;
-    case GOODIX_ENROLL_CHECK_DUPLICATE:
+    case FP_ENROLL_CHECK_DUPLICATE:
      goodix_sensor_cmd (self, MOC_CMD0_CHECK4DUPLICATE, MOC_CMD1_DEFAULT,
                         false,
                         (const guint8 *) &dummy,
@ -962,7 +906,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_enroll_check_duplicate_cb);
      break;
-    case GOODIX_ENROLL_COMMIT:
+    case FP_ENROLL_COMMIT:
      {
        fpi_device_get_enroll_data (device, &print);
        user_id = fpi_print_generate_user_id (print);
@ -1015,7 +959,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;
-    case GOODIX_ENROLL_PWR_BTN_SHIELD_OFF:
+    case FP_ENROLL_PWR_BTN_SHIELD_OFF:
      {
        goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
                           false,
@ -1106,7 +1050,7 @@ fp_init_cb_reset_or_complete (FpiDeviceGoodixMoc  *self,
    {
      fp_warn ("Template storage appears to have been corrupted! Error was: %s", error->message);
      fp_warn ("A known reason for this to happen is a firmware bug triggered by another storage area being initialized.");
-      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_INIT_RESET_DEVICE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_INIT_RESET_DEVICE);
    }
  else
    {
@ -1147,7 +1091,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case GOODIX_INIT_VERSION:
+    case FP_INIT_VERSION:
      goodix_sensor_cmd (self, MOC_CMD0_GET_VERSION, MOC_CMD1_DEFAULT,
                         false,
                         &dummy,
@ -1155,7 +1099,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_init_version_cb);
      break;
-    case GOODIX_INIT_CONFIG:
+    case FP_INIT_CONFIG:
      goodix_sensor_cmd (self, MOC_CMD0_UPDATE_CONFIG, MOC_CMD1_WRITE_CFG_TO_FLASH,
                         false,
                         (guint8 *) self->sensorcfg,
@ -1163,7 +1107,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_init_config_cb);
      break;
-    case GOODIX_INIT_TEMPLATE_LIST:
+    case FP_INIT_TEMPLATE_LIST:
      /* List prints to check whether the template DB was corrupted.
       * As of 2022-06-13 there is a known firmware issue that can cause the
       * stored templates for Linux to be corrupted when the Windows storage
@ -1178,7 +1122,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_init_cb_reset_or_complete);
      break;
-    case GOODIX_INIT_RESET_DEVICE:
+    case FP_INIT_RESET_DEVICE:
      fp_warn ("Resetting device storage, you will need to enroll all prints again!");
      goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL,
                         FALSE,
@ -1417,13 +1361,10 @@ gx_fp_probe (FpDevice *device)
    case 0x60A2:
    case 0x60A4:
    case 0x6014:
    case 0x6090:
    case 0x6092:
    case 0x6094:
    case 0x609A:
    case 0x609C:
    case 0x60BC:
    case 0x60C2:
    case 0x6304:
    case 0x631C:
    case 0x633C:
@ -1433,12 +1374,8 @@ gx_fp_probe (FpDevice *device)
    case 0x63AC:
    case 0x63BC:
    case 0x63CC:
    case 0x650A:
    case 0x650C:
    case 0x6582:
    case 0x6A94:
    case 0x659A:
    case 0x6890:
      self->max_enroll_stage = 12;
      break;
@ -1494,7 +1431,7 @@ gx_fp_init (FpDevice *device)
    }
  self->task_ssm = fpi_ssm_new (device, fp_init_sm_run_state,
-                                GOODIX_INIT_NUM_STATES);
+                                FP_INIT_NUM_STATES);
  fpi_ssm_start (self->task_ssm, fp_init_ssm_done);
@ -1525,7 +1462,9 @@ gx_fp_exit_cb (FpiDeviceGoodixMoc  *self,
               gxfp_cmd_response_t *resp,
               GError              *error)
 {
-  if (resp && resp->result >= GX_FAILED)
+
  if (resp->result >= GX_FAILED)
    fp_dbg ("Setting power button shield failed, result: 0x%x", resp->result);
  self->is_power_button_shield_on = false;
  gx_fp_release_interface (self, error);
@ -1560,8 +1499,8 @@ gx_fp_verify_identify (FpDevice *device)
  FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
  self->task_ssm = fpi_ssm_new_full (device, fp_verify_sm_run_state,
-                                     GOODIX_VERIFY_NUM_STATES,
+                                     FP_VERIFY_NUM_STATES,
-                                     GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
+                                     FP_VERIFY_PWR_BTN_SHIELD_OFF,
                                     "verify");
  fpi_ssm_start (self->task_ssm, fp_verify_ssm_done);
@ -1577,8 +1516,8 @@ gx_fp_enroll (FpDevice *device)
  self->enroll_stage = 0;
  self->task_ssm = fpi_ssm_new_full (device, fp_enroll_sm_run_state,
-                                     GOODIX_ENROLL_NUM_STATES,
+                                     FP_ENROLL_NUM_STATES,
-                                     GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
+                                     FP_ENROLL_PWR_BTN_SHIELD_OFF,
                                     "enroll");
  fpi_ssm_start (self->task_ssm, fp_enroll_ssm_done);
@ -1668,15 +1607,12 @@ fpi_device_goodixmoc_init (FpiDeviceGoodixMoc *self)
 static const FpIdEntry id_table[] = {
  { .vid = 0x27c6,  .pid = 0x5840,  },
  { .vid = 0x27c6,  .pid = 0x6014,  },
  { .vid = 0x27c6,  .pid = 0x6090,  },
  { .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 = 0x60C2,  },
  { .vid = 0x27c6,  .pid = 0x6304,  },
  { .vid = 0x27c6,  .pid = 0x631C,  },
  { .vid = 0x27c6,  .pid = 0x633C,  },
@ -1687,9 +1623,6 @@ 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,  },
@ -1697,10 +1630,6 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x27c6,  .pid = 0x659A,  },
  { .vid = 0x27c6,  .pid = 0x659C,  },
  { .vid = 0x27c6,  .pid = 0x6A94,  },
  { .vid = 0x27c6,  .pid = 0x6512,  },
  { .vid = 0x27c6,  .pid = 0x6890,  },
  { .vid = 0x27c6,  .pid = 0x689A,  },
  { .vid = 0x27c6,  .pid = 0x66A9,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
--- a/libfprint/drivers/goodixmoc/goodix.h
+++ b/libfprint/drivers/goodixmoc/goodix.h
@ -25,40 +25,39 @@
 G_DECLARE_FINAL_TYPE (FpiDeviceGoodixMoc, fpi_device_goodixmoc, FPI, DEVICE_GOODIXMOC, FpDevice)
 typedef enum {
-  GOODIX_CMD_SEND = 0,
+  FP_CMD_SEND = 0,
-  GOODIX_CMD_GET_ACK,
+  FP_CMD_GET_ACK,
-  GOODIX_CMD_GET_DATA,
+  FP_CMD_GET_DATA,
-  GOODIX_CMD_NUM_STATES,
+  FP_CMD_NUM_STATES,
-} GoodixCmdState;
+} FpCmdState;
 typedef enum {
-  GOODIX_INIT_VERSION = 0,
+  FP_INIT_VERSION = 0,
-  GOODIX_INIT_CONFIG,
+  FP_INIT_CONFIG,
-  GOODIX_INIT_TEMPLATE_LIST,
+  FP_INIT_TEMPLATE_LIST,
-  GOODIX_INIT_RESET_DEVICE,
+  FP_INIT_RESET_DEVICE,
-  GOODIX_INIT_NUM_STATES,
+  FP_INIT_NUM_STATES,
-} GoodixInitState;
+} FpInitState;
 typedef enum {
-  GOODIX_ENROLL_PWR_BTN_SHIELD_ON = 0,
+  FP_ENROLL_PWR_BTN_SHIELD_ON = 0,
-  GOODIX_ENROLL_ENUM,
+  FP_ENROLL_ENUM,
-  GOODIX_ENROLL_CREATE,
+  FP_ENROLL_CREATE,
-  GOODIX_ENROLL_CAPTURE,
+  FP_ENROLL_CAPTURE,
-  GOODIX_ENROLL_UPDATE,
+  FP_ENROLL_UPDATE,
-  GOODIX_ENROLL_WAIT_FINGER_UP,
+  FP_ENROLL_WAIT_FINGER_UP,
-  GOODIX_ENROLL_CHECK_DUPLICATE,
+  FP_ENROLL_CHECK_DUPLICATE,
-  GOODIX_ENROLL_COMMIT,
+  FP_ENROLL_COMMIT,
-  GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
+  FP_ENROLL_PWR_BTN_SHIELD_OFF,
-  GOODIX_ENROLL_NUM_STATES,
+  FP_ENROLL_NUM_STATES,
-} GoodixEnrollState;
+} FpEnrollState;
 typedef enum {
-  GOODIX_VERIFY_PWR_BTN_SHIELD_ON = 0,
+  FP_VERIFY_PWR_BTN_SHIELD_ON = 0,
-  GOODIX_VERIFY_CAPTURE,
+  FP_VERIFY_CAPTURE,
-  GOODIX_VERIFY_IDENTIFY,
+  FP_VERIFY_IDENTIFY,
-  GOODIX_VERIFY_WAIT_FINGER_UP,
+  FP_VERIFY_PWR_BTN_SHIELD_OFF,
-  GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
+  FP_VERIFY_NUM_STATES,
-  GOODIX_VERIFY_NUM_STATES,
+} FpVerifyState;
 } GoodixVerifyState;
--- a/libfprint/drivers/goodixmoc/goodix_proto.c
+++ b/libfprint/drivers/goodixmoc/goodix_proto.c
@ -18,8 +18,6 @@
 */
 #include <glib.h>
 #include <stdint.h>
 #include "goodix_proto.h"
 /*
@ -109,7 +107,7 @@ reflect (uint32_t data, uint8_t n_bits)
       * If the LSB bit is set, set the reflection of it.
       */
      if (data & 0x01)
-        reflection |= (1LU << ((n_bits - 1) - bit));
+        reflection |= (1 << ((n_bits - 1) - bit));
      data = (data >> 1);
    }
@ -213,11 +211,7 @@ gx_proto_build_package (uint8_t       *ppackage,
  init_pack_header (&header, payload_size, cmd, 0);
  memcpy (ppackage, &header, PACKAGE_HEADER_SIZE);
-
+  memcpy (ppackage + PACKAGE_HEADER_SIZE, payload, payload_size);
  if (payload)
    memcpy (ppackage + PACKAGE_HEADER_SIZE, payload, payload_size);
  else
    ppackage[PACKAGE_HEADER_SIZE] = 0;
  gx_proto_crc32_calc (ppackage, PACKAGE_HEADER_SIZE + payload_size, ppackage + PACKAGE_HEADER_SIZE + payload_size);
@ -226,108 +220,94 @@ gx_proto_build_package (uint8_t       *ppackage,
 int
-gx_proto_parse_header (FpiByteReader *reader,
+gx_proto_parse_header (
-                       pack_header   *pheader)
+  uint8_t     *buffer,
  uint32_t     buffer_len,
  pack_header *pheader)
 {
-  if (!pheader)
+  if (!buffer || !pheader)
    return -1;
  if (buffer_len < PACKAGE_HEADER_SIZE + PACKAGE_CRC_SIZE)
    return -1;
-  if (!fpi_byte_reader_get_uint8 (reader, &pheader->cmd0))
+  memcpy (pheader, buffer, sizeof (pack_header));
-    g_return_val_if_reached (-1);
+  pheader->len = GUINT16_FROM_LE (pheader->len);
-
+  if (buffer_len < pheader->len + PACKAGE_HEADER_SIZE)
-  if (!fpi_byte_reader_get_uint8 (reader, &pheader->cmd1))
+    return -1;
    g_return_val_if_reached (-1);
  if (!fpi_byte_reader_get_uint8 (reader, &pheader->packagenum))
    g_return_val_if_reached (-1);
  if (!fpi_byte_reader_get_uint8 (reader, &pheader->reserved))
    g_return_val_if_reached (-1);
  if (!fpi_byte_reader_get_uint16_le (reader, &pheader->len))
    g_return_val_if_reached (-1);
  if (!fpi_byte_reader_get_uint8 (reader, &pheader->crc8))
    g_return_val_if_reached (-1);
  if (!fpi_byte_reader_get_uint8 (reader, &pheader->rev_crc8))
    g_return_val_if_reached (-1);
  pheader->len -= PACKAGE_CRC_SIZE;
  return 0;
 }
 static int
-gx_proto_parse_fingerid (FpiByteReader     *reader,
+gx_proto_parse_fingerid (
-                         ptemplate_format_t template)
+  uint8_t          * fid_buffer,
  uint16_t           fid_buffer_size,
  ptemplate_format_t template
                        )
 {
-  uint8_t byte;
+  uint8_t * buffer = NULL;
-  const uint8_t *buffer;
+  uint16_t Offset = 0;
-  if (!template)
+  if (!template || !fid_buffer)
    return -1;
-  if (!fpi_byte_reader_get_uint8 (reader, &byte) || byte != 67)
+  if (fid_buffer_size < G_STRUCT_OFFSET (template_format_t, payload) + sizeof (uint32_t))
-    g_return_val_if_reached (-1);
+    return -1;
-  if (!fpi_byte_reader_get_uint8 (reader, &template->type))
+  buffer = fid_buffer;
-    g_return_val_if_reached (-1);
+  Offset = 0;
-  if (!fpi_byte_reader_get_uint8 (reader, &template->finger_index))
+  if (buffer[Offset++] != 67)
-    g_return_val_if_reached (-1);
+    return -1;
-  if (!fpi_byte_reader_skip (reader, 1))
+  template->type = buffer[Offset++];
-    g_return_val_if_reached (-1);
+  template->finger_index = buffer[Offset++];
-
+  Offset++;
-  if (!fpi_byte_reader_get_data (reader, sizeof (template->accountid), &buffer))
+  memcpy (template->accountid, &buffer[Offset], sizeof (template->accountid));
-    g_return_val_if_reached (-1);
+  Offset += sizeof (template->accountid);
-
+  memcpy (template->tid, &buffer[Offset], sizeof (template->tid));
-  memcpy (template->accountid, buffer, sizeof (template->accountid));
+  Offset += sizeof (template->tid);   // Offset == 68
-
+  template->payload.size = buffer[Offset++];
-  if (!fpi_byte_reader_get_data (reader, sizeof (template->tid), &buffer))
+  if (template->payload.size > sizeof (template->payload.data))
-    g_return_val_if_reached (-1);
+    return -1;
-
+  if (template->payload.size + Offset > fid_buffer_size)
-  memcpy (template->tid, buffer, sizeof (template->tid));
+    return -1;
-
+  memset (template->payload.data, 0, template->payload.size);
-  if (!fpi_byte_reader_get_uint8 (reader, &template->payload.size))
+  memcpy (template->payload.data, &buffer[Offset], template->payload.size);
    g_return_val_if_reached (-1);
  if (!fpi_byte_reader_get_data (reader, template->payload.size, &buffer))
    g_return_val_if_reached (-1);
  memcpy (template->payload.data, buffer, template->payload.size);
  return 0;
 }
 int
-gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_response_t presp)
+gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_cmd_response_t presp)
 {
-  if (!presp)
+  uint16_t offset = 0;
  uint8_t *fingerlist = NULL;
  if (!buffer || !presp)
    return -1;
-
+  if (buffer_len < 1)
-  if (!fpi_byte_reader_get_uint8 (byte_reader, &presp->result))
+    return -1;
-    g_return_val_if_reached (-1);
+  presp->result = buffer[0];
  switch (HIBYTE (cmd))
    {
    case RESPONSE_PACKAGE_CMD:
      {
-        if (!fpi_byte_reader_get_uint8 (byte_reader, &presp->parse_msg.ack_cmd))
+        if (buffer_len < sizeof (gxfp_parse_msg_t) + 1)
-          g_return_val_if_reached (-1);
+          return -1;
        presp->parse_msg.ack_cmd = buffer[1];
      }
      break;
    case MOC_CMD0_UPDATE_CONFIG:
      {
-        presp->finger_config.status = presp->result;
+        presp->finger_config.status = buffer[0];
-        /* to compatiable old version firmware */
+        if (buffer_len >= 3)
-        presp->finger_config.max_stored_prints = FP_MAX_FINGERNUM;
+          presp->finger_config.max_stored_prints = buffer[2];
        else
          /* to compatiable old version firmware */
          presp->finger_config.max_stored_prints = FP_MAX_FINGERNUM;
        if (fpi_byte_reader_skip (byte_reader, 1))
          fpi_byte_reader_get_uint8 (byte_reader,
                                     &presp->finger_config.max_stored_prints);
      }
      break;
@ -338,99 +318,85 @@ gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_respons
    case MOC_CMD0_PWR_BTN_SHIELD:
      presp->power_button_shield_resp.resp_cmd1 = LOBYTE (cmd);
-      uint8_t support_pwr_shield;
+      if (buffer_len >= 2)
-
+        {
-      if (fpi_byte_reader_get_uint8 (byte_reader, &support_pwr_shield) &&
+          uint8_t support_pwr_shield = buffer[1];
-          support_pwr_shield == 0xFF)
+          if (support_pwr_shield == 0xFF)
-        g_debug ("Power button shield feature not supported!\n");
+            g_debug ("Power button shield feature not supported!\n");
        }
      break;
    case MOC_CMD0_GET_VERSION:
-      const uint8_t *version_info;
+      if (buffer_len < sizeof (gxfp_version_info_t) + 1)
-
+        return -1;
-      if (!fpi_byte_reader_get_data (byte_reader, sizeof (gxfp_version_info_t), &version_info))
+      memcpy (&presp->version_info, buffer + 1, sizeof (gxfp_version_info_t));
        g_return_val_if_reached (-1);
      memcpy (&presp->version_info, version_info, sizeof (gxfp_version_info_t));
      break;
    case MOC_CMD0_CAPTURE_DATA:
      if (LOBYTE (cmd) == MOC_CMD1_DEFAULT)
        {
-          if (!fpi_byte_reader_get_uint8 (byte_reader,
+          if (buffer_len < sizeof (gxfp_capturedata_t) + 1)
-                                          &presp->capture_data_resp.img_quality))
+            return -1;
-            g_return_val_if_reached (-1);
+          presp->capture_data_resp.img_quality  = buffer[1];
-
+          presp->capture_data_resp.img_coverage = buffer[2];
          if (!fpi_byte_reader_get_uint8 (byte_reader,
                                          &presp->capture_data_resp.img_coverage))
            g_return_val_if_reached (-1);
        }
      break;
    case MOC_CMD0_ENROLL_INIT:
-      if (presp->result != GX_SUCCESS)
+      if (buffer_len < sizeof (gxfp_enroll_create_t) + 1)
-        break;
+        return -1;
-      const uint8_t *tid;
+      if (presp->result == GX_SUCCESS)
-      if (!fpi_byte_reader_get_data (byte_reader, TEMPLATE_ID_SIZE, &tid))
+        memcpy (&presp->enroll_create.tid, &buffer[1], TEMPLATE_ID_SIZE);
        g_return_val_if_reached (-1);
      memcpy (presp->enroll_create.tid, tid, TEMPLATE_ID_SIZE);
      break;
    case MOC_CMD0_ENROLL:
-      presp->enroll_update.rollback = (presp->result < 0x80) ? false : true;
+      if (buffer_len < sizeof (gxfp_enroll_update_t))
-      if (!fpi_byte_reader_get_uint8 (byte_reader,
+        return -1;
-                                      &presp->enroll_update.img_overlay))
+      presp->enroll_update.rollback = (buffer[0] < 0x80) ? false : true;
-        g_return_val_if_reached (-1);
+      presp->enroll_update.img_overlay    = buffer[1];
-
+      presp->enroll_update.img_preoverlay = buffer[2];
      if (!fpi_byte_reader_get_uint8 (byte_reader,
                                      &presp->enroll_update.img_preoverlay))
        g_return_val_if_reached (-1);
      break;
    case MOC_CMD0_CHECK4DUPLICATE:
      presp->check_duplicate_resp.duplicate = (presp->result == 0) ? false : true;
      if (presp->check_duplicate_resp.duplicate)
        {
-          uint16_t tid_size;
+          if (buffer_len < 3)
-          FpiByteReader tid_reader;
+            return -1;
          uint16_t tid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + 1));
          offset += 3;
-          if (!fpi_byte_reader_get_uint16_le (byte_reader, &tid_size))
+          if (buffer_len < tid_size + offset)
-            g_return_val_if_reached (-1);
+            return -1;
-
+          if (gx_proto_parse_fingerid (buffer + offset, tid_size, &presp->check_duplicate_resp.template) != 0)
-          if (!fpi_byte_reader_get_sub_reader (byte_reader, &tid_reader, tid_size))
+            return -1;
            g_return_val_if_reached (-1);
          if (gx_proto_parse_fingerid (&tid_reader, &presp->check_duplicate_resp.template) != 0)
            g_return_val_if_reached (-1);
        }
      break;
    case MOC_CMD0_GETFINGERLIST:
      if (presp->result != GX_SUCCESS)
        break;
-
+      if (buffer_len < 2)
-      if (!fpi_byte_reader_get_uint8 (byte_reader,
+        return -1;
-                                      &presp->finger_list_resp.finger_num))
+      presp->finger_list_resp.finger_num = buffer[1];
-        g_return_val_if_reached (-1);
+      fingerlist = buffer + 2;
      for(uint8_t num = 0; num < presp->finger_list_resp.finger_num; num++)
        {
          uint16_t fingerid_length;
-          FpiByteReader fingerid_reader;
+          if (buffer_len < offset + 2)
-
+            return -1;
-          if (!fpi_byte_reader_get_uint16_le (byte_reader, &fingerid_length))
+          fingerid_length = GUINT16_FROM_LE (*(uint16_t *) (fingerlist + offset));
-            g_return_val_if_reached (-1);
+          offset += 2;
-
+          if (buffer_len < fingerid_length + offset)
-          if (!fpi_byte_reader_get_sub_reader (byte_reader, &fingerid_reader,
+            return -1;
-                                               fingerid_length))
+          if (gx_proto_parse_fingerid (fingerlist + offset,
-            g_return_val_if_reached (-1);
+                                       fingerid_length,
          if (gx_proto_parse_fingerid (&fingerid_reader,
                                       &presp->finger_list_resp.finger_list[num]) != 0)
            {
              g_warning ("Failed to parse finger list");
-              g_return_val_if_reached (-1);
+              return -1;
            }
          offset += fingerid_length;
        }
      break;
@ -439,32 +405,23 @@ gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_respons
        uint32_t score = 0;
        uint8_t study = 0;
        uint16_t fingerid_size = 0;
-
+        presp->verify.match = (buffer[0] == 0) ? true : false;
        presp->verify.match = (presp->result == 0) ? true : false;
        if (presp->verify.match)
          {
-            FpiByteReader finger_reader;
+            if (buffer_len < 10)
-
+              return -1;
-            if (!fpi_byte_reader_get_uint16_le (byte_reader,
+            offset += 1;
-                                                &presp->verify.rejectdetail))
+            presp->verify.rejectdetail = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
-              g_return_val_if_reached (-1);
+            offset += 2;
-
+            score = GUINT32_FROM_LE (*(uint32_t *) (buffer + offset));
-            if (!fpi_byte_reader_get_uint32_le (byte_reader, &score))
+            offset += 4;
-              g_return_val_if_reached (-1);
+            study = buffer[offset];
-
+            offset += 1;
-            if (!fpi_byte_reader_get_uint8 (byte_reader, &study))
+            fingerid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
-              g_return_val_if_reached (-1);
+            offset += 2;
-
+            if (buffer_len < fingerid_size + offset)
-            if (!fpi_byte_reader_get_uint16_le (byte_reader, &fingerid_size))
+              return -1;
-              g_return_val_if_reached (-1);
+            if (gx_proto_parse_fingerid (buffer + offset, fingerid_size, &presp->verify.template) != 0)
            if (!fpi_byte_reader_get_sub_reader (byte_reader, &finger_reader,
                                                 fingerid_size))
              g_return_val_if_reached (-1);
            if (gx_proto_parse_fingerid (&finger_reader,
                                         &presp->verify.template) != 0)
              {
                presp->result = GX_FAILED;
                break;
@ -475,7 +432,7 @@ gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_respons
      break;
    case MOC_CMD0_FINGER_MODE:
-      presp->finger_status.status = presp->result;
+      presp->finger_status.status = buffer[0];
      break;
    default:
--- a/libfprint/drivers/goodixmoc/goodix_proto.h
+++ b/libfprint/drivers/goodixmoc/goodix_proto.h
@ -22,8 +22,6 @@
 #include <stdbool.h>
 #include <string.h>
 #include "fpi-byte-reader.h"
 #define PACKAGE_CRC_SIZE (4)
 #define PACKAGE_HEADER_SIZE (8)
@ -135,7 +133,7 @@ typedef struct _template_format
 typedef struct _gxfp_verify
 {
  bool     match;
-  uint16_t rejectdetail;
+  uint32_t rejectdetail;
  template_format_t  template;
 } gxfp_verify_t, *pgxfp_verify_t;
@ -234,11 +232,13 @@ int gx_proto_build_package (uint8_t       *ppackage,
                            const uint8_t *payload,
                            uint32_t       payload_size);
-int gx_proto_parse_header (FpiByteReader *reader,
+int gx_proto_parse_header (uint8_t     *buffer,
-                           pack_header   *pheader);
+                           uint32_t     buffer_len,
                           pack_header *pheader);
 int gx_proto_parse_body (uint16_t             cmd,
-                         FpiByteReader       *byte_reader,
+                         uint8_t             *buffer,
                         uint16_t             buffer_len,
                         pgxfp_cmd_response_t presponse);
 int gx_proto_init_sensor_config (pgxfp_sensor_cfg_t pconfig);
--- a/libfprint/drivers/realtek/realtek.c
+++ b/libfprint/drivers/realtek/realtek.c
--- a/libfprint/drivers/realtek/realtek.h
+++ b/libfprint/drivers/realtek/realtek.h
@ -1,246 +0,0 @@
 /*
 * 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},
 };
--- a/libfprint/drivers/synaptics/bmkt_message.c
+++ b/libfprint/drivers/synaptics/bmkt_message.c
@ -256,8 +256,7 @@ bmkt_compose_message (uint8_t *cmd, int *cmd_len, uint8_t msg_id, uint8_t seq_nu
  cmd[BMKT_MESSAGE_SEQ_NUM_FIELD] = seq_num;
  cmd[BMKT_MESSAGE_ID_FIELD] = msg_id;
  cmd[BMKT_MESSAGE_PAYLOAD_LEN_FIELD] = payload_size;
-  if (payload_size > 0)
+  memcpy (&cmd[BMKT_MESSAGE_PAYLOAD_FIELD], payload, payload_size);
    memcpy (&cmd[BMKT_MESSAGE_PAYLOAD_FIELD], payload, payload_size);
  *cmd_len = message_len;
--- a/libfprint/drivers/synaptics/synaptics.c
+++ b/libfprint/drivers/synaptics/synaptics.c
@ -32,35 +32,19 @@ static void compose_and_send_identify_msg (FpDevice *device);
 static const FpIdEntry id_table[] = {
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00BD,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C2,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C4,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C6,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00DF,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00E9,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C2,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0103,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0104,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0106,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0107,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0108,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0109,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x010A,  },
  { .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 = 0x015F,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0168,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0169,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x015F,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x016C,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0104,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0173,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0174,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019D,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019F,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x01A0,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
@ -122,11 +106,7 @@ cmd_receive_cb (FpiUsbTransfer *transfer,
          if (self->cmd_complete_on_removal)
            {
-              if (self->delay_error)
+              fpi_ssm_mark_completed (transfer->ssm);
                fpi_ssm_mark_failed (transfer->ssm,
                                     g_steal_pointer (&self->delay_error));
              else
                fpi_ssm_mark_completed (transfer->ssm);
              return;
            }
        }
@ -661,21 +641,18 @@ verify (FpDevice *device)
 }
 static void
-identify_complete_after_finger_removal (FpiDeviceSynaptics *self, GError *error)
+identify_complete_after_finger_removal (FpiDeviceSynaptics *self)
 {
  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, error);
+      fpi_device_identify_complete (device, NULL);
    }
 }
@ -725,18 +702,19 @@ 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, NULL);
+          identify_complete_after_finger_removal (self);
        }
      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, NULL);
+          identify_complete_after_finger_removal (self);
        }
-      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS || resp->result == BMKT_FP_DATABASE_EMPTY)
+      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS)
        {
          fp_info ("Print is not in database");
-          identify_complete_after_finger_removal (self, fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
+          fpi_device_identify_complete (device,
                                        fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
        }
      else
        {
@ -772,7 +750,7 @@ identify_msg_cb (FpiDeviceSynaptics *self,
        else
          fpi_device_identify_report (device, NULL, print, NULL);
-        identify_complete_after_finger_removal (self, NULL);
+        identify_complete_after_finger_removal (self);
      }
    }
 }
@ -1260,12 +1238,6 @@ dev_probe (FpDevice *device)
      return;
    }
  if (!g_usb_device_reset (usb_dev, &error))
    {
      fp_dbg ("%s g_usb_device_reset failed %s", G_STRFUNC, error->message);
      goto err_close;
    }
  if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
    goto err_close;
--- a/libfprint/drivers/synaptics/synaptics.h
+++ b/libfprint/drivers/synaptics/synaptics.h
@ -127,5 +127,4 @@ struct _FpiDeviceSynaptics
  struct syna_enroll_resp_data enroll_resp_data;
  syna_state_t                 state;
  GError                      *delay_error;
 };
--- a/libfprint/drivers/upekts.c
+++ b/libfprint/drivers/upekts.c
@ -196,9 +196,8 @@ struct read_msg_data
 static void __read_msg_async (FpDevice             *dev,
                              struct read_msg_data *udata);
-#define READ_MSG_DATA_CB_ERR(dev, udata, error) \
+#define READ_MSG_DATA_CB_ERR(dev, udata, error) (udata)->callback (dev, \
-  (udata)->callback (dev, \
+                                                                   READ_MSG_CMD, 0, 0, NULL, 0, (udata)->user_data, error)
                     READ_MSG_CMD, 0, 0, NULL, 0, (udata)->user_data, error)
 static void
 busy_ack_sent_cb (FpiUsbTransfer *transfer, FpDevice *device,
@ -1244,7 +1243,7 @@ do_verify_stop (FpDevice *dev, FpiMatchResult res, GError *error)
  FpiSsm *ssm = deinitsm_new (dev, data);
  /* Report the error immediately if possible, otherwise delay it. */
-  if (!error || error->domain == FP_DEVICE_RETRY)
+  if (error && error->domain == FP_DEVICE_RETRY)
    fpi_device_verify_report (dev, res, NULL, error);
  else
    data->error = error;
@ -1296,7 +1295,7 @@ verify_start_sm_run_state (FpiSsm *ssm, FpDevice *dev)
      memcpy (msg, verify_hdr, sizeof (verify_hdr));
      memcpy (msg + sizeof (verify_hdr), data, data_len);
-      transfer = alloc_send_cmd28_transfer (dev, 0x03, msg, msg_len);
+      transfer = alloc_send_cmd28_transfer (dev, 0x03, data, data_len);
      g_free (msg);
@ -1342,6 +1341,7 @@ v_handle_resp00 (FpDevice *dev, unsigned char *data,
      fp_dbg ("good image");
      break;
    case 0x1c:     /* FIXME what does this one mean? */
    case 0x0b:     /* FIXME what does this one mean? */
    case 0x23:     /* FIXME what does this one mean? */
      error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL);
@ -1351,14 +1351,6 @@ v_handle_resp00 (FpDevice *dev, unsigned char *data,
      error = fpi_device_retry_new (FP_DEVICE_RETRY_REMOVE_FINGER);
      break;
    case 0x1c:     /* swipe too fast */
      error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_FAST);
      break;
    case 0x1d:     /* too much horizontal movement */
      error = fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER);
      break;
    case 0x1e:     /* swipe too short */
      error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_SHORT);
      break;
@ -1447,7 +1439,7 @@ verify_rd2800_cb (FpDevice *dev, enum read_msg_type msgtype,
      do_verify_stop (dev,
                      FPI_MATCH_ERROR,
                      fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                "Response had wrong command sequence"));
+                                                "Response hat wrong command sequence"));
      return;
    }
--- a/libfprint/drivers/uru4000.c
+++ b/libfprint/drivers/uru4000.c
@ -20,8 +20,8 @@
 #define FP_COMPONENT "uru4000"
-#include <openssl/evp.h>
+#include <nss.h>
-#include <openssl/err.h>
+#include <pk11pub.h>
 #include "drivers_api.h"
@ -148,7 +148,10 @@ struct _FpiDeviceUru4000
  int                             fwfixer_offset;
  unsigned char                   fwfixer_value;
-  EVP_CIPHER_CTX                 *cipher_ctx;
+  CK_MECHANISM_TYPE               cipher;
  PK11SlotInfo                   *slot;
  PK11SymKey                     *symkey;
  SECItem                        *param;
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceUru4000, fpi_device_uru4000, FPI, DEVICE_URU4000,
                      FpImageDevice);
@ -243,29 +246,13 @@ response_cb (FpiUsbTransfer *transfer, FpDevice *dev, void *user_data, GError *e
    fpi_ssm_mark_failed (ssm, error);
 }
 static GError *
 openssl_device_error (void)
 {
  char buf[256];
  unsigned long e;
  e = ERR_get_error ();
  if (e == 0)
    return fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
                                     "unexpected OpenSSL error");
  ERR_error_string_n (e, buf, G_N_ELEMENTS (buf));
  return fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL, "OpenSSL error: %s",
                                   buf);
 }
 static void
 challenge_cb (FpiUsbTransfer *transfer, FpDevice *dev, void *user_data, GError *error)
 {
  FpiSsm *ssm = user_data;
  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
-  unsigned char respdata[CR_LENGTH * 2];
+  unsigned char respdata[CR_LENGTH];
  PK11Context *ctx;
  int outlen;
  if (error)
@ -274,39 +261,17 @@ challenge_cb (FpiUsbTransfer *transfer, FpDevice *dev, void *user_data, GError *
      return;
    }
  if (transfer->actual_length != CR_LENGTH)
    {
      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
                                        "Unexpected buffer length (%" G_GSIZE_FORMAT
                                        "instead of %d)",
                                        transfer->actual_length, CR_LENGTH);
      fpi_ssm_mark_failed (ssm, g_steal_pointer (&error));
      return;
    }
  /* submit response */
  /* produce response from challenge */
-  if (!EVP_EncryptUpdate (self->cipher_ctx, respdata, &outlen, transfer->buffer, CR_LENGTH))
+  ctx = PK11_CreateContextBySymKey (self->cipher, CKA_ENCRYPT,
                                    self->symkey, self->param);
  if (PK11_CipherOp (ctx, respdata, &outlen, CR_LENGTH, transfer->buffer, CR_LENGTH) != SECSuccess ||
      PK11_Finalize (ctx) != SECSuccess)
    {
-      fpi_ssm_mark_failed (ssm, openssl_device_error ());
+      fp_err ("Failed to encrypt challenge data");
-      return;
+      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, "Failed to encrypt challenge data");
    }
  if (outlen != CR_LENGTH)
    {
      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
                                        "Unexpected encrypted buffer length (%d"
                                        "instead of %d)",
                                        outlen, CR_LENGTH);
      fpi_ssm_mark_failed (ssm, g_steal_pointer (&error));
      return;
    }
  if (!EVP_EncryptFinal_ex (self->cipher_ctx, respdata + outlen, &outlen))
    {
      fpi_ssm_mark_failed (ssm, openssl_device_error ());
      return;
    }
  PK11_DestroyContext (ctx, PR_TRUE);
  if (!error)
    write_regs (FP_IMAGE_DEVICE (dev), REG_RESPONSE, CR_LENGTH, respdata, response_cb, ssm);
@ -738,9 +703,9 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
    case IMAGING_DECODE:
      key  = self->last_reg_rd[0];
-      key |= (uint32_t) self->last_reg_rd[1] << 8;
+      key |= self->last_reg_rd[1] << 8;
-      key |= (uint32_t) self->last_reg_rd[2] << 16;
+      key |= self->last_reg_rd[2] << 16;
-      key |= (uint32_t) self->last_reg_rd[3] << 24;
+      key |= self->last_reg_rd[3] << 24;
      key ^= self->img_enc_seed;
      fp_dbg ("encryption id %02x -> key %08x", img->key_number, key);
@ -1305,6 +1270,8 @@ dev_init (FpImageDevice *dev)
  g_autoptr(GPtrArray) interfaces = NULL;
  GUsbInterface *iface = NULL;
  guint64 driver_data;
  SECStatus rv;
  SECItem item;
  int i;
  interfaces = g_usb_device_get_interfaces (fpi_device_get_usb_device (FP_DEVICE (dev)), &error);
@ -1376,6 +1343,20 @@ dev_init (FpImageDevice *dev)
      return;
    }
  /* Disable loading p11-kit's user configuration */
  g_setenv ("P11_KIT_NO_USER_CONFIG", "1", TRUE);
  /* Initialise NSS early */
  rv = NSS_NoDB_Init (".");
  if (rv != SECSuccess)
    {
      fp_err ("could not initialise NSS");
      fpi_image_device_open_complete (dev,
                                      fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
                                                                "Could not initialise NSS"));
      return;
    }
  self = FPI_DEVICE_URU4000 (dev);
  g_clear_pointer (&self->rand, g_rand_free);
@ -1388,17 +1369,35 @@ dev_init (FpImageDevice *dev)
  self->interface = g_usb_interface_get_number (iface);
  /* Set up encryption */
-  if (!(self->cipher_ctx = EVP_CIPHER_CTX_new ()))
+  self->cipher = CKM_AES_ECB;
  self->slot = PK11_GetBestSlot (self->cipher, NULL);
  if (self->slot == NULL)
    {
-      fpi_image_device_open_complete (dev, openssl_device_error ());
+      fp_err ("could not get encryption slot");
      fpi_image_device_open_complete (dev,
                                      fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
                                                                "Could not get encryption slot"));
      return;
    }
-
+  item.type = siBuffer;
-  if (!EVP_EncryptInit_ex (self->cipher_ctx, EVP_aes_128_ecb (), NULL, crkey, NULL))
+  item.data = (unsigned char *) crkey;
  item.len = sizeof (crkey);
  self->symkey = PK11_ImportSymKey (self->slot,
                                    self->cipher,
                                    PK11_OriginUnwrap,
                                    CKA_ENCRYPT,
                                    &item, NULL);
  if (self->symkey == NULL)
    {
-      fpi_image_device_open_complete (dev, openssl_device_error ());
+      fp_err ("failed to import key into NSS");
      PK11_FreeSlot (self->slot);
      self->slot = NULL;
      fpi_image_device_open_complete (dev,
                                      fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
                                                                "Failed to import key into NSS"));
      return;
    }
  self->param = PK11_ParamFromIV (self->cipher, NULL);
  fpi_image_device_open_complete (dev, NULL);
 }
@ -1409,7 +1408,14 @@ dev_deinit (FpImageDevice *dev)
  GError *error = NULL;
  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
-  g_clear_pointer (&self->cipher_ctx, EVP_CIPHER_CTX_free);
+  if (self->symkey)
    PK11_FreeSymKey (self->symkey);
  if (self->param)
    SECITEM_FreeItem (self->param, PR_TRUE);
  if (self->slot)
    PK11_FreeSlot (self->slot);
  NSS_Shutdown ();
  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
                                  self->interface, 0, &error);
--- a/libfprint/drivers/vfs101.c
+++ b/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
--- a/libfprint/drivers/vfs301_proto.c
+++ b/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,
--- a/libfprint/drivers/vfs5011.c
+++ b/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
 {
--- a/libfprint/drivers/vfs7552.c
+++ b/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
 {
--- a/libfprint/drivers/virtual-device.c
+++ b/libfprint/drivers/virtual-device.c
@ -772,7 +772,6 @@ fpi_device_virtual_device_class_init (FpDeviceVirtualDeviceClass *klass)
 {
  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  const char *hot_seconds;
  object_class->finalize = fpi_device_virtual_device_finalize;
@ -788,18 +787,5 @@ fpi_device_virtual_device_class_init (FpDeviceVirtualDeviceClass *klass)
  dev_class->enroll = dev_enroll;
  dev_class->cancel = dev_cancel;
  if ((hot_seconds = g_getenv ("FP_VIRTUAL_DEVICE_HOT_SECONDS")) &&
      *hot_seconds != '\0')
    {
      gint64 hot_seconds_value;
      hot_seconds_value = g_ascii_strtoll (hot_seconds, NULL, 10);
      if (hot_seconds_value >= G_MAXINT32 || hot_seconds_value < 0)
        hot_seconds_value = -1;
      dev_class->temp_hot_seconds = hot_seconds_value;
      g_debug ("device hot seconds set to %d", dev_class->temp_hot_seconds);
    }
  fpi_device_class_auto_initialize_features (dev_class);
 }
--- a/libfprint/drivers/virtual-image.c
+++ b/libfprint/drivers/virtual-image.c
@ -191,12 +191,12 @@ on_listener_connected (FpiDeviceVirtualListener *listener,
  switch (state)
    {
    case FPI_IMAGE_DEVICE_STATE_IDLE:
    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
    case FPI_IMAGE_DEVICE_STATE_CAPTURE:
    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
      recv_image (self);
    case FPI_IMAGE_DEVICE_STATE_IDLE:
    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
    case FPI_IMAGE_DEVICE_STATE_ACTIVATING:
    case FPI_IMAGE_DEVICE_STATE_DEACTIVATING:
@ -310,7 +310,6 @@ fpi_device_virtual_image_class_init (FpDeviceVirtualImageClass *klass)
 {
  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
  const char *hot_seconds;
  dev_class->id = FP_COMPONENT;
  dev_class->full_name = "Virtual image device for debugging";
@ -322,17 +321,4 @@ fpi_device_virtual_image_class_init (FpDeviceVirtualImageClass *klass)
  img_class->activate = dev_activate;
  img_class->deactivate = dev_deactivate;
  if ((hot_seconds = g_getenv ("FP_VIRTUAL_IMAGE_HOT_SECONDS")) &&
      *hot_seconds != '\0')
    {
      gint64 hot_seconds_value;
      hot_seconds_value = g_ascii_strtoll (hot_seconds, NULL, 10);
      if (hot_seconds_value >= G_MAXINT32 || hot_seconds_value < 0)
        hot_seconds_value = -1;
      dev_class->temp_hot_seconds = hot_seconds_value;
      g_debug ("device hot seconds set to %d", dev_class->temp_hot_seconds);
    }
 }
--- a/libfprint/fp-context.c
+++ b/libfprint/fp-context.c
@ -67,26 +67,32 @@ enum {
 static guint signals[LAST_SIGNAL] = { 0 };
 static const char *
-get_drivers_allowlist_env (void)
+get_drivers_whitelist_env (void)
 {
-  return g_getenv ("FP_DRIVERS_ALLOWLIST");
+  return g_getenv ("FP_DRIVERS_WHITELIST");
 }
 static gboolean
 is_driver_allowed (const gchar *driver)
 {
-  g_auto(GStrv) allowlisted_drivers = NULL;
+  g_auto(GStrv) whitelisted_drivers = NULL;
-  const char *fp_drivers_allowlist_env;
+  const char *fp_drivers_whitelist_env;
  int i;
  g_return_val_if_fail (driver, TRUE);
-  fp_drivers_allowlist_env = get_drivers_allowlist_env ();
+  fp_drivers_whitelist_env = get_drivers_whitelist_env ();
-  if (!fp_drivers_allowlist_env)
+  if (!fp_drivers_whitelist_env)
    return TRUE;
-  allowlisted_drivers = g_strsplit (fp_drivers_allowlist_env, ":", -1);
+  whitelisted_drivers = g_strsplit (fp_drivers_whitelist_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
@ -358,7 +364,7 @@ fp_context_init (FpContext *self)
  priv->drivers = fpi_get_driver_types ();
-  if (get_drivers_allowlist_env ())
+  if (get_drivers_whitelist_env ())
    {
      for (i = 0; i < priv->drivers->len;)
        {
--- a/libfprint/fp-device-private.h
+++ b/libfprint/fp-device-private.h
@ -44,7 +44,7 @@ typedef struct
  FpDeviceType type;
  GUsbDevice  *usb_device;
-  gchar       *virtual_env;
+  const gchar *virtual_env;
  struct
  {
    gchar *spidev_path;
--- a/libfprint/fp-device.c
+++ b/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, priv->udev_data.spidev_path);
+        g_value_set_string (value, g_strdup (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, priv->udev_data.hidraw_path);
+        g_value_set_string (value, g_strdup (priv->udev_data.hidraw_path));
      else
        g_value_set_string (value, NULL);
      break;
@ -483,9 +483,6 @@ fp_device_class_init (FpDeviceClass *klass)
                         NULL,
                         G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
  /**
   * FpDevice:open: (getter is_open):
   */
  properties[PROP_OPEN] =
    g_param_spec_boolean ("open",
                          "Opened",
@ -1106,8 +1103,8 @@ enroll_data_free (FpEnrollData *data)
 * @device: a #FpDevice
 * @template_print: (transfer floating): a #FpPrint
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @progress_cb: (nullable) (closure progress_data) (scope notified): progress reporting callback
+ * @progress_cb: (nullable) (scope notified): progress reporting callback
- * @progress_data: user data for @progress_cb
+ * @progress_data: (closure progress_cb): user data for @progress_cb
 * @progress_destroy: (destroy progress_data): Destroy notify for @progress_data
 * @callback: (scope async): the function to call on completion
 * @user_data: the data to pass to @callback
@ -1251,8 +1248,8 @@ match_data_free (FpMatchData *data)
 * @device: a #FpDevice
 * @enrolled_print: a #FpPrint to verify
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope notified) (closure match_data): match reporting callback
+ * @match_cb: (nullable) (scope notified): match reporting callback
- * @match_data: user data for @match_cb
+ * @match_data: (closure match_cb): user data for @match_cb
 * @match_destroy: (destroy match_data): Destroy notify for @match_data
 * @callback: the function to call on completion
 * @user_data: the data to pass to @callback
@ -1377,8 +1374,8 @@ fp_device_verify_finish (FpDevice     *device,
 * @device: a #FpDevice
 * @prints: (element-type FpPrint) (transfer none): #GPtrArray of #FpPrint
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope notified) (closure match_data): match reporting callback
+ * @match_cb: (nullable) (scope notified): match reporting callback
- * @match_data: user data for @match_cb
+ * @match_data: (closure match_cb): user data for @match_cb
 * @match_destroy: (destroy match_data): Destroy notify for @match_data
 * @callback: the function to call on completion
 * @user_data: the data to pass to @callback
@ -1946,8 +1943,8 @@ fp_device_enroll_sync (FpDevice        *device,
 * @device: a #FpDevice
 * @enrolled_print: a #FpPrint to verify
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope call) (closure match_data): match reporting callback
+ * @match_cb: (nullable) (scope call): match reporting callback
- * @match_data: user data for @match_cb
+ * @match_data: (closure match_cb): user data for @match_cb
 * @match: (out): Whether the user presented the correct finger
 * @print: (out) (transfer full) (nullable): Location to store the scanned print, or %NULL to ignore
 * @error: Return location for errors, or %NULL to ignore
@ -1986,8 +1983,8 @@ fp_device_verify_sync (FpDevice     *device,
 * @device: a #FpDevice
 * @prints: (element-type FpPrint) (transfer none): #GPtrArray of #FpPrint
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope call) (closure match_data): match reporting callback
+ * @match_cb: (nullable) (scope call): match reporting callback
- * @match_data: user data for @match_cb
+ * @match_data: (closure match_cb): user data for @match_cb
 * @match: (out) (transfer full) (nullable): Location for the matched #FpPrint, or %NULL
 * @print: (out) (transfer full) (nullable): Location for the new #FpPrint, or %NULL
 * @error: Return location for errors, or %NULL to ignore
--- a/libfprint/fp-device.h
+++ b/libfprint/fp-device.h
@ -113,8 +113,6 @@ typedef enum {
 * @FP_DEVICE_RETRY_REMOVE_FINGER: The scan did not succeed due to quality or
 *   pressure problems; the user should remove their finger from the scanner
 *   before retrying.
 * @FP_DEVICE_RETRY_TOO_FAST: The scan did not succeed because the finger
 *   swipe or touch was too fast.
 *
 * Error codes representing scan failures resulting in the user needing to
 * retry.
@ -124,7 +122,6 @@ typedef enum {
  FP_DEVICE_RETRY_TOO_SHORT,
  FP_DEVICE_RETRY_CENTER_FINGER,
  FP_DEVICE_RETRY_REMOVE_FINGER,
  FP_DEVICE_RETRY_TOO_FAST,
 } FpDeviceRetry;
 /**
--- a/libfprint/fp-image.c
+++ b/libfprint/fp-image.c
@ -160,65 +160,60 @@ fp_image_init (FpImage *self)
 typedef struct
 {
  GAsyncReadyCallback user_cb;
  struct fp_minutiae *minutiae;
-  guchar             *binarized;
+  gint                width, height;
  gdouble             ppmm;
  FpiImageFlags       flags;
-  unsigned char      *image;
+  guchar             *image;
-  gboolean            image_changed;
+  guchar             *binarized;
-} DetectMinutiaeNbisData;
+} DetectMinutiaeData;
 static void
-fp_image_detect_minutiae_free (DetectMinutiaeNbisData *data)
+fp_image_detect_minutiae_free (DetectMinutiaeData *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);
 }
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (DetectMinutiaeNbisData, fp_image_detect_minutiae_free)
+static void
-
+fp_image_detect_minutiae_cb (GObject      *source_object,
-
+                             GAsyncResult *res,
-static gboolean
+                             gpointer      user_data)
 fp_image_detect_minutiae_nbis_finish (FpImage *self,
                                      GTask   *task,
                                      GError **error)
 {
-  g_autoptr(DetectMinutiaeNbisData) data = NULL;
+  GTask *task = G_TASK (res);
  FpImage *image;
  DetectMinutiaeData *data = g_task_get_task_data (task);
-  data = g_task_propagate_pointer (task, error);
+  if (!g_task_had_error (task))
  if (data != NULL)
    {
-      self->flags = data->flags;
+      gint i;
      image = FP_IMAGE (source_object);
-      if (data->image_changed)
+      image->flags = data->flags;
        {
          g_clear_pointer (&self->data, g_free);
          self->data = g_steal_pointer (&data->image);
        }
-      g_clear_pointer (&self->binarized, g_free);
+      g_clear_pointer (&image->data, g_free);
-      self->binarized = g_steal_pointer (&data->binarized);
+      image->data = g_steal_pointer (&data->image);
-      g_clear_pointer (&self->minutiae, g_ptr_array_unref);
+      g_clear_pointer (&image->binarized, g_free);
-      self->minutiae = g_ptr_array_new_full (data->minutiae->num,
+      image->binarized = g_steal_pointer (&data->binarized);
                                             (GDestroyNotify) free_minutia);
-      for (int i = 0; i < data->minutiae->num; i++)
+      g_clear_pointer (&image->minutiae, g_ptr_array_unref);
-        g_ptr_array_add (self->minutiae,
+      image->minutiae = g_ptr_array_new_full (data->minutiae->num,
                                              (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 free_minutiae delete the minutiae that we now own. */
+      /* Don't let it delete anything. */
      data->minutiae->num = 0;
      return TRUE;
    }
-  return FALSE;
+  if (data->user_cb)
    data->user_cb (source_object, res, user_data);
 }
 static void
@ -271,83 +266,70 @@ invert_colors (guint8 *data, gint width, gint height)
 }
 static void
-fp_image_detect_minutiae_nbis_thread_func (GTask        *task,
+fp_image_detect_minutiae_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;
-  g_autoptr(DetectMinutiaeNbisData) ret_data = NULL;
+  DetectMinutiaeData *data = task_data;
-  g_autoptr(GTask) thread_task = g_steal_pointer (&task);
+  struct fp_minutiae *minutiae = NULL;
  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 LFSPARMS *lfsparms = NULL;
+  g_autofree guchar *bdata = 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 (self->flags & FPI_IMAGE_H_FLIPPED)
+  if (data->flags & FPI_IMAGE_H_FLIPPED)
-    hflip (image, self->width, self->height);
+    hflip (data->image, data->width, data->height);
-  if (self->flags & FPI_IMAGE_V_FLIPPED)
+  if (data->flags & FPI_IMAGE_V_FLIPPED)
-    vflip (image, self->width, self->height);
+    vflip (data->image, data->width, data->height);
-  if (self->flags & FPI_IMAGE_COLORS_INVERTED)
+  if (data->flags & FPI_IMAGE_COLORS_INVERTED)
-    invert_colors (image, self->width, self->height);
+    invert_colors (data->image, data->width, data->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 = minutiae_flags & FPI_IMAGE_PARTIAL ? TRUE : FALSE;
+  lfsparms->remove_perimeter_pts = data->flags & FPI_IMAGE_PARTIAL ? TRUE : FALSE;
  timer = g_timer_new ();
-  r = get_minutiae (&ret_data->minutiae, &quality_map, &direction_map,
+  r = get_minutiae (&minutiae, &quality_map, &direction_map,
                    &low_contrast_map, &low_flow_map, &high_curve_map,
-                    &map_w, &map_h, &ret_data->binarized, &bw, &bh, &bd,
+                    &map_w, &map_h, &bdata, &bw, &bh, &bd,
-                    image, self->width, self->height, 8,
+                    data->image, data->width, data->height, 8,
-                    self->ppmm, lfsparms);
+                    data->ppmm, lfsparms);
  g_timer_stop (timer);
  fp_dbg ("Minutiae scan completed in %f secs", g_timer_elapsed (timer, NULL));
-  if (g_task_had_error (thread_task))
+  data->binarized = g_steal_pointer (&bdata);
-    return;
+  data->minutiae = minutiae;
  if (r)
    {
      fp_err ("get minutiae failed, code %d", r);
-      g_task_return_new_error (thread_task, G_IO_ERROR,
+      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "Minutiae scan failed with code %d", r);
-                               G_IO_ERROR_FAILED,
+      g_object_unref (task);
                               "Minutiae scan failed with code %d", r);
      return;
    }
-  if (!ret_data->minutiae || ret_data->minutiae->num == 0)
+  if (!data->minutiae || data->minutiae->num == 0)
    {
-      g_task_return_new_error (thread_task, G_IO_ERROR, G_IO_ERROR_FAILED,
+      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
                               "No minutiae found");
      g_object_unref (task);
      return;
    }
-  g_task_return_pointer (thread_task, g_steal_pointer (&ret_data),
+  g_task_return_boolean (task, TRUE);
-                         (GDestroyNotify) fp_image_detect_minutiae_free);
+  g_object_unref (task);
 }
 /**
@ -463,25 +445,21 @@ fp_image_detect_minutiae (FpImage            *self,
                          GAsyncReadyCallback callback,
                          gpointer            user_data)
 {
-  g_autoptr(GTask) task = NULL;
+  GTask *task;
  DetectMinutiaeData *data = g_new0 (DetectMinutiaeData, 1);
-  g_return_if_fail (FP_IS_IMAGE (self));
+  task = g_task_new (self, cancellable, fp_image_detect_minutiae_cb, user_data);
  g_return_if_fail (callback != NULL);
-  task = g_task_new (self, cancellable, callback, user_data);
+  data->image = g_malloc (self->width * self->height);
-  g_task_set_source_tag (task, fp_image_detect_minutiae);
+  memcpy (data->image, self->data, self->width * self->height);
-  g_task_set_check_cancellable (task, TRUE);
+  data->flags = self->flags;
  data->width = self->width;
  data->height = self->height;
  data->ppmm = self->ppmm;
  data->user_cb = callback;
-  if (!g_atomic_int_compare_and_exchange (&self->detection_in_progress,
+  g_task_set_task_data (task, data, (GDestroyNotify) fp_image_detect_minutiae_free);
-                                          FALSE, TRUE))
+  g_task_run_in_thread (task, fp_image_detect_minutiae_thread_func);
    {
      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);
 }
 /**
@ -499,27 +477,7 @@ fp_image_detect_minutiae_finish (FpImage      *self,
                                 GAsyncResult *result,
                                 GError      **error)
 {
-  GTask *task;
+  return g_task_propagate_boolean (G_TASK (result), error);
  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);
 }
 /**
--- a/libfprint/fp-print.c
+++ b/libfprint/fp-print.c
@ -721,12 +721,13 @@ 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;
+    {
-  tmp = g_variant_byteswap (result);
+      GVariant *tmp;
-  g_variant_unref (result);
+      tmp = g_variant_byteswap (result);
-  result = tmp;
+      g_variant_unref (result);
-#endif
+      result = tmp;
    }
  len = g_variant_get_size (result);
  /* Add 3 bytes of header */
@ -799,11 +800,10 @@ 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)",
--- a/libfprint/fp-print.h
+++ b/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"
--- a/libfprint/fpi-byte-reader.h
+++ b/libfprint/fpi-byte-reader.h
@ -675,6 +675,4 @@ 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
--- a/libfprint/fpi-byte-writer.c
+++ b/libfprint/fpi-byte-writer.c
@ -75,8 +75,7 @@ fpi_byte_writer_new_with_size (guint size, gboolean fixed)
  FpiByteWriter *ret = fpi_byte_writer_new ();
  ret->alloc_size = size;
-  ret->parent.data = g_malloc0 (ret->alloc_size);
+  ret->parent.data = g_malloc (ret->alloc_size);
  ret->parent.size = size;
  ret->fixed = fixed;
  ret->owned = TRUE;
@ -143,8 +142,7 @@ fpi_byte_writer_init_with_size (FpiByteWriter * writer, guint size,
  fpi_byte_writer_init (writer);
-  writer->parent.data = g_malloc0 (size);
+  writer->parent.data = g_malloc (size);
  writer->parent.size = size;
  writer->alloc_size = size;
  writer->fixed = fixed;
  writer->owned = TRUE;
@ -211,9 +209,10 @@ fpi_byte_writer_reset_and_get_data (FpiByteWriter * writer)
  g_return_val_if_fail (writer != NULL, NULL);
-  data = (guint8 *) g_steal_pointer (&writer->parent.data);
+  data = (guint8 *) writer->parent.data;
  if (!writer->owned)
    data = g_memdup2 (data, writer->parent.size);
  writer->parent.data = NULL;
  fpi_byte_writer_reset (writer);
  return data;
--- a/libfprint/fpi-byte-writer.h
+++ b/libfprint/fpi-byte-writer.h
@ -111,17 +111,6 @@ 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)
 {
@ -418,7 +407,4 @@ 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
--- a/libfprint/fpi-compat.h
+++ b/libfprint/fpi-compat.h
@ -20,6 +20,36 @@
 #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
--- a/libfprint/fpi-device.c
+++ b/libfprint/fpi-device.c
@ -117,10 +117,6 @@ fpi_device_retry_new (FpDeviceRetry error)
      msg = "Please try again after removing the finger first.";
      break;
    case FP_DEVICE_RETRY_TOO_FAST:
      msg = "The swipe was too fast, please try again.";
      break;
    default:
      g_warning ("Unsupported error, returning general error instead!");
      error = FP_DEVICE_RETRY_GENERAL;
@ -1046,41 +1042,34 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
 static void
 fpi_device_task_return_data_free (FpDeviceTaskReturnData *data)
 {
-  switch (data->type)
+  if (data->result)
    {
-    case FP_DEVICE_TASK_RETURN_INT:
+      switch (data->type)
-    case FP_DEVICE_TASK_RETURN_BOOL:
+        {
-      break;
+        case FP_DEVICE_TASK_RETURN_INT:
        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,
@ -1112,7 +1101,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: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing probe operation. If error is %NULL success is assumed.
 */
@ -1158,7 +1147,7 @@ fpi_device_probe_complete (FpDevice    *device,
 /**
 * fpi_device_open_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing open operation. If error is %NULL success is assumed.
 */
@ -1185,7 +1174,7 @@ fpi_device_open_complete (FpDevice *device, GError *error)
 /**
 * fpi_device_close_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing close operation. If error is %NULL success is assumed.
 */
@ -1237,7 +1226,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: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing enroll operation. The #FpPrint can be stored by the
 * caller for later verification.
@ -1366,7 +1355,7 @@ fpi_device_verify_complete (FpDevice *device,
 /**
 * fpi_device_identify_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing identify operation.
 *
@ -1432,7 +1421,7 @@ fpi_device_identify_complete (FpDevice *device,
 * fpi_device_capture_complete:
 * @device: The #FpDevice
 * @image: The #FpImage, or %NULL on error
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing capture operation.
 */
@ -1479,7 +1468,7 @@ fpi_device_capture_complete (FpDevice *device,
 /**
 * fpi_device_delete_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing delete operation.
 */
@ -1508,7 +1497,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: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing list operation.
 *
@ -1786,7 +1775,7 @@ fpi_device_suspend_completed (FpDevice *device)
 /**
 * fpi_device_suspend_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: 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
@ -1837,7 +1826,7 @@ fpi_device_suspend_complete (FpDevice *device,
 /**
 * fpi_device_resume_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish a resume request.
 */
@ -1865,7 +1854,7 @@ fpi_device_resume_complete (FpDevice *device,
 /**
 * fpi_device_clear_storage_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing clear_storage operation.
 */
@ -1896,7 +1885,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: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: (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().
--- a/libfprint/fpi-image-device.c
+++ b/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: (nullable) (transfer full): The #GError to report.
+ * @error: 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: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: A #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: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: A #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: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: A #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: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: A #GError or %NULL on success
 *
 * Reports completion of close operation.
 */
--- a/libfprint/fpi-image.h
+++ b/libfprint/fpi-image.h
@ -33,7 +33,6 @@
 * 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,8 +67,7 @@ struct _FpImage
  guint8    *binarized;
  GPtrArray *minutiae;
-
+  guint      ref_count;
  gboolean   detection_in_progress;
 };
 gint fpi_std_sq_dev (const guint8 *buf,
--- a/libfprint/fpi-log.h
+++ b/libfprint/fpi-log.h
@ -79,16 +79,13 @@
 *
 * Uses fp_err() to print an error if the @condition is true.
 */
-#define BUG_ON(condition) \
+#define BUG_ON(condition) G_STMT_START          \
-  G_STMT_START          \
+        if (condition) {                        \
-  if (condition) \
+            char *s;                        \
-    {                        \
+            s = g_strconcat ("BUG: (", #condition, ")", NULL); \
-      char *s;                        \
+            fp_err ("%s: %s() %s:%d", s, G_STRFUNC, __FILE__, __LINE__); \
-      s = g_strconcat ("BUG: (", #condition, ")", NULL); \
+            g_free (s);                     \
-      fp_err ("%s: %s() %s:%d", s, G_STRFUNC, __FILE__, __LINE__); \
+          } G_STMT_END
      g_free (s);                     \
    } \
  G_STMT_END
 /**
 * BUG:
--- a/libfprint/fpi-ssm.c
+++ b/libfprint/fpi-ssm.c
@ -73,7 +73,7 @@
 struct _FpiSsm
 {
  FpDevice               *dev;
-  char                   *name;
+  const char             *name;
  FpiSsm                 *parentsm;
  gpointer                ssm_data;
  GDestroyNotify          ssm_data_destroy;
--- a/libfprint/fpi-ssm.h
+++ b/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,
--- a/libfprint/fprint-list-metainfo.c
+++ b/libfprint/fprint-list-metainfo.c
@ -1,107 +0,0 @@
 /*
 * Copyright (C) 2025 Marco Trevisan <marco.trevisan@canonical.com>
 *
 * 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
 */
 #include "glib.h"
 #include "fpi-context.h"
 #include "fpi-device.h"
 #define METAINFO_BASE \
  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" \
  "<component>\n" \
  "  <id>org.freedesktop.libfprint</id>\n" \
  "  <name>libfprint</name>\n" \
  "  <metadata_license>CC0-1.0</metadata_license>\n" \
  "  <project_license>LGPL-2.1-or-later</project_license>\n" \
  "  <url type=\"homepage\">https://fprint.freedesktop.org</url>\n" \
  "  <url type=\"vcs-browser\">https://gitlab.freedesktop.org/libfprint/libfprint</url>\n" \
  "  <url type=\"help\">https://fprint.freedesktop.org/libfprint-dev</url>\n" \
  "  <url type=\"bugtracker\">https://gitlab.freedesktop.org/libfprint/libfprint/-/issues</url>\n" \
  "  <summary>Async fingerprint readers library</summary>\n" \
  "  <description>\n" \
  "    <p>\n" \
  "      The fprint project aims to support for consumer fingerprint reader devices.\n" \
  "    </p>\n" \
  "  </description>\n" \
  "  <provides>\n" \
  "%s\n" \
  "  </provides>\n" \
  "</component>\n"
 static int
 driver_compare (gconstpointer p1, gconstpointer p2)
 {
  g_autoptr(FpDeviceClass) cls1 = g_type_class_ref (*(GType *) p1);
  g_autoptr(FpDeviceClass) cls2 = g_type_class_ref (*(GType *) p2);
  return g_strcmp0 (cls1->id, cls2->id);
 }
 static void
 usb_driver_devices_append (GPtrArray           *devices_list,
                           const FpDeviceClass *cls)
 {
  const FpIdEntry *entry;
  if (cls->type != FP_DEVICE_TYPE_USB)
    return;
  for (entry = cls->id_table; entry->vid != 0; entry++)
    {
      if (entry->vid == 0 || entry->pid == 0)
        continue;
      g_ptr_array_add (devices_list,
                       g_strdup_printf ("v%04xp%04x", entry->vid, entry->pid));
    }
 }
 int
 main (void)
 {
  g_autoptr(GPtrArray) devices_list = g_ptr_array_new_with_free_func (g_free);
  g_autoptr(GArray) drivers = fpi_get_driver_types ();
  g_autoptr(GString) provided_modules = g_string_new (NULL);
  g_autoptr(GError) error = NULL;
  g_array_sort (drivers, driver_compare);
  for (guint i = 0; i < drivers->len; ++i)
    {
      GType driver = g_array_index (drivers, GType, i);
      g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
      if (cls->type != FP_DEVICE_TYPE_USB)
        continue;
      usb_driver_devices_append (devices_list, cls);
    }
  for (guint i = 0; i < devices_list->len; ++i)
    {
      const char *device_id = g_ptr_array_index (devices_list, i);
      g_string_append (provided_modules, "    ");
      g_string_append_printf (provided_modules, "<modalias>usb:%s*</modalias>",
                              device_id);
      if (i < devices_list->len - 1)
        g_string_append_c (provided_modules, '\n');
    }
  g_print (METAINFO_BASE, provided_modules->str);
 }
--- a/libfprint/fprint-list-supported-devices.c
+++ b/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 ("%% libfprint — Supported Devices\n");
+  g_print ("%% lifprint — Supported Devices\n");
  g_print ("%% Bastien Nocera, Daniel Drake\n");
  g_print ("%% 2018\n");
  g_print ("\n");
--- a/libfprint/fprint-list-udev-hwdb.c
+++ b/libfprint/fprint-list-udev-hwdb.c
@ -24,15 +24,11 @@
 #include "fpi-context.h"
 #include "fpi-device.h"
-static const FpIdEntry allowlist_id_table[] = {
+static const FpIdEntry whitelist_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 = 0x0a5c, .pid = 0x5802 },
  { .vid = 0x047d, .pid = 0x00f2 },
  { .vid = 0x047d, .pid = 0x8054 },
  { .vid = 0x047d, .pid = 0x8055 },
  { .vid = 0x04e8, .pid = 0x730b },
  { .vid = 0x04f3, .pid = 0x036b },
  { .vid = 0x04f3, .pid = 0x0c00 },
@ -40,37 +36,23 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x04f3, .pid = 0x0c57 },
  { .vid = 0x04f3, .pid = 0x0c5e },
  { .vid = 0x04f3, .pid = 0x0c5a },
  { .vid = 0x04f3, .pid = 0x0c60 },
  { .vid = 0x04f3, .pid = 0x0c6c },
  { .vid = 0x04f3, .pid = 0x0c70 },
  { .vid = 0x04f3, .pid = 0x0c72 },
  { .vid = 0x04f3, .pid = 0x0c77 },
  { .vid = 0x04f3, .pid = 0x0c7c },
  { .vid = 0x04f3, .pid = 0x0c7f },
  { .vid = 0x04f3, .pid = 0x0c80 },
  { .vid = 0x04f3, .pid = 0x0c85 },
  { .vid = 0x04f3, .pid = 0x0c90 },
  { .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 = 0x04f3, .pid = 0x0c8a },
  { .vid = 0x05ba, .pid = 0x000e },
  { .vid = 0x06cb, .pid = 0x0051 },
  { .vid = 0x06cb, .pid = 0x0081 },
  { .vid = 0x06cb, .pid = 0x0088 },
  { .vid = 0x06cb, .pid = 0x008a },
  { .vid = 0x06cb, .pid = 0x009a },
  { .vid = 0x06cb, .pid = 0x009b },
  { .vid = 0x06cb, .pid = 0x00a1 },
  { .vid = 0x06cb, .pid = 0x00a2 },
  { .vid = 0x06cb, .pid = 0x00a8 },
  { .vid = 0x06cb, .pid = 0x00b7 },
  { .vid = 0x06cb, .pid = 0x00bb },
  { .vid = 0x06cb, .pid = 0x00bc },
  { .vid = 0x06cb, .pid = 0x00be },
  { .vid = 0x06cb, .pid = 0x00c4 },
  { .vid = 0x06cb, .pid = 0x00cb },
  { .vid = 0x06cb, .pid = 0x00c9 },
  { .vid = 0x06cb, .pid = 0x00d8 },
@ -78,8 +60,8 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x06cb, .pid = 0x00dc },
  { .vid = 0x06cb, .pid = 0x00e4 },
  { .vid = 0x06cb, .pid = 0x00e7 },
  { .vid = 0x06cb, .pid = 0x00e9 },
  { .vid = 0x06cb, .pid = 0x00fd },
  { .vid = 0x06cb, .pid = 0x00ff },
  { .vid = 0x0a5c, .pid = 0x5801 },
  { .vid = 0x0a5c, .pid = 0x5805 },
  { .vid = 0x0a5c, .pid = 0x5834 },
@ -89,21 +71,10 @@ static const FpIdEntry allowlist_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 = 0x9201 },
  { .vid = 0x10a5, .pid = 0x9800 },
  { .vid = 0x10a5, .pid = 0xa120 },
  { .vid = 0x10a5, .pid = 0xa900 },
  { .vid = 0x10a5, .pid = 0xa921 },
  { .vid = 0x10a5, .pid = 0xe340 },
  { .vid = 0x1188, .pid = 0x9545 },
  { .vid = 0x138a, .pid = 0x0007 },
  { .vid = 0x138a, .pid = 0x003a },
@ -116,17 +87,12 @@ static const FpIdEntry allowlist_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 = 0x1c7a, .pid = 0x057e },
  { .vid = 0x2541, .pid = 0x0236 },
  { .vid = 0x2541, .pid = 0x9711 },
  { .vid = 0x27c6, .pid = 0x5042 },
  { .vid = 0x27c6, .pid = 0x5110 },
  { .vid = 0x27c6, .pid = 0x5117 },
@ -154,36 +120,26 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x27c6, .pid = 0x5740 },
  { .vid = 0x27c6, .pid = 0x5e0a },
  { .vid = 0x27c6, .pid = 0x581a },
  { .vid = 0x27c6, .pid = 0x589a },
  { .vid = 0x27c6, .pid = 0x5f10 },
  { .vid = 0x27c6, .pid = 0x5f91 },
  { .vid = 0x27c6, .pid = 0x6382 },
  { .vid = 0x2808, .pid = 0x9338 },
  { .vid = 0x2808, .pid = 0x9348 },
  { .vid = 0x2808, .pid = 0x93a9 },
  { .vid = 0x2808, .pid = 0xa658 },
  { .vid = 0x2808, .pid = 0xc652 },
  { .vid = 0x2808, .pid = 0xa553 },
  { .vid = 0x298d, .pid = 0x2020 },
  { .vid = 0x298d, .pid = 0x2033 },
  { .vid = 0x2df0, .pid = 0x0003 },
  { .vid = 0x3274, .pid = 0x8012 },
  { .vid = 0x3538, .pid = 0x0930 },
  { .vid = 0 },
 };
-static const FpIdEntry denylist_id_table[] = {
+static const FpIdEntry blacklist_id_table[] = {
  { .vid = 0x0483, .pid = 0x2016 },
  /* https://bugs.freedesktop.org/show_bug.cgi?id=66659 */
  { .vid = 0x045e, .pid = 0x00bb },
  { .vid = 0 },
 };
-static const FpDeviceClass allowlist = {
+static const FpDeviceClass whitelist = {
  .type = FP_DEVICE_TYPE_USB,
-  .id_table = allowlist_id_table,
+  .id_table = whitelist_id_table,
-  .id = "allowlist",
+  .id = "whitelist",
-  .full_name = "Hardcoded allowlist"
+  .full_name = "Hardcoded whitelist"
 };
 GHashTable *printed = NULL;
@ -202,7 +158,7 @@ print_driver (const FpDeviceClass *cls)
      const FpIdEntry *bl_entry;
      char *key;
-      for (bl_entry = denylist_id_table; bl_entry->vid != 0; bl_entry++)
+      for (bl_entry = blacklist_id_table; bl_entry->vid != 0; bl_entry++)
        if (entry->vid == bl_entry->vid && entry->pid == bl_entry->pid)
          break;
@ -213,7 +169,7 @@ print_driver (const FpDeviceClass *cls)
      if (g_hash_table_lookup (printed, key) != NULL)
        {
-          if (cls == &allowlist)
+          if (cls == &whitelist)
            g_warning ("%s implemented by driver %s",
                       key, (const char *) g_hash_table_lookup (printed, key));
          g_free (key);
@ -224,7 +180,7 @@ print_driver (const FpDeviceClass *cls)
      if (num_printed == 0)
        {
-          if (cls != &allowlist)
+          if (cls != &whitelist)
            g_print ("\n# Supported by libfprint driver %s\n", cls->id);
          else
            g_print ("\n# Known unsupported devices\n");
@ -278,7 +234,7 @@ main (int argc, char **argv)
      print_driver (cls);
    }
-  print_driver (&allowlist);
+  print_driver (&whitelist);
  g_hash_table_destroy (printed);
--- a/libfprint/meson.build
+++ b/libfprint/meson.build
@ -1,11 +1,3 @@
 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',
@ -24,7 +16,8 @@ libfprint_private_sources = [
    'fpi-print.c',
    'fpi-ssm.c',
    'fpi-usb-transfer.c',
-] + spi_sources
+    'fpi-spi-transfer.c',
 ]
 libfprint_public_headers = [
    'fp-context.h',
@ -48,8 +41,9 @@ libfprint_private_headers = [
    'fpi-minutiae.h',
    'fpi-print.h',
    'fpi-usb-transfer.h',
    'fpi-spi-transfer.h',
    'fpi-ssm.h',
-] + spi_headers
+]
 nbis_sources = [
    'nbis/bozorth3/bozorth3.c',
@ -125,8 +119,6 @@ driver_sources = {
        [ 'drivers/etes603.c' ],
    'egis0570' :
        [ 'drivers/egis0570.c' ],
    'egismoc' :
        [ 'drivers/egismoc/egismoc.c' ],
    'vfs0050' :
        [ 'drivers/vfs0050.c' ],
    'elan' :
@ -149,10 +141,6 @@ 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 = {
@ -162,7 +150,7 @@ helper_sources = {
        [ 'drivers/aesx660.c' ],
    'aes3k' :
        [ 'drivers/aes3k.c' ],
-    'openssl' :
+    'nss' :
        [ ],
    'udev' :
        [ ],
@ -255,7 +243,6 @@ libnbis = static_library('nbis',
        '-Wno-discarded-qualifiers',
        '-Wno-array-bounds',
        '-Wno-array-parameter',
        '-Wno-unused-but-set-variable',
    ]),
    install: false)
@ -275,13 +262,8 @@ libfprint_drivers = static_library('fprint-drivers',
    link_with: libfprint_private,
    install: false)
-mapfile = files('libfprint.ver')[0]
+mapfile = files('libfprint.ver')
-if meson.version().version_compare('>=1.4')
+vflag = '-Wl,--version-script,@0@/@1@'.format(meson.project_source_root(), mapfile[0])
    mapfile_path = mapfile.full_path()
 else
    mapfile_path = meson.project_source_root() / '@0@'.format(mapfile)
 endif
 vflag = '-Wl,--version-script,@0@'.format(mapfile_path)
 libfprint = shared_library(versioned_libname.split('lib')[1],
    sources: [
@ -333,21 +315,6 @@ udev_hwdb_generator = custom_target('udev-hwdb',
    install: false,
 )
 metainfo = executable('fprint-list-metainfo',
    'fprint-list-metainfo.c',
    dependencies: libfprint_private_dep,
    link_with: libfprint_drivers,
    install: false)
 metainfo_generator = custom_target('metainfo',
    output: 'org.freedesktop.libfprint.metainfo.xml',
    depend_files: drivers_sources,
    capture: true,
    command: [ metainfo ],
    install: true,
    install_dir: datadir / 'metainfo'
 )
 if install_udev_rules
    udev_rules = executable('fprint-list-udev-rules',
        'fprint-list-udev-rules.c',
@ -411,7 +378,6 @@ if get_option('introspection')
            'GObject-2.0',
            'GUsb-1.0',
        ],
        fatal_warnings: true,
        install : true)
    libfprint_gir = libfprint_girtarget[0]
    libfprint_typelib = libfprint_girtarget[1]
--- a/meson.build
+++ b/meson.build
@ -1,14 +1,13 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.94.10',
+    version: '1.94.6',
    license: 'LGPLv2.1+',
    default_options: [
        'buildtype=debugoptimized',
        'warning_level=1',
        'c_std=gnu99',
    ],
-    meson_version: '>= 0.59.0')
+    meson_version: '>= 0.56.0')
 fs = import('fs')
 gnome = import('gnome')
 libfprint_conf = configuration_data()
@ -22,17 +21,12 @@ 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'
 libfprint_sanitizers = get_option('b_sanitize').split(',')
 if libfprint_sanitizers == ['none']
  libfprint_sanitizers = []
 endif
 glib_min_version = '2.68'
 glib_version_def = 'GLIB_VERSION_@0@_@1@'.format(
    glib_min_version.split('.')[0], glib_min_version.split('.')[1])
 common_cflags = cc.get_supported_arguments([
    '-Wall',
    '-Wcast-align',
    '-Wformat-nonliteral',
    '-Wformat-security',
@ -97,15 +91,11 @@ 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 = [
@ -130,7 +120,6 @@ default_drivers = [
    'vfs0050',
    'etes603',
    'egis0570',
    'egismoc',
    'vcom5s',
    'synaptics',
    'elan',
@ -142,42 +131,16 @@ default_drivers = [
    'goodixmoc',
    'nb1010',
    'fpcmoc',
    'realtek',
    'focaltech_moc',
 ]
-spi_drivers = [
+    # SPI
-    'elanspi'
+    '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
@ -190,17 +153,6 @@ 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' ],
@ -209,7 +161,7 @@ driver_helper_mapping = {
    'aes2660' : [ 'aeslib', 'aesx660' ],
    'aes3500' : [ 'aeslib', 'aes3k' ],
    'aes4000' : [ 'aeslib', 'aes3k' ],
-    'uru4000' : [ 'openssl' ],
+    'uru4000' : [ 'nss' ],
    'elanspi' : [ 'udev' ],
    'virtual_image'          : [ 'virtual' ],
    'virtual_device'         : [ 'virtual' ],
@ -266,13 +218,13 @@ foreach i : driver_helpers
        libfprint_conf.set10('HAVE_PIXMAN', true)
        optional_deps += imaging_dep
-    elif i == 'openssl'
+    elif i == 'nss'
-        openssl_dep = dependency('openssl', version: '>= 3.0', required: false)
+        nss_dep = dependency('nss', required: false)
-        if not openssl_dep.found()
+        if not nss_dep.found()
-            error('OpenSSL is required for @0@ and possibly others'.format(driver))
+            error('nss is required for @0@ and possibly others'.format(driver))
        endif
-        optional_deps += openssl_dep
+        optional_deps += nss_dep
    elif i == 'udev'
        install_udev_rules = true
@ -295,7 +247,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_variable(pkgconfig: 'udevdir') + '/rules.d'
+        udev_rules_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/rules.d'
    endif
 endif
@ -332,7 +284,7 @@ if not udev_hwdb.disabled()
    if udev_hwdb_dir == 'auto'
        udev_dep = dependency('udev')
-        udev_hwdb_dir = udev_dep.get_variable(pkgconfig: 'udevdir') + '/hwdb.d'
+        udev_hwdb_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/hwdb.d'
    endif
 else
    udev_hwdb_dir = ''
--- a/scripts/uncrustify.cfg
+++ b/scripts/uncrustify.cfg
@ -19,7 +19,6 @@ indent_func_proto_param false
 indent_switch_case      0
 indent_case_brace       2
 indent_paren_close      1
 pp_multiline_define_body_indent 2
 # spacing
 sp_arith                        Add
@ -115,7 +114,6 @@ nl_create_for_one_liner         False
 nl_create_while_one_liner       False
 nl_after_semicolon              True
 nl_multi_line_cond              true
 nl_multi_line_define            true
 # mod
 # I'd like these to be remove, but that removes brackets in if { if { foo } }, which i dislike
--- a/tests/create-driver-test.py.in
+++ b/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_ALLOWLIST'] = driver_name
+os.environ['FP_DRIVERS_WHITELIST'] = driver_name
 test_variant = None
 if len(sys.argv) == 3:
--- a/tests/egis0570/capture.pcapng
+++ b/tests/egis0570/capture.pcapng
--- a/tests/egis0570/device
+++ b/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 allowlist
+E: LIBFPRINT_DRIVER=Hardcoded whitelist
 A: authorized=1\n
 A: avoid_reset_quirk=0\n
 A: bConfigurationValue=1\n
--- a/tests/egismoc-0586/custom.pcapng
+++ b/tests/egismoc-0586/custom.pcapng
--- a/tests/egismoc-0586/custom.py
+++ b/tests/egismoc-0586/custom.py
@ -1,156 +0,0 @@
 #!/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
--- a/tests/egismoc-0586/device
+++ b/tests/egismoc-0586/device
@ -1,255 +0,0 @@
 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
--- a/tests/egismoc-0587/custom.pcapng
+++ b/tests/egismoc-0587/custom.pcapng
--- a/tests/egismoc-0587/custom.py
+++ b/tests/egismoc-0587/custom.py
@ -1,156 +0,0 @@
 #!/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
--- a/tests/egismoc-0587/device
+++ b/tests/egismoc-0587/device
@ -1,270 +0,0 @@
 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
--- a/tests/egismoc-05a1/custom.pcapng
+++ b/tests/egismoc-05a1/custom.pcapng
--- a/tests/egismoc-05a1/custom.py
+++ b/tests/egismoc-05a1/custom.py
@ -1,156 +0,0 @@
 #!/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
--- a/tests/egismoc-05a1/device
+++ b/tests/egismoc-05a1/device
@ -1,262 +0,0 @@
 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
--- a/tests/egismoc/custom.pcapng
+++ b/tests/egismoc/custom.pcapng
--- a/tests/egismoc/custom.py
+++ b/tests/egismoc/custom.py
@ -1,156 +0,0 @@
 #!/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
--- a/tests/egismoc/device
+++ b/tests/egismoc/device
@ -1,262 +0,0 @@
 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
--- a/tests/focaltech_moc/custom.pcapng
+++ b/tests/focaltech_moc/custom.pcapng
--- a/tests/focaltech_moc/custom.py
+++ b/tests/focaltech_moc/custom.py
@ -1,89 +0,0 @@
 #!/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
--- a/tests/focaltech_moc/device
+++ b/tests/focaltech_moc/device
--- a/tests/fpcmoc/device
+++ b/tests/fpcmoc/device
@ -3,7 +3,7 @@ N: bus/usb/001/019=1201000200000040A510E0FF10000102000109021900010104A0320904000
 E: DEVNAME=/dev/bus/usb/001/019
 E: DEVTYPE=usb_device
 E: DRIVER=usb
-E: PRODUCT=10a5/a306/10
+E: PRODUCT=10a5/ffe0/10
 E: TYPE=0/0/0
 E: BUSNUM=001
 E: DEVNUM=019
@ -13,11 +13,11 @@ E: SUBSYSTEM=usb
 E: ID_VENDOR=FPC
 E: ID_VENDOR_ENC=FPC
 E: ID_VENDOR_ID=10a5
-E: ID_MODEL=FPC_L:0001_FW:222709
+E: ID_MODEL=FPC_L:0001_FW:127010
-E: ID_MODEL_ENC=FPC\x20L:0001\x20FW:222709
+E: ID_MODEL_ENC=FPC\x20L:0001\x20FW:127010
-E: ID_MODEL_ID=a306
+E: ID_MODEL_ID=ffe0
 E: ID_REVISION=0010
-E: ID_SERIAL=FPC_FPC_L:0001_FW:222709
+E: ID_SERIAL=FPC_FPC_L:0001_FW:127010
 E: ID_BUS=usb
 E: ID_USB_INTERFACES=:ffffff:
 E: ID_PATH=pci-0000:00:14.0-usb-0:1
@ -45,7 +45,7 @@ A: devnum=19\n
 A: devpath=1\n
 L: driver=../../../../../bus/usb/drivers/usb
 L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:1c/device:1d/device:1e
-A: idProduct=a306\n
+A: idProduct=ffe0\n
 A: idVendor=10a5\n
 A: ltm_capable=no\n
 A: manufacturer=FPC\n
@ -74,7 +74,7 @@ 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=FPC L:0001 FW:222709\n
+A: product=FPC L:0001 FW:127010\n
 A: quirks=0x0\n
 A: removable=removable\n
 A: rx_lanes=1\n
--- a/tests/goodixmoc/custom.pcapng
+++ b/tests/goodixmoc/custom.pcapng
--- a/tests/goodixmoc/custom.py
+++ b/tests/goodixmoc/custom.py
@ -53,20 +53,17 @@ 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")
 assert p.get_description() == 'FP1-00000000-0-00000000-nobody'
 print("listing")
 stored = d.list_prints_sync()
 print("listing done")
 assert len(stored) == 1
 assert stored[0].equal(p)
 assert stored[0].get_description() == 'FP1-00000000-0-00000000-nobody'
 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")
 assert verify_print.get_description() == 'FP1-00000000-0-00000000-nobody'
 del p
 assert verify_res == True
--- a/tests/goodixmoc/device
+++ b/tests/goodixmoc/device
--- a/tests/libfprint.supp
+++ b/tests/libfprint.supp
@ -24,12 +24,3 @@
   ...
   fun:g_thread_new
 }
 {
   <ignore-libusb-context>
   Memcheck:Leak
   match-leak-kinds: possible
   fun:calloc
   ...
   fun:libusb_init_context
 }
--- a/tests/meson.build
+++ b/tests/meson.build
@ -6,8 +6,6 @@ envs.set('G_MESSAGES_DEBUG', 'all')
 # Setup paths
 envs.set('MESON_SOURCE_ROOT', meson.project_source_root())
 envs.set('MESON_BUILD_ROOT', meson.project_build_root())
 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
@ -15,7 +13,7 @@ envs.prepend('LD_LIBRARY_PATH', meson.project_build_root() / 'libfprint')
 envs.set('FP_DEVICE_EMULATION', '1')
 # Set a colon-separated list of native drivers we enable in tests
-envs.set('FP_DRIVERS_ALLOWLIST', ':'.join([
+envs.set('FP_DRIVERS_WHITELIST', ':'.join([
    'virtual_image',
    'virtual_device',
    'virtual_device_storage',
@ -51,14 +49,7 @@ drivers_tests = [
    'goodixmoc',
    'nb1010',
    'egis0570',
    'egismoc',
    'egismoc-05a1',
    'egismoc-0586',
    'egismoc-0587',
    'fpcmoc',
 	'realtek',
 	'realtek-5816',
    'focaltech_moc',
 ]
 if get_option('introspection')
@ -80,12 +71,6 @@ 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', meson.project_build_root() / 'libfprint')
    virtual_devices_tests = [
@ -103,17 +88,11 @@ if get_option('introspection')
            base_args = files(vdtest + '.py')
            suite = ['virtual-driver']
-            r = run_command(unittest_inspector, files(vdtest + '.py'), check: false)
+            r = run_command(unittest_inspector, files(vdtest + '.py'), check: true)
            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
@ -145,7 +124,8 @@ if get_option('introspection')
                    output: vdtest + '.test',
                    install_dir: installed_tests_testdir,
                    configuration: {
-                        'exec': installed_tests_execdir / fs.name(base_args[0]),
+                        # 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,
@ -159,7 +139,7 @@ if get_option('introspection')
            endif
        else
            test(vdtest,
-                sh,
+                find_program('sh'),
                args: ['-c', 'exit 77']
            )
        endif
@ -169,7 +149,7 @@ if get_option('introspection')
    foreach driver_test: drivers_tests
        driver_name = driver_test.split('-')[0]
        driver_envs = envs
-        driver_envs.set('FP_DRIVERS_ALLOWLIST', driver_name)
+        driver_envs.set('FP_DRIVERS_WHITELIST', driver_name)
        if (driver_name in supported_drivers and
            gusb_dep.version().version_compare('>= 0.3.0'))
@ -213,7 +193,7 @@ if get_option('introspection')
            endif
        else
            test(driver_test,
-                sh,
+                find_program('sh'),
                args: ['-c', 'exit 77']
            )
        endif
@ -232,13 +212,13 @@ if get_option('introspection')
 else
    warning('Skipping all driver tests as introspection bindings are missing')
    test('virtual-image',
-        sh,
+        find_program('sh'),
        args: ['-c', 'exit 77']
    )
    foreach driver_test: drivers_tests
        test(driver_test,
-            sh,
+            find_program('sh'),
            args: ['-c', 'exit 77']
        )
    endforeach
@ -267,6 +247,10 @@ endif
 unit_tests_deps = { 'fpi-assembling' : [cairo_dep] }
 test_config = configuration_data()
 test_config.set_quoted('SOURCE_ROOT', meson.project_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
@ -281,7 +265,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,
-                sh,
+                find_program('sh'),
                suite: ['unit-tests'],
                args: ['-c', 'exit 77'],
            )
@ -294,7 +278,7 @@ foreach test_name: unit_tests
    basename = 'test-' + test_name
    test_exe = executable(basename,
-        sources: basename + '.c',
+        sources: [basename + '.c', test_config_h],
        dependencies: [ libfprint_private_dep ] + extra_deps,
        c_args: common_cflags,
        link_whole: test_utils,
@ -324,25 +308,13 @@ endforeach
 # Run udev rule generator with fatal warnings
 envs.set('UDEV_HWDB', udev_hwdb.full_path())
 envs.set('UDEV_HWDB_CHECK_CONTENTS', default_drivers_are_enabled ? '1' : '0')
 envs.set('G_MESSAGES_DEBUG', '')
 test('udev-hwdb',
     find_program('test-generated-hwdb.sh'),
     depends: udev_hwdb,
     suite: ['data', 'no-valgrind'],
     env: envs)
 appstreamcli = find_program('appstreamcli', required: false)
 if appstreamcli.found()
    test('metainfo-validate',
        appstreamcli,
        args: ['validate', metainfo_generator],
        depends: metainfo_generator,
        suite: ['data', 'no-valgrind'],
    )
 endif
 gdb = find_program('gdb', required: false)
-if gdb.found() and libfprint_sanitizers.length() == 0
+if gdb.found()
    libfprint_wrapper = [
        gdb.full_path(),
        '-batch',
@ -357,32 +329,14 @@ if gdb.found() and libfprint_sanitizers.length() == 0
        ])
 endif
 if ('address' in libfprint_sanitizers or
    'undefined' in libfprint_sanitizers or
    'leak' in libfprint_sanitizers)
    add_test_setup('sanitizers',
        is_default: true,
        timeout_multiplier: 3,
        env: [
            'ASAN_OPTIONS=verify_asan_link_order=0',
        ])
 endif
 valgrind = find_program('valgrind', required: false)
-if valgrind.found() and libfprint_sanitizers.length() == 0
+if valgrind.found()
-    glib_share = glib_dep.get_variable(pkgconfig: 'prefix') / 'share' / glib_dep.name()
+    glib_share = glib_dep.get_pkgconfig_variable('prefix') / 'share' / glib_dep.name()
    glib_suppressions = glib_share + '/valgrind/glib.supp'
-    libfprint_suppressions = files('libfprint.supp')[0]
+    libfprint_suppressions = '@0@/@1@'.format(meson.project_source_root(),
-    python_suppressions = files('valgrind-python.supp')[0]
+        files('libfprint.supp')[0])
-
+    python_suppressions = '@0@/@1@'.format(meson.project_source_root(),
-    if meson.version().version_compare('>=1.4')
+        files('valgrind-python.supp')[0])
        libfprint_suppressions = libfprint_suppressions.full_path()
        python_suppressions = python_suppressions.full_path()
    else
        libfprint_suppressions = meson.project_source_root() / '@0@'.format(libfprint_suppressions)
        python_suppressions = meson.project_source_root() / '@0@'.format(python_suppressions)
    endif
    libfprint_wrapper = [
        valgrind.full_path(),
        '--tool=memcheck',
@ -399,14 +353,11 @@ if valgrind.found() and libfprint_sanitizers.length() == 0
        '--suppressions=' + python_suppressions,
    ]
    add_test_setup('valgrind',
-        timeout_multiplier: 20,
+        timeout_multiplier: 15,
        exe_wrapper: libfprint_wrapper,
        exclude_suites: ['no-valgrind'],
        env: [
            'G_SLICE=always-malloc',
            'UNDER_VALGRIND=1',
            'FP_VIRTUAL_IMAGE_HOT_SECONDS=-1',
            'FP_VIRTUAL_DEVICE_HOT_SECONDS=-1',
            'LIBFPRINT_TEST_WRAPPER=' + ' '.join(libfprint_wrapper),
        ])
 endif
--- a/tests/realtek-5816/custom.pcapng
+++ b/tests/realtek-5816/custom.pcapng
--- a/tests/realtek-5816/custom.py
+++ b/tests/realtek-5816/custom.py
@ -1,110 +0,0 @@
 #!/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
--- a/tests/realtek-5816/device
+++ b/tests/realtek-5816/device
@ -1,250 +0,0 @@
 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
--- a/tests/realtek/custom.pcapng
+++ b/tests/realtek/custom.pcapng
--- a/tests/realtek/custom.py
+++ b/tests/realtek/custom.py
@ -1,110 +0,0 @@
 #!/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
--- a/tests/realtek/device
+++ b/tests/realtek/device
@ -1,244 +0,0 @@
 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
--- a/tests/test-fpi-assembling.c
+++ b/tests/test-fpi-assembling.c
@ -22,6 +22,7 @@
 #include <cairo.h>
 #include "fpi-assembling.h"
 #include "fpi-image.h"
 #include "test-config.h"
 typedef struct
 {
@ -66,7 +67,8 @@ test_frame_assembling (void)
  g_autoptr(FpImage) fp_img = NULL;
  GSList *frames = NULL;
-  path = g_test_build_filename (G_TEST_DIST, "vfs5011", "capture.png", NULL);
+  g_assert_false (SOURCE_ROOT == 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);
--- a/tests/test-generated-hwdb.sh
+++ b/tests/test-generated-hwdb.sh
@ -1,12 +1,13 @@
-#!/bin/sh -e
+#!/usr/bin/env bash
 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.hwdb.XXXXXX")
+    generated_rules=$(mktemp "${TMPDIR:-/tmp}/libfprint-XXXXXX.hwdb")
 else
    generated_rules=/dev/null
 fi
--- a/tests/valgrind-python.supp
+++ b/tests/valgrind-python.supp
@ -67,52 +67,3 @@
   ...
   fun:_Py*
 }
 {
   ignore__libpython_leaks
   Memcheck:Leak
   fun:malloc
   obj:/usr/lib*/libpython3*.so.*
 }
 {
   ignore__libpython_leaks
   Memcheck:Leak
   fun:malloc
   obj:/usr/lib/*/libpython3*.so.*
 }
 {
   ignore__libpython_leaks
   Memcheck:Leak
   fun:realloc
   obj:/usr/lib*/libpython3*.so.*
 }
 {
   ignore__libpython_leaks
   Memcheck:Leak
   fun:realloc
   obj:/usr/lib/*/libpython3*.so.*
 }
 {
   ignore__pygobject_possible_leaks
   Memcheck:Leak
   match-leak-kinds: possible
   ...
   obj:/usr/lib*/python*/site-packages/gi/_gi.cpython-*.so
   obj:/usr/lib*/libpython3.*.so.*
 }
 {
   ignore__pygobject_instance_leaks
   Memcheck:Leak
   match-leak-kinds: definite
   ...
   fun:g_type_create_instance
   fun:gi_info_new_full
   ...
   obj:/usr/lib*/python*/site-packages/gi/_gi.cpython-*.so
   obj:/usr/lib*/libpython3.*.so.*
 }
--- a/tests/virtual-image.py
+++ b/tests/virtual-image.py
@ -140,24 +140,6 @@ class VirtualImage(unittest.TestCase):
        while iterate and ctx.pending():
            ctx.iteration(False)
    def wait_for_finger_status(self, finger_status, timeout=5000):
        done = False
        def on_timeout_reached():
            nonlocal done
            done = True
        if 'UNDER_VALGRIND' in os.environ:
            timeout = timeout * 3
        source = GLib.timeout_add(timeout, on_timeout_reached)
        while not done:
            if self.dev.get_finger_status() & finger_status:
                GLib.source_remove(source)
                return
            ctx.iteration(True)
        self.assertFalse(done)
    def test_features(self):
        self.assertTrue(self.dev.has_feature(FPrint.DeviceFeature.CAPTURE))
        self.assertTrue(self.dev.has_feature(FPrint.DeviceFeature.IDENTIFY))
@ -222,7 +204,6 @@ class VirtualImage(unittest.TestCase):
        self.dev.enroll(template, None, progress_cb, tuple(), done_cb)
        # Note: Assumes 5 enroll steps for this device!
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image(image)
        while self._step < 1:
            ctx.iteration(True)
@ -281,7 +262,6 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl, callback=verify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('whorl')
        while self._verify_match is None:
            ctx.iteration(True)
@ -291,7 +271,6 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl, callback=verify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('tented_arch')
        while self._verify_match is None:
            ctx.iteration(True)
@ -305,7 +284,6 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl_tended_arch, callback=verify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('whorl')
        while self._verify_match is None:
            ctx.iteration(True)
@ -315,7 +293,6 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl_tended_arch, callback=verify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('tented_arch')
        while self._verify_match is None:
            ctx.iteration(True)
@ -325,7 +302,6 @@ class VirtualImage(unittest.TestCase):
        self._verify_fp = None
        self._verify_error = None
        self.dev.verify(fp_whorl, callback=verify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_retry()
        while self._verify_fp is None and self._verify_error is None:
            ctx.iteration(True)
@ -335,7 +311,6 @@ class VirtualImage(unittest.TestCase):
        self._verify_fp = None
        self._verify_error = None
        self.dev.verify(fp_whorl, callback=verify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_error()
        while self._verify_fp is None and self._verify_error is None:
            ctx.iteration(True)
@ -359,7 +334,6 @@ class VirtualImage(unittest.TestCase):
        self._identify_fp = None
        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('tented_arch')
        while self._identify_fp is None:
            ctx.iteration(True)
@ -367,7 +341,6 @@ class VirtualImage(unittest.TestCase):
        self._identify_fp = None
        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('whorl')
        while self._identify_fp is None:
            ctx.iteration(True)
@ -377,7 +350,6 @@ class VirtualImage(unittest.TestCase):
        self._identify_fp = None
        self._identify_error = None
        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_retry()
        while self._identify_fp is None and self._identify_error is None:
            ctx.iteration(True)
@ -421,7 +393,6 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl_new, callback=verify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('whorl')
        while self._verify_match is None:
            ctx.iteration(True)
@ -430,7 +401,6 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl_new, callback=verify_cb)
        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('tented_arch')
        while self._verify_match is None:
            ctx.iteration(True)
`@ -1,2 +1,2 @@`
	`variables:`	`variables:`
	`LIBFPRINT_IMAGE_TAG: v6`	`LIBFPRINT_IMAGE_TAG: v3`
		`@ -1 +0,0 @@`
			`gcov-ignore-parse-errors = suspicious_hits.warn`