list-supported: Relativate "support" statement for website

The website suggest that the devices are "supported", however, it is not clear what this means and can be read to imply that all of the devices are expected to work well and upstream will fix issues. Unfortunately, that is not really the case for all drivers. As such, add a statement that the quality and supportability of drivers varies widely.
sdcp-device: Use a key DB for testing
2026-09-10 13:00:08 +00:00 · 2021-03-08 12:34:41 +01:00 · 2021-02-18 12:28:19 +01:00 · 2021-02-18 12:28:19 +01:00 · 2021-02-18 12:28:19 +01:00 · 2021-02-18 12:28:19 +01:00
189 changed files with 24346 additions and 4756 deletions
@@ -0,0 +1,10 @@
+# The commits that did automated reformatting. You can ignore them
+# during git-blame with `--ignore-rev` or `--ignore-revs-file`.
+#
+#   $ git config --add 'blame.ignoreRevsFile' '.git-blame-ignore-revs'
+#
+
+d1fb1e26f3b79e54febc94496c1184763cf2af3d
+e4f9935706be4c0e3253afe251c182019ff7ccef
+65e602d8c72baa7020efb62d10bf28e621feb05d
+4115ae7ced77d392ee11ea55212206d9404356f0
@@ -1,24 +1,3 @@
-ltmain.sh
-missing
-stamp-h1
-libtool
-*.la
-*.lo
 *.o
 *.swp
-Makefile
-Makefile.in
-config.h*
-aclocal.m4
-autom4te.cache
-config.guess
-config.log
-config.status
-config.sub
-configure
-depcomp
-install-sh
-.deps
-.libs
-compile
-ChangeLog
+_build
@@ -1,89 +1,165 @@
-image: fedora:rawhide
-stages:
-  - build
-  - test
-  - flatpack
+include:
+  - local: '.gitlab-ci/libfprint-templates.yaml'
+  - project: 'wayland/ci-templates'
+    ref: master
+    file: '/templates/fedora.yml'
+  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/master/flatpak/flatpak_ci_initiative.yml'

 variables:
-  DEPENDENCIES: libgusb-devel glib2-devel nss-devel pixman-devel systemd meson gtk-doc
-                gcc gcc-c++ glibc-devel libX11-devel libXv-devel gtk3-devel flatpak-builder
-                gobject-introspection-devel python3-cairo python3-gobject umockdev
+  extends: .libfprint_common_variables
+  FDO_DISTRIBUTION_TAG: latest
+  FDO_DISTRIBUTION_VERSION: rawhide
+  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"

+stages:
+  - check-source
+  - build
+  - test
+  - flatpak
+
+image: "$FEDORA_IMAGE"
+
 .build_one_driver_template: &build_one_driver
  script:
-    - dnf update -y --nogpgcheck && dnf install -y --nogpgcheck $DEPENDENCIES
    # Build with a driver that doesn't need imaging, or nss
-    - meson -Ddrivers=$driver . _build
+    - meson --werror -Ddrivers=$driver . _build
    - ninja -C _build
    - rm -rf _build/

 .build_template: &build
  script:
-    - dnf update -y --nogpgcheck && dnf install -y --nogpgcheck $DEPENDENCIES
    # And build with everything
-    - meson -Ddrivers=all . _build
+    - meson --werror -Ddrivers=all . _build
    - ninja -C _build
    - ninja -C _build install

 .build_template: &check_abi
  script:
-    - dnf update -y --nogpgcheck && dnf install -y --nogpgcheck $DEPENDENCIES doxygen libabigail git
    - ./.ci/check-abi ${LAST_ABI_BREAK} $(git rev-parse HEAD)

 build:
  stage: build
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
  variables:
    driver: virtual_image
  <<: *build_one_driver
  <<: *build
 #  <<: *check_abi
+  artifacts:
+    expose_as: "HTML Documentation"
+    paths:
+    - _build/doc/html/
+    expire_in: 1 week

 test:
  stage: test
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
  script:
-    - dnf update -y --nogpgcheck && dnf install -y --nogpgcheck $DEPENDENCIES
-    - meson -Ddrivers=all . _build
+    - meson --werror -Ddrivers=all -Db_coverage=true -Dsdcp_virt_binary=/usr/local/bin/sdcp_virt_device . _build
    - ninja -C _build
-    - meson test -C _build --verbose --no-stdsplit
+    - meson test -C _build --verbose --no-stdsplit --timeout-multiplier 3
+    - ninja -C _build coverage
+    - cat _build/meson-logs/coverage.txt
+  artifacts:
+    paths:
+      - _build/meson-logs
+    expire_in: 1 week
+  coverage: '/^TOTAL.*\s+(\d+\%)$/'
+
+test_valgrind:
+  stage: test
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
+  script:
+    - meson -Ddrivers=all -Dsdcp_virt_binary=/usr/local/bin/sdcp_virt_device . _build
+    - ninja -C _build
+    - meson test -C _build --verbose --no-stdsplit --setup=valgrind
+
+test_scan_build:
+  stage: test
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
+  allow_failure: true
+  script:
+    - meson -Ddrivers=all . _build
+    # This is ugly, the wrapper disables the malloc checker
+    - SCANBUILD=$CI_PROJECT_DIR/.gitlab-ci/scan-build ninja -C _build scan-build
+    # Check that the directory is empty
+    - "! ls -A _build/meson-logs/scanbuild | grep -q ."
+  artifacts:
+    paths:
+      - _build/meson-logs
+    expire_in: 1 week

 test_indent:
-  stage: test
-  script:
-    - dnf update -y --nogpgcheck && dnf install -y --nogpgcheck git uncrustify
-    - scripts/uncrustify.sh --check
-
-.flatpak_script_template: &flatpak_script
-    script:
-        - flatpak-builder --stop-at=${FLATPAK_MODULE} app ${MANIFEST_PATH}
-        # Make sure to keep this in sync with the Flatpak manifest, all arguments
-        # are passed except the config-args because we build it ourselves
-        - flatpak build app meson --prefix=/app --libdir=lib ${MESON_ARGS} _build
-        - flatpak build app ninja -C _build install
-        - flatpak build app rm -rf /app/include/ /app/lib/pkgconfig/
-        - flatpak-builder --finish-only --repo=repo app ${MANIFEST_PATH}
-        # Generate a Flatpak bundle
-        - flatpak build-bundle repo ${BUNDLE} --runtime-repo=${RUNTIME_REPO} ${DBUS_ID}
-
-.flatpak_artifacts_template: &flatpak_artifacts
-    artifacts:
-        paths:
-            - ${BUNDLE}
-        when: always
-        expire_in: 30 days
-
-.flatpak_template: &flatpak
-    <<: *flatpak_script
-    <<: *flatpak_artifacts
-
-flatpak master:
-    image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:3.32
-    stage: flatpack
+  stage: check-source
+  except:
    variables:
-        MANIFEST_PATH: "demo/org.freedesktop.libfprint.Demo.json"
-        # From demo/org.freedesktop.libfprint.Demo.json
-        MESON_ARGS: "-Dudev_rules=false -Dx11-examples=false -Dgtk-examples=true"
-        FLATPAK_MODULE: "libfprint"
-        DBUS_ID: "org.freedesktop.libfprint.Demo"
-    <<: *flatpak
+      - $CI_PIPELINE_SOURCE == "schedule"
+  script:
+    - scripts/uncrustify.sh
+    - git diff
+    - "! git status -s | grep -q ."
+
+test_unsupported_list:
+  stage: check-source
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
+  allow_failure: true
+  script:
+    - tests/hwdb-check-unsupported.py
+
+flatpak:
+  stage: flatpak
+  extends: .flatpak
+  image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:3.36
+  variables:
+    MANIFEST_PATH: "demo/org.freedesktop.libfprint.Demo.json"
+    FLATPAK_MODULE: "libfprint"
+    APP_ID: "org.freedesktop.libfprint.Demo"
+  rules:
+    - if: '$CI_PROJECT_PATH != "libfprint/libfprint"'
+      when: never
+    - if: '$CI_PIPELINE_SOURCE == "schedule"'
+      when: never
+    - if: '$CI_COMMIT_BRANCH == "master"'
+      when: always
+    - if: '$CI_COMMIT_TAG'
+      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
+
+# CONTAINERS creation stage
+container_fedora_build:
+  extends: .fdo.container-build@fedora
+  only:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
+  variables:
+    GIT_STRATEGY: none # no need to pull the whole tree for rebuilding the image
+    # a list of packages to install; we only include mbedtls here
+    FDO_DISTRIBUTION_PACKAGES: $LIBFPRINT_DEPENDENCIES mbedtls-devel
+    FDO_DISTRIBUTION_EXEC: |
+      cd /tmp
+      mkdir -p /usr/local/bin
+      git clone https://github.com/benzea/SecureDeviceConnectionProtocol.git
+      # Don't bother with cmake
+      gcc -l mbedcrypto -I SecureDeviceConnectionProtocol/src/include \
+        SecureDeviceConnectionProtocol/src/test/virt_device.c \
+        SecureDeviceConnectionProtocol/src/client/client.c \
+        SecureDeviceConnectionProtocol/src/test/helpers.c \
+        SecureDeviceConnectionProtocol/src/test/testkeys.c \
+        -o /usr/local/bin/sdcp_virt_device
+      rm -rf SecureDeviceConnectionProtocol
@@ -0,0 +1,27 @@
+.libfprint_common_variables:
+  LIBFPRINT_DEPENDENCIES:
+    doxygen
+    flatpak-builder
+    gcc
+    gcc-c++
+    gcovr
+    git
+    glib2-devel
+    glibc-devel
+    gobject-introspection-devel
+    gtk-doc
+    gtk3-devel
+    libabigail
+    libgusb-devel
+    libX11-devel
+    libXv-devel
+    meson
+    nss-devel
+    pixman-devel
+    python3-cairo
+    python3-gobject
+    systemd
+    umockdev
+    uncrustify
+    valgrind
+    clang-analyzer
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+# This wrapper just disables the malloc checker
+exec /usr/bin/scan-build -disable-checker unix.Malloc "$@"
@@ -0,0 +1,13 @@
+Current maintainers of libfprint are:
+
+ * Benjamin Berg <bberg@redhat.com>
+ * Marco Trevisan (Treviño) <mail@3v1n0.net>
+
+Many drivers are not actively maintained and may not be fully functional.
+We are happy to receive contributions, but the support we can give is
+limitted unfortunately. For many drivers we may not even have test devices.
+
+Maintained drivers are:
+ * synaptics:
+   Contributed and maintained by Synaptics Inc.
+   Contact: Vincent Huang <vincent.huang@tw.synaptics.com>
@@ -1,6 +1,129 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.

+2020-12-01: v1.90.7 release
+
+Highlights:
+ * vfs5011: Fix possible use-after-free
+ * goodixmoc: Add two new PIDs (0x63AC, 0x639C)
+ * goodixmoc: Support finger status API
+ * synaptics: Only identify within provided prints
+ * synaptics: Reject devices with old firmware during probe (#239)
+
+
+2020-12-01: v1.90.6 release
+
+This release is primarily a bugfix release for some older issues.
+
+The major change is that fp_print_deserialize will now correctly return a
+sunken reference rather than a floating one. Most API users will have
+assumed this was true, and issues could happen at a later point.
+If any API user worked around this libfprint bug, they will now leak the
+returned print.
+
+Highlights:
+ * Object reference management fixes for FpPrint and identify
+ * Fixed issues that caused problem on non-x86 machines (#236)
+ * Fix building with older GLib versions
+ * synaptics: Support PID 00e7
+ * goodix: Fix issue with long USB packages
+
+
+2020-12-01: v1.90.5 release
+
+The 1.90.4 release caused a major regression, as it included a USB hub in
+UDEV the autosupend rule list.
+
+Highlights:
+ * Remove USB hub from udev autosupend rules
+ * synaptics: Add PID 0x00c9 which is used in some HP laptops
+
+
+2020-11-27: v1.90.4 release
+
+This release contains a number of important bugfixes. On the feature side,
+the USB hotplug support was improved. A lot of drivers received fixes and
+improvements.
+
+Highlights:
+ * Work around GUsb cancellation issue
+ * Redefine internal image device state machine for more robustness
+ * Add public finger-status reporting to FpDevice
+ * Rework device removal API to be convenient (#330)
+ * Enable powersave for unsupported USB devices
+ * Improvements to examples
+ * synaptics: Support identify operation
+ * synaptics: Fix possible crash when the interrupt transfer is resubmitted
+ * synaptics: Add support for PIDs 0x00f9, 0x00fc and 0x00c2
+ * elan: Add PID 0x0c4d to supported device list
+ * aes3k: Fix driver and add CI test (#306)
+ * uru4000: Fix reference counting of image transfer
+ * vfs301: Fix driver and add CI test (#320)
+
+2020-06-08: v1.90.3 release
+
+This release mostly contains support for a number of new match-on-chip
+devices. Most notable is the addition of the new goodixmoc driver.
+Currently the driver has the small caveat that we have no strategy to
+garbage collect old prints yet (a simple strategy could be implemented
+in fprintd).
+
+Highlights:
+ * New goodixmoc driver supporting Goodix USB devices:
+   27C6:5840
+   27C6:6496
+   27C6:60A2
+ * Newly added support for Synaptics device:
+   06CB:00E9
+   06CB:00DF
+ * Fixed an issue with Synaptics devices sometimes not working at boot
+ * Fix issue with aes3k driver (#306)
+
+2020-06-08: v1.90.2 release
+
+This release contains a large amount of bug and regression fixes. These
+are not listed explicitly, but affect the majority of drivers.
+
+Highlights:
+ * A patch for nbis required for some sensors was accidentally dropped in
+   an earlier release. Users of these sensors/drivers (aes1610, aes2501,
+   aes2550, aes1660, aes2660, elan, upektc_img) need to re-enroll (#142).
+
+2019-11-20: v1.90.1 release
+
+This release fixes a lot of the regressions introduced in 1.90.0. Please note
+that both the driver and external APIs have changed, as both the verify and
+the identify functions now have early reporting mechanisms.
+The soname for the library, as well as a number of file locations have also
+changed. While this allows installation in parallel with the 1.0 version of
+libfprint, we recommend installing only one, and migrating from version 1.0 to
+version 2.0 alongside its main consumer (fprintd).
+
+Only major changes are listed below. A lot of other cleanup work and small
+fixes have also been merged.
+
+* Library:
+  - Add support to run tests in gdb/valgrind
+  - Allow testing on all architectures
+  - Avoid image device AWAIT_FINGER_ON to deactivate state transitions
+  - Fix verify/identify error propagation to library user
+  - Correctly read image device information from class data
+  - Continue enroll after an image driver reported a retry error
+  - Change external API to allow reporting match results early
+  - A lot of new unit tests and integration tests have been added
+
+* Drivers API
+  - Support variadic arguments in error functions
+  - Various re-definitions of ownership handling
+  - Add convenience API to change state after a timeout
+  - Add unit tests for all the drivers API
+
+* Drivers:
+  - elan: Ensure correct deactivation of device
+  - uru4000: Fix IRQ handler registration and internal state handling
+  - uru4000: Fix control transfer request type
+  - synaptics: Ensure errors are only reported after finger removal
+
 2019-11-20: v1.90.0 release

 This release updates the core of the library to use GLib routines and Gio
@@ -0,0 +1,264 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# This file has been generated using fprint-list-udev-hwdb with all drivers enabled
+
+# Supported by libfprint driver aes1610
+usb:v08FFp1600*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver aes1660
+usb:v08FFp1660*
+usb:v08FFp1680*
+usb:v08FFp1681*
+usb:v08FFp1682*
+usb:v08FFp1683*
+usb:v08FFp1684*
+usb:v08FFp1685*
+usb:v08FFp1686*
+usb:v08FFp1687*
+usb:v08FFp1688*
+usb:v08FFp1689*
+usb:v08FFp168A*
+usb:v08FFp168B*
+usb:v08FFp168C*
+usb:v08FFp168D*
+usb:v08FFp168E*
+usb:v08FFp168F*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver aes2501
+usb:v08FFp2500*
+usb:v08FFp2580*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver aes2550
+usb:v08FFp2550*
+usb:v08FFp2810*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver aes2660
+usb:v08FFp2660*
+usb:v08FFp2680*
+usb:v08FFp2681*
+usb:v08FFp2682*
+usb:v08FFp2683*
+usb:v08FFp2684*
+usb:v08FFp2685*
+usb:v08FFp2686*
+usb:v08FFp2687*
+usb:v08FFp2688*
+usb:v08FFp2689*
+usb:v08FFp268A*
+usb:v08FFp268B*
+usb:v08FFp268C*
+usb:v08FFp268D*
+usb:v08FFp268E*
+usb:v08FFp268F*
+usb:v08FFp2691*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver aes3500
+usb:v08FFp5731*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver aes4000
+usb:v5501p08FF*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver elan
+usb:v04F3p0903*
+usb:v04F3p0907*
+usb:v04F3p0C01*
+usb:v04F3p0C02*
+usb:v04F3p0C03*
+usb:v04F3p0C04*
+usb:v04F3p0C05*
+usb:v04F3p0C06*
+usb:v04F3p0C07*
+usb:v04F3p0C08*
+usb:v04F3p0C09*
+usb:v04F3p0C0A*
+usb:v04F3p0C0B*
+usb:v04F3p0C0C*
+usb:v04F3p0C0D*
+usb:v04F3p0C0E*
+usb:v04F3p0C0F*
+usb:v04F3p0C10*
+usb:v04F3p0C11*
+usb:v04F3p0C12*
+usb:v04F3p0C13*
+usb:v04F3p0C14*
+usb:v04F3p0C15*
+usb:v04F3p0C16*
+usb:v04F3p0C17*
+usb:v04F3p0C18*
+usb:v04F3p0C19*
+usb:v04F3p0C1A*
+usb:v04F3p0C1B*
+usb:v04F3p0C1C*
+usb:v04F3p0C1D*
+usb:v04F3p0C1E*
+usb:v04F3p0C1F*
+usb:v04F3p0C20*
+usb:v04F3p0C21*
+usb:v04F3p0C22*
+usb:v04F3p0C23*
+usb:v04F3p0C24*
+usb:v04F3p0C25*
+usb:v04F3p0C26*
+usb:v04F3p0C27*
+usb:v04F3p0C28*
+usb:v04F3p0C29*
+usb:v04F3p0C2A*
+usb:v04F3p0C2B*
+usb:v04F3p0C2C*
+usb:v04F3p0C2D*
+usb:v04F3p0C2E*
+usb:v04F3p0C2F*
+usb:v04F3p0C30*
+usb:v04F3p0C31*
+usb:v04F3p0C32*
+usb:v04F3p0C33*
+usb:v04F3p0C42*
+usb:v04F3p0C4D*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver etes603
+usb:v1C7Ap0603*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver goodixmoc
+usb:v27C6p5840*
+usb:v27C6p6496*
+usb:v27C6p60A2*
+usb:v27C6p63AC*
+usb:v27C6p639C*
+usb:v27C6p6594*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver synaptics
+usb:v06CBp00BD*
+usb:v06CBp00E9*
+usb:v06CBp00DF*
+usb:v06CBp00F9*
+usb:v06CBp00FC*
+usb:v06CBp00C2*
+usb:v06CBp00C9*
+usb:v06CBp00E7*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver upeksonly
+usb:v147Ep2016*
+usb:v147Ep1000*
+usb:v147Ep1001*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver upektc
+usb:v0483p2015*
+usb:v147Ep3001*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver upektc_img
+usb:v147Ep2020*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver uru4000
+usb:v045Ep00BC*
+usb:v045Ep00BD*
+usb:v045Ep00CA*
+usb:v05BAp0007*
+usb:v05BAp0008*
+usb:v05BAp000A*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver vcom5s
+usb:v061Ap0110*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver vfs0050
+usb:v138Ap0050*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver vfs101
+usb:v138Ap0001*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver vfs301
+usb:v138Ap0005*
+usb:v138Ap0008*
+ ID_AUTOSUSPEND=1
+
+# Supported by libfprint driver vfs5011
+usb:v138Ap0010*
+usb:v138Ap0011*
+usb:v138Ap0015*
+usb:v138Ap0017*
+usb:v138Ap0018*
+ ID_AUTOSUSPEND=1
+
+# Known unsupported devices
+usb:v04F3p036B*
+usb:v04F3p0C00*
+usb:v04F3p0C4B*
+usb:v04F3p0C4C*
+usb:v04F3p0C4F*
+usb:v04F3p0C57*
+usb:v04F3p2706*
+usb:v06CBp0081*
+usb:v06CBp0088*
+usb:v06CBp008A*
+usb:v06CBp009A*
+usb:v06CBp009B*
+usb:v06CBp00A2*
+usb:v06CBp00B7*
+usb:v06CBp00BB*
+usb:v06CBp00BE*
+usb:v06CBp00CB*
+usb:v06CBp00D8*
+usb:v06CBp00DA*
+usb:v0A5Cp5801*
+usb:v0A5Cp5805*
+usb:v0A5Cp5834*
+usb:v0A5Cp5843*
+usb:v10A5p0007*
+usb:v1188p9545*
+usb:v138Ap0007*
+usb:v138Ap003A*
+usb:v138Ap003C*
+usb:v138Ap003D*
+usb:v138Ap003F*
+usb:v138Ap0090*
+usb:v138Ap0091*
+usb:v138Ap0092*
+usb:v138Ap0094*
+usb:v138Ap0097*
+usb:v138Ap009D*
+usb:v138Ap00AB*
+usb:v147Ep1002*
+usb:v1491p0088*
+usb:v16D1p1027*
+usb:v1C7Ap0300*
+usb:v1C7Ap0570*
+usb:v1C7Ap0575*
+usb:v27C6p5042*
+usb:v27C6p5110*
+usb:v27C6p5117*
+usb:v27C6p5201*
+usb:v27C6p521D*
+usb:v27C6p5301*
+usb:v27C6p530C*
+usb:v27C6p532D*
+usb:v27C6p533C*
+usb:v27C6p5381*
+usb:v27C6p5385*
+usb:v27C6p538C*
+usb:v27C6p538D*
+usb:v27C6p5395*
+usb:v27C6p5584*
+usb:v27C6p55A2*
+usb:v27C6p55A4*
+usb:v27C6p55B4*
+usb:v27C6p5740*
+usb:v2808p9338*
+usb:v298Dp2033*
+usb:v3538p0930*
+ ID_AUTOSUSPEND=1
@@ -0,0 +1,9 @@
+if get_option('udev_rules')
+    # This file has to be updated using
+    # ninja -C <builddir> libfprint/sync-udev-hwdb
+
+    install_data('autosuspend.hwdb',
+        rename: '60-autosuspend-@0@.hwdb'.format(versioned_libname),
+        install_dir: udev_hwdb_dir,
+    )
+endif
@@ -22,9 +22,11 @@
 #include <gtk/gtk.h>
 #include <libfprint/fprint.h>

-typedef GtkApplication      LibfprintDemo;
-typedef GtkApplicationClass LibfprintDemoClass;
-
+struct _LibfprintDemo
+{
+  GtkApplication parent;
+};
+G_DECLARE_FINAL_TYPE (LibfprintDemo, libfprint_demo, FP, DEMO, GtkApplication)
 G_DEFINE_TYPE (LibfprintDemo, libfprint_demo, GTK_TYPE_APPLICATION)

 typedef enum {
@@ -33,7 +35,7 @@ typedef enum {
  IMAGE_DISPLAY_BINARY   =  1 << 1
 } ImageDisplayFlags;

-typedef struct
+struct _LibfprintDemoWindow
 {
  GtkApplicationWindow parent_instance;

@@ -52,10 +54,9 @@ typedef struct

  FpImage             *img;
  ImageDisplayFlags    img_flags;
-} LibfprintDemoWindow;
-
-typedef GtkApplicationWindowClass LibfprintDemoWindowClass;
+};

+G_DECLARE_FINAL_TYPE (LibfprintDemoWindow, libfprint_demo_window, FP, DEMO_WINDOW, GtkApplicationWindow)
 G_DEFINE_TYPE (LibfprintDemoWindow, libfprint_demo_window, GTK_TYPE_APPLICATION_WINDOW)

 typedef enum {
@@ -240,6 +241,8 @@ dev_capture_start_cb (FpDevice     *dev,
      if (error->domain == FP_DEVICE_RETRY ||
          g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        libfprint_demo_set_mode (win, RETRY_MODE);
+      else if (g_error_matches (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_NOT_SUPPORTED))
+        libfprint_demo_set_mode (win, NOIMAGING_MODE);
      else
        libfprint_demo_set_mode (win, ERROR_MODE);
      return;
@@ -1,21 +1,21 @@
-gtk_test_resources = gnome.compile_resources('gtk-test-resources', 'gtk-libfprint-test.gresource.xml',
-                                             source_dir : '.',
-                                             c_name : 'gtk_test')
+gtk_test_resources = gnome.compile_resources('gtk-test-resources',
+    'gtk-libfprint-test.gresource.xml',
+    source_dir : '.',
+    c_name : 'gtk_test')

 prefix = get_option('prefix')
 bindir = join_paths(prefix, get_option('bindir'))
 datadir = join_paths(prefix, get_option('datadir'))

 executable('gtk-libfprint-test',
-           [ 'gtk-libfprint-test.c', gtk_test_resources ],
-           dependencies: [ libfprint_dep, gtk_dep ],
-           include_directories: [
-             root_inc,
-           ],
-           c_args: [ common_cflags,
-                     '-DPACKAGE_VERSION="' + meson.project_version() + '"' ],
-           install: true,
-           install_dir: bindir)
+    [ 'gtk-libfprint-test.c', gtk_test_resources ],
+    dependencies: [
+        gtk_dep,
+        libfprint_dep,
+    ],
+    c_args: '-DPACKAGE_VERSION="' + meson.project_version() + '"',
+    install: true,
+    install_dir: bindir)

 appdata = 'org.freedesktop.libfprint.Demo.appdata.xml'
 install_data(appdata,
@@ -1,7 +1,7 @@
 {
    "app-id": "org.freedesktop.libfprint.Demo",
    "runtime": "org.gnome.Platform",
-    "runtime-version": "3.32",
+    "runtime-version": "3.36",
    "sdk": "org.gnome.Sdk",
    "command": "gtk-libfprint-test",
    "finish-args": [
@@ -26,6 +26,7 @@ FpDeviceError
 fp_device_retry_quark
 fp_device_error_quark
 FpEnrollProgress
+FpMatchCb
 fp_device_get_driver
 fp_device_get_device_id
 fp_device_get_name
@@ -84,14 +85,18 @@ FP_TYPE_IMAGE_DEVICE
 FpImageDevice
 </SECTION>

+<SECTION>
+<FILE>fp-sdcp-device</FILE>
+FP_TYPE_SDCP_DEVICE
+FpSdcpDevice
+</SECTION>
+
 <SECTION>
 <FILE>fp-print</FILE>
 FP_TYPE_PRINT
 FpFinger
 FpPrint
 fp_print_new
-fp_print_new_from_data
-fp_print_to_data
 fp_print_get_driver
 fp_print_get_device_id
 fp_print_get_device_stored
@@ -129,7 +134,7 @@ fpi_get_driver_types
 <FILE>fpi-device</FILE>
 FpDeviceClass
 FpTimeoutFunc
-FpDeviceAction
+FpiDeviceAction
 FpIdEntry
 fpi_device_get_usb_device
 fpi_device_get_virtual_env
@@ -159,6 +164,8 @@ fpi_device_identify_complete
 fpi_device_capture_complete
 fpi_device_delete_complete
 fpi_device_enroll_progress
+fpi_device_verify_report
+fpi_device_identify_report
 </SECTION>

 <SECTION>
@@ -172,8 +179,8 @@ fpi_image_resize

 <SECTION>
 <FILE>fpi-image-device</FILE>
-<TITLE>FpImageDevice</TITLE>
-FpImageDeviceState
+<TITLE>Internal FpImageDevice</TITLE>
+FpiImageDeviceState
 FpImageDeviceClass
 fpi_image_device_session_error
 fpi_image_device_open_complete
@@ -185,6 +192,26 @@ fpi_image_device_image_captured
 fpi_image_device_retry_scan
 </SECTION>

+<SECTION>
+<FILE>fpi-sdcp-device</FILE>
+<TITLE>Internal FpSdcpDevice</TITLE>
+FpiSdcpClaim
+FpSdcpDeviceClass
+fpi_sdcp_claim_copy
+fpi_sdcp_claim_free
+fpi_sdcp_claim_get_type
+fpi_sdcp_claim_new
+fpi_sdcp_device_connect_complete
+fpi_sdcp_device_get_connect_data
+fpi_sdcp_device_get_reconnect_data
+fpi_sdcp_device_reconnect_complete
+fpi_sdcp_device_enroll_commit_complete
+fpi_sdcp_device_enroll_ready
+fpi_sdcp_device_enroll_set_nonce
+fpi_sdcp_device_identify_retry
+fpi_sdcp_device_identify_complete
+</SECTION>
+
 <SECTION>
 <FILE>fpi-log</FILE>
 fp_dbg
@@ -197,13 +224,15 @@ BUG

 <SECTION>
 <FILE>fpi-print</FILE>
-FpPrintType
+FpiPrintType
 FpiMatchResult
 fpi_print_add_print
 fpi_print_set_type
 fpi_print_set_device_stored
 fpi_print_add_from_image
 fpi_print_bz3_match
+fpi_print_generate_user_id
+fpi_print_fill_from_user_id
 </SECTION>

 <SECTION>
@@ -211,11 +240,15 @@ fpi_print_bz3_match
 FpiSsmCompletedCallback
 FpiSsmHandlerCallback
 fpi_ssm_new
+fpi_ssm_new_full
 fpi_ssm_free
 fpi_ssm_start
 fpi_ssm_start_subsm
 fpi_ssm_next_state
+fpi_ssm_next_state_delayed
 fpi_ssm_jump_to_state
+fpi_ssm_jump_to_state_delayed
+fpi_ssm_cancel_delayed_state_change
 fpi_ssm_mark_completed
 fpi_ssm_mark_failed
 fpi_ssm_set_data
@@ -28,6 +28,7 @@
    <xi:include href="xml/fp-context.xml"/>
    <xi:include href="xml/fp-device.xml"/>
    <xi:include href="xml/fp-image-device.xml"/>
+    <xi:include href="xml/fp-sdcp-device.xml"/>
    <xi:include href="xml/fp-print.xml"/>
    <xi:include href="xml/fp-image.xml"/>
  </part>
@@ -38,6 +39,7 @@
      <title>Device methods for drivers</title>
      <xi:include href="xml/fpi-device.xml"/>
      <xi:include href="xml/fpi-image-device.xml"/>
+      <xi:include href="xml/fpi-sdcp-device.xml"/>
    </chapter>

    <chapter id="driver-helpers">
@@ -90,7 +90,7 @@ fp_image_get_width
 <TITLE>Base class for image devices</TITLE>
 FpImageDevice
 FpImageDeviceClass
-FpImageDeviceState
+FpiImageDeviceState
 </SECTION>

 <SECTION>
@@ -114,5 +114,3 @@ FpUsbTransferCallback
 FP_USB_ENDPOINT_IN
 FP_USB_ENDPOINT_OUT
 </SECTION>
-
-
@@ -1,14 +1,13 @@
 subdir('xml')

 private_headers = [
-  'config.h',
-  'nbis-helpers.h',
-  'fprint.h',
-  'fp_internal.h',
+    'config.h',
+    'nbis-helpers.h',
+    'fprint.h',

-  # Subdirectories to ignore
-  'drivers',
-  'nbis',
+    # Subdirectories to ignore
+    'drivers',
+    'nbis',
 ]

 html_images = [
@@ -24,21 +23,17 @@ 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')

-gnome.gtkdoc('libfprint',
-             main_xml: 'libfprint-docs.xml',
-             src_dir: join_paths(meson.source_root(), 'libfprint'),
-             dependencies: libfprint_dep,
-             content_files: content_files,
-             expand_content_files: expand_content_files,
-             scan_args: [
-               #'--rebuild-sections',
-               '--ignore-decorators=API_EXPORTED',
-               '--ignore-headers=' + ' '.join(private_headers),
-             ],
-             fixxref_args: [
-               '--html-dir=@0@'.format(docpath),
-               '--extra-dir=@0@'.format(join_paths(glib_docpath, 'glib')),
-               '--extra-dir=@0@'.format(join_paths(glib_docpath, 'gobject')),
-             ],
-             html_assets: html_images,
-             install: true)
+gnome.gtkdoc(versioned_libname,
+    main_xml: 'libfprint-docs.xml',
+    src_dir: join_paths(meson.source_root(), 'libfprint'),
+    dependencies: libfprint_dep,
+    content_files: content_files,
+    expand_content_files: expand_content_files,
+    ignore_headers: private_headers,
+    fixxref_args: [
+        '--html-dir=@0@'.format(docpath),
+        '--extra-dir=@0@'.format(join_paths(glib_docpath, 'glib')),
+        '--extra-dir=@0@'.format(join_paths(glib_docpath, 'gobject')),
+    ],
+    html_assets: html_images,
+    install: true)
@@ -1,10 +1,12 @@
 ent_conf = configuration_data()
-ent_conf.set('PACKAGE', 'libfprint')
+ent_conf.set('PACKAGE', versioned_libname)
 ent_conf.set('PACKAGE_BUGREPORT', 'https://gitlab.freedesktop.org/libfprint/libfprint/issues')
-ent_conf.set('PACKAGE_NAME', 'libfprint')
-ent_conf.set('PACKAGE_STRING', 'libfprint')
+ent_conf.set('PACKAGE_NAME', versioned_libname)
+ent_conf.set('PACKAGE_STRING', versioned_libname)
 ent_conf.set('PACKAGE_TARNAME', 'libfprint-' + meson.project_version())
 ent_conf.set('PACKAGE_URL', 'https://fprint.freedesktop.org/')
 ent_conf.set('PACKAGE_VERSION', meson.project_version())
 ent_conf.set('PACKAGE_API_VERSION', '1.0')
-configure_file(input: 'gtkdocentities.ent.in', output: 'gtkdocentities.ent', configuration: ent_conf)
+configure_file(input: 'gtkdocentities.ent.in',
+    output: 'gtkdocentities.ent',
+    configuration: ent_conf)
@@ -6,10 +6,10 @@

 int main (int argc, char **argv)
 {
-	FpContext *ctx;
+  FpContext *ctx;

-	ctx = fp_context_new ();
-	g_object_unref (ctx);
+  ctx = fp_context_new ();
+  g_object_unref (ctx);

-	return 0;
+  return 0;
 }
@@ -1,6 +1,6 @@
 /*
 * Example fingerprint enrollment program
- * Enrolls your choosen finger and saves the print to disk
+ * Enrolls your chosen finger and saves the print to disk
 * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
 * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
 *
@@ -19,22 +19,29 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

+#define FP_COMPONENT "example-enroll"
+
 #include <stdio.h>
 #include <libfprint/fprint.h>
+#include <glib-unix.h>

 #include "storage.h"
 #include "utilities.h"

 typedef struct _EnrollData
 {
-  GMainLoop *loop;
-  FpFinger   finger;
-  int        ret_value;
+  GMainLoop    *loop;
+  GCancellable *cancellable;
+  unsigned int  sigint_handler;
+  FpFinger      finger;
+  int           ret_value;
 } EnrollData;

 static void
 enroll_data_free (EnrollData *enroll_data)
 {
+  g_clear_handle_id (&enroll_data->sigint_handler, g_source_remove);
+  g_clear_object (&enroll_data->cancellable);
  g_main_loop_unref (enroll_data->loop);
  g_free (enroll_data);
 }
@@ -50,7 +57,7 @@ on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
  fp_device_close_finish (dev, res, &error);

  if (error)
-    g_warning ("Failed closing device %s\n", error->message);
+    g_warning ("Failed closing device %s", error->message);

  g_main_loop_quit (enroll_data->loop);
 }
@@ -69,20 +76,24 @@ on_enroll_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
    {
      enroll_data->ret_value = EXIT_SUCCESS;

-      if (!fp_device_has_storage (dev))
+      if (fp_device_has_storage (dev))
+        g_debug ("Device has storage, saving a print reference locally");
+      else
+        g_debug ("Device has not storage, saving print only locally");
+
+      /* Even if the device has storage, it may not be able to save all the
+       * metadata that the print contains, so we can always save a local copy
+       * containing the handle to the device print */
+      int r = print_data_save (print, enroll_data->finger);
+      if (r < 0)
        {
-          g_debug ("Device has not storage, saving locally");
-          int r = print_data_save (print, enroll_data->finger);
-          if (r < 0)
-            {
-              g_warning ("Data save failed, code %d", r);
-              enroll_data->ret_value = EXIT_FAILURE;
-            }
+          g_warning ("Data save failed, code %d", r);
+          enroll_data->ret_value = EXIT_FAILURE;
        }
    }
  else
    {
-      g_warning ("Enroll failed with error %s\n", error->message);
+      g_warning ("Enroll failed with error %s", error->message);
    }

  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed,
@@ -105,7 +116,7 @@ on_enroll_progress (FpDevice *device,
      return;
    }

-  if (fp_device_supports_capture (device) &&
+  if (print && fp_print_get_image (print) &&
      print_image_save (print, "enrolled.pgm"))
    printf ("Wrote scanned image to enrolled.pgm\n");

@@ -135,11 +146,22 @@ on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
  printf ("Scan your finger now.\n");

  print_template = print_create_template (dev, enroll_data->finger);
-  fp_device_enroll (dev, print_template, NULL, on_enroll_progress, NULL,
-                    NULL, (GAsyncReadyCallback) on_enroll_completed,
+  fp_device_enroll (dev, print_template, enroll_data->cancellable,
+                    on_enroll_progress, NULL, NULL,
+                    (GAsyncReadyCallback) on_enroll_completed,
                    enroll_data);
 }

+static gboolean
+sigint_cb (void *user_data)
+{
+  EnrollData *enroll_data = user_data;
+
+  g_cancellable_cancel (enroll_data->cancellable);
+
+  return G_SOURCE_CONTINUE;
+}
+
 int
 main (void)
 {
@@ -186,8 +208,15 @@ main (void)
  enroll_data->finger = finger;
  enroll_data->ret_value = EXIT_FAILURE;
  enroll_data->loop = g_main_loop_new (NULL, FALSE);
+  enroll_data->cancellable = g_cancellable_new ();
+  enroll_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
+                                                        SIGINT,
+                                                        sigint_cb,
+                                                        enroll_data,
+                                                        NULL);

-  fp_device_open (dev, NULL, (GAsyncReadyCallback) on_device_opened,
+  fp_device_open (dev, enroll_data->cancellable,
+                  (GAsyncReadyCallback) on_device_opened,
                  enroll_data);

  g_main_loop_run (enroll_data->loop);
@@ -0,0 +1,319 @@
+/*
+ * Example fingerprint verification program, which verifies the
+ * finger which has been previously enrolled to disk.
+ * Copyright (C) 2020 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
+ */
+
+#define FP_COMPONENT "example-identify"
+
+#include <stdio.h>
+#include <libfprint/fprint.h>
+#include <glib-unix.h>
+
+#include "storage.h"
+#include "utilities.h"
+
+typedef struct _IdentifyData
+{
+  GMainLoop    *loop;
+  GCancellable *cancellable;
+  unsigned int  sigint_handler;
+  int           ret_value;
+} IdentifyData;
+
+static void
+identify_data_free (IdentifyData *identify_data)
+{
+  g_clear_handle_id (&identify_data->sigint_handler, g_source_remove);
+  g_clear_object (&identify_data->cancellable);
+  g_main_loop_unref (identify_data->loop);
+  g_free (identify_data);
+}
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (IdentifyData, identify_data_free)
+
+static void
+on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_autoptr(GError) error = NULL;
+
+  fp_device_close_finish (dev, res, &error);
+
+  if (error)
+    g_warning ("Failed closing device %s", error->message);
+
+  g_main_loop_quit (identify_data->loop);
+}
+
+static void
+identify_quit (FpDevice     *dev,
+               IdentifyData *identify_data)
+{
+  if (!fp_device_is_open (dev))
+    {
+      g_main_loop_quit (identify_data->loop);
+      return;
+    }
+
+  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed, identify_data);
+}
+
+static void start_identification (FpDevice     *dev,
+                                  IdentifyData *identify_data);
+
+static void
+on_identify_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_autoptr(FpPrint) print = NULL;
+  g_autoptr(FpPrint) match = NULL;
+  g_autoptr(GError) error = NULL;
+  char buffer[20];
+
+  if (!fp_device_identify_finish (dev, res, &match, &print, &error))
+    {
+      g_warning ("Failed to identify print: %s", error->message);
+      identify_data->ret_value = EXIT_FAILURE;
+
+      if (error->domain != FP_DEVICE_RETRY)
+        {
+          identify_quit (dev, identify_data);
+          return;
+        }
+    }
+
+  g_print ("Identify again? [Y/n]? ");
+  if (fgets (buffer, sizeof (buffer), stdin) &&
+      (buffer[0] == 'Y' || buffer[0] == 'y' || buffer[0] == '\n'))
+    {
+      start_identification (dev, identify_data);
+      return;
+    }
+
+  identify_quit (dev, identify_data);
+}
+
+static FpPrint *
+get_stored_print (FpDevice *dev, FpPrint *print)
+{
+  g_autoptr(GPtrArray) gallery = gallery_data_load (dev);
+  guint index;
+
+  if (g_ptr_array_find_with_equal_func (gallery, print,
+                                        (GEqualFunc) fp_print_equal,
+                                        &index))
+    return g_object_ref (g_ptr_array_index (gallery, index));
+
+  return NULL;
+}
+
+static void
+on_identify_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
+                gpointer user_data, GError *error)
+{
+  IdentifyData *identify_data = user_data;
+
+  if (error)
+    {
+      g_warning ("Identify report: No finger matched, retry error reported: %s",
+                 error->message);
+      return;
+    }
+
+  if (print && fp_print_get_image (print) &&
+      print_image_save (print, "identify.pgm"))
+    g_print ("Print image saved as identify.pgm\n");
+
+  if (match)
+    {
+      g_autoptr(FpPrint) matched_print = g_object_ref (match);
+      char date_str[128] = {};
+
+      identify_data->ret_value = EXIT_SUCCESS;
+
+      if (fp_print_get_device_stored (match))
+        {
+          FpPrint *stored_print = get_stored_print (dev, match);
+
+          if (stored_print)
+            matched_print = g_steal_pointer (&stored_print);
+        }
+
+      if (fp_print_get_enroll_date (matched_print))
+        g_date_strftime (date_str, G_N_ELEMENTS (date_str), "%Y-%m-%d\0",
+                         fp_print_get_enroll_date (matched_print));
+      else
+        strcpy (date_str, "<unknown>");
+
+      g_debug ("Identify report: device %s matched finger %s successfully "
+               "with print '%s', enrolled on date %s by user %s",
+               fp_device_get_name (dev),
+               finger_to_string (fp_print_get_finger (matched_print)),
+               fp_print_get_description (matched_print), date_str,
+               fp_print_get_username (matched_print));
+
+      g_print ("IDENTIFIED!\n");
+    }
+  else
+    {
+      g_debug ("Identification report: No finger matched");
+      g_print ("NOT IDENTIFIED!\n");
+    }
+}
+
+static void
+on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_autoptr(GPtrArray) gallery = NULL;
+  g_autoptr(GError) error = NULL;
+
+  gallery = fp_device_list_prints_finish (dev, res, &error);
+
+  if (!error)
+    {
+      if (!gallery->len)
+        {
+          g_warning ("No prints saved on device");
+          identify_quit (dev, identify_data);
+          return;
+        }
+
+      g_debug ("Identifying with %u prints in gallery", gallery->len);
+      fp_device_identify (dev, gallery, identify_data->cancellable,
+                          on_identify_cb, identify_data, NULL,
+                          (GAsyncReadyCallback) on_identify_completed,
+                          identify_data);
+    }
+  else
+    {
+      g_warning ("Loading prints failed with error %s", error->message);
+      identify_quit (dev, identify_data);
+    }
+}
+
+static void
+start_identification (FpDevice *dev, IdentifyData *identify_data)
+{
+  if (fp_device_has_storage (dev))
+    {
+      g_print ("Creating finger template, using device storage...\n");
+      fp_device_list_prints (dev, NULL,
+                             (GAsyncReadyCallback) on_list_completed,
+                             identify_data);
+    }
+  else
+    {
+      g_autoptr(GPtrArray) gallery = gallery_data_load (dev);
+
+      if (!gallery)
+        {
+          identify_quit (dev, identify_data);
+          return;
+        }
+
+      g_print ("Gallery loaded. Time to identify!\n");
+      fp_device_identify (dev, gallery, identify_data->cancellable,
+                          on_identify_cb, identify_data, NULL,
+                          (GAsyncReadyCallback) on_identify_completed,
+                          identify_data);
+    }
+}
+
+static void
+on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_autoptr(GError) error = NULL;
+
+  if (!fp_device_open_finish (dev, res, &error))
+    {
+      g_warning ("Failed to open device: %s", error->message);
+      identify_quit (dev, identify_data);
+      return;
+    }
+
+  g_print ("Opened device. ");
+
+  start_identification (dev, identify_data);
+}
+
+static gboolean
+sigint_cb (void *user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_cancellable_cancel (identify_data->cancellable);
+
+  return G_SOURCE_CONTINUE;
+}
+
+int
+main (void)
+{
+  g_autoptr(FpContext) ctx = NULL;
+  g_autoptr(IdentifyData) identify_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;
+    }
+
+  if (!fp_device_supports_identify (dev))
+    {
+      g_warning ("Device %s does not support identification.",
+                 fp_device_get_name (dev));
+      return EXIT_FAILURE;
+    }
+
+  identify_data = g_new0 (IdentifyData, 1);
+  identify_data->ret_value = EXIT_FAILURE;
+  identify_data->loop = g_main_loop_new (NULL, FALSE);
+  identify_data->cancellable = g_cancellable_new ();
+  identify_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
+                                                          SIGINT,
+                                                          sigint_cb,
+                                                          identify_data,
+                                                          NULL);
+  fp_device_open (dev, identify_data->cancellable,
+                  (GAsyncReadyCallback) on_device_opened,
+                  identify_data);
+
+  g_main_loop_run (identify_data->loop);
+
+  return identify_data->ret_value;
+}
@@ -0,0 +1,192 @@
+/*
+ * Example fingerprint verification program, which verifies the
+ * finger which has been previously enrolled to disk.
+ * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
+ * Copyright (C) 2020 Vasily Khoruzhick <anarsoul@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-capture"
+
+#include <stdio.h>
+#include <libfprint/fprint.h>
+#include <glib-unix.h>
+
+#include "storage.h"
+#include "utilities.h"
+
+typedef struct CaptureData
+{
+  GMainLoop    *loop;
+  GCancellable *cancellable;
+  unsigned int  sigint_handler;
+  int           ret_value;
+  const char   *filename;
+} CaptureData;
+
+static void
+capture_data_free (CaptureData *capture_data)
+{
+  g_clear_handle_id (&capture_data->sigint_handler, g_source_remove);
+  g_clear_object (&capture_data->cancellable);
+  g_main_loop_unref (capture_data->loop);
+  g_free (capture_data);
+}
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (CaptureData, capture_data_free)
+
+static void
+on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  CaptureData *capture_data = user_data;
+
+  g_autoptr(GError) error = NULL;
+
+  fp_device_close_finish (dev, res, &error);
+
+  if (error)
+    g_warning ("Failed closing device %s", error->message);
+
+  g_main_loop_quit (capture_data->loop);
+}
+
+static void
+capture_quit (FpDevice    *dev,
+              CaptureData *capture_data)
+{
+  if (!fp_device_is_open (dev))
+    {
+      g_main_loop_quit (capture_data->loop);
+      return;
+    }
+
+  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed, capture_data);
+}
+
+static void
+dev_capture_cb (FpDevice     *dev,
+                GAsyncResult *res,
+                void         *user_data)
+{
+  g_autoptr(GError) error = NULL;
+  CaptureData *capture_data = user_data;
+  FpImage *image = NULL;
+
+  g_clear_object (&capture_data->cancellable);
+
+  image = fp_device_capture_finish (dev, res, &error);
+  if (!image)
+    {
+      g_warning ("Error capturing data: %s", error->message);
+      capture_quit (dev, capture_data);
+      return;
+    }
+
+  save_image_to_pgm (image, capture_data->filename);
+
+  capture_quit (dev, capture_data);
+}
+
+static void
+start_capture (FpDevice *dev, CaptureData *capture_data)
+{
+  fp_device_capture (dev, TRUE, capture_data->cancellable, (GAsyncReadyCallback) dev_capture_cb, capture_data);
+}
+
+static void
+on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  CaptureData *capture_data = user_data;
+
+  g_autoptr(GError) error = NULL;
+
+  if (!fp_device_open_finish (dev, res, &error))
+    {
+      g_warning ("Failed to open device: %s", error->message);
+      capture_quit (dev, capture_data);
+      return;
+    }
+
+  g_print ("Opened device. ");
+
+  start_capture (dev, capture_data);
+}
+
+static gboolean
+sigint_cb (void *user_data)
+{
+  CaptureData *capture_data = user_data;
+
+  g_cancellable_cancel (capture_data->cancellable);
+
+  return G_SOURCE_CONTINUE;
+}
+
+int
+main (int argc, const char *argv[])
+{
+  g_autoptr(FpContext) ctx = NULL;
+  g_autoptr(CaptureData) capture_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;
+    }
+
+  if (!fp_device_supports_capture (dev))
+    {
+      g_warning ("Device %s doesn't support capture",
+                 fp_device_get_name (dev));
+      return EXIT_FAILURE;
+    }
+
+  capture_data = g_new0 (CaptureData, 1);
+  capture_data->ret_value = EXIT_FAILURE;
+  capture_data->loop = g_main_loop_new (NULL, FALSE);
+  capture_data->cancellable = g_cancellable_new ();
+  capture_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
+                                                         SIGINT,
+                                                         sigint_cb,
+                                                         capture_data,
+                                                         NULL);
+  if (argc == 2)
+    capture_data->filename = argv[1];
+  else
+    capture_data->filename = "finger.pgm";
+  fp_device_open (dev, capture_data->cancellable,
+                  (GAsyncReadyCallback) on_device_opened,
+                  capture_data);
+
+  g_main_loop_run (capture_data->loop);
+
+  return capture_data->ret_value;
+}
@@ -18,6 +18,8 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

+#define FP_COMPONENT "example-mange-prints"
+
 #include <stdio.h>

 #include <libfprint/fprint.h>
@@ -52,7 +54,7 @@ on_device_closed (FpDevice     *dev,
  fp_device_close_finish (dev, res, &error);

  if (error)
-    g_warning ("Failed closing device %s\n", error->message);
+    g_warning ("Failed closing device %s", error->message);

  g_main_loop_quit (list_data->loop);
 }
@@ -84,7 +86,7 @@ delete_next_print (FpDevice *dev,
  g_assert_nonnull (list_data->to_delete);
  print = list_data->to_delete->data;

-  g_debug ("Deleting print %s\n", fp_print_get_description (print));
+  g_debug ("Deleting print %s", fp_print_get_description (print));
  fp_device_delete_print (dev, print, NULL,
                          (GAsyncReadyCallback) on_print_deleted, list_data);
 }
@@ -153,14 +155,19 @@ on_list_completed (FpDevice     *dev,
      for (i = 0; i < prints->len; ++i)
        {
          FpPrint * print = prints->pdata[i];
+          const GDate *date = fp_print_get_enroll_date (print);

-          g_date_strftime (buf, G_N_ELEMENTS (buf), "%Y-%m-%d",
-                           fp_print_get_enroll_date (print));
-          g_print ("[%d] Print of %s finger for username %s, enrolled "
-                   "on %s. Description: %s\n", i + 1,
+          g_print ("[%d] Print of %s finger for username %s", i + 1,
                   finger_to_string (fp_print_get_finger (print)),
-                   fp_print_get_username (print), buf,
-                   fp_print_get_description (print));
+                   fp_print_get_username (print));
+
+          if (date)
+            {
+              g_date_strftime (buf, G_N_ELEMENTS (buf), "%Y-%m-%d\0", date);
+              g_print (", enrolled on %s", buf);
+            }
+
+          g_print (". Description: %s\n", fp_print_get_description (print));
        }

      if (prints->len)
@@ -192,9 +199,6 @@ on_list_completed (FpDevice     *dev,
                list_data->ret_value = EXIT_SUCCESS;
              else
                g_warning ("Invalid finger selected");
-
-              fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed,
-                               list_data);
            }
        }

@@ -1,19 +1,23 @@

-examples = [ 'enroll', 'verify', 'manage-prints' ]
+examples = [
+    'enroll',
+    'identify',
+    'img-capture',
+    'manage-prints',
+    'verify',
+]
+
 foreach example: examples
    executable(example,
-               [example + '.c', 'storage.c', 'utilities.c'],
-               dependencies: [libfprint_dep, glib_dep],
-               include_directories: [
-                 root_inc,
-               ],
-               c_args: common_cflags)
+        [ example + '.c', 'storage.c', 'utilities.c' ],
+        dependencies: [
+            libfprint_dep,
+            glib_dep,
+        ],
+    )
 endforeach

 executable('cpp-test',
-           'cpp-test.cpp',
-           dependencies: libfprint_dep,
-           include_directories: [
-             root_inc,
-           ],
-           c_args: common_cflags)
+    'cpp-test.cpp',
+    dependencies: libfprint_dep,
+)
@@ -2,7 +2,7 @@
 * Trivial storage driver for example programs
 *
 * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
+ * Copyright (C) 2019-2020 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
@@ -19,7 +19,11 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

+#define FP_COMPONENT "example-storage"
+
 #include <libfprint/fprint.h>
+#include <libfprint/fpi-compat.h>
+#include "storage.h"

 #include <errno.h>
 #include <stdio.h>
@@ -56,8 +60,8 @@ load_data (void)
 {
  GVariantDict *res;
  GVariant *var;
-  g_autofree gchar *contents = NULL;
-  gssize length = 0;
+  gchar *contents = NULL;
+  gsize length = 0;

  if (!g_file_get_contents (STORAGE_FILE, &contents, &length, NULL))
    {
@@ -65,7 +69,12 @@ load_data (void)
      return g_variant_dict_new (NULL);
    }

-  var = g_variant_new_from_data (G_VARIANT_TYPE_VARDICT, contents, length, FALSE, NULL, NULL);
+  var = g_variant_new_from_data (G_VARIANT_TYPE_VARDICT,
+                                 contents,
+                                 length,
+                                 FALSE,
+                                 g_free,
+                                 contents);

  res = g_variant_dict_new (var);
  g_variant_unref (var);
@@ -128,7 +137,7 @@ print_data_load (FpDevice *dev, FpFinger finger)

  g_autoptr(GVariant) val = NULL;
  g_autoptr(GVariantDict) dict = NULL;
-  g_autofree guchar *stored_data = NULL;
+  const guchar *stored_data = NULL;
  gsize stored_len;

  dict = load_data ();
@@ -139,7 +148,7 @@ print_data_load (FpDevice *dev, FpFinger finger)
      FpPrint *print;
      g_autoptr(GError) error = NULL;

-      stored_data = (guchar *) g_variant_get_fixed_array (val, &stored_len, 1);
+      stored_data = (const guchar *) g_variant_get_fixed_array (val, &stored_len, 1);
      print = fp_print_deserialize (stored_data, stored_len, &error);

      if (error)
@@ -151,12 +160,58 @@ print_data_load (FpDevice *dev, FpFinger finger)
  return NULL;
 }

+GPtrArray *
+gallery_data_load (FpDevice *dev)
+{
+  g_autoptr(GVariantDict) dict = NULL;
+  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;
+
+  gallery = g_ptr_array_new_with_free_func (g_object_unref);
+  dict = load_data ();
+  dict_variant = g_variant_dict_end (dict);
+  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))
+    {
+      FpPrint *print;
+      const guchar *stored_data;
+      g_autoptr(GError) error = NULL;
+      gsize stored_len;
+
+      if (!g_str_has_prefix (key, dev_prefix))
+        continue;
+
+      stored_data = (const guchar *) g_variant_get_fixed_array (value, &stored_len, 1);
+      print = fp_print_deserialize (stored_data, stored_len, &error);
+
+      if (error)
+        {
+          g_warning ("Error deserializing data: %s", error->message);
+          continue;
+        }
+
+      g_ptr_array_add (gallery, print);
+    }
+
+  return gallery;
+}
+
 FpPrint *
 print_create_template (FpDevice *dev, FpFinger finger)
 {
  g_autoptr(GDateTime) datetime = NULL;
+  g_autoptr(GDate) date = NULL;
  FpPrint *template = NULL;
-  GDate *date = NULL;
  gint year, month, day;

  template = fp_print_new (dev);
@@ -166,13 +221,12 @@ print_create_template (FpDevice *dev, FpFinger finger)
  g_date_time_get_ymd (datetime, &year, &month, &day);
  date = g_date_new_dmy (day, month, year);
  fp_print_set_enroll_date (template, date);
-  g_date_free (date);

  return template;
 }


-static gboolean
+gboolean
 save_image_to_pgm (FpImage *img, const char *path)
 {
  FILE *fd = fopen (path, "w");
@@ -212,7 +266,7 @@ save_image_to_pgm (FpImage *img, const char *path)
 gboolean
 print_image_save (FpPrint *print, const char *path)
 {
-  g_autoptr(FpImage) img = NULL;
+  FpImage *img = NULL;

  g_return_val_if_fail (FP_IS_PRINT (print), FALSE);
  g_return_val_if_fail (path != NULL, FALSE);
@@ -18,17 +18,16 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __STORAGE_H
-#define __STORAGE_H
-
+#pragma once

 int print_data_save (FpPrint *print,
                     FpFinger finger);
 FpPrint * print_data_load (FpDevice *dev,
                           FpFinger  finger);
+GPtrArray * gallery_data_load (FpDevice *dev);
 FpPrint * print_create_template (FpDevice *dev,
                                 FpFinger  finger);
 gboolean print_image_save (FpPrint    *print,
                           const char *path);
-
-#endif /* __STORAGE_H */
+gboolean save_image_to_pgm (FpImage    *img,
+                            const char *path);
@@ -18,6 +18,8 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

+#define FP_COMPONENT "example-utilities"
+
 #include <libfprint/fprint.h>
 #include <stdio.h>

@@ -107,29 +109,19 @@ finger_to_string (FpFinger finger)
 FpFinger
 finger_chooser (void)
 {
-  int i;
-  const FpFinger all_fingers[] = {
-    FP_FINGER_LEFT_THUMB,
-    FP_FINGER_LEFT_INDEX,
-    FP_FINGER_LEFT_MIDDLE,
-    FP_FINGER_LEFT_RING,
-    FP_FINGER_LEFT_LITTLE,
-    FP_FINGER_RIGHT_THUMB,
-    FP_FINGER_RIGHT_INDEX,
-    FP_FINGER_RIGHT_MIDDLE,
-    FP_FINGER_RIGHT_RING,
-    FP_FINGER_RIGHT_LITTLE,
-  };
+  int i = FP_FINGER_UNKNOWN;

-  for (i = all_fingers[0]; i <= G_N_ELEMENTS (all_fingers); ++i)
-    g_print ("  [%d] %s\n", (i - all_fingers[0]), finger_to_string (i));
+  for (i = FP_FINGER_FIRST; i <= FP_FINGER_LAST; ++i)
+    g_print ("  [%d] %s\n", (i - FP_FINGER_FIRST), finger_to_string (i));

  g_print ("> ");
  if (!scanf ("%d%*c", &i))
    return FP_FINGER_UNKNOWN;

-  if (i < 0 || i >= G_N_ELEMENTS (all_fingers))
+  i += FP_FINGER_FIRST;
+
+  if (i < FP_FINGER_FIRST || i > FP_FINGER_LAST)
    return FP_FINGER_UNKNOWN;

-  return all_fingers[i];
+  return i;
 }
@@ -18,11 +18,8 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __UTILITIES_H
-#define __UTILITIES_H
+#pragma once

 FpDevice * discover_device (GPtrArray *devices);
 FpFinger finger_chooser (void);
 const char * finger_to_string (FpFinger finger);
-
-#endif /* __UTILITIES_H */
@@ -19,22 +19,29 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

+#define FP_COMPONENT "example-verify"
+
 #include <stdio.h>
 #include <libfprint/fprint.h>
+#include <glib-unix.h>

 #include "storage.h"
 #include "utilities.h"

 typedef struct _VerifyData
 {
-  GMainLoop *loop;
-  FpFinger   finger;
-  int        ret_value;
+  GMainLoop    *loop;
+  GCancellable *cancellable;
+  unsigned int  sigint_handler;
+  FpFinger      finger;
+  int           ret_value;
 } VerifyData;

 static void
 verify_data_free (VerifyData *verify_data)
 {
+  g_clear_handle_id (&verify_data->sigint_handler, g_source_remove);
+  g_clear_object (&verify_data->cancellable);
  g_main_loop_unref (verify_data->loop);
  g_free (verify_data);
 }
@@ -50,11 +57,24 @@ on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
  fp_device_close_finish (dev, res, &error);

  if (error)
-    g_warning ("Failed closing device %s\n", error->message);
+    g_warning ("Failed closing device %s", error->message);

  g_main_loop_quit (verify_data->loop);
 }

+static void
+verify_quit (FpDevice   *dev,
+             VerifyData *verify_data)
+{
+  if (!fp_device_is_open (dev))
+    {
+      g_main_loop_quit (verify_data->loop);
+      return;
+    }
+
+  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed, verify_data);
+}
+
 static void start_verification (FpDevice   *dev,
                                VerifyData *verify_data);

@@ -71,35 +91,85 @@ on_verify_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
  if (!fp_device_verify_finish (dev, res, &match, &print, &error))
    {
      g_warning ("Failed to verify print: %s", error->message);
-      g_main_loop_quit (verify_data->loop);
-      return;
-    }
-
-  if (match)
-    {
-      g_print ("MATCH!\n");
-      if (fp_device_supports_capture (dev) &&
-          print_image_save (print, "verify.pgm"))
-        g_print ("Print image saved as verify.pgm");
-
-      verify_data->ret_value = EXIT_SUCCESS;
-    }
-  else
-    {
-      g_print ("NO MATCH!\n");
      verify_data->ret_value = EXIT_FAILURE;
+
+      if (error->domain != FP_DEVICE_RETRY)
+        {
+          verify_quit (dev, verify_data);
+          return;
+        }
    }

  g_print ("Verify again? [Y/n]? ");
  if (fgets (buffer, sizeof (buffer), stdin) &&
-      (buffer[0] == 'Y' || buffer[0] == 'y'))
+      (buffer[0] == 'Y' || buffer[0] == 'y' || buffer[0] == '\n'))
    {
      start_verification (dev, verify_data);
      return;
    }

-  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed,
-                   verify_data);
+  verify_quit (dev, verify_data);
+}
+
+static void
+on_match_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
+             gpointer user_data, GError *error)
+{
+  VerifyData *verify_data = user_data;
+
+  if (error)
+    {
+      g_warning ("Match report: Finger not matched, retry error reported: %s",
+                 error->message);
+      return;
+    }
+
+  if (print && fp_print_get_image (print) &&
+      print_image_save (print, "verify.pgm"))
+    g_print ("Print image saved as verify.pgm\n");
+
+  if (match)
+    {
+      char date_str[128];
+
+      verify_data->ret_value = EXIT_SUCCESS;
+
+      g_date_strftime (date_str, G_N_ELEMENTS (date_str), "%Y-%m-%d\0",
+                       fp_print_get_enroll_date (match));
+      g_debug ("Match report: device %s matched finger %s successifully "
+               "with print %s, enrolled on date %s by user %s",
+               fp_device_get_name (dev),
+               finger_to_string (fp_print_get_finger (match)),
+               fp_print_get_description (match), date_str,
+               fp_print_get_username (match));
+
+      g_print ("MATCH!\n");
+    }
+  else
+    {
+      g_debug ("Match report: Finger not matched");
+      g_print ("NO MATCH!\n");
+    }
+}
+
+static FpPrint *
+get_stored_print (FpDevice *dev, VerifyData *verify_data)
+{
+  FpPrint *verify_print;
+
+  g_print ("Loading previously enrolled %s finger data...\n",
+           finger_to_string (verify_data->finger));
+
+  verify_print = print_data_load (dev, verify_data->finger);
+
+  if (!verify_print)
+    {
+      g_warning ("Failed to load fingerprint data");
+      g_warning ("Did you remember to enroll your %s finger first?",
+                 finger_to_string (verify_data->finger));
+    }
+
+  return verify_print;
 }

 static void
@@ -115,30 +185,45 @@ on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
  if (!error)
    {
      FpPrint *verify_print = NULL;
+      g_autoptr(FpPrint) stored_print = NULL;
      guint i;

      if (!prints->len)
-        g_warning ("No prints saved on device");
+        {
+          g_warning ("No prints saved on device");
+          verify_quit (dev, verify_data);
+          return;
+        }
+
+      stored_print = get_stored_print (dev, verify_data);

      for (i = 0; i < prints->len; ++i)
        {
          FpPrint *print = prints->pdata[i];

+          if (stored_print && fp_print_equal (stored_print, print))
+            /* If the private print data matches, let's use the stored print
+             * as it contains more metadata to show */
+            print = stored_print;
+
          if (fp_print_get_finger (print) == verify_data->finger &&
              g_strcmp0 (fp_print_get_username (print), g_get_user_name ()) == 0)
            {
-              if (!verify_print ||
-                  (g_date_compare (fp_print_get_enroll_date (print),
-                                   fp_print_get_enroll_date (verify_print)) >= 0))
+              const GDate *verify_print_date = NULL;
+              const GDate *print_date = fp_print_get_enroll_date (print);
+
+              if (verify_print)
+                verify_print_date = fp_print_get_enroll_date (verify_print);
+
+              if (!verify_print || !print_date || !verify_print_date ||
+                  g_date_compare (print_date, verify_print_date) >= 0)
                verify_print = print;
            }
        }

      if (!verify_print)
        {
-          g_warning ("Did you remember to enroll your %s finger first?",
-                     finger_to_string (verify_data->finger));
-          g_main_loop_quit (verify_data->loop);
+          verify_quit (dev, verify_data);
          return;
        }

@@ -146,28 +231,32 @@ on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
               fp_print_get_description (verify_print));

      g_print ("Print loaded. Time to verify!\n");
-      fp_device_verify (dev, verify_print, NULL,
+      fp_device_verify (dev, verify_print, verify_data->cancellable,
+                        on_match_cb, verify_data, NULL,
                        (GAsyncReadyCallback) on_verify_completed,
                        verify_data);
    }
  else
    {
      g_warning ("Loading prints failed with error %s", error->message);
-      g_main_loop_quit (verify_data->loop);
+      verify_quit (dev, verify_data);
    }
 }

 static void
 start_verification (FpDevice *dev, VerifyData *verify_data)
 {
-  g_print ("Choose the finger to verify:\n");
-  verify_data->finger = finger_chooser ();
+  if (verify_data->finger == FP_FINGER_UNKNOWN)
+    {
+      g_print ("Choose the finger to verify:\n");
+      verify_data->finger = finger_chooser ();
+    }

  if (verify_data->finger == FP_FINGER_UNKNOWN)
    {
      g_warning ("Unknown finger selected");
      verify_data->ret_value = EXIT_FAILURE;
-      g_main_loop_quit (verify_data->loop);
+      verify_quit (dev, verify_data);
      return;
    }

@@ -180,23 +269,17 @@ start_verification (FpDevice *dev, VerifyData *verify_data)
    }
  else
    {
-      g_print ("Loading previously enrolled %s finger data...\n",
-               finger_to_string (verify_data->finger));
-      g_autoptr(FpPrint) verify_print;
-
-      verify_print = print_data_load (dev, verify_data->finger);
+      g_autoptr(FpPrint) verify_print = get_stored_print (dev, verify_data);

      if (!verify_print)
        {
-          g_warning ("Failed to load fingerprint data");
-          g_warning ("Did you remember to enroll your %s finger first?",
-                     finger_to_string (verify_data->finger));
-          g_main_loop_quit (verify_data->loop);
+          verify_quit (dev, verify_data);
          return;
        }

      g_print ("Print loaded. Time to verify!\n");
-      fp_device_verify (dev, verify_print, NULL,
+      fp_device_verify (dev, verify_print, verify_data->cancellable,
+                        on_match_cb, verify_data, NULL,
                        (GAsyncReadyCallback) on_verify_completed,
                        verify_data);
    }
@@ -212,7 +295,7 @@ on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
  if (!fp_device_open_finish (dev, res, &error))
    {
      g_warning ("Failed to open device: %s", error->message);
-      g_main_loop_quit (verify_data->loop);
+      verify_quit (dev, verify_data);
      return;
    }

@@ -221,6 +304,16 @@ on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
  start_verification (dev, verify_data);
 }

+static gboolean
+sigint_cb (void *user_data)
+{
+  VerifyData *verify_data = user_data;
+
+  g_cancellable_cancel (verify_data->cancellable);
+
+  return G_SOURCE_CONTINUE;
+}
+
 int
 main (void)
 {
@@ -251,8 +344,14 @@ main (void)
  verify_data = g_new0 (VerifyData, 1);
  verify_data->ret_value = EXIT_FAILURE;
  verify_data->loop = g_main_loop_new (NULL, FALSE);
-
-  fp_device_open (dev, NULL, (GAsyncReadyCallback) on_device_opened,
+  verify_data->cancellable = g_cancellable_new ();
+  verify_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
+                                                        SIGINT,
+                                                        sigint_cb,
+                                                        verify_data,
+                                                        NULL);
+  fp_device_open (dev, verify_data->cancellable,
+                  (GAsyncReadyCallback) on_device_opened,
                  verify_data);

  g_main_loop_run (verify_data->loop);
@@ -116,18 +116,6 @@ stub_capture_stop_cb (FpImageDevice *dev, GError *error,
    }
 }

-
-/* check that read succeeded but ignore all data */
-static void
-generic_ignore_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                        gpointer user_data, GError *error)
-{
-  if (error)
-    fpi_ssm_mark_failed (transfer->ssm, error);
-  else
-    fpi_ssm_next_state (transfer->ssm);
-}
-
 static void
 generic_write_regv_cb (FpImageDevice *dev, GError *error,
                       void *user_data)
@@ -147,15 +135,12 @@ generic_read_ignore_data (FpiSsm *ssm, FpDevice *dev,
                          size_t bytes)
 {
  FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
-  unsigned char *data;

-  data = g_malloc (bytes);
-  fpi_usb_transfer_fill_bulk_full (transfer, EP_IN, data, bytes, NULL);
+  fpi_usb_transfer_fill_bulk (transfer, EP_IN, bytes);
  transfer->ssm = ssm;
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                           generic_ignore_data_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
+                           fpi_ssm_usb_transfer_cb, NULL);
 }

 /****** FINGER PRESENCE DETECTION ******/
@@ -238,7 +223,6 @@ finger_det_reqs_cb (FpImageDevice *dev, GError *error,
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           finger_det_data_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -628,6 +612,7 @@ capture_read_strip_cb (FpiUsbTransfer *transfer, FpDevice *device,
      self->strips = g_slist_reverse (self->strips);
      fpi_do_movement_estimation (&assembling_ctx, self->strips);
      img = fpi_assemble_frames (&assembling_ctx, self->strips);
+      img->flags |= FPI_IMAGE_PARTIAL;

      g_slist_free_full (self->strips, g_free);
      self->strips = NULL;
@@ -683,7 +668,6 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev)
      transfer->short_is_error = TRUE;
      fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                               capture_read_strip_cb, NULL);
-      fpi_usb_transfer_unref (transfer);
      break;
    }
  ;
@@ -710,7 +694,6 @@ capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
    {
      start_finger_detection (dev);
    }
-  fpi_ssm_free (ssm);
 }

 static void
@@ -774,7 +757,6 @@ activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)

  if (!error)
    start_finger_detection (dev);
-  fpi_ssm_free (ssm);
 }

 static void
@@ -18,11 +18,12 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __AES1660_H
-#define __AES1660_H
+#pragma once

 #define AES1660_FRAME_SIZE 0x244

+/* *INDENT-OFF* */
+
 /* First init sequence, 0x07 cmd returns following before INIT1:
 * { 0x07, 0x05, 0x00, 0x8f, 0x16, 0x25, 0x01, 0x00  }
 */
@@ -1986,5 +1987,3 @@ static const unsigned char aes1660_start_imaging_cmd[] = {
  0x55, 0x07, 0x00, 0x80, 0x42, 0x00, 0x7f, 0x00, 0x00, 0x14,
  0x49, 0x03, 0x00, 0x20, 0x00, 0xc8
 };
-
-#endif
@@ -126,7 +126,6 @@ read_regs_rq_cb (FpImageDevice *dev, GError *error, void *user_data)
  fpi_usb_transfer_fill_bulk (transfer, EP_IN, READ_REGS_LEN);
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           read_regs_data_cb, rdata);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -183,19 +182,6 @@ generic_write_regv_cb (FpImageDevice *dev, GError *error,
    fpi_ssm_mark_failed (ssm, error);
 }

-/* check that read succeeded but ignore all data */
-static void
-generic_ignore_data_cb (FpiUsbTransfer *transfer, FpDevice *dev,
-                        gpointer user_data, GError *error)
-{
-  FpiSsm *ssm = transfer->ssm;
-
-  if (error)
-    fpi_ssm_mark_failed (ssm, error);
-  else
-    fpi_ssm_next_state (ssm);
-}
-
 /* read the specified number of bytes from the IN endpoint but throw them
 * away, then increment the SSM */
 static void
@@ -209,8 +195,7 @@ generic_read_ignore_data (FpiSsm *ssm, FpDevice *dev,
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_fill_bulk (transfer, EP_IN, bytes);
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                           generic_ignore_data_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
+                           fpi_ssm_usb_transfer_cb, NULL);
 }

 /****** IMAGE PROCESSING ******/
@@ -315,7 +300,6 @@ finger_det_reqs_cb (FpImageDevice *dev, GError *error,
  fpi_usb_transfer_fill_bulk (transfer, EP_IN, FINGER_DETECTION_LEN);
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           finger_det_data_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -474,6 +458,7 @@ capture_read_strip_cb (FpiUsbTransfer *transfer, FpDevice *_dev,
          fpi_do_movement_estimation (&assembling_ctx, self->strips);
          img = fpi_assemble_frames (&assembling_ctx,
                                     self->strips);
+          img->flags |= FPI_IMAGE_PARTIAL;
          g_slist_free_full (self->strips, g_free);
          self->strips = NULL;
          self->strips_len = 0;
@@ -547,7 +532,6 @@ capture_run_state (FpiSsm *ssm, FpDevice *device)
        fpi_usb_transfer_fill_bulk (transfer, EP_IN, STRIP_CAPTURE_LEN);
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                                 capture_read_strip_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
        break;
      }
    }
@@ -575,7 +559,6 @@ capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
    {
      start_finger_detection (dev);
    }
-  fpi_ssm_free (ssm);
 }

 static void
@@ -704,7 +687,7 @@ enum activate_states {
  ACTIVATE_NUM_STATES,
 };

-void
+static void
 activate_read_regs_cb (FpImageDevice *dev, GError *error,
                       unsigned char *regs, void *user_data)
 {
@@ -806,7 +789,6 @@ activate_sm_complete (FpiSsm *ssm, FpDevice *dev, GError *error)

  if (!error)
    start_finger_detection (FP_IMAGE_DEVICE (dev));
-  fpi_ssm_free (ssm);
 }

 static void
@@ -19,8 +19,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __AES2501_H
-#define __AES2501_H
+#pragma once

 enum aes2501_regs {
  AES2501_REG_CTRL1 = 0x80,
@@ -172,5 +171,3 @@ enum aes2501_sensor_gain2 {

 #define AES2501_SUM_HIGH_THRESH 1000
 #define AES2501_SUM_LOW_THRESH 700
-
-#endif  /* __AES2501_H */
@@ -134,7 +134,6 @@ finger_det_reqs_cb (FpiUsbTransfer *t, FpDevice *device,
  fpi_usb_transfer_fill_bulk (transfer, EP_IN, AES2550_EP_IN_BUF_SIZE);
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           finger_det_data_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -157,7 +156,6 @@ start_finger_detection (FpImageDevice *dev)
                                   sizeof (finger_det_reqs), NULL);
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           finger_det_reqs_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /****** CAPTURE ******/
@@ -199,12 +197,12 @@ process_strip_data (FpiSsm *ssm, FpImageDevice *dev,

  if (data[0] != AES2550_EDATA_MAGIC)
    {
-      fp_dbg ("Bogus magic: %.2x\n", (int) (data[0]));
+      fp_dbg ("Bogus magic: %.2x", (int) (data[0]));
      return FALSE;
    }
  len = data[1] * 256 + data[2];
  if (len != (AES2550_STRIP_SIZE - 3))
-    fp_dbg ("Bogus frame len: %.4x\n", len);
+    fp_dbg ("Bogus frame len: %.4x", len);
  stripe = g_malloc0 (FRAME_WIDTH * FRAME_HEIGHT / 2 + sizeof (struct fpi_frame));     /* 4 bits per pixel */
  stripe->delta_x = (int8_t) data[6];
  stripe->delta_y = -(int8_t) data[7];
@@ -218,16 +216,6 @@ process_strip_data (FpiSsm *ssm, FpImageDevice *dev,
  return TRUE;
 }

-static void
-capture_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                 gpointer user_data, GError *error)
-{
-  if (!error)
-    fpi_ssm_next_state (transfer->ssm);
-  else
-    fpi_ssm_mark_failed (transfer->ssm, error);
-}
-
 static void
 capture_set_idle_reqs_cb (FpiUsbTransfer *transfer,
                          FpDevice *device, gpointer user_data,
@@ -242,6 +230,7 @@ capture_set_idle_reqs_cb (FpiUsbTransfer *transfer,

      self->strips = g_slist_reverse (self->strips);
      img = fpi_assemble_frames (&assembling_ctx, self->strips);
+      img->flags |= FPI_IMAGE_PARTIAL;
      g_slist_free_full (self->strips, g_free);
      self->strips = NULL;
      self->strips_len = 0;
@@ -334,8 +323,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->ssm = ssm;
        transfer->short_is_error = TRUE;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                                 capture_reqs_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
+                                 fpi_ssm_usb_transfer_cb, NULL);
      }
      break;

@@ -347,7 +335,6 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->ssm = ssm;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                                 capture_read_data_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
      }
      break;

@@ -363,7 +350,6 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->short_is_error = TRUE;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                                 capture_set_idle_reqs_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
      }
      break;
    }
@@ -391,7 +377,6 @@ capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
    {
      start_finger_detection (dev);
    }
-  fpi_ssm_free (ssm);
 }

 static void
@@ -436,36 +421,13 @@ enum activate_states {
  ACTIVATE_NUM_STATES,
 };

-static void
-init_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device,
-              gpointer user_data, GError *error)
-{
-  if (!error)
-    fpi_ssm_next_state (transfer->ssm);
-  else
-    fpi_ssm_mark_failed (transfer->ssm, error);
-}
-
-static void
-init_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                   gpointer user_data, GError *error)
-{
-  if (!error)
-    fpi_ssm_next_state (transfer->ssm);
-  else
-    fpi_ssm_mark_failed (transfer->ssm, error);
-}
-
 /* TODO: use calibration table, datasheet is rather terse on that
 * need more info for implementation */
 static void
 calibrate_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                        gpointer user_data, GError *error)
 {
-  if (!error)
-    fpi_ssm_next_state (transfer->ssm);
-  else
-    fpi_ssm_mark_failed (transfer->ssm, error);
+  fpi_ssm_usb_transfer_cb (transfer, device, user_data, error);
 }

 static void
@@ -482,8 +444,7 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->ssm = ssm;
        transfer->short_is_error = TRUE;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                                 init_reqs_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
+                                 fpi_ssm_usb_transfer_cb, NULL);
      }
      break;

@@ -494,8 +455,7 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev)
        fpi_usb_transfer_fill_bulk (transfer, EP_IN, AES2550_EP_IN_BUF_SIZE);
        transfer->ssm = ssm;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                                 init_read_data_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
+                                 fpi_ssm_usb_transfer_cb, NULL);
      }
      break;

@@ -509,8 +469,7 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->ssm = ssm;
        transfer->short_is_error = TRUE;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                                 init_reqs_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
+                                 fpi_ssm_usb_transfer_cb, NULL);
      }
      break;

@@ -522,7 +481,6 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->ssm = ssm;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                                 calibrate_read_data_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
      }
      break;
    }
@@ -537,7 +495,6 @@ activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)

  if (!error)
    start_finger_detection (dev);
-  fpi_ssm_free (ssm);
 }

 static void
@@ -17,8 +17,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __AES2550_H
-#define __AES2550_H
+#pragma once

 /* Registers bits */

@@ -110,5 +109,3 @@ enum aes2550_cmds {
 #define AES2550_HEARTBEAT_MAGIC 0xdb

 #define AES2550_EP_IN_BUF_SIZE 8192
-
-#endif
@@ -17,11 +17,12 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __AES2660_H
-#define __AES2660_H
+#pragma once

 #define AES2660_FRAME_SIZE 0x354

+/* *INDENT-OFF* */
+
 /* First init sequence, 0x07 cmd returns following before INIT1:
 * { 0x07, 0x05, 0x00, 0x91, 0x26, 0x21, 0x00, 0x00  }
 */
@@ -1960,5 +1961,3 @@ static const unsigned char aes2660_start_imaging_cmd[] = {
  0x55, 0x07, 0x00, 0x80, 0x42, 0x00, 0xbf, 0x00, 0x00, 0x18,
  0x49, 0x03, 0x00, 0x20, 0x08, 0xc8
 };
-
-#endif
@@ -106,7 +106,9 @@ static struct aes_regwrite init_reqs[] = {
  { 0x9e, 0x53 },       /* clear challenge word bits */
  { 0x9f, 0x6b },       /* set some challenge word bits */
  { 0, 0 },
+};

+static struct aes_regwrite capture_reqs[] = {
  { 0x80, 0x00 },
  { 0x81, 0x00 },
  { 0, 0 },
@@ -155,4 +157,6 @@ fpi_device_aes3500_class_init (FpiDeviceAes3500Class *klass)
  aes_class->enlarge_factor = ENLARGE_FACTOR;
  aes_class->init_reqs = init_reqs;
  aes_class->init_reqs_len = G_N_ELEMENTS (init_reqs);
+  aes_class->capture_reqs = capture_reqs;
+  aes_class->capture_reqs_len = G_N_ELEMENTS (capture_reqs);
 }
@@ -42,8 +42,10 @@

 typedef struct
 {
-  FpiUsbTransfer *img_trf;
-  gboolean        deactivating;
+  /* This is used both as a flag that we are in a capture operation
+   * and for cancellation.
+   */
+  GCancellable *img_capture_cancel;
 } FpiDeviceAes3kPrivate;

 #define CTRL_TIMEOUT 1000
@@ -84,7 +86,8 @@ img_cb (FpiUsbTransfer *transfer, FpDevice *device,
  FpImage *img;
  int i;

-  priv->img_trf = NULL;
+  /* Image capture operation is finished (error/completed) */
+  g_clear_object (&priv->img_capture_cancel);

  if (error)
    {
@@ -92,14 +95,14 @@ img_cb (FpiUsbTransfer *transfer, FpDevice *device,
                           G_IO_ERROR,
                           G_IO_ERROR_CANCELLED))
        {
-          /* Deactivation was completed. */
+          /* Cancellation implies we are deactivating. */
          g_error_free (error);
-          if (priv->deactivating)
-            fpi_image_device_deactivate_complete (dev, NULL);
+          fpi_image_device_deactivate_complete (dev, NULL);
          return;
        }

      fpi_image_device_session_error (dev, error);
+      return;
    }

  fpi_image_device_report_finger_status (dev, TRUE);
@@ -123,44 +126,69 @@ img_cb (FpiUsbTransfer *transfer, FpDevice *device,
  fpi_image_device_image_captured (dev, img);

  /* FIXME: rather than assuming finger has gone, we should poll regs until
-   * it really has, then restart the capture */
+   * it really has. */
  fpi_image_device_report_finger_status (dev, FALSE);

-  do_capture (dev);
+  /* Note: The transfer is re-started when we switch to the AWAIT_FINGER_ON state. */
 }

 static void
 do_capture (FpImageDevice *dev)
 {
+  g_autoptr(FpiUsbTransfer) img_trf = NULL;
  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
  FpiDeviceAes3kClass *cls = FPI_DEVICE_AES3K_GET_CLASS (self);

-  priv->img_trf = fpi_usb_transfer_new (FP_DEVICE (dev));
-  fpi_usb_transfer_fill_bulk (priv->img_trf, EP_IN, cls->data_buflen);
-  priv->img_trf->short_is_error = TRUE;
-  fpi_usb_transfer_submit (priv->img_trf, 0,
-                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+  img_trf = fpi_usb_transfer_new (FP_DEVICE (dev));
+  fpi_usb_transfer_fill_bulk (img_trf, EP_IN, cls->data_buflen);
+  img_trf->short_is_error = TRUE;
+  fpi_usb_transfer_submit (g_steal_pointer (&img_trf), 0,
+                           priv->img_capture_cancel,
                           img_cb, NULL);
-  fpi_usb_transfer_unref (priv->img_trf);
+}
+
+static void
+capture_reqs_cb (FpImageDevice *dev, GError *result, void *user_data)
+{
+  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
+  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
+
+  if (result)
+    {
+      g_clear_object (&priv->img_capture_cancel);
+      fpi_image_device_session_error (dev, result);
+      return;
+    }
+
+  /* FIXME: we never cancel a pending capture. So we are likely leaving the
+   * hardware in a bad state should we abort the capture operation and the
+   * user does not touch the device.
+   * But, we don't know how we might cancel, so just leave it as is. */
+  do_capture (dev);
+}
+
+static void
+do_capture_start (FpImageDevice *dev)
+{
+  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
+  FpiDeviceAes3kClass *cls = FPI_DEVICE_AES3K_GET_CLASS (self);
+
+  aes_write_regv (dev, cls->capture_reqs, cls->capture_reqs_len, capture_reqs_cb, NULL);
 }

 static void
 init_reqs_cb (FpImageDevice *dev, GError *result, void *user_data)
 {
  fpi_image_device_activate_complete (dev, result);
-  if (!result)
-    do_capture (dev);
 }

 static void
 aes3k_dev_activate (FpImageDevice *dev)
 {
  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
-  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
  FpiDeviceAes3kClass *cls = FPI_DEVICE_AES3K_GET_CLASS (self);

-  priv->deactivating = FALSE;
  aes_write_regv (dev, cls->init_reqs, cls->init_reqs_len, init_reqs_cb, NULL);
 }

@@ -170,10 +198,26 @@ aes3k_dev_deactivate (FpImageDevice *dev)
  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);

-  priv->deactivating = TRUE;
-  if (priv->img_trf)
-    return;
-  fpi_image_device_deactivate_complete (dev, NULL);
+  /* If a capture is running, then deactivation finishes from the cancellation handler */
+  if (priv->img_capture_cancel)
+    g_cancellable_cancel (priv->img_capture_cancel);
+  else
+    fpi_image_device_deactivate_complete (dev, NULL);
+}
+
+static void
+aes3k_dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
+{
+  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
+  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
+
+  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+    {
+      g_assert (!priv->img_capture_cancel);
+      priv->img_capture_cancel = g_cancellable_new ();
+
+      do_capture_start (dev);
+    }
 }

 static void
@@ -218,6 +262,7 @@ fpi_device_aes3k_class_init (FpiDeviceAes3kClass *klass)
  img_class->img_open = aes3k_dev_init;
  img_class->img_close = aes3k_dev_deinit;
  img_class->activate = aes3k_dev_activate;
+  img_class->change_state = aes3k_dev_change_state;
  img_class->deactivate = aes3k_dev_deactivate;

  /* Extremely low due to low image quality. */
@@ -57,4 +57,6 @@ struct _FpiDeviceAes3kClass
  gsize                data_buflen;    /* buffer length of usb bulk transfer */
  struct aes_regwrite *init_reqs;       /* initial values sent to device */
  gsize                init_reqs_len;
+  struct aes_regwrite *capture_reqs;       /* capture values sent to device */
+  gsize                capture_reqs_len;
 };
@@ -103,7 +103,9 @@ static struct aes_regwrite init_reqs[] = {
  { 0x9e, 0x53 },       /* clear challenge word bits */
  { 0x9f, 0x6b },       /* set some challenge word bits */
  { 0, 0 },
+};

+static struct aes_regwrite capture_reqs[] = {
  { 0x80, 0x00 },
  { 0x81, 0x00 },
  { 0, 0 },
@@ -152,4 +154,6 @@ fpi_device_aes4000_class_init (FpiDeviceAes4000Class *klass)
  aes_class->enlarge_factor = ENLARGE_FACTOR;
  aes_class->init_reqs = init_reqs;
  aes_class->init_reqs_len = G_N_ELEMENTS (init_reqs);
+  aes_class->capture_reqs = capture_reqs;
+  aes_class->capture_reqs_len = G_N_ELEMENTS (capture_reqs);
 }
@@ -19,13 +19,11 @@

 #define FP_COMPONENT "aeslib"

-#include "fp_internal.h"
+#include "drivers_api.h"

 #include <errno.h>
 #include <string.h>

-#include "fpi-usb-transfer.h"
-#include "fpi-assembling.h"
 #include "aeslib.h"

 #define MAX_REGWRITES_PER_REQUEST 16
@@ -88,7 +86,6 @@ do_write_regv (FpImageDevice *dev, struct write_regv_data *wdata, int upper_boun
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           write_regv_trf_complete, wdata);
-  fpi_usb_transfer_unref (transfer);
 }

 /* write the next batch of registers to be written, or if there are no more,
@@ -17,8 +17,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __AESLIB_H__
-#define __AESLIB_H__
+#pragma once

 #include <fprint.h>

@@ -45,5 +44,3 @@ unsigned char aes_get_pixel (struct fpi_frame_asmbl_ctx *ctx,
                             struct fpi_frame           *frame,
                             unsigned int                x,
                             unsigned int                y);
-
-#endif
@@ -54,6 +54,7 @@ static void complete_deactivation (FpImageDevice *dev);
 #define CALIBRATE_DATA_LEN 4
 #define FINGER_DET_DATA_LEN 4

+FP_GNUC_ACCESS (read_only, 3, 4)
 static void
 aesX660_send_cmd_timeout (FpiSsm                *ssm,
                          FpDevice              *_dev,
@@ -68,9 +69,9 @@ aesX660_send_cmd_timeout (FpiSsm                *ssm,
                                   cmd_len, NULL);
  transfer->ssm = ssm;
  fpi_usb_transfer_submit (transfer, timeout, NULL, callback, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

+FP_GNUC_ACCESS (read_only, 3, 4)
 static void
 aesX660_send_cmd (FpiSsm                *ssm,
                  FpDevice              *dev,
@@ -90,27 +91,15 @@ aesX660_read_response (FpiSsm                *ssm,
                       FpiUsbTransferCallback callback)
 {
  FpiUsbTransfer *transfer = fpi_usb_transfer_new (_dev);
-  unsigned char *data;
  GCancellable *cancel = NULL;

  if (cancellable)
    cancel = fpi_device_get_cancellable (_dev);
-  data = g_malloc (buf_len);
-  fpi_usb_transfer_fill_bulk_full (transfer, EP_IN, data, buf_len, NULL);
+
+  fpi_usb_transfer_fill_bulk (transfer, EP_IN, buf_len);
  transfer->ssm = ssm;
  transfer->short_is_error = short_is_error;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, cancel, callback, NULL);
-  fpi_usb_transfer_unref (transfer);
-}
-
-static void
-aesX660_send_cmd_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                     gpointer user_data, GError *error)
-{
-  if (!error)
-    fpi_ssm_next_state (transfer->ssm);
-  else
-    fpi_ssm_mark_failed (transfer->ssm, error);
 }

 static void
@@ -128,10 +117,12 @@ aesX660_read_calibrate_data_cb (FpiUsbTransfer *transfer,
  /* Calibrate response was read correctly? */
  if (data[AESX660_RESPONSE_TYPE_OFFSET] != AESX660_CALIBRATE_RESPONSE)
    {
-      fp_dbg ("Bogus calibrate response: %.2x\n", data[0]);
+      fp_dbg ("Bogus calibrate response: %.2x", data[0]);
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Bogus calibrate response"));
+                                                     "Bogus calibrate "
+                                                     "response: %.2x",
+                                                     data[0]));
      return;
    }

@@ -165,17 +156,18 @@ finger_det_read_fd_data_cb (FpiUsbTransfer *transfer,

  if (error)
    {
-      fp_dbg ("Failed to read FD data\n");
+      fp_dbg ("Failed to read FD data");
      fpi_ssm_mark_failed (transfer->ssm, error);
      return;
    }

  if (data[AESX660_RESPONSE_TYPE_OFFSET] != AESX660_FINGER_DET_RESPONSE)
    {
-      fp_dbg ("Bogus FD response: %.2x\n", data[0]);
+      fp_dbg ("Bogus FD response: %.2x", data[0]);
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Bogus FD response"));
+                                                     "Bogus FD response %.2x",
+                                                     data[0]));
      return;
    }

@@ -186,7 +178,7 @@ finger_det_read_fd_data_cb (FpiUsbTransfer *transfer,
    }
  else
    {
-      fp_dbg ("Wait for finger returned %.2x as result\n",
+      fp_dbg ("Wait for finger returned %.2x as result",
              data[AESX660_FINGER_PRESENT_OFFSET]);
      fpi_ssm_jump_to_state (transfer->ssm, FINGER_DET_SEND_FD_CMD);
    }
@@ -212,7 +204,6 @@ finger_det_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)

  fp_dbg ("Finger detection completed");
  fpi_image_device_report_finger_status (dev, TRUE);
-  fpi_ssm_free (ssm);

  if (priv->deactivating)
    {
@@ -238,12 +229,12 @@ finger_det_run_state (FpiSsm *ssm, FpDevice *dev)
    {
    case FINGER_DET_SEND_LED_CMD:
      aesX660_send_cmd (ssm, dev, led_blink_cmd, sizeof (led_blink_cmd),
-                        aesX660_send_cmd_cb);
+                        fpi_ssm_usb_transfer_cb);
      break;

    case FINGER_DET_SEND_FD_CMD:
      aesX660_send_cmd_timeout (ssm, dev, wait_for_finger_cmd, sizeof (wait_for_finger_cmd),
-                                aesX660_send_cmd_cb, 0);
+                                fpi_ssm_usb_transfer_cb, 0);
      break;

    case FINGER_DET_READ_FD_DATA:
@@ -341,6 +332,7 @@ capture_set_idle_cmd_cb (FpiUsbTransfer *transfer, FpDevice *device,

      priv->strips = g_slist_reverse (priv->strips);
      img = fpi_assemble_frames (cls->assembling_ctx, priv->strips);
+      img->flags |= FPI_IMAGE_PARTIAL;
      g_slist_foreach (priv->strips, (GFunc) g_free, NULL);
      g_slist_free (priv->strips);
      priv->strips = NULL;
@@ -414,7 +406,7 @@ capture_read_stripe_data_cb (FpiUsbTransfer *transfer,
      g_byte_array_set_size (priv->stripe_packet, 0);
    }

-  fp_dbg ("finger %s\n", finger_missing ? "missing" : "present");
+  fp_dbg ("finger %s", finger_missing ? "missing" : "present");

  if (finger_missing)
    fpi_ssm_next_state (transfer->ssm);
@@ -433,14 +425,14 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev)
    {
    case CAPTURE_SEND_LED_CMD:
      aesX660_send_cmd (ssm, _dev, led_solid_cmd, sizeof (led_solid_cmd),
-                        aesX660_send_cmd_cb);
+                        fpi_ssm_usb_transfer_cb);
      break;

    case CAPTURE_SEND_CAPTURE_CMD:
      g_byte_array_set_size (priv->stripe_packet, 0);
      aesX660_send_cmd (ssm, _dev, cls->start_imaging_cmd,
                        cls->start_imaging_cmd_len,
-                        aesX660_send_cmd_cb);
+                        fpi_ssm_usb_transfer_cb);
      break;

    case CAPTURE_READ_STRIPE_DATA:
@@ -449,7 +441,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev)
      break;

    case CAPTURE_SET_IDLE:
-      fp_dbg ("Got %lu frames\n", priv->strips_len);
+      fp_dbg ("Got %lu frames", priv->strips_len);
      aesX660_send_cmd (ssm, _dev, set_idle_cmd, sizeof (set_idle_cmd),
                        capture_set_idle_cmd_cb);
      break;
@@ -463,7 +455,6 @@ capture_sm_complete (FpiSsm *ssm, FpDevice *device, GError *error)
  FpiDeviceAesX660Private *priv = fpi_device_aes_x660_get_instance_private (self);

  fp_dbg ("Capture completed");
-  fpi_ssm_free (ssm);

  if (priv->deactivating)
    {
@@ -523,22 +514,23 @@ activate_read_id_cb (FpiUsbTransfer *transfer, FpDevice *device,

  if (error)
    {
-      fp_dbg ("read_id cmd failed\n");
+      fp_dbg ("read_id cmd failed");
      fpi_ssm_mark_failed (transfer->ssm, error);
      return;
    }
  /* ID was read correctly */
  if (data[0] == 0x07)
    {
-      fp_dbg ("Sensor device id: %.2x%2x, bcdDevice: %.2x.%.2x, init status: %.2x\n",
+      fp_dbg ("Sensor device id: %.2x%2x, bcdDevice: %.2x.%.2x, init status: %.2x",
              data[4], data[3], data[5], data[6], data[7]);
    }
  else
    {
-      fp_dbg ("Bogus read ID response: %.2x\n", data[AESX660_RESPONSE_TYPE_OFFSET]);
+      fp_dbg ("Bogus read ID response: %.2x", data[AESX660_RESPONSE_TYPE_OFFSET]);
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Bogus read ID response"));
+                                                     "Bogus read ID response %.2x",
+                                                     data[AESX660_RESPONSE_TYPE_OFFSET]));
      return;
    }

@@ -562,10 +554,11 @@ activate_read_id_cb (FpiUsbTransfer *transfer, FpDevice *device,
      break;

    default:
-      fp_dbg ("Failed to init device! init status: %.2x\n", data[7]);
+      fp_dbg ("Failed to init device! init status: %.2x", data[7]);
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Failed to init device"));
+                                                     "Failed to init device %.2x",
+                                                     data[7]));
      break;
    }
 }
@@ -578,11 +571,11 @@ activate_read_init_cb (FpiUsbTransfer *transfer, FpDevice *device,
  FpiDeviceAesX660Private *priv = fpi_device_aes_x660_get_instance_private (self);
  unsigned char *data = transfer->buffer;

-  fp_dbg ("read_init_cb\n");
+  fp_dbg ("read_init_cb");

  if (error)
    {
-      fp_dbg ("read_init transfer status: %s, actual_len: %d\n", error->message,
+      fp_dbg ("read_init transfer status: %s, actual_len: %d", error->message,
              (gint) transfer->actual_length);
      fpi_ssm_mark_failed (transfer->ssm, error);
      return;
@@ -590,11 +583,12 @@ activate_read_init_cb (FpiUsbTransfer *transfer, FpDevice *device,
  /* ID was read correctly */
  if (data[0] != 0x42 || data[3] != 0x01)
    {
-      fp_dbg ("Bogus read init response: %.2x %.2x\n", data[0],
+      fp_dbg ("Bogus read init response: %.2x %.2x", data[0],
              data[3]);
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Bogus read init response"));
+                                                     "Bogus read init response: "
+                                                     "%.2x %.2x", data[0], data[3]));
      return;
    }
  priv->init_cmd_idx++;
@@ -621,15 +615,15 @@ activate_run_state (FpiSsm *ssm, FpDevice *_dev)
    {
    case ACTIVATE_SET_IDLE:
      priv->init_seq_idx = 0;
-      fp_dbg ("Activate: set idle\n");
+      fp_dbg ("Activate: set idle");
      aesX660_send_cmd (ssm, _dev, set_idle_cmd, sizeof (set_idle_cmd),
-                        aesX660_send_cmd_cb);
+                        fpi_ssm_usb_transfer_cb);
      break;

    case ACTIVATE_SEND_READ_ID_CMD:
-      fp_dbg ("Activate: read ID\n");
+      fp_dbg ("Activate: read ID");
      aesX660_send_cmd (ssm, _dev, read_id_cmd, sizeof (read_id_cmd),
-                        aesX660_send_cmd_cb);
+                        fpi_ssm_usb_transfer_cb);
      break;

    case ACTIVATE_READ_ID:
@@ -637,23 +631,23 @@ activate_run_state (FpiSsm *ssm, FpDevice *_dev)
      break;

    case ACTIVATE_SEND_INIT_CMD:
-      fp_dbg ("Activate: send init seq #%d cmd #%d\n",
+      fp_dbg ("Activate: send init seq #%d cmd #%d",
              priv->init_seq_idx,
              priv->init_cmd_idx);
      aesX660_send_cmd (ssm, _dev,
                        priv->init_seq[priv->init_cmd_idx].cmd,
                        priv->init_seq[priv->init_cmd_idx].len,
-                        aesX660_send_cmd_cb);
+                        fpi_ssm_usb_transfer_cb);
      break;

    case ACTIVATE_READ_INIT_RESPONSE:
-      fp_dbg ("Activate: read init response\n");
+      fp_dbg ("Activate: read init response");
      aesX660_read_response (ssm, _dev, TRUE, FALSE, INIT_LEN, activate_read_init_cb);
      break;

    case ACTIVATE_SEND_CALIBRATE_CMD:
      aesX660_send_cmd (ssm, _dev, calibrate_cmd, sizeof (calibrate_cmd),
-                        aesX660_send_cmd_cb);
+                        fpi_ssm_usb_transfer_cb);
      break;

    case ACTIVATE_READ_CALIBRATE_DATA:
@@ -666,7 +660,6 @@ static void
 activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
  fpi_image_device_activate_complete (FP_IMAGE_DEVICE (_dev), error);
-  fpi_ssm_free (ssm);

  if (!error)
    start_finger_detection (FP_IMAGE_DEVICE (_dev));
@@ -41,7 +41,7 @@
 #include "drivers_api.h"
 #include "elan.h"

-unsigned char
+static unsigned char
 elan_get_pixel (struct fpi_frame_asmbl_ctx *ctx,
                struct fpi_frame *frame, unsigned int x,
                unsigned int y)
@@ -73,25 +73,22 @@ struct _FpiDeviceElan
  /* end commands */

  /* state */
-  gboolean           deactivating;
-  FpImageDeviceState dev_state;
-  FpImageDeviceState dev_state_next;
-  unsigned char     *last_read;
-  unsigned char      calib_atts_left;
-  unsigned char      calib_status;
-  unsigned short    *background;
-  unsigned char      frame_width;
-  unsigned char      frame_height;
-  unsigned char      raw_frame_height;
-  int                num_frames;
-  GSList            *frames;
+  gboolean        active;
+  gboolean        deactivating;
+  unsigned char  *last_read;
+  unsigned char   calib_atts_left;
+  unsigned char   calib_status;
+  unsigned short *background;
+  unsigned char   frame_width;
+  unsigned char   frame_height;
+  unsigned char   raw_frame_height;
+  int             num_frames;
+  GSList         *frames;
  /* end state */
 };
-G_DECLARE_FINAL_TYPE (FpiDeviceElan, fpi_device_elan, FPI, DEVICE_ELAN,
-                      FpImageDevice);
 G_DEFINE_TYPE (FpiDeviceElan, fpi_device_elan, FP_TYPE_IMAGE_DEVICE);

-int
+static int
 cmp_short (const void *a, const void *b)
 {
  return (int) (*(short *) a - *(short *) b);
@@ -207,6 +204,7 @@ elan_save_img_frame (FpiDeviceElan *elandev)

  unsigned int frame_size = elandev->frame_width * elandev->frame_height;
  unsigned short *frame = g_malloc (frame_size * sizeof (short));
+
  elan_save_frame (elandev, frame);
  unsigned int sum = 0;

@@ -223,6 +221,7 @@ elan_save_img_frame (FpiDeviceElan *elandev)
    {
      fp_dbg
        ("frame darker than background; finger present during calibration?");
+      g_free (frame);
      return -1;
    }

@@ -243,6 +242,7 @@ elan_process_frame_linear (unsigned short *raw_frame,
  G_DEBUG_HERE ();

  unsigned short min = 0xffff, max = 0;
+
  for (int i = 0; i < frame_size; i++)
    {
      if (raw_frame[i] < min)
@@ -254,6 +254,7 @@ elan_process_frame_linear (unsigned short *raw_frame,
  g_assert (max != min);

  unsigned short px;
+
  for (int i = 0; i < frame_size; i++)
    {
      px = raw_frame[i];
@@ -277,6 +278,7 @@ elan_process_frame_thirds (unsigned short *raw_frame,

  unsigned short lvl0, lvl1, lvl2, lvl3;
  unsigned short *sorted = g_malloc (frame_size * sizeof (short));
+
  memcpy (sorted, raw_frame, frame_size * sizeof (short));
  qsort (sorted, frame_size, sizeof (short), cmp_short);
  lvl0 = sorted[0];
@@ -286,6 +288,7 @@ elan_process_frame_thirds (unsigned short *raw_frame,
  g_free (sorted);

  unsigned short px;
+
  for (int i = 0; i < frame_size; i++)
    {
      px = raw_frame[i];
@@ -319,6 +322,9 @@ elan_submit_image (FpImageDevice *dev)
  g_slist_foreach (raw_frames, (GFunc) self->process_frame, &frames);
  fpi_do_movement_estimation (&assembling_ctx, frames);
  img = fpi_assemble_frames (&assembling_ctx, frames);
+  img->flags |= FPI_IMAGE_PARTIAL;
+
+  g_slist_free_full (frames, g_free);

  fpi_image_device_image_captured (dev, img);
 }
@@ -405,7 +411,6 @@ elan_cmd_read (FpiSsm *ssm, FpDevice *dev)
    cancellable = fpi_device_get_cancellable (dev);

  fpi_usb_transfer_submit (transfer, self->cmd_timeout, cancellable, elan_cmd_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -448,7 +453,6 @@ elan_run_cmd (FpiSsm                *ssm,
                           cancellable,
                           elan_cmd_cb,
                           NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 enum stop_capture_states {
@@ -478,10 +482,9 @@ stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)

  G_DEBUG_HERE ();

-  fpi_ssm_free (ssm);

  /* The device is inactive at this point. */
-  self->dev_state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+  self->active = FALSE;

  if (self->deactivating)
    {
@@ -499,16 +502,15 @@ stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 }

 static void
-elan_stop_capture (FpDevice *dev)
+elan_stop_capture (FpiDeviceElan *self)
 {
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-
  G_DEBUG_HERE ();

  elan_dev_reset_state (self);

  FpiSsm *ssm =
-    fpi_ssm_new (dev, stop_capture_run_state, STOP_CAPTURE_NUM_STATES);
+    fpi_ssm_new (FP_DEVICE (self), stop_capture_run_state, STOP_CAPTURE_NUM_STATES);
+
  fpi_ssm_start (ssm, stop_capture_complete);
 }

@@ -538,8 +540,6 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
      break;

    case CAPTURE_READ_DATA:
-      self->dev_state = FP_IMAGE_DEVICE_STATE_CAPTURE;
-
      /* 0x55 - finger present
       * 0xff - device not calibrated (probably) */
      if (self->last_read && self->last_read[0] == 0x55)
@@ -549,7 +549,11 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
        }
      else
        {
-          fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
+          /* XXX: The timeout is emulated incorrectly, resulting in a zero byte read. */
+          if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
+            fpi_ssm_mark_completed (ssm);
+          else
+            fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
        }
      break;

@@ -581,8 +585,6 @@ capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)

  G_DEBUG_HERE ();

-  /* XXX: cancellation was specially handled by doing nothing! */
-
  /* either max frames captured or timed out waiting for the next frame */
  if (!error ||
      (g_error_matches (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_TIMED_OUT) &&
@@ -605,19 +607,22 @@ capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
      fpi_image_device_session_error (dev, error);
    }

-  fpi_ssm_free (ssm);
+  /* Note: We always stop capturing even if that may not be needed always.
+   * Doing this between captures appears to make it at least less likely for
+   * devices to end up in a bad state.
+   */
+  elan_stop_capture (self);
 }

 static void
-elan_capture (FpDevice *dev)
+elan_capture (FpiDeviceElan *self)
 {
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-
  G_DEBUG_HERE ();

  elan_dev_reset_state (self);
  FpiSsm *ssm =
-    fpi_ssm_new (dev, capture_run_state, CAPTURE_NUM_STATES);
+    fpi_ssm_new (FP_DEVICE (self), capture_run_state, CAPTURE_NUM_STATES);
+
  fpi_ssm_start (ssm, capture_complete);
 }

@@ -732,7 +737,7 @@ calibrate_run_state (FpiSsm *ssm, FpDevice *dev)
          fp_dbg ("calibration failed");
          fpi_ssm_mark_failed (ssm,
                               fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                         "Callibration failed!"));
+                                                         "Calibration failed!"));
        }
      break;

@@ -752,15 +757,10 @@ calibrate_run_state (FpiSsm *ssm, FpDevice *dev)
        }
      else
        {
-          GSource *timeout;
-
          if (self->calib_status == 0x00 &&
              self->last_read[0] == 0x01)
            self->calib_status = 0x01;
-          timeout = fpi_device_add_timeout (dev, 50,
-                                            fpi_ssm_next_state_timeout_cb,
-                                            ssm);
-          g_source_set_name (timeout, "calibrate_run_state");
+          fpi_ssm_next_state_delayed (ssm, 50, NULL);
        }
      break;

@@ -773,36 +773,33 @@ calibrate_run_state (FpiSsm *ssm, FpDevice *dev)
 static void
 calibrate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-
  G_DEBUG_HERE ();

  if (error)
    {
-      self->dev_state = FP_IMAGE_DEVICE_STATE_INACTIVE;
      fpi_image_device_session_error (FP_IMAGE_DEVICE (dev), error);
+      elan_stop_capture (FPI_DEVICE_ELAN (dev));
    }
  else
    {
-      self->dev_state = FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
-      elan_capture (dev);
+      elan_capture (FPI_DEVICE_ELAN (dev));
    }
-
-  fpi_ssm_free (ssm);
 }

 static void
-elan_calibrate (FpDevice *dev)
+elan_calibrate (FpiDeviceElan *self)
 {
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-
  G_DEBUG_HERE ();

  elan_dev_reset_state (self);
+
+  g_return_if_fail (!self->active);
+  self->active = TRUE;
  self->calib_atts_left = ELAN_CALIBRATION_ATTEMPTS;

-  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), calibrate_run_state,
+  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (self), calibrate_run_state,
                             CALIBRATE_NUM_STATES);
+
  fpi_ssm_start (ssm, calibrate_complete);
 }

@@ -885,7 +882,6 @@ activate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)

  fpi_image_device_activate_complete (idev, error);

-  fpi_ssm_free (ssm);
 }

 static void
@@ -899,6 +895,7 @@ elan_activate (FpImageDevice *dev)
  FpiSsm *ssm =
    fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
                 ACTIVATE_NUM_STATES);
+
  fpi_ssm_start (ssm, activate_complete);
 }

@@ -956,96 +953,18 @@ dev_activate (FpImageDevice *dev)
 }

 static void
-elan_change_state (FpImageDevice *idev)
-{
-  FpDevice *dev = FP_DEVICE (idev);
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-  FpImageDeviceState next_state = self->dev_state_next;
-
-  if (self->dev_state == next_state)
-    {
-      fp_dbg ("already in %d", next_state);
-      return;
-    }
-  else
-    {
-      fp_dbg ("changing to %d", next_state);
-    }
-
-  switch (next_state)
-    {
-      break;
-
-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
-      /* activation completed or another enroll stage started */
-      elan_calibrate (dev);
-      break;
-
-    case FP_IMAGE_DEVICE_STATE_CAPTURE:
-      /* not used */
-      break;
-
-    case FP_IMAGE_DEVICE_STATE_INACTIVE:
-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
-      if (self->dev_state != FP_IMAGE_DEVICE_STATE_INACTIVE ||
-          self->dev_state != FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
-        elan_stop_capture (dev);
-    }
-}
-
-static void
-elan_change_state_async (FpDevice *dev,
-                         void     *data)
-{
-  g_message ("state change dev: %p", dev);
-  elan_change_state (FP_IMAGE_DEVICE (dev));
-}
-
-static void
-dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
+dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
 {
  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-  GSource *timeout;

  G_DEBUG_HERE ();

-  /* Inactive and await finger off are equivalent for the elan driver. */
-  if (state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
-    state = FP_IMAGE_DEVICE_STATE_INACTIVE;
-
-  if (self->dev_state_next == state)
-    fp_dbg ("change to state %d already queued", state);
-
-  switch (state)
-    {
-    case FP_IMAGE_DEVICE_STATE_INACTIVE:
-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: {
-        char *name;
-
-        /* schedule state change instead of calling it directly to allow all actions
-         * related to the previous state to complete */
-        self->dev_state_next = state;
-        timeout = fpi_device_add_timeout (FP_DEVICE (dev), 10,
-                                          elan_change_state_async,
-                                          NULL);
-
-        name = g_strdup_printf ("dev_change_state to %d", state);
-        g_source_set_name (timeout, name);
-        g_free (name);
-
-        break;
-      }
-
-    case FP_IMAGE_DEVICE_STATE_CAPTURE:
-      /* TODO MAYBE: split capture ssm into smaller ssms and use this state */
-      self->dev_state = state;
-      self->dev_state_next = state;
-      break;
-
-    default:
-      g_assert_not_reached ();
-    }
+  /* Note: We always calibrate even if that may not be needed always.
+   * Doing this for each capture appears to make it at least less likely for
+   * devices to end up in a bad state.
+   */
+  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+    elan_calibrate (self);
 }

 static void
@@ -1055,19 +974,14 @@ dev_deactivate (FpImageDevice *dev)

  G_DEBUG_HERE ();

-  if (self->dev_state == FP_IMAGE_DEVICE_STATE_INACTIVE)
-    {
-      /* The device is inactive already, complete the operation immediately. */
-      fpi_image_device_deactivate_complete (dev, NULL);
-    }
+  if (!self->active)
+    /* The device is inactive already, complete the operation immediately. */
+    fpi_image_device_deactivate_complete (dev, NULL);
  else
-    {
-      /* The device is not yet inactive, flag that we are deactivating (and
-       * need to signal back deactivation) and then ensure we will change
-       * to the inactive state eventually. */
-      self->deactivating = TRUE;
-      dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE);
-    }
+    /* The device is not yet inactive, flag that we are deactivating (and
+     * need to signal back deactivation).
+     * Note that any running capture will be cancelled already if needed. */
+    self->deactivating = TRUE;
 }

 static void
@@ -18,8 +18,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __ELAN_H
-#define __ELAN_H
+#pragma once

 #include <glib.h>

@@ -71,6 +70,9 @@
 #define ELAN_CMD_TIMEOUT 10000
 #define ELAN_FINGER_TIMEOUT 200

+G_DECLARE_FINAL_TYPE (FpiDeviceElan, fpi_device_elan, FPI, DEVICE_ELAN,
+                      FpImageDevice);
+
 struct elan_cmd
 {
  unsigned char  cmd[ELAN_CMD_LEN];
@@ -212,6 +214,7 @@ static const FpIdEntry elan_id_table[] = {
  {.vid = ELAN_VEND_ID,  .pid = 0x0c32, .driver_data = ELAN_ALL_DEV},
  {.vid = ELAN_VEND_ID,  .pid = 0x0c33, .driver_data = ELAN_ALL_DEV},
  {.vid = ELAN_VEND_ID,  .pid = 0x0c42, .driver_data = ELAN_0C42},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c4d, .driver_data = ELAN_ALL_DEV},
  {.vid = 0,  .pid = 0,  .driver_data = 0},
 };

@@ -219,10 +222,8 @@ static void elan_cmd_done (FpiSsm *ssm);
 static void elan_cmd_read (FpiSsm   *ssm,
                           FpDevice *dev);

-static void elan_calibrate (FpDevice *dev);
-static void elan_capture (FpDevice *dev);
+static void elan_calibrate (FpiDeviceElan *self);
+static void elan_capture (FpiDeviceElan *self);

-static void dev_change_state (FpImageDevice     *dev,
-                              FpImageDeviceState state);
-
-#endif
+static void dev_change_state (FpImageDevice      *dev,
+                              FpiImageDeviceState state);
@@ -36,7 +36,6 @@
 #define FP_COMPONENT "etes603"

 #include "drivers_api.h"
-#include "driver_ids.h"

 /* libusb defines */
 #define EP_IN 0x81
@@ -710,7 +709,6 @@ async_tx (FpDevice *dev, unsigned int ep, void *cb,
  transfer->ssm = ssm;
  fpi_usb_transfer_fill_bulk_full (transfer, ep, buffer, length, NULL);
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL, cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }


@@ -789,7 +787,6 @@ m_exit_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
  else
    fp_dbg ("The device is now in idle state");
  fpi_image_device_deactivate_complete (idev, error);
-  fpi_ssm_free (ssm);
 }

 static void
@@ -862,21 +859,29 @@ m_capture_state (FpiSsm *ssm, FpDevice *dev)
        }
      else
        {
-          FpImage *img;
-          unsigned int img_size;
          /* Remove empty parts 2 times for the 2 frames */
          process_removefpi_end (self);
          process_removefpi_end (self);
-          img_size = self->fp_height * FE_WIDTH;
-          img = fp_image_new (FE_WIDTH, self->fp_height);
-          /* Images received are white on black, so invert it. */
-          /* TODO detect sweep direction */
-          img->flags = FPI_IMAGE_COLORS_INVERTED | FPI_IMAGE_V_FLIPPED;
-          img->height = self->fp_height;
-          process_4to8_bpp (self->fp, img_size / 2, img->data);
-          fp_dbg ("Sending the raw fingerprint image (%dx%d)",
-                  img->width, img->height);
-          fpi_image_device_image_captured (idev, img);
+
+          if (self->fp_height >= FE_WIDTH)
+            {
+              FpImage *img = fp_image_new (FE_WIDTH, self->fp_height);
+              unsigned int img_size = self->fp_height * FE_WIDTH;
+
+              /* Images received are white on black, so invert it. */
+              /* TODO detect sweep direction */
+              img->flags = FPI_IMAGE_COLORS_INVERTED | FPI_IMAGE_V_FLIPPED;
+              img->height = self->fp_height;
+              process_4to8_bpp (self->fp, img_size / 2, img->data);
+              fp_dbg ("Sending the raw fingerprint image (%dx%d)",
+                      img->width, img->height);
+              fpi_image_device_image_captured (idev, img);
+            }
+          else
+            {
+              fpi_image_device_retry_scan (idev, FP_DEVICE_RETRY_TOO_SHORT);
+            }
+
          fpi_image_device_report_finger_status (idev, FALSE);
          fpi_ssm_mark_completed (ssm);
        }
@@ -911,7 +916,6 @@ m_capture_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
          g_error_free (error);
        }
    }
-  fpi_ssm_free (ssm);

  if (self->is_active == TRUE)
    {
@@ -1061,7 +1065,6 @@ m_finger_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
      self->is_active = FALSE;
    }

-  fpi_ssm_free (ssm);
 }

 static void
@@ -1265,7 +1268,6 @@ m_tunevrb_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
  if (!self->is_active)
    m_exit_start (idev);

-  fpi_ssm_free (ssm);
 }

 /*
@@ -1409,7 +1411,6 @@ m_tunedc_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
  if (!self->is_active)
    m_exit_start (idev);

-  fpi_ssm_free (ssm);
 }

 static void
@@ -1543,7 +1544,6 @@ m_init_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
      reset_param (FPI_DEVICE_ETES603 (dev));
      fpi_image_device_session_error (idev, error);
    }
-  fpi_ssm_free (ssm);
 }

 static void
@@ -0,0 +1,62 @@
+/*
+ * Goodix Moc driver for libfprint
+ * Copyright (C) 2019 Shenzhen Goodix Technology Co., Ltd.
+ *
+ * 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 (FpiDeviceGoodixMoc, fpi_device_goodixmoc, FPI, DEVICE_GOODIXMOC, FpDevice)
+
+typedef enum {
+  FP_CMD_SEND = 0,
+  FP_CMD_GET_ACK,
+  FP_CMD_GET_DATA,
+  FP_CMD_NUM_STATES,
+} FpCmdState;
+
+
+typedef enum {
+  FP_INIT_VERSION = 0,
+  FP_INIT_CONFIG,
+  FP_INIT_NUM_STATES,
+} FpInitState;
+
+
+typedef enum {
+  FP_ENROLL_PWR_BTN_SHIELD_ON = 0,
+  FP_ENROLL_ENUM,
+  FP_ENROLL_IDENTIFY,
+  FP_ENROLL_CREATE,
+  FP_ENROLL_CAPTURE,
+  FP_ENROLL_UPDATE,
+  FP_ENROLL_WAIT_FINGER_UP,
+  FP_ENROLL_CHECK_DUPLICATE,
+  FP_ENROLL_COMMIT,
+  FP_ENROLL_PWR_BTN_SHIELD_OFF,
+  FP_ENROLL_NUM_STATES,
+} FpEnrollState;
+
+typedef enum {
+  FP_VERIFY_PWR_BTN_SHIELD_ON = 0,
+  FP_VERIFY_CAPTURE,
+  FP_VERIFY_IDENTIFY,
+  FP_VERIFY_PWR_BTN_SHIELD_OFF,
+  FP_VERIFY_NUM_STATES,
+} FpVerifyState;
@@ -0,0 +1,463 @@
+/*
+ * Goodix Moc driver for libfprint
+ * Copyright (C) 2019 Shenzhen Goodix Technology Co., Ltd.
+ *
+ * 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 "goodix_proto.h"
+
+/*
+ *  Crc functions
+ */
+
+#define WIDTH (8 * sizeof (uint32_t))
+#define FINAL_XOR_VALUE 0xFFFFFFFF
+#define REFLECT_DATA(X)         ((uint8_t) reflect ((X), 8))
+#define REFLECT_REMAINDER(X)    ((unsigned int) reflect ((X), WIDTH))
+
+
+uint8_t
+gx_proto_crc8_calc (uint8_t *lubp_date, uint32_t lui_len)
+{
+  const uint8_t *data = lubp_date;
+  unsigned int crc = 0;
+  int i, j;
+
+  for (j = lui_len; j; j--, data++)
+    {
+      crc ^= (*data << 8);
+      for (i = 8; i; i--)
+        {
+          if (crc & 0x8000)
+            crc ^= (0x1070 << 3);
+          crc <<= 1;
+        }
+    }
+
+  crc >>= 8;
+  crc = ~crc;
+  return (uint8_t) crc;
+}
+
+typedef struct
+{
+  uint32_t crc;
+} gf_crc32_context;
+
+static uint32_t s_crc_table[256] =
+{ 0x0,         0x4c11db7,  0x9823b6e,  0xd4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
+  0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
+  0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
+  0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
+  0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
+  0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
+  0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
+  0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
+  0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
+  0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x18aeb13,   0x54bf6a4,  0x808d07d,  0xcc9cdca,
+  0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
+  0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
+  0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
+  0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
+  0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
+  0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
+  0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
+  0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
+  0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
+  0x315d626,  0x7d4cb91,  0xa97ed48,  0xe56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
+  0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
+  0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
+  0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
+  0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
+  0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
+  0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
+  0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x29f3d35,  0x65e2082,   0xb1d065b,  0xfdc1bec,
+  0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
+  0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
+  0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
+  0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
+  0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4};
+
+static uint32_t
+reflect (uint32_t data, uint8_t n_bits)
+{
+  unsigned long reflection = 0x00000000;
+  uint8_t bit;
+
+  /*
+   * Reflect the data about the center bit.
+   */
+  for (bit = 0; bit < n_bits; ++bit)
+    {
+      /*
+       * If the LSB bit is set, set the reflection of it.
+       */
+      if (data & 0x01)
+        reflection |= (1 << ((n_bits - 1) - bit));
+
+      data = (data >> 1);
+    }
+
+  return reflection;
+
+}
+
+static void
+crc32_init (gf_crc32_context *ctx)
+{
+  ctx->crc = 0xFFFFFFFF;
+}
+
+static void
+crc32_update (gf_crc32_context *ctx, const uint8_t *message, uint32_t n_bytes)
+{
+  uint8_t data;
+  uint32_t byte;
+
+  /*
+   * Divide the message by the polynomial, a byte at a time.
+   */
+  for (byte = 0; byte < n_bytes; ++byte)
+    {
+      data = REFLECT_DATA (message[byte]) ^ (ctx->crc >> (WIDTH - 8));
+      ctx->crc = s_crc_table[data] ^ (ctx->crc << 8);
+    }
+}
+
+static void
+crc32_final (gf_crc32_context *ctx, uint8_t *md)
+{
+  uint32_t crc = 0;
+
+  ctx->crc = (REFLECT_REMAINDER (ctx->crc) ^ FINAL_XOR_VALUE);
+  crc = GUINT32_TO_LE (ctx->crc);
+  memcpy (md, &crc, 4);
+}
+
+uint8_t
+gx_proto_crc32_calc (uint8_t *pchMsg, uint32_t wDataLen, uint8_t *pchMsgDst)
+{
+  gf_crc32_context context = { 0 };
+
+  if (!pchMsg)
+    return 0;
+
+  crc32_init (&context);
+
+  crc32_update (&context, pchMsg, wDataLen);
+
+  crc32_final (&context, pchMsgDst);
+
+
+  return 1;
+}
+/*
+ *  protocol
+ *
+ */
+
+static uint8_t dump_seq = 0;
+
+static void
+init_pack_header (
+  ppack_header pheader,
+  uint16_t     len,
+  uint16_t     cmd,
+  uint8_t      packagenum
+                 )
+{
+  g_assert (pheader);
+
+  memset (pheader, 0, sizeof (*pheader));
+  pheader->cmd0 = HIBYTE (cmd);
+  pheader->cmd1 = LOBYTE (cmd);
+  pheader->packagenum = packagenum;
+  pheader->reserved = dump_seq++;
+  pheader->len = GUINT16_TO_LE (len + PACKAGE_CRC_SIZE);
+  pheader->crc8 = gx_proto_crc8_calc ((uint8_t *) pheader, 6);
+  pheader->rev_crc8 = ~pheader->crc8;
+}
+
+
+int
+gx_proto_build_package (uint8_t       *ppackage,
+                        uint32_t      *package_len,
+                        uint16_t       cmd,
+                        const uint8_t *payload,
+                        uint32_t       payload_size)
+{
+  pack_header header;
+
+  if (!ppackage || !package_len)
+    return -1;
+
+  if(*package_len < (payload_size + PACKAGE_HEADER_SIZE + PACKAGE_CRC_SIZE))
+    return -1;
+
+  init_pack_header (&header, payload_size, cmd, 0);
+
+  memcpy (ppackage, &header, PACKAGE_HEADER_SIZE);
+  memcpy (ppackage + PACKAGE_HEADER_SIZE, payload, payload_size);
+
+  gx_proto_crc32_calc (ppackage, PACKAGE_HEADER_SIZE + payload_size, ppackage + PACKAGE_HEADER_SIZE + payload_size);
+
+  return 0;
+}
+
+
+int
+gx_proto_parse_header (
+  uint8_t     *buffer,
+  uint32_t     buffer_len,
+  pack_header *pheader)
+{
+  if (!buffer || !pheader)
+    return -1;
+  if (buffer_len < PACKAGE_HEADER_SIZE + PACKAGE_CRC_SIZE)
+    return -1;
+
+  memcpy (pheader, buffer, sizeof (pack_header));
+  pheader->len = GUINT16_FROM_LE (pheader->len);
+  if (buffer_len < pheader->len + PACKAGE_HEADER_SIZE)
+    return -1;
+  pheader->len -= PACKAGE_CRC_SIZE;
+  return 0;
+}
+
+static int
+gx_proto_parse_fingerid (
+  uint8_t          * fid_buffer,
+  uint16_t           fid_buffer_size,
+  ptemplate_format_t template
+                        )
+{
+  uint8_t * buffer = NULL;
+  uint16_t Offset = 0;
+
+  if (!template || !fid_buffer)
+    return -1;
+
+  if (fid_buffer_size < G_STRUCT_OFFSET (template_format_t, payload) + sizeof (uint32_t))
+    return -1;
+
+  buffer = fid_buffer;
+  Offset = 0;
+
+  if (buffer[Offset++] != 67)
+    return -1;
+  fid_buffer_size--;
+
+  template->type = buffer[Offset++];
+  fid_buffer_size--;
+  template->finger_index = buffer[Offset++];
+  fid_buffer_size--;
+  Offset++;
+  memcpy (template->accountid, &buffer[Offset], sizeof (template->accountid));
+  Offset += sizeof (template->accountid);
+  memcpy (template->tid, &buffer[Offset], sizeof (template->tid));
+  Offset += sizeof (template->tid);   // Offset == 68
+  template->payload.size = buffer[Offset++];
+  if (template->payload.size > sizeof (template->payload.data))
+    return -1;
+  memset (template->payload.data, 0, template->payload.size);
+  memcpy (template->payload.data, &buffer[Offset], template->payload.size);
+
+  return 0;
+}
+
+int
+gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_cmd_response_t presp)
+{
+  uint16_t offset = 0;
+  uint8_t *fingerlist = NULL;
+
+  if (!buffer || !presp)
+    return -1;
+  if (buffer_len < 1)
+    return -1;
+  presp->result = buffer[0];
+  switch (HIBYTE (cmd))
+    {
+    case RESPONSE_PACKAGE_CMD:
+      {
+        if (buffer_len < sizeof (gxfp_parse_msg_t) + 1)
+          return -1;
+        presp->parse_msg.ack_cmd = buffer[1];
+      }
+      break;
+
+    case MOC_CMD0_UPDATE_CONFIG:
+      {
+        presp->finger_config.status = buffer[0];
+        if (buffer_len >= 3)
+          presp->finger_config.max_stored_prints = buffer[2];
+        else
+          /* to compatiable old version firmware */
+          presp->finger_config.max_stored_prints = FP_MAX_FINGERNUM;
+
+      }
+      break;
+
+    case MOC_CMD0_COMMITENROLLMENT:
+    case MOC_CMD0_DELETETEMPLATE:
+      /* just check result */
+      break;
+
+    case MOC_CMD0_PWR_BTN_SHIELD:
+      presp->power_button_shield_resp.resp_cmd1 = LOBYTE (cmd);
+      if (buffer_len >= 2)
+        {
+          uint8_t support_pwr_shield = buffer[1];
+          if (support_pwr_shield == 0xFF)
+            g_debug ("Power button shield feature not supported!\n");
+        }
+      break;
+
+    case MOC_CMD0_GET_VERSION:
+      if (buffer_len < sizeof (gxfp_version_info_t) + 1)
+        return -1;
+      memcpy (&presp->version_info, buffer + 1, sizeof (gxfp_version_info_t));
+      break;
+
+    case MOC_CMD0_CAPTURE_DATA:
+      if (LOBYTE (cmd) == MOC_CMD1_DEFAULT)
+        {
+          if (buffer_len < sizeof (gxfp_capturedata_t) + 1)
+            return -1;
+          presp->capture_data_resp.img_quality  = buffer[1];
+          presp->capture_data_resp.img_coverage = buffer[2];
+        }
+      break;
+
+    case MOC_CMD0_ENROLL_INIT:
+      if (buffer_len < sizeof (gxfp_enroll_init_t) + 1)
+        return -1;
+      if (presp->result == GX_SUCCESS)
+        memcpy (&presp->enroll_init.tid, &buffer[1], TEMPLATE_ID_SIZE);
+      break;
+
+    case MOC_CMD0_ENROLL:
+      if (buffer_len < sizeof (gxfp_enroll_update_t))
+        return -1;
+      presp->enroll_update.rollback = (buffer[0] < 0x80) ? false : true;
+      presp->enroll_update.img_overlay    = buffer[1];
+      presp->enroll_update.img_preoverlay = buffer[2];
+      break;
+
+    case MOC_CMD0_CHECK4DUPLICATE:
+      presp->check_duplicate_resp.duplicate = (presp->result == 0) ? false : true;
+      if (presp->check_duplicate_resp.duplicate)
+        {
+          if (buffer_len < 3)
+            return -1;
+          uint16_t tid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + 1));
+          if ((buffer_len < tid_size + 3) || (buffer_len > sizeof (template_format_t)) + 3)
+            return -1;
+          memcpy (&presp->check_duplicate_resp.template, buffer + 3, tid_size);
+        }
+      break;
+
+    case MOC_CMD0_GETFINGERLIST:
+      if (presp->result != GX_SUCCESS)
+        break;
+      if (buffer_len < 2)
+        return -1;
+      presp->finger_list_resp.finger_num = buffer[1];
+      fingerlist = buffer + 2;
+      for(uint8_t num = 0; num < presp->finger_list_resp.finger_num; num++)
+        {
+          uint16_t fingerid_length = GUINT16_FROM_LE (*(uint16_t *) (fingerlist + offset));
+          offset += 2;
+          if (buffer_len < fingerid_length + offset + 2)
+            return -1;
+          if (gx_proto_parse_fingerid (fingerlist + offset,
+                                       fingerid_length,
+                                       &presp->finger_list_resp.finger_list[num]) != 0)
+            {
+              g_error ("parse fingerlist error");
+              presp->finger_list_resp.finger_num = 0;
+              presp->result = GX_FAILED;
+              break;
+            }
+          offset += fingerid_length;
+        }
+      break;
+
+    case MOC_CMD0_IDENTIFY:
+      {
+        uint32_t score = 0;
+        uint8_t study = 0;
+        uint16_t fingerid_size = 0;
+        presp->verify.match = (buffer[0] == 0) ? true : false;
+        if (presp->verify.match)
+          {
+            if (buffer_len < sizeof (template_format_t) + 10)
+              return -1;
+            offset += 1;
+            presp->verify.rejectdetail = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
+            offset += 2;
+            score = GUINT32_FROM_LE (*(uint32_t *) (buffer + offset));
+            offset += 4;
+            study = buffer[offset];
+            offset += 1;
+            fingerid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
+            offset += 2;
+            if (gx_proto_parse_fingerid (buffer + offset, fingerid_size, &presp->verify.template) != 0)
+              {
+                presp->result = GX_FAILED;
+                break;
+              }
+            g_debug ("match, score: %d, study: %d", score, study);
+          }
+      }
+      break;
+
+    case MOC_CMD0_FINGER_MODE:
+      presp->finger_status.status = buffer[0];
+      break;
+
+    default:
+      break;
+    }
+
+  return 0;
+}
+
+static uint8_t sensor_config[26] = {
+  0x00, 0x00, 0x64, 0x50, 0x0f, 0x41, 0x08, 0x0a, 0x18, 0x00, 0x00, 0x23, 0x00,
+  0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x05, 0x05
+};
+
+int
+gx_proto_init_sensor_config (pgxfp_sensor_cfg_t pconfig)
+{
+  uint32_t crc32_calc = 0;
+
+  if (!pconfig)
+    return -1;
+  memset (pconfig, 0, sizeof (*pconfig));
+
+  //NOTICE: Do not change any value!
+  memcpy (&pconfig->config, sensor_config, G_N_ELEMENTS (sensor_config));
+  pconfig->reserved[0] = 1;
+
+  gx_proto_crc32_calc ((uint8_t *) pconfig, sizeof (*pconfig) - PACKAGE_CRC_SIZE, (uint8_t *) &crc32_calc);
+
+  memcpy (pconfig->crc_value, &crc32_calc, PACKAGE_CRC_SIZE);
+
+  return 0;
+}
@@ -0,0 +1,249 @@
+/*
+ * Goodix Moc driver for libfprint
+ * Copyright (C) 2019 Shenzhen Goodix Technology Co., Ltd.
+ *
+ * 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 <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define PACKAGE_CRC_SIZE (4)
+#define PACKAGE_HEADER_SIZE (8)
+
+#define FP_MAX_FINGERNUM (20)
+
+#define TEMPLATE_ID_SIZE (32)
+
+#define GX_VERSION_LEN (8)
+
+/* Type covert */
+#define MAKE_CMD_EX(cmd0, cmd1)    ((uint16_t) (((cmd0) << 8) | (cmd1)))
+#define LOBYTE(value) ((uint8_t) (value))
+#define HIBYTE(value) ((uint8_t) (((uint16_t) (value) >> 8) & 0xFF))
+
+
+/* Error code */
+#define GX_SUCCESS 0x00
+#define GX_FAILED 0x80
+#define GX_ERROR_FINGER_ID_NOEXIST 0x9C
+#define GX_ERROR_TEMPLATE_INCOMPLETE 0xB8
+#define GX_ERROR_WAIT_FINGER_UP_TIMEOUT 0xC7
+#define GX_ERROR_NO_AVAILABLE_SPACE 0x8F
+
+/* Command Type Define */
+#define RESPONSE_PACKAGE_CMD 0xAA
+
+#define MOC_CMD0_ENROLL 0xA0
+#define MOC_CMD0_ENROLL_INIT 0xA1
+#define MOC_CMD0_CAPTURE_DATA 0xA2
+#define MOC_CMD0_CHECK4DUPLICATE 0xA3
+#define MOC_CMD0_COMMITENROLLMENT 0xA4
+
+#define MOC_CMD0_IDENTIFY 0xA5
+#define MOC_CMD0_GETFINGERLIST 0xA6
+#define MOC_CMD0_DELETETEMPLATE 0xA7
+
+#define MOC_CMD1_DEFAULT 0x00
+#define MOC_CMD1_UNTIL_DOWN 0x00
+#define MOC_CMD1_WHEN_DOWN 0x01
+
+#define MOC_CMD1_DELETE_TEMPLATE 0x04
+#define MOC_CMD1_DELETE_ALL 0x01
+
+#define MOC_CMD0_GET_VERSION 0xD0
+
+#define MOC_CMD0_UPDATE_CONFIG 0xC0
+#define MOC_CMD1_NWRITE_CFG_TO_FLASH 0x00
+#define MOC_CMD1_WRITE_CFG_TO_FLASH 0x01
+
+#define MOC_CMD0_FINGER_MODE 0xB0
+#define MOC_CMD1_GET_FINGER_MODE 0x00
+#define MOC_CMD1_SET_FINGER_DOWN 0x01
+#define MOC_CMD1_SET_FINGER_UP 0x02
+
+#define MOC_CMD0_PWR_BTN_SHIELD 0xE0
+#define MOC_CMD1_PWR_BTN_SHIELD_OFF 0x00
+#define MOC_CMD1_PWR_BTN_SHIELD_ON 0x01
+
+/* */
+
+typedef struct _gxfp_version_info
+{
+  uint8_t format[2];
+  uint8_t fwtype[GX_VERSION_LEN];
+  uint8_t fwversion[GX_VERSION_LEN];
+  uint8_t customer[GX_VERSION_LEN];
+  uint8_t mcu[GX_VERSION_LEN];
+  uint8_t sensor[GX_VERSION_LEN];
+  uint8_t algversion[GX_VERSION_LEN];
+  uint8_t interface[GX_VERSION_LEN];
+  uint8_t protocol[GX_VERSION_LEN];
+  uint8_t flashVersion[GX_VERSION_LEN];
+  uint8_t reserved[38];
+} gxfp_version_info_t, *pgxfp_version_info_t;
+
+
+typedef struct _gxfp_parse_msg
+{
+  uint8_t ack_cmd;
+  bool    has_no_config;
+} gxfp_parse_msg_t, *pgxfp_parse_msg_t;
+
+
+typedef struct _gxfp_enroll_init
+{
+  uint8_t tid[TEMPLATE_ID_SIZE];
+} gxfp_enroll_init_t, *pgxfp_enroll_init_t;
+
+#pragma pack(push, 1)
+typedef struct _template_format
+{
+  uint8_t type;
+  uint8_t finger_index;
+  uint8_t accountid[32];
+  uint8_t tid[32];
+  struct
+  {
+    uint32_t size;
+    uint8_t  data[56];
+  } payload;
+  uint8_t reserve[2];
+} template_format_t, *ptemplate_format_t;
+
+#pragma pack(pop)
+
+
+typedef struct _gxfp_verify
+{
+  bool     match;
+  uint32_t rejectdetail;
+  template_format_t  template;
+} gxfp_verify_t, *pgxfp_verify_t;
+
+
+typedef struct _gxfp_capturedata
+{
+  uint8_t img_quality;
+  uint8_t img_coverage;
+} gxfp_capturedata_t, *pgxfp_capturedata_t;
+
+typedef struct _gxfp_check_duplicate
+{
+  bool duplicate;
+  template_format_t  template;
+} gxfp_check_duplicate_t, *pgxfp_check_duplicate_t;
+
+
+typedef struct _gxfp_enroll_update
+{
+  bool    rollback;
+  uint8_t img_overlay;
+  uint8_t img_preoverlay;
+} gxfp_enroll_update_t, *Pgxfp_enroll_update_t;
+
+typedef struct _gxfp_enum_fingerlist
+{
+  uint8_t           finger_num;
+  template_format_t finger_list[FP_MAX_FINGERNUM];
+} gxfp_enum_fingerlist_t, *pgxfp_enum_fingerlist_t;
+
+typedef struct _gxfp_enroll_commit
+{
+  uint8_t result;
+} gxfp_enroll_commit_t, *pgxfp_enroll_commit_t;
+
+typedef struct _fp_finger_status
+{
+  uint8_t status;
+} fp_finger_status_t, *pfp_finger_status_t;
+
+typedef struct _fp_finger_config
+{
+  uint8_t status;
+  uint8_t max_stored_prints;
+} fp_finger_config_t, *pfp_finger_config_t;
+
+typedef struct _fp_pwr_btn_shield
+{
+  uint8_t resp_cmd1;
+} fp_pwr_btn_shield_t, *pfp_pwr_btn_shield_t;
+
+typedef struct _fp_cmd_response
+{
+  uint8_t result;
+  union
+  {
+    gxfp_parse_msg_t       parse_msg;
+    gxfp_verify_t          verify;
+    gxfp_enroll_init_t     enroll_init;
+    gxfp_capturedata_t     capture_data_resp;
+    gxfp_check_duplicate_t check_duplicate_resp;
+    gxfp_enroll_commit_t   enroll_commit;
+    gxfp_enroll_update_t   enroll_update;
+    gxfp_enum_fingerlist_t finger_list_resp;
+    gxfp_version_info_t    version_info;
+    fp_finger_status_t     finger_status;
+    fp_finger_config_t     finger_config;
+    fp_pwr_btn_shield_t    power_button_shield_resp;
+  };
+} gxfp_cmd_response_t, *pgxfp_cmd_response_t;
+
+
+typedef struct _pack_header
+{
+  uint8_t  cmd0;
+  uint8_t  cmd1;
+  uint8_t  packagenum;
+  uint8_t  reserved;
+  uint16_t len;
+  uint8_t  crc8;
+  uint8_t  rev_crc8;
+} pack_header, *ppack_header;
+
+
+typedef struct _gxfp_sensor_cfg
+{
+  uint8_t config[26];
+  uint8_t reserved[98];
+  uint8_t crc_value[4];
+} gxfp_sensor_cfg_t, *pgxfp_sensor_cfg_t;
+/* */
+
+int gx_proto_build_package (uint8_t       *ppackage,
+                            uint32_t      *package_len,
+                            uint16_t       cmd,
+                            const uint8_t *payload,
+                            uint32_t       payload_size);
+
+int gx_proto_parse_header (uint8_t     *buffer,
+                           uint32_t     buffer_len,
+                           pack_header *pheader);
+
+int gx_proto_parse_body (uint16_t             cmd,
+                         uint8_t             *buffer,
+                         uint16_t             buffer_len,
+                         pgxfp_cmd_response_t presponse);
+
+int gx_proto_init_sensor_config (pgxfp_sensor_cfg_t pconfig);
+
+uint8_t gx_proto_crc8_calc (uint8_t *lubp_date,
+                            uint32_t lui_len);
+
+uint8_t gx_proto_crc32_calc (uint8_t *pchMsg,
+                             uint32_t wDataLen,
+                             uint8_t *pchMsgDst);
@@ -17,8 +17,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef _BMKT_H_
-#define _BMKT_H_
+#pragma once

 /**< User ID maximum length allowed */
 #define BMKT_MAX_USER_ID_LEN 100
@@ -228,5 +227,3 @@ typedef struct bmkt_user_id
 #ifdef __cplusplus
 }
 #endif
-
-#endif /* _BMKT_H_ */
@@ -206,6 +206,7 @@ parse_get_enrolled_users_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *res
  get_enroll_templates_resp->query_sequence = extract8 (msg_resp->payload, &offset);

  int n = 0;
+
  for (n = 0; n < BMKT_MAX_NUM_TEMPLATES_INTERNAL_FLASH; n++)
    {
      if (offset >= msg_resp->payload_len)
@@ -16,10 +16,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-
-#ifndef BMKT_MESSAGE_H_
-#define BMKT_MESSAGE_H_
-
+#pragma once

 #define BMKT_MESSAGE_HEADER_ID 0xFE
 #define BMKT_MESSAGE_HEADER_LEN (4)
@@ -90,4 +87,3 @@ int bmkt_parse_message_header (uint8_t         *resp_buf,
                               bmkt_msg_resp_t *msg_resp);
 int bmkt_parse_message_payload (bmkt_msg_resp_t *msg_resp,
                                bmkt_response_t *resp);
-#endif /* BMKT_MESSAGE_H_ */
@@ -17,9 +17,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-
-#ifndef _BMKT_RESPONSE_H_
-#define _BMKT_RESPONSE_H_
+#pragma once

 #include "bmkt.h"

@@ -318,7 +316,7 @@ typedef struct bmkt_init_resp
 */
 typedef struct bmkt_enroll_resp
 {
-  int     progress;                             /**< Shows current progress stutus [0-100] */
+  int     progress;                             /**< Shows current progress status [0-100] */
  uint8_t finger_id;                            /**< User's finger id [1-10] */
  uint8_t user_id[BMKT_MAX_USER_ID_LEN];        /**< User name to be enrolled */
 } bmkt_enroll_resp_t;
@@ -485,5 +483,3 @@ typedef struct bmkt_response
  int                  complete;        /**< Operation completion status 1: complete / 0: not completed */
  bmkt_response_data_t response;        /**< Operation specific response union */
 } bmkt_response_t;
-
-#endif /* _BMKT_RESPONSE_H_ */
@@ -16,8 +16,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef _SENSOR_H_
-#define _SENSOR_H_
+#pragma once

 #include "usb_transport.h"
 #define BMKT_MAX_PENDING_SESSIONS 2
@@ -84,4 +83,3 @@ int bmkt_sensor_handle_response (bmkt_sensor_t   *sensor,
                                 bmkt_msg_resp_t *msg_resp);

 int bmkt_sensor_send_async_read_command (bmkt_sensor_t *sensor);
-#endif /* _SENSOR_H_ */
@@ -27,15 +27,24 @@

 G_DEFINE_TYPE (FpiDeviceSynaptics, fpi_device_synaptics, FP_TYPE_DEVICE)

+static void init_identify_msg (FpDevice *device);
+static void compose_and_send_identify_msg (FpDevice *device);
+
 static const FpIdEntry id_table[] = {
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xBD,  },
-
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xE9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xDF,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xF9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xFC,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC2,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xE7,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };


 static void
-cmd_recieve_cb (FpiUsbTransfer *transfer,
+cmd_receive_cb (FpiUsbTransfer *transfer,
                FpDevice       *device,
                gpointer        user_data,
                GError         *error)
@@ -78,10 +87,17 @@ cmd_recieve_cb (FpiUsbTransfer *transfer,
      if (msg_resp.payload[0] == 0x01)
        {
          self->finger_on_sensor = TRUE;
+          fpi_device_report_finger_status_changes (device,
+                                                   FP_FINGER_STATUS_PRESENT,
+                                                   FP_FINGER_STATUS_NONE);
        }
      else
        {
          self->finger_on_sensor = FALSE;
+          fpi_device_report_finger_status_changes (device,
+                                                   FP_FINGER_STATUS_NONE,
+                                                   FP_FINGER_STATUS_PRESENT);
+
          if (self->cmd_complete_on_removal)
            {
              fpi_ssm_mark_completed (transfer->ssm);
@@ -108,7 +124,7 @@ cmd_recieve_cb (FpiUsbTransfer *transfer,
    {
      if (resp.response_id == BMKT_RSP_CANCEL_OP_OK)
        {
-          fp_dbg ("Received cancellation success resonse");
+          fp_dbg ("Received cancellation success response");
          fpi_ssm_mark_failed (transfer->ssm,
                               g_error_new_literal (G_IO_ERROR,
                                                    G_IO_ERROR_CANCELLED,
@@ -137,7 +153,8 @@ cmd_recieve_cb (FpiUsbTransfer *transfer,
          fp_warn ("Received General Error %d from the sensor", (guint) err);
          fpi_ssm_mark_failed (transfer->ssm,
                               fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                         "Received general error from device"));
+                                                         "Received general error %u from device",
+                                                         (guint) err));
          //fpi_ssm_jump_to_state (transfer->ssm, fpi_ssm_get_cur_state (transfer->ssm));
          return;
        }
@@ -167,7 +184,7 @@ cmd_recieve_cb (FpiUsbTransfer *transfer,
   * depending on resp.complete. */
  if (self->cmd_pending_transfer)
    fpi_ssm_jump_to_state (transfer->ssm, SYNAPTICS_CMD_SEND_PENDING);
-  else if (!resp.complete)
+  else if (!resp.complete || self->cmd_complete_on_removal)
    fpi_ssm_next_state (transfer->ssm);             /* SYNAPTICS_CMD_WAIT_INTERRUPT */
  else
    fpi_ssm_mark_completed (transfer->ssm);
@@ -192,19 +209,26 @@ cmd_interrupt_cb (FpiUsbTransfer *transfer,
      fpi_ssm_mark_failed (transfer->ssm, error);
      return;
    }
-  g_clear_pointer (&error, g_error_free);

-  if (transfer->buffer[0] & USB_ASYNC_MESSAGE_PENDING || error)
-    fpi_ssm_next_state (transfer->ssm);
+  if (transfer->buffer[0] & USB_ASYNC_MESSAGE_PENDING)
+    {
+      fpi_ssm_next_state (transfer->ssm);
+    }
  else
-    fpi_usb_transfer_submit (transfer, 1000, NULL, cmd_interrupt_cb, NULL);
+    {
+      fpi_usb_transfer_submit (fpi_usb_transfer_ref (transfer),
+                               0,
+                               NULL,
+                               cmd_interrupt_cb,
+                               NULL);
+    }
 }

 static void
 synaptics_cmd_run_state (FpiSsm   *ssm,
                         FpDevice *dev)
 {
-  g_autoptr(FpiUsbTransfer) transfer = NULL;
+  FpiUsbTransfer *transfer;
  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (dev);

  switch (fpi_ssm_get_cur_state (ssm))
@@ -218,7 +242,7 @@ synaptics_cmd_run_state (FpiSsm   *ssm,
                                   NULL,
                                   fpi_ssm_usb_transfer_cb,
                                   NULL);
-          g_clear_pointer (&self->cmd_pending_transfer, fpi_usb_transfer_unref);
+          self->cmd_pending_transfer = NULL;
        }
      else
        {
@@ -233,7 +257,7 @@ synaptics_cmd_run_state (FpiSsm   *ssm,
      fpi_usb_transfer_submit (transfer,
                               5000,
                               NULL,
-                               cmd_recieve_cb,
+                               cmd_receive_cb,
                               fpi_ssm_get_data (ssm));

      break;
@@ -278,18 +302,10 @@ cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
  self->cmd_ssm = NULL;

  /* Notify about the SSM failure from here instead. */
-  if (error)
-    {
-      callback (self, NULL, error);
-    }
-  else if (self->cmd_complete_on_removal)
-    {
-      callback (self, NULL, self->cmd_complete_error);
-      self->cmd_complete_error = NULL;
-    }
+  if (error || self->cmd_complete_on_removal)
+    callback (self, NULL, error);
+
  self->cmd_complete_on_removal = FALSE;
-  g_clear_pointer (&self->cmd_complete_error, g_error_free);
-  fpi_ssm_free (ssm);
 }

 static void
@@ -317,7 +333,7 @@ synaptics_sensor_cmd (FpiDeviceSynaptics *self,
                      gssize              payload_len,
                      SynCmdMsgCallback   callback)
 {
-  g_autoptr(FpiUsbTransfer) transfer = NULL;
+  FpiUsbTransfer *transfer;
  guint8 real_seq_num;
  gint msg_len;
  gint res;
@@ -328,11 +344,11 @@ synaptics_sensor_cmd (FpiDeviceSynaptics *self,
  g_assert (payload || payload_len == 0);

  /* seq_num of 0 means a normal command, -1 means the current commands
-   * sequence number should not be udpated (i.e. second async command which
+   * sequence number should not be updated (i.e. second async command which
   * may only be a cancellation currently). */
  if (seq_num <= 0)
    {
-      self->last_seq_num = MAX (1, self->last_seq_num + 1);
+      self->last_seq_num = MAX (1, (self->last_seq_num + 1) & 0xff);
      real_seq_num = self->last_seq_num;
      if (seq_num == 0)
        self->cmd_seq_num = self->last_seq_num;
@@ -407,7 +423,7 @@ static gboolean
 parse_print_data (GVariant      *data,
                  guint8        *finger,
                  const guint8 **user_id,
-                  gssize        *user_id_len)
+                  gsize         *user_id_len)
 {
  g_autoptr(GVariant) user_id_var = NULL;

@@ -438,6 +454,37 @@ parse_print_data (GVariant      *data,
  return TRUE;
 }

+static FpPrint *
+create_print (FpiDeviceSynaptics *self,
+              guint8             *user_id,
+              guint8              finger_id)
+{
+  FpPrint *print;
+  g_autofree gchar *user_id_safe;
+  GVariant *data = NULL;
+  GVariant *uid = NULL;
+
+  user_id_safe = g_strndup ((char *) user_id, BMKT_MAX_USER_ID_LEN);
+
+  print = fp_print_new (FP_DEVICE (self));
+  uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
+                                   user_id_safe,
+                                   strlen (user_id_safe),
+                                   1);
+  data = g_variant_new ("(y@ay)",
+                        finger_id,
+                        uid);
+
+  fpi_print_set_type (print, FPI_PRINT_RAW);
+  fpi_print_set_device_stored (print, TRUE);
+  g_object_set (print, "fpi-data", data, NULL);
+  g_object_set (print, "description", user_id_safe, NULL);
+
+  fpi_print_fill_from_user_id (print, user_id_safe);
+
+  return print;
+}
+
 static void
 list_msg_cb (FpiDeviceSynaptics *self,
             bmkt_response_t    *resp,
@@ -447,7 +494,7 @@ list_msg_cb (FpiDeviceSynaptics *self,

  if (error)
    {
-      g_clear_pointer (&self->list_result, g_ptr_array_free);
+      g_clear_pointer (&self->list_result, g_ptr_array_unref);
      fpi_device_list_complete (FP_DEVICE (self), NULL, error);
      return;
    }
@@ -468,11 +515,12 @@ list_msg_cb (FpiDeviceSynaptics *self,
      else
        {
          fp_info ("Failed to query enrolled users: %d", resp->result);
-          g_clear_pointer (&self->list_result, g_ptr_array_free);
+          g_clear_pointer (&self->list_result, g_ptr_array_unref);
          fpi_device_list_complete (FP_DEVICE (self),
                                    NULL,
                                    fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                              "Failed to query enrolled users"));
+                                                              "Failed to query enrolled users: %d",
+                                                              resp->result));
        }
      break;

@@ -489,10 +537,7 @@ list_msg_cb (FpiDeviceSynaptics *self,

      for (int n = 0; n < BMKT_MAX_NUM_TEMPLATES_INTERNAL_FLASH; n++)
        {
-          GVariant *data = NULL;
-          GVariant *uid = NULL;
          FpPrint *print;
-          gchar *userid;

          if (get_enroll_templates_resp->templates[n].user_id_len == 0)
            continue;
@@ -505,56 +550,9 @@ list_msg_cb (FpiDeviceSynaptics *self,
                   get_enroll_templates_resp->templates[n].user_id,
                   get_enroll_templates_resp->templates[n].finger_id);

-          userid = get_enroll_templates_resp->templates[n].user_id;
-
-          print = fp_print_new (FP_DEVICE (self));
-          uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
-                                           get_enroll_templates_resp->templates[n].user_id,
-                                           get_enroll_templates_resp->templates[n].user_id_len,
-                                           1);
-          data = g_variant_new ("(y@ay)",
-                                get_enroll_templates_resp->templates[n].finger_id,
-                                uid);
-
-          fpi_print_set_type (print, FP_PRINT_RAW);
-          fpi_print_set_device_stored (print, TRUE);
-          g_object_set (print, "fp-data", data, NULL);
-          g_object_set (print, "description", get_enroll_templates_resp->templates[n].user_id, NULL);
-
-          /* The format has 24 bytes at the start and some dashes in the right places */
-          if (g_str_has_prefix (userid, "FP1-") && strlen (userid) >= 24 &&
-              userid[12] == '-' && userid[14] == '-' && userid[23] == '-')
-            {
-              g_autofree gchar *copy = g_strdup (userid);
-              gint32 date_ymd;
-              GDate *date = NULL;
-              gint32 finger;
-              gchar *username;
-              /* Try to parse information from the string. */
-
-              copy[12] = '\0';
-              date_ymd = g_ascii_strtod (copy + 4, NULL);
-              if (date_ymd > 0)
-                date = g_date_new_dmy (date_ymd % 100,
-                                       (date_ymd / 100) % 100,
-                                       date_ymd / 10000);
-              else
-                date = g_date_new ();
-
-              fp_print_set_enroll_date (print, date);
-              g_date_free (date);
-
-              copy[14] = '\0';
-              finger = g_ascii_strtoll (copy + 13, NULL, 16);
-              fp_print_set_finger (print, finger);
-
-              /* We ignore the next chunk, it is just random data.
-               * Then comes the username; nobody is the default if the metadata
-               * is unknown */
-              username = copy + 24;
-              if (strlen (username) > 0 && g_strcmp0 (username, "nobody") != 0)
-                fp_print_set_username (print, username);
-            }
+          print = create_print (self,
+                                get_enroll_templates_resp->templates[n].user_id,
+                                get_enroll_templates_resp->templates[n].finger_id);

          g_ptr_array_add (self->list_result, g_object_ref_sink (print));
        }
@@ -581,6 +579,22 @@ list (FpDevice *device)
  synaptics_sensor_cmd (self, 0, BMKT_CMD_GET_TEMPLATE_RECORDS, NULL, 0, list_msg_cb);
 }

+static void
+verify_complete_after_finger_removal (FpiDeviceSynaptics *self)
+{
+  FpDevice *device = FP_DEVICE (self);
+
+  if (self->finger_on_sensor)
+    {
+      fp_dbg ("delaying verify report until after finger removal!");
+      self->cmd_complete_on_removal = TRUE;
+    }
+  else
+    {
+      fpi_device_verify_complete (device, NULL);
+    }
+}
+
 static void
 verify_msg_cb (FpiDeviceSynaptics *self,
               bmkt_response_t    *resp,
@@ -591,24 +605,26 @@ verify_msg_cb (FpiDeviceSynaptics *self,

  if (error)
    {
-      fpi_device_verify_complete (device, FPI_MATCH_ERROR, NULL, error);
+      fpi_device_verify_complete (device, error);
      return;
    }

  if (resp == NULL && self->cmd_complete_on_removal)
    {
-      fpi_device_verify_complete (device,
-                                  GPOINTER_TO_INT (self->cmd_complete_data),
-                                  NULL,
-                                  error);
+      fpi_device_verify_complete (device, NULL);
      return;
    }

+  g_assert (resp != NULL);
+
  verify_resp = &resp->response.verify_resp;

  switch (resp->response_id)
    {
    case BMKT_RSP_VERIFY_READY:
+      fpi_device_report_finger_status_changes (device,
+                                               FP_FINGER_STATUS_NEEDED,
+                                               FP_FINGER_STATUS_NONE);
      fp_info ("Place Finger on the Sensor!");
      break;

@@ -617,39 +633,40 @@ verify_msg_cb (FpiDeviceSynaptics *self,
      break;

    case BMKT_RSP_VERIFY_FAIL:
-      if(resp->result == BMKT_SENSOR_STIMULUS_ERROR)
+      if (resp->result == BMKT_SENSOR_STIMULUS_ERROR)
        {
-          fp_dbg ("delaying retry error until after finger removal!");
-          self->cmd_complete_on_removal = TRUE;
-          self->cmd_complete_data = GINT_TO_POINTER (FPI_MATCH_ERROR);
-          self->cmd_complete_error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL);
+          fp_info ("Match error occurred");
+          fpi_device_verify_report (device, FPI_MATCH_ERROR, NULL,
+                                    fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
+          verify_complete_after_finger_removal (self);
        }
      else if (resp->result == BMKT_FP_NO_MATCH)
        {
-          fp_dbg ("delaying match failure until after finger removal!");
-          self->cmd_complete_on_removal = TRUE;
-          self->cmd_complete_data = GINT_TO_POINTER (FPI_MATCH_FAIL);
-          self->cmd_complete_error = NULL;
+          fp_info ("Print didn't match");
+          fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, NULL);
+          verify_complete_after_finger_removal (self);
        }
-      else if (BMKT_FP_DATABASE_NO_RECORD_EXISTS)
+      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS)
        {
          fp_info ("Print is not in database");
          fpi_device_verify_complete (device,
-                                      FPI_MATCH_ERROR,
-                                      NULL,
                                      fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
        }
      else
        {
          fp_warn ("Verify has failed: %d", resp->result);
-          fpi_device_verify_complete (device, FPI_MATCH_FAIL, NULL, NULL);
+          fpi_device_verify_complete (device,
+                                      fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                                "Unexpected result from device %d",
+                                                                resp->result));
        }
      break;

    case BMKT_RSP_VERIFY_OK:
      fp_info ("Verify was successful! for user: %s finger: %d score: %f",
               verify_resp->user_id, verify_resp->finger_id, verify_resp->match_result);
-      fpi_device_verify_complete (device, FPI_MATCH_SUCCESS, NULL, NULL);
+      fpi_device_verify_report (device, FPI_MATCH_SUCCESS, NULL, NULL);
+      verify_complete_after_finger_removal (self);
      break;
    }
 }
@@ -667,13 +684,11 @@ verify (FpDevice *device)

  fpi_device_get_verify_data (device, &print);

-  g_object_get (print, "fp-data", &data, NULL);
+  g_object_get (print, "fpi-data", &data, NULL);
  g_debug ("data is %p", data);
  if (!parse_print_data (data, &finger, &user_id, &user_id_len))
    {
      fpi_device_verify_complete (device,
-                                  FPI_MATCH_ERROR,
-                                  NULL,
                                  fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
      return;
    }
@@ -683,6 +698,212 @@ verify (FpDevice *device)
  synaptics_sensor_cmd (self, 0, BMKT_CMD_VERIFY_USER, user_id, user_id_len, verify_msg_cb);
 }

+static void
+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!");
+      self->cmd_complete_on_removal = TRUE;
+    }
+  else
+    {
+      fpi_device_identify_complete (device, NULL);
+    }
+}
+
+
+static void
+identify_msg_cb (FpiDeviceSynaptics *self,
+                 bmkt_response_t    *resp,
+                 GError             *error)
+{
+  FpDevice *device = FP_DEVICE (self);
+
+  if (error)
+    {
+      fpi_device_identify_complete (device, error);
+      return;
+    }
+
+  if (resp == NULL && self->cmd_complete_on_removal)
+    {
+      fpi_device_identify_complete (device, NULL);
+      return;
+    }
+
+  g_assert (resp != NULL);
+
+  switch (resp->response_id)
+    {
+    case BMKT_RSP_ID_READY:
+      fp_info ("Place Finger on the Sensor!");
+      break;
+
+    case BMKT_RSP_SEND_NEXT_USER_ID:
+      {
+        compose_and_send_identify_msg (device);
+        break;
+      }
+
+    case BMKT_RSP_ID_FAIL:
+      if (resp->result == BMKT_SENSOR_STIMULUS_ERROR)
+        {
+          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);
+        }
+      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);
+        }
+      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS)
+        {
+          fp_info ("Print is not in database");
+          fpi_device_identify_complete (device,
+                                        fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
+        }
+      else
+        {
+          fp_warn ("identify has failed: %d", resp->result);
+          fpi_device_identify_complete (device,
+                                        fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                                  "Unexpected result from device %d",
+                                                                  resp->result));
+        }
+      break;
+
+    case BMKT_RSP_ID_OK:
+      {
+        FpPrint *print = NULL;
+        GPtrArray *prints = NULL;
+        g_autoptr(GVariant) data = NULL;
+        gboolean found = FALSE;
+        guint index;
+
+        print = create_print (self,
+                              resp->response.id_resp.user_id,
+                              resp->response.id_resp.finger_id);
+
+        fpi_device_get_identify_data (device, &prints);
+
+        found = g_ptr_array_find_with_equal_func (prints,
+                                                  print,
+                                                  (GEqualFunc) fp_print_equal,
+                                                  &index);
+
+        if (found)
+          fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL);
+        else
+          fpi_device_identify_report (device, NULL, print, NULL);
+
+        identify_complete_after_finger_removal (self);
+      }
+    }
+}
+
+static void
+identify (FpDevice *device)
+{
+  init_identify_msg (device);
+  compose_and_send_identify_msg (device);
+}
+
+static void
+init_identify_msg (FpDevice *device)
+{
+  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (device);
+
+  self->id_idx = 0;
+}
+
+static void
+compose_and_send_identify_msg (FpDevice *device)
+{
+  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (device);
+  FpPrint *print = NULL;
+  GPtrArray *prints = NULL;
+
+  g_autoptr(GVariant) data = NULL;
+  guint8 finger;
+  const guint8 *user_id;
+  gsize user_id_len = 0;
+  g_autofree guint8 *payload = NULL;
+  guint8 payload_len = 0;
+  guint8 payloadOffset = 0;
+
+  fpi_device_get_identify_data (device, &prints);
+  if (prints->len > UINT8_MAX)
+    {
+      fpi_device_identify_complete (device,
+                                    fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
+      return;
+    }
+  if(self->id_idx >= prints->len)
+    {
+      fp_warn ("Device asked for more prints than we are providing.");
+      fpi_device_identify_complete (device,
+                                    fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                              "Unexpected index"));
+      return;
+    }
+  print = g_ptr_array_index (prints, self->id_idx);
+  g_object_get (print, "fpi-data", &data, NULL);
+  g_debug ("data is %p", data);
+  if (!parse_print_data (data, &finger, &user_id, &user_id_len))
+    {
+      fpi_device_identify_complete (device,
+                                    fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
+      return;
+    }
+  if(self->id_idx == 0)
+    {
+      /*
+       * Construct payload.
+       * 1st byte is total number of IDs in list.
+       * 2nd byte is number of IDs in list.
+       * 1 byte for each ID length, maximum id length is 100.
+       * user_id_len bytes of each ID
+       */
+      payload_len = 2 + 1 + user_id_len;
+      payload = g_malloc0 (payload_len);
+      payload[payloadOffset] = prints->len;
+      payloadOffset += 1;
+      payload[payloadOffset] = 1; /* send one id per message */
+      payloadOffset += 1;
+      payload[payloadOffset] = user_id_len;
+      payloadOffset += 1;
+      memcpy (&payload[payloadOffset], user_id, user_id_len);
+      payloadOffset += user_id_len;
+
+      G_DEBUG_HERE ();
+
+      synaptics_sensor_cmd (self, 0, BMKT_CMD_ID_USER_IN_ORDER, payload, payloadOffset, identify_msg_cb);
+    }
+  else
+    {
+      /*
+       * 1st byte is the number of IDs
+       * 1 byte for each ID length
+       * id_length bytes for each ID
+       */
+      payload_len = 1 + 1 + user_id_len;
+      payload = g_malloc0 (payload_len);
+      payload[payloadOffset] = 1; /* send one id per message */
+      payloadOffset += 1;
+      payload[payloadOffset] = user_id_len;
+      payloadOffset += 1;
+      memcpy (&payload[payloadOffset], user_id, user_id_len);
+      payloadOffset += user_id_len;
+      synaptics_sensor_cmd (self, self->cmd_seq_num, BMKT_CMD_ID_NEXT_USER, payload, payloadOffset, NULL);
+    }
+  self->id_idx++;
+}
 static void
 enroll_msg_cb (FpiDeviceSynaptics *self,
               bmkt_response_t    *resp,
@@ -704,6 +925,9 @@ enroll_msg_cb (FpiDeviceSynaptics *self,
    case BMKT_RSP_ENROLL_READY:
      {
        self->enroll_stage = 0;
+        fpi_device_report_finger_status_changes (device,
+                                                 FP_FINGER_STATUS_NEEDED,
+                                                 FP_FINGER_STATUS_NONE);
        fp_info ("Place Finger on the Sensor!");
        break;
      }
@@ -723,7 +947,7 @@ enroll_msg_cb (FpiDeviceSynaptics *self,
        if (enroll_resp->progress < 100)
          done_stages = MIN (done_stages, ENROLL_SAMPLES - 1);

-        /* Emit a retry error if there has been no discernable
+        /* Emit a retry error if there has been no discernible
         * progress. Some firmware revisions report more required
         * touches. */
        if (self->enroll_stage == done_stages)
@@ -768,7 +992,8 @@ enroll_msg_cb (FpiDeviceSynaptics *self,
            fpi_device_enroll_complete (device,
                                        NULL,
                                        fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                                  "Enrollment failed"));
+                                                                  "Enrollment failed (%d)",
+                                                                  resp->result));
          }
        break;
      }
@@ -787,8 +1012,6 @@ enroll_msg_cb (FpiDeviceSynaptics *self,
    }
 }

-#define TEMPLATE_ID_SIZE 20
-
 static void
 enroll (FpDevice *device)
 {
@@ -796,52 +1019,21 @@ enroll (FpDevice *device)
  FpPrint *print = NULL;
  GVariant *data = NULL;
  GVariant *uid = NULL;
-  const gchar *username;
  guint finger;
-  g_autofree gchar *user_id;
+  g_autofree gchar *user_id = NULL;
  gssize user_id_len;
  g_autofree guint8 *payload = NULL;
-  const GDate *date;
-  gint y, m, d;
-  gint32 rand_id = 0;

  fpi_device_get_enroll_data (device, &print);

  G_DEBUG_HERE ();

-  date = fp_print_get_enroll_date (print);
-  if (date && g_date_valid (date))
-    {
-      y = date->year;
-      m = date->month;
-      d = date->day;
-    }
-  else
-    {
-      y = 0;
-      m = 0;
-      d = 0;
-    }
-
-  username = fp_print_get_username (print);
-  if (!username)
-    username = "nobody";
-
-  if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
-    rand_id = 0;
-  else
-    rand_id = g_random_int ();
-
-  user_id = g_strdup_printf ("FP1-%04d%02d%02d-%X-%08X-%s",
-                             y, m, d,
-                             fp_print_get_finger (print),
-                             rand_id,
-                             username);
+  user_id = fpi_print_generate_user_id (print);

  user_id_len = strlen (user_id);
  user_id_len = MIN (BMKT_MAX_USER_ID_LEN, user_id_len);

-  /* We currently always use finger 1 from the devices piont of view */
+  /* We currently always use finger 1 from the devices point of view */
  finger = 1;

  uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
@@ -852,9 +1044,9 @@ enroll (FpDevice *device)
                        finger,
                        uid);

-  fpi_print_set_type (print, FP_PRINT_RAW);
+  fpi_print_set_type (print, FPI_PRINT_RAW);
  fpi_print_set_device_stored (print, TRUE);
-  g_object_set (print, "fp-data", data, NULL);
+  g_object_set (print, "fpi-data", data, NULL);
  g_object_set (print, "description", user_id, NULL);

  g_debug ("user_id: %s, finger: %d", user_id, finger);
@@ -923,7 +1115,7 @@ delete_print (FpDevice *device)

  fpi_device_get_delete_data (device, &print);

-  g_object_get (print, "fp-data", &data, NULL);
+  g_object_get (print, "fpi-data", &data, NULL);
  g_debug ("data is %p", data);
  if (!parse_print_data (data, &finger, &user_id, &user_id_len))
    {
@@ -941,18 +1133,58 @@ delete_print (FpDevice *device)
  synaptics_sensor_cmd (self, 0, BMKT_CMD_DEL_USER_FP, payload, user_id_len + 1, delete_msg_cb);
 }

+static void
+prob_msg_cb (FpiDeviceSynaptics *self,
+             bmkt_response_t    *resp,
+             GError             *error)
+{
+  GUsbDevice *usb_dev = NULL;
+  g_autofree gchar *serial = NULL;
+
+  usb_dev = fpi_device_get_usb_device (FP_DEVICE (self));
+
+  if (error)
+    {
+      g_usb_device_close (usb_dev, NULL);
+      fpi_device_probe_complete (FP_DEVICE (self), NULL, NULL,
+                                 fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL, "unsupported firmware version"));
+      return;
+    }
+
+  if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
+    serial = g_strdup ("emulated-device");
+  else
+    serial = g_usb_device_get_string_descriptor (usb_dev,
+                                                 g_usb_device_get_serial_number_index (usb_dev),
+                                                 &error);
+
+  if (resp->result == BMKT_SUCCESS)
+    {
+      g_usb_device_close (usb_dev, NULL);
+      fpi_device_probe_complete (FP_DEVICE (self), serial, NULL, error);
+    }
+  else
+    {
+      g_warning ("Probe fingerprint sensor failed with %d!", resp->result);
+      g_usb_device_close (usb_dev, NULL);
+      fpi_device_probe_complete (FP_DEVICE (self), serial, NULL, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+    }
+}
+
 static void
 dev_probe (FpDevice *device)
 {
  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (device);
  GUsbDevice *usb_dev;
-  FpiUsbTransfer *transfer;
+
+  g_autoptr(FpiUsbTransfer) transfer = NULL;
  FpiByteReader reader;
  GError *error = NULL;
  guint16 status;
  const guint8 *data;
  gboolean read_ok = TRUE;
  g_autofree gchar *serial = NULL;
+  gboolean retry = TRUE;

  G_DEBUG_HERE ();

@@ -964,45 +1196,49 @@ dev_probe (FpDevice *device)
      return;
    }

-  if (!g_usb_device_reset (fpi_device_get_usb_device (device), &error))
-    {
-      fpi_device_probe_complete (device, NULL, NULL, error);
-      return;
-    }
-
-  if (!g_usb_device_claim_interface (fpi_device_get_usb_device (device), 0, 0, &error))
+  if (!g_usb_device_reset (usb_dev, &error))
    goto err_close;

-  /* TODO: Do not do this synchronous. */
-  transfer = fpi_usb_transfer_new (device);
-  fpi_usb_transfer_fill_bulk (transfer, USB_EP_REQUEST, SENSOR_FW_CMD_HEADER_LEN);
-  transfer->short_is_error = TRUE;
-  transfer->buffer[0] = SENSOR_CMD_GET_VERSION;
-  if (!fpi_usb_transfer_submit_sync (transfer, 1000, &error))
-    goto err_close;
-  fpi_usb_transfer_unref (transfer);
-
-
-  transfer = fpi_usb_transfer_new (device);
-  fpi_usb_transfer_fill_bulk (transfer, USB_EP_REPLY, 40);
-  if (!fpi_usb_transfer_submit_sync (transfer, 1000, &error))
+  if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
    goto err_close;

-  fpi_byte_reader_init (&reader, transfer->buffer, transfer->actual_length);
-
-  if (!fpi_byte_reader_get_uint16_le (&reader, &status))
+  while(1)
    {
-      g_warning ("Transfer in response to version query was too short");
-      error = fpi_device_error_new (FP_DEVICE_ERROR_PROTO);
-      goto err_close;
-    }
-  if (status != 0)
-    {
-      g_warning ("Device responded with error: %d", status);
-      error = fpi_device_error_new (FP_DEVICE_ERROR_PROTO);
-      goto err_close;
-    }
+      /* TODO: Do not do this synchronous. */
+      transfer = fpi_usb_transfer_new (device);
+      fpi_usb_transfer_fill_bulk (transfer, USB_EP_REQUEST, SENSOR_FW_CMD_HEADER_LEN);
+      transfer->short_is_error = TRUE;
+      transfer->buffer[0] = SENSOR_CMD_GET_VERSION;
+      if (!fpi_usb_transfer_submit_sync (transfer, 1000, &error))
+        goto err_close;

+      g_clear_pointer (&transfer, fpi_usb_transfer_unref);
+      transfer = fpi_usb_transfer_new (device);
+      fpi_usb_transfer_fill_bulk (transfer, USB_EP_REPLY, 40);
+      if (!fpi_usb_transfer_submit_sync (transfer, 1000, &error))
+        goto err_close;
+
+      fpi_byte_reader_init (&reader, transfer->buffer, transfer->actual_length);
+
+      if (!fpi_byte_reader_get_uint16_le (&reader, &status))
+        {
+          g_warning ("Transfer in response to version query was too short");
+          error = fpi_device_error_new (FP_DEVICE_ERROR_PROTO);
+          goto err_close;
+        }
+      if (status != 0)
+        {
+          g_warning ("Device responded with error: %d retry: %d", status, retry);
+          if(retry)
+            {
+              retry = FALSE;
+              continue;
+            }
+          error = fpi_device_error_new (FP_DEVICE_ERROR_PROTO);
+          goto err_close;
+        }
+      break;
+    }
  read_ok &= fpi_byte_reader_get_uint32_le (&reader, &self->mis_version.build_time);
  read_ok &= fpi_byte_reader_get_uint32_le (&reader, &self->mis_version.build_num);
  read_ok &= fpi_byte_reader_get_uint8 (&reader, &self->mis_version.version_major);
@@ -1024,7 +1260,7 @@ dev_probe (FpDevice *device)

  if (!read_ok)
    {
-      g_warning ("Transfer in response to verison query was too short");
+      g_warning ("Transfer in response to version query was too short");
      error = fpi_device_error_new (FP_DEVICE_ERROR_PROTO);
      goto err_close;
    }
@@ -1035,37 +1271,7 @@ dev_probe (FpDevice *device)
  fp_dbg ("Target: %d", self->mis_version.target);
  fp_dbg ("Product: %d", self->mis_version.product);

-  fpi_usb_transfer_unref (transfer);
-
-  /* We need at least firmware version 10.1, and for 10.1 build 2989158 */
-  if (self->mis_version.version_major < 10 ||
-      self->mis_version.version_minor < 1 ||
-      (self->mis_version.version_major == 10 &&
-       self->mis_version.version_minor == 1 &&
-       self->mis_version.build_num < 2989158))
-    {
-      fp_warn ("Firmware version %d.%d with build number %d is unsupported",
-               self->mis_version.version_major,
-               self->mis_version.version_minor,
-               self->mis_version.build_num);
-
-      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                        "Unsupported firmware version");
-      goto err_close;
-    }
-
-  /* This is the same as the serial_number from above, hex encoded and somewhat reordered */
-  /* Should we add in more, e.g. the chip revision? */
-  if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
-    serial = g_strdup ("emulated-device");
-  else
-    serial = g_usb_device_get_string_descriptor (usb_dev,
-                                                 g_usb_device_get_serial_number_index (usb_dev),
-                                                 &error);
-
-  g_usb_device_close (usb_dev, NULL);
-
-  fpi_device_probe_complete (device, serial, NULL, error);
+  synaptics_sensor_cmd (self, 0, BMKT_CMD_FPS_INIT, NULL, 0, prob_msg_cb);

  return;

@@ -1118,7 +1324,7 @@ fps_deinit_cb (FpiDeviceSynaptics *self,
        case BMKT_RSP_POWER_DOWN_FAIL:
          fp_info ("Failed to go to power down mode: %d", resp->result);
          error = fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                            "Power down failed");
+                                            "Power down failed: %d", resp->result);

          break;
        }
@@ -1199,6 +1405,7 @@ fpi_device_synaptics_class_init (FpiDeviceSynapticsClass *klass)
  dev_class->close = dev_exit;
  dev_class->probe = dev_probe;
  dev_class->verify = verify;
+  dev_class->identify = identify;
  dev_class->enroll = enroll;
  dev_class->delete = delete_print;
  dev_class->cancel = cancel;
@@ -16,8 +16,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __synaptics_h__
-#define __synaptics_h__
+#pragma once

 #include "fpi-device.h"
 #include "fpi-ssm.h"
@@ -111,8 +110,7 @@ struct _FpiDeviceSynaptics
  FpiSsm               *cmd_ssm;
  FpiUsbTransfer       *cmd_pending_transfer;
  gboolean              cmd_complete_on_removal;
-  GError               *cmd_complete_error;
-  void                 *cmd_complete_data;
+  guint8                id_idx;

  bmkt_sensor_version_t mis_version;

@@ -126,5 +124,3 @@ struct _FpiDeviceSynaptics
  struct syna_enroll_resp_data enroll_resp_data;
  syna_state_t                 state;
 };
-
-#endif //__synaptics_h__
@@ -47,17 +47,11 @@ enum {
 enum sonly_kill_transfers_action {
  NOT_KILLING = 0,

-  /* abort a SSM with an error code */
-  ABORT_SSM,
-
  /* report an image session error */
  IMG_SESSION_ERROR,

  /* iterate a SSM to the next state */
  ITERATE_SSM,
-
-  /* call a callback */
-  EXEC_CALLBACK,
 };

 enum sonly_fs {
@@ -97,13 +91,9 @@ struct _FpiDeviceUpeksonly

  enum sonly_kill_transfers_action killing_transfers;
  GError                          *kill_error;
-  union
-  {
-    FpiSsm *kill_ssm;
-    void    (*kill_cb)(FpImageDevice *dev);
-  };
+  FpiSsm                          *kill_ssm;

-  struct fpi_line_asmbl_ctx assembling_ctx;
+  struct fpi_line_asmbl_ctx        assembling_ctx;
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceUpeksonly, fpi_device_upeksonly, FPI,
                      DEVICE_UPEKSONLY, FpImageDevice);
@@ -176,11 +166,6 @@ last_transfer_killed (FpImageDevice *dev)

  switch (self->killing_transfers)
    {
-    case ABORT_SSM:
-      fp_dbg ("abort ssm error %s", self->kill_error->message);
-      fpi_ssm_mark_failed (self->kill_ssm, g_steal_pointer (&self->kill_error));
-      return;
-
    case ITERATE_SSM:
      fp_dbg ("iterate ssm");
      fpi_ssm_next_state (self->kill_ssm);
@@ -531,6 +516,14 @@ img_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
      return;
    }

+  /* NOTE: The old code assume 4096 bytes are received each time
+   * but there is no reason we need to enforce that. However, we
+   * always need full lines. */
+  if (transfer->actual_length % 64 != 0)
+    error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                      "Data packets need to be multiple of 64 bytes, got %zi bytes",
+                                      transfer->actual_length);
+
  if (error)
    {
      fp_warn ("bad status %s, terminating session", error->message);
@@ -551,7 +544,7 @@ img_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
   * the first 2 bytes are a sequence number
   * then there are 62 bytes for image data
   */
-  for (i = 0; i < 4096; i += 64)
+  for (i = 0; i + 64 <= transfer->actual_length; i += 64)
    {
      if (!is_capturing (self))
        return;
@@ -560,7 +553,7 @@ img_data_cb (FpiUsbTransfer *transfer, FpDevice *device,

  if (is_capturing (self))
    {
-      fpi_usb_transfer_submit (transfer,
+      fpi_usb_transfer_submit (fpi_usb_transfer_ref (transfer),
                               0,
                               self->img_cancellable,
                               img_data_cb,
@@ -588,6 +581,8 @@ write_regs_finished (struct write_regs_data *wrdata, GError *error)
    fpi_ssm_next_state (wrdata->ssm);
  else
    fpi_ssm_mark_failed (wrdata->ssm, error);
+
+  g_free (wrdata);
 }

 static void write_regs_iterate (struct write_regs_data *wrdata);
@@ -634,10 +629,9 @@ write_regs_iterate (struct write_regs_data *wrdata)
                                 1);
  transfer->short_is_error = TRUE;
  transfer->ssm = wrdata->ssm;
-  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, write_regs_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
-
  transfer->buffer[0] = regwrite->value;
+
+  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, write_regs_cb, wrdata);
 }

 static void
@@ -657,17 +651,6 @@ sm_write_regs (FpiSsm                      *ssm,
  write_regs_iterate (wrdata);
 }

-static void
-sm_write_reg_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                 gpointer user_data, GError *error)
-{
-  if (error)
-    fpi_ssm_mark_failed (transfer->ssm, error);
-  else
-    fpi_ssm_next_state (transfer->ssm);
-
-}
-
 static void
 sm_write_reg (FpiSsm        *ssm,
              FpImageDevice *dev,
@@ -687,10 +670,10 @@ sm_write_reg (FpiSsm        *ssm,
                                 1);
  transfer->short_is_error = TRUE;
  transfer->ssm = ssm;
-  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, sm_write_reg_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
-
  transfer->buffer[0] = value;
+
+  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL,
+                           fpi_ssm_usb_transfer_cb, NULL);
 }

 static void
@@ -737,7 +720,6 @@ sm_read_reg (FpiSsm        *ssm,
                           NULL,
                           sm_read_reg_cb,
                           NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -782,7 +764,6 @@ sm_await_intr (FpiSsm        *ssm,
                           fpi_device_get_cancellable (FP_DEVICE (dev)),
                           sm_await_intr_cb,
                           NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /***** AWAIT FINGER *****/
@@ -922,7 +903,7 @@ capsm_fire_bulk (FpiSsm   *ssm,
  self->img_cancellable = g_cancellable_new ();
  for (i = 0; i < self->img_transfers->len; i++)
    {
-      fpi_usb_transfer_submit (g_ptr_array_index (self->img_transfers, i),
+      fpi_usb_transfer_submit (fpi_usb_transfer_ref (g_ptr_array_index (self->img_transfers, i)),
                               0,
                               self->img_cancellable,
                               img_data_cb,
@@ -1249,6 +1230,9 @@ loopsm_run_state (FpiSsm *ssm, FpDevice *_dev)
                                       awfsm_1000_run_state,
                                       AWFSM_1000_NUM_STATES);
                  break;
+
+                default:
+                  g_assert_not_reached ();
                }
              fpi_ssm_start_subsm (ssm, awfsm);
            }
@@ -1290,6 +1274,9 @@ loopsm_run_state (FpiSsm *ssm, FpDevice *_dev)
                               capsm_1001_run_state,
                               CAPSM_1001_NUM_STATES);
          break;
+
+        default:
+          g_assert_not_reached ();
        }
      fpi_ssm_start_subsm (ssm, capsm);
      break;
@@ -1318,6 +1305,9 @@ loopsm_run_state (FpiSsm *ssm, FpDevice *_dev)
                                  deinitsm_1001_run_state,
                                  DEINITSM_1001_NUM_STATES);
          break;
+
+        default:
+          g_assert_not_reached ();
        }
      self->capturing = FALSE;
      fpi_ssm_start_subsm (ssm, deinitsm);
@@ -1371,7 +1361,6 @@ loopsm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
  FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);

-  fpi_ssm_free (ssm);

  if (self->deactivating)
    {
@@ -1392,7 +1381,6 @@ initsm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
  FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);

-  fpi_ssm_free (ssm);
  fpi_image_device_activate_complete (dev, error);
  if (error)
    return;
@@ -1412,10 +1400,13 @@ dev_activate (FpImageDevice *dev)
  self->deactivating = FALSE;
  self->capturing = FALSE;

-  self->img_transfers = g_ptr_array_new_full (NUM_BULK_TRANSFERS, (GDestroyNotify) fpi_usb_transfer_unref);
  self->num_flying = 0;
+  self->img_transfers = g_ptr_array_new_with_free_func ((GFreeFunc) fpi_usb_transfer_unref);

-  for (i = 0; i < self->img_transfers->len; i++)
+  /* This might seem odd, but we do need multiple in-flight URBs so that
+   * we never stop polling the device for more data.
+   */
+  for (i = 0; i < NUM_BULK_TRANSFERS; i++)
    {
      FpiUsbTransfer *transfer;

@@ -1441,6 +1432,9 @@ dev_activate (FpImageDevice *dev)
      ssm = fpi_ssm_new (FP_DEVICE (dev), initsm_1001_run_state,
                         INITSM_1001_NUM_STATES);
      break;
+
+    default:
+      g_assert_not_reached ();
    }
  fpi_ssm_start (ssm, initsm_complete);
 }
@@ -128,7 +128,6 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->short_is_error = TRUE;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                                 write_init_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
      }
      break;

@@ -142,7 +141,6 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->ssm = ssm;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                                 read_init_data_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
      }
      break;
    }
@@ -157,7 +155,6 @@ activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)

  if (!error)
    start_finger_detection (dev);
-  fpi_ssm_free (ssm);
 }


@@ -174,7 +171,7 @@ finger_present (unsigned char *img, size_t len, int sum_threshold)
    if (img[i] < 160)
      sum++;

-  fp_dbg ("finger_present: sum is %d\n", sum);
+  fp_dbg ("finger_present: sum is %d", sum);
  return sum < sum_threshold ? 0 : 1;
 }

@@ -187,7 +184,7 @@ finger_det_data_cb (FpiUsbTransfer *transfer, FpDevice *device,

  if (error)
    {
-      fp_dbg ("data transfer status %s\n", error->message);
+      fp_dbg ("data transfer status %s", error->message);
      fpi_image_device_session_error (dev, error);
      return;
    }
@@ -215,7 +212,7 @@ finger_det_cmd_cb (FpiUsbTransfer *t, FpDevice *device,

  if (error)
    {
-      fp_dbg ("req transfer status %s\n", error->message);
+      fp_dbg ("req transfer status %s", error->message);
      fpi_image_device_session_error (dev, error);
      return;
    }
@@ -226,7 +223,6 @@ finger_det_cmd_cb (FpiUsbTransfer *t, FpDevice *device,
                              IMAGE_SIZE);
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           finger_det_data_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -250,7 +246,6 @@ start_finger_detection (FpImageDevice *dev)
                                   UPEKTC_CMD_LEN, NULL);
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           finger_det_cmd_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /****** CAPTURE ******/
@@ -261,16 +256,6 @@ enum capture_states {
  CAPTURE_NUM_STATES,
 };

-static void
-capture_cmd_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                gpointer user_data, GError *error)
-{
-  if (!error)
-    fpi_ssm_next_state (transfer->ssm);
-  else
-    fpi_ssm_mark_failed (transfer->ssm, error);
-}
-
 static void
 capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                      gpointer user_data, GError *error)
@@ -309,8 +294,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev)
        transfer->ssm = ssm;
        transfer->short_is_error = TRUE;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                                 capture_cmd_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
+                                 fpi_ssm_usb_transfer_cb, NULL);
      }
      break;

@@ -324,7 +308,6 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev)
        transfer->short_is_error = TRUE;
        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                                 capture_read_data_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
      }
      break;
    }
@@ -345,7 +328,6 @@ capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
  else
    start_finger_detection (dev);

-  fpi_ssm_free (ssm);
 }

 static void
@@ -429,7 +411,7 @@ dev_init (FpImageDevice *dev)
      break;

    default:
-      fp_err ("Device variant %lu is not known\n", driver_data);
+      fp_err ("Device variant %lu is not known", driver_data);
      g_assert_not_reached ();
      fpi_image_device_open_complete (dev, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
      return;
@@ -19,8 +19,9 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __UPEKTC_H
-#define __UPEKTC_H
+/* *INDENT-OFF* */
+
+#pragma once

 #define UPEKTC_CMD_LEN 0x40
 #define IMAGE_WIDTH 208
@@ -1936,5 +1937,3 @@ static const unsigned char scan_cmd[0x40] = {
  0x05, 0x90, 0xf6, 0x77, 0x84, 0xf5, 0x2f, 0x01,
  0x05, 0x90, 0xf6, 0x00, 0xc8, 0x00, 0xec, 0x00
 };
-
-#endif
@@ -78,6 +78,7 @@ upektc_img_cmd_update_crc (unsigned char *cmd_buf, size_t size)
  cmd_buf[size - 1] = (crc & 0xff00) >> 8;
 }

+FP_GNUC_ACCESS (read_only, 3, 4)
 static void
 upektc_img_submit_req (FpiSsm                *ssm,
                       FpImageDevice         *dev,
@@ -100,7 +101,6 @@ upektc_img_submit_req (FpiSsm                *ssm,
  transfer->ssm = ssm;
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL, cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -120,7 +120,6 @@ upektc_img_read_data (FpiSsm                *ssm,
                                   NULL);
  transfer->ssm = ssm;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL, cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /****** CAPTURE ******/
@@ -195,7 +194,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,

  if (self->deactivating)
    {
-      fp_dbg ("Deactivate requested\n");
+      fp_dbg ("Deactivate requested");
      fpi_ssm_mark_completed (transfer->ssm);
      return;
    }
@@ -210,7 +209,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,

  if (fpi_ssm_get_cur_state (transfer->ssm) == CAPTURE_READ_DATA_TERM)
    {
-      fp_dbg ("Terminating SSM\n");
+      fp_dbg ("Terminating SSM");
      fpi_ssm_mark_completed (transfer->ssm);
      return;
    }
@@ -221,7 +220,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
      response_size += 9;           /* 7 bytes for header, 2 for CRC */
      if (response_size > transfer->actual_length)
        {
-          fp_dbg ("response_size is %lu, actual_length is %d\n",
+          fp_dbg ("response_size is %lu, actual_length is %d",
                  response_size, (gint) transfer->actual_length);
          fp_dbg ("Waiting for rest of transfer");
          BUG_ON (self->response_rest);
@@ -239,7 +238,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
        {
        /* No finger */
        case 0x28:
-          fp_dbg ("18th byte is %.2x\n", data[18]);
+          fp_dbg ("18th byte is %.2x", data[18]);
          switch (data[18])
            {
            case 0x0c:
@@ -256,7 +255,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,

            case 0x1e:
              /* short scan */
-              fp_err ("short scan, aborting\n");
+              fp_err ("short scan, aborting");
              fpi_image_device_retry_scan (dev,
                                           FP_DEVICE_RETRY_TOO_SHORT);
              fpi_image_device_report_finger_status (dev,
@@ -267,7 +266,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,

            case 0x1d:
              /* too much horisontal movement */
-              fp_err ("too much horisontal movement, aborting\n");
+              fp_err ("too much horisontal movement, aborting");
              fpi_image_device_retry_scan (dev,
                                           FP_DEVICE_RETRY_CENTER_FINGER);
              fpi_image_device_report_finger_status (dev,
@@ -278,7 +277,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,

            default:
              /* some error happened, cancel scan */
-              fp_err ("something bad happened, stop scan\n");
+              fp_err ("something bad happened, stop scan");
              fpi_image_device_retry_scan (dev,
                                           FP_DEVICE_RETRY);
              fpi_image_device_report_finger_status (dev,
@@ -309,9 +308,10 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
            upektc_img_process_image_frame (self->image_bits + self->image_size,
                                            data);
          BUG_ON (self->image_size != IMAGE_SIZE);
-          fp_dbg ("Image size is %lu\n",
+          fp_dbg ("Image size is %lu",
                  self->image_size);
          img = fp_image_new (IMAGE_WIDTH, IMAGE_HEIGHT);
+          img->flags |= FPI_IMAGE_PARTIAL;
          memcpy (img->data, self->image_bits,
                  IMAGE_SIZE);
          fpi_image_device_image_captured (dev, img);
@@ -321,7 +321,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
          break;

        default:
-          fp_err ("Unknown response!\n");
+          fp_err ("Unknown response!");
          fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
          break;
        }
@@ -332,7 +332,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
      break;

    default:
-      fp_err ("Not handled response!\n");
+      fp_err ("Not handled response!");
      fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
    }
 }
@@ -389,7 +389,6 @@ capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error_arg)

  g_autoptr(GError) error = error_arg;

-  fpi_ssm_free (ssm);

  /* Note: We assume that the error is a cancellation in the deactivation case */
  if (self->deactivating)
@@ -470,7 +469,6 @@ deactivate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);

  fp_dbg ("Deactivate completed");
-  fpi_ssm_free (ssm);

  self->deactivating = FALSE;
  fpi_image_device_deactivate_complete (dev,  error);
@@ -505,16 +503,6 @@ enum activate_states {
  ACTIVATE_NUM_STATES,
 };

-static void
-init_reqs_ctrl_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                   gpointer user_data, GError *error)
-{
-  if (!error)
-    fpi_ssm_next_state (transfer->ssm);
-  else
-    fpi_ssm_mark_failed (transfer->ssm, error);
-}
-
 static void
 init_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device,
              gpointer user_data, GError *error)
@@ -558,8 +546,7 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev)
        transfer->buffer[0] = '\0';
        transfer->ssm = ssm;
        fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL,
-                                 init_reqs_ctrl_cb, NULL);
-        fpi_usb_transfer_unref (transfer);
+                                 fpi_ssm_usb_transfer_cb, NULL);
      }
      break;

@@ -601,7 +588,6 @@ activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);

-  fpi_ssm_free (ssm);
  fpi_image_device_activate_complete (dev, error);

  if (!error)
@@ -17,8 +17,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __UPEKTC_IMG_H
-#define __UPEKTC_IMG_H
+#pragma once

 static const unsigned char upek2020_init_1[] = {
  'C', 'i', 'a', 'o',
@@ -140,5 +139,3 @@ static const unsigned char upek2020_ack_frame[] = {
  0x30,
  0xac, 0x5b /* CRC */
 };
-
-#endif
@@ -35,7 +35,6 @@
 #define TIMEOUT 5000

 #define MSG_READ_BUF_SIZE 0x40
-#define MAX_DATA_IN_READ_BUF (MSG_READ_BUF_SIZE - 9)

 struct _FpiDeviceUpekts
 {
@@ -226,7 +225,6 @@ busy_ack_retry_read (FpDevice *device, struct read_msg_data *udata)
  transfer->short_is_error = TRUE;

  fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, busy_ack_sent_cb, udata);
-  fpi_usb_transfer_unref (transfer);
 }

 /* Returns 0 if message was handled, 1 if it was a device-busy message, and
@@ -237,12 +235,18 @@ __handle_incoming_msg (FpDevice             *device,
 {
  GError *error = NULL;
  guint8 *buf = udata->buffer;
-  guint16 len = ((buf[5] & 0xf) << 8) | buf[6];
-  guint16 computed_crc = udf_crc (buf + 4, len + 3);
-  guint16 msg_crc = (buf[len + 8] << 8) | buf[len + 7];
-  unsigned char *retdata = NULL;
+  guint16 len;
+  guint16 computed_crc;
+  guint16 msg_crc;
  unsigned char code_a, code_b;

+  g_assert (udata->buflen >= 6);
+  len = ((buf[5] & 0xf) << 8) | buf[6];
+
+  g_assert (udata->buflen >= len + 9);
+  computed_crc = udf_crc (buf + 4, len + 3);
+  msg_crc = (buf[len + 8] << 8) | buf[len + 7];
+
  if (computed_crc != msg_crc)
    {
      fp_err ("CRC failed, got %04x expected %04x", msg_crc, computed_crc);
@@ -268,12 +272,7 @@ __handle_incoming_msg (FpDevice             *device,
          return;
        }

-      if (len > 0)
-        {
-          retdata = g_malloc (len);
-          memcpy (retdata, buf + 7, len);
-        }
-      udata->callback (device, READ_MSG_CMD, code_a, 0, retdata, len,
+      udata->callback (device, READ_MSG_CMD, code_a, 0, buf + 7, len,
                       udata->user_data, NULL);
      goto done;
    }
@@ -288,7 +287,7 @@ __handle_incoming_msg (FpDevice             *device,
        {
          fp_warn ("cmd response too short (%d)", len);
          error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                            "CMD response too short");
+                                            "CMD response too short (%d)", len);
          goto err;
        }
      if (innerbuf[0] != 0x28)
@@ -310,14 +309,8 @@ __handle_incoming_msg (FpDevice             *device,
      innerlen = innerlen - 3;
      _subcmd = innerbuf[5];
      fp_dbg ("device responds to subcmd %x with %d bytes", _subcmd, innerlen);
-      if (innerlen > 0)
-        {
-          retdata = g_malloc (innerlen);
-          memcpy (retdata, innerbuf + 6, innerlen);
-        }
      udata->callback (device, READ_MSG_RESPONSE, code_b, _subcmd,
-                       retdata, innerlen, udata->user_data, NULL);
-      g_free (retdata);
+                       innerbuf + 6, innerlen, udata->user_data, NULL);
      goto done;
    }
  else
@@ -359,7 +352,8 @@ read_msg_cb (FpiUsbTransfer *transfer, FpDevice *device,
             gpointer user_data, GError *error)
 {
  struct read_msg_data *udata = user_data;
-  guint16 len;
+  guint16 payload_len;
+  gsize packet_len;

  if (error)
    {
@@ -371,11 +365,12 @@ read_msg_cb (FpiUsbTransfer *transfer, FpDevice *device,
      fp_err ("async msg read too short (%d)",
              (gint) transfer->actual_length);
      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                        "Packet from device was too short");
+                                        "Packet from device was too short (%lu)",
+                                        transfer->actual_length);
      goto err;
    }

-  if (strncmp (udata->buffer, "Ciao", 4) != 0)
+  if (strncmp ((char *) udata->buffer, "Ciao", 4) != 0)
    {
      fp_err ("no Ciao for you!!");
      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@@ -383,14 +378,15 @@ read_msg_cb (FpiUsbTransfer *transfer, FpDevice *device,
      goto err;
    }

-  len = ((udata->buffer[5] & 0xf) << 8) | udata->buffer[6];
+  payload_len = ((udata->buffer[5] & 0xf) << 8) | udata->buffer[6];
+  packet_len = payload_len + 9;
  if (transfer->actual_length != MSG_READ_BUF_SIZE &&
-      (len + 9) > transfer->actual_length)
+      packet_len > transfer->actual_length)
    {
      /* Check that the length claimed inside the message is in line with
       * the amount of data that was transferred over USB. */
      fp_err ("msg didn't include enough data, expected=%d recv=%d",
-              len + 9, (gint) transfer->actual_length);
+              (gint) packet_len, (gint) transfer->actual_length);
      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
                                        "Packet from device didn't include data");
      goto err;
@@ -399,14 +395,14 @@ read_msg_cb (FpiUsbTransfer *transfer, FpDevice *device,
  /* We use a 64 byte buffer for reading messages. However, sometimes
   * messages are longer, in which case we have to do another USB bulk read
   * to read the remainder. This is handled below. */
-  if (len > MAX_DATA_IN_READ_BUF)
+  if (packet_len > MSG_READ_BUF_SIZE)
    {
-      int needed = len - MAX_DATA_IN_READ_BUF;
+      int needed = packet_len - MSG_READ_BUF_SIZE;
      FpiUsbTransfer *etransfer = fpi_usb_transfer_new (device);

      fp_dbg ("didn't fit in buffer, need to extend by %d bytes", needed);
-      udata->buffer = g_realloc ((gpointer) udata->buffer, len);
-      udata->buflen = len;
+      udata->buffer = g_realloc ((gpointer) udata->buffer, packet_len);
+      udata->buflen = packet_len;

      fpi_usb_transfer_fill_bulk_full (etransfer, EP_IN,
                                       udata->buffer + MSG_READ_BUF_SIZE,
@@ -415,7 +411,6 @@ read_msg_cb (FpiUsbTransfer *transfer, FpDevice *device,
      fpi_usb_transfer_submit (etransfer, TIMEOUT,
                               NULL,
                               read_msg_extend_cb, udata);
-      fpi_usb_transfer_unref (etransfer);
      return;
    }

@@ -441,7 +436,6 @@ __read_msg_async (FpDevice *device, struct read_msg_data *udata)

  fpi_usb_transfer_fill_bulk_full (transfer, EP_IN, udata->buffer, udata->buflen, NULL);
  fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, read_msg_cb, udata);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -533,15 +527,6 @@ initsm_read_msg_response_cb (FpiSsm            *ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
                                                     "Unexpected response subcommand"));
    }
-  else if (seq != upekdev->seq)
-    {
-      fp_err ("expected response to cmd seq=%02x, got response to %02x "
-              "in state %d", upekdev->seq, seq,
-              fpi_ssm_get_cur_state (ssm));
-      fpi_ssm_mark_failed (ssm,
-                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Unexpected sequence number in response"));
-    }
  else
    {
      fpi_ssm_next_state (ssm);
@@ -675,7 +660,6 @@ initsm_send_msg28_handler (FpiSsm              *ssm,
  transfer->ssm = ssm;
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, fpi_ssm_usb_transfer_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -696,7 +680,6 @@ initsm_run_state (FpiSsm *ssm, FpDevice *dev)
      transfer->ssm = ssm;
      transfer->short_is_error = TRUE;
      fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, fpi_ssm_usb_transfer_cb, NULL);
-      fpi_usb_transfer_unref (transfer);
      break;

    case READ_MSG03:
@@ -704,11 +687,10 @@ initsm_run_state (FpiSsm *ssm, FpDevice *dev)
      break;

    case SEND_RESP03:;
-      transfer = alloc_send_cmd28_transfer (dev, ++upekdev->seq, init_resp03, sizeof (init_resp03));
+      transfer = alloc_send_cmdresponse_transfer (dev, ++upekdev->seq, init_resp03, sizeof (init_resp03));
      transfer->ssm = ssm;
      transfer->short_is_error = TRUE;
      fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, fpi_ssm_usb_transfer_cb, NULL);
-      fpi_usb_transfer_unref (transfer);
      break;

    case READ_MSG05:
@@ -798,7 +780,8 @@ read_msg01_cb (FpDevice *dev, enum read_msg_type type,
    {
      fp_err ("expected seq=1, got %x", seq);
      fpi_ssm_mark_failed (ssm, fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                          "Got wrong sequence number"));
+                                                          "Got wrong sequence number (%x)",
+                                                          seq));
      return;
    }

@@ -818,7 +801,6 @@ deinitsm_state_handler (FpiSsm *ssm, FpDevice *dev)
      transfer->short_is_error = TRUE;
      transfer->ssm = ssm;
      fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, fpi_ssm_usb_transfer_cb, NULL);
-      fpi_usb_transfer_unref (transfer);
      break;

    case READ_MSG01:;
@@ -861,21 +843,14 @@ dev_init (FpDevice *dev)
  fpi_ssm_start (ssm, initsm_done);
 }

-static void
-deinitsm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
-{
-  g_usb_device_release_interface (fpi_device_get_usb_device (dev), 0, 0, NULL);
-
-  fpi_device_close_complete (dev, error);
-}
-
 static void
 dev_exit (FpDevice *dev)
 {
-  FpiSsm *ssm;
+  GError *error = NULL;

-  ssm = fpi_ssm_new (dev, deinitsm_state_handler, DEINITSM_NUM_STATES);
-  fpi_ssm_start (ssm, deinitsm_done);
+  g_usb_device_release_interface (fpi_device_get_usb_device (dev), 0, 0, &error);
+
+  fpi_device_close_complete (dev, error);
 }

 static const unsigned char enroll_init[] = {
@@ -907,8 +882,10 @@ enroll_start_sm_cb_msg28 (FpDevice *dev,
  FpiSsm *ssm = user_data;

  if (error)
-    fpi_ssm_mark_failed (ssm, error);
-  if (type != READ_MSG_RESPONSE)
+    {
+      fpi_ssm_mark_failed (ssm, error);
+    }
+  else if (type != READ_MSG_RESPONSE)
    {
      fp_err ("expected response, got %d seq=%x", type, seq);
      fpi_ssm_mark_failed (ssm, fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@@ -951,7 +928,6 @@ enroll_start_sm_run_state (FpiSsm *ssm, FpDevice *dev)
      transfer->ssm = ssm;

      fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, fpi_ssm_usb_transfer_cb, NULL);
-      fpi_usb_transfer_unref (transfer);
      break;

    case READ_ENROLL_MSG28:;
@@ -987,8 +963,9 @@ enroll_stop_deinit_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
  if (error)
    fp_warn ("Error deinitializing: %s", error->message);

-  fpi_device_enroll_complete (dev, data->print, data->error);
-  fpi_ssm_free (ssm);
+  fpi_device_enroll_complete (dev,
+                              g_steal_pointer (&data->print),
+                              g_steal_pointer (&data->error));
 }

 static void
@@ -997,7 +974,7 @@ do_enroll_stop (FpDevice *dev, FpPrint *print, GError *error)
  EnrollStopData *data = g_new0 (EnrollStopData, 1);
  FpiSsm *ssm = deinitsm_new (dev, data);

-  data->print = g_object_ref (print);
+  data->print = print;
  data->error = error;

  fpi_ssm_start (ssm, enroll_stop_deinit_cb);
@@ -1124,7 +1101,6 @@ e_handle_resp02 (FpDevice *dev, unsigned char *data,
  else
    {
      GVariant *fp_data;
-      print = fp_print_new (dev);

      fpi_device_get_enroll_data (dev, &print);

@@ -1133,7 +1109,8 @@ e_handle_resp02 (FpDevice *dev, unsigned char *data,
                                           data_len - sizeof (scan_comp),
                                           1);

-      g_object_set (print, "fp-data", fp_data, NULL);
+      fpi_print_set_type (print, FPI_PRINT_RAW);
+      g_object_set (print, "fpi-data", fp_data, NULL);
      g_object_ref (print);
    }

@@ -1204,7 +1181,6 @@ enroll_iterate (FpDevice *dev)
  transfer->short_is_error = TRUE;

  fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, enroll_iterate_cmd_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -1215,7 +1191,6 @@ enroll_started (FpiSsm *ssm, FpDevice *dev, GError *error)
  else
    enroll_iterate (dev);

-  fpi_ssm_free (ssm);
 }

 static void
@@ -1234,8 +1209,7 @@ enroll (FpDevice *dev)

 typedef struct
 {
-  FpiMatchResult res;
-  GError        *error;
+  GError *error;
 } VerifyStopData;

 static void
@@ -1253,8 +1227,12 @@ verify_stop_deinit_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
  if (error)
    fp_warn ("Error deinitializing: %s", error->message);

-  fpi_device_verify_complete (dev, data->res, NULL, data->error);
-  fpi_ssm_free (ssm);
+  if (data->error)
+    fpi_device_verify_complete (dev, g_steal_pointer (&data->error));
+  else
+    fpi_device_verify_complete (dev, g_steal_pointer (&error));
+
+  g_clear_error (&error);
 }

 static void
@@ -1263,8 +1241,11 @@ do_verify_stop (FpDevice *dev, FpiMatchResult res, GError *error)
  VerifyStopData *data = g_new0 (VerifyStopData, 1);
  FpiSsm *ssm = deinitsm_new (dev, data);

-  data->res = res;
-  data->error = error;
+  /* Report the error immediately if possible, otherwise delay it. */
+  if (error && error->domain == FP_DEVICE_RETRY)
+    fpi_device_verify_report (dev, res, NULL, error);
+  else
+    data->error = error;

  fpi_ssm_start (ssm, verify_stop_deinit_cb);
  fpi_ssm_set_data (ssm, data, (GDestroyNotify) verify_stop_data_free);
@@ -1303,7 +1284,7 @@ verify_start_sm_run_state (FpiSsm *ssm, FpDevice *dev)

    case VERIFY_INIT:
      fpi_device_get_verify_data (dev, &print);
-      g_object_get (dev, "fp-data", &fp_data, NULL);
+      g_object_get (print, "fpi-data", &fp_data, NULL);

      data = g_variant_get_fixed_array (fp_data, &data_len, 1);

@@ -1320,7 +1301,6 @@ verify_start_sm_run_state (FpiSsm *ssm, FpDevice *dev)
      transfer->short_is_error = TRUE;
      transfer->ssm = ssm;
      fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, fpi_ssm_usb_transfer_cb, NULL);
-      fpi_usb_transfer_unref (transfer);

      break;
    }
@@ -1520,7 +1500,6 @@ verify_iterate (FpDevice *dev)
      transfer->short_is_error = TRUE;

      fpi_usb_transfer_submit (transfer, TIMEOUT, NULL, verify_wr2800_cb, NULL);
-      fpi_usb_transfer_unref (transfer);
    }
 }

@@ -1538,7 +1517,6 @@ verify_started (FpiSsm *ssm, FpDevice *dev, GError *error)
  upekdev->first_verify_iteration = TRUE;
  verify_iterate (dev);

-  fpi_ssm_free (ssm);
 }

 static void
@@ -81,7 +81,7 @@ static const struct uru4k_dev_profile
 {
  const char *name;
  gboolean    auth_cr;
-  gboolean    encryption;
+  gboolean    image_not_flipped;
 } uru4k_dev_info[] = {
  [MS_KBD] = {
    .name = "Microsoft Keyboard with Fingerprint Reader",
@@ -106,7 +106,7 @@ static const struct uru4k_dev_profile
  [DP_URU4000B] = {
    .name = "Digital Persona U.are.U 4000B",
    .auth_cr = FALSE,
-    .encryption = TRUE,
+    .image_not_flipped = TRUE, /* See comment in the code where it is used. */
  },
 };

@@ -122,7 +122,7 @@ struct _FpiDeviceUru4000

  const struct uru4k_dev_profile *profile;
  uint8_t                         interface;
-  FpImageDeviceState              activate_state;
+  FpiImageDeviceState             activate_state;
  unsigned char                   last_reg_rd[16];
  unsigned char                   last_hwstat;

@@ -175,13 +175,12 @@ write_regs (FpImageDevice *dev, uint16_t first_reg,
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_fill_control (transfer,
                                 G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
-                                 G_USB_DEVICE_REQUEST_TYPE_STANDARD,
+                                 G_USB_DEVICE_REQUEST_TYPE_VENDOR,
                                 G_USB_DEVICE_RECIPIENT_DEVICE,
                                 USB_RQ, first_reg, 0,
                                 num_regs);
  memcpy (transfer->buffer, values, num_regs);
  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, callback, user_data);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -203,11 +202,10 @@ read_regs (FpImageDevice *dev, uint16_t first_reg,

  fpi_usb_transfer_fill_control (transfer,
                                 G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
-                                 G_USB_DEVICE_REQUEST_TYPE_STANDARD,
+                                 G_USB_DEVICE_REQUEST_TYPE_VENDOR,
                                 G_USB_DEVICE_RECIPIENT_DEVICE,
                                 USB_RQ, first_reg, 0, num_regs);
  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, callback, user_data);
-  fpi_usb_transfer_unref (transfer);
 }

 /*
@@ -334,6 +332,8 @@ irq_handler (FpiUsbTransfer *transfer,
      return;
    }

+  start_irq_handler (imgdev);
+
  type = GUINT16_FROM_BE (*((uint16_t *) data));
  fp_dbg ("recv irq type %04x", type);

@@ -346,8 +346,6 @@ irq_handler (FpiUsbTransfer *transfer,
    urudev->irq_cb (imgdev, NULL, type, urudev->irq_cb_data);
  else
    fp_dbg ("ignoring interrupt");
-
-  start_irq_handler (imgdev);
 }

 static void
@@ -365,7 +363,6 @@ start_irq_handler (FpImageDevice *dev)
                              EP_INTR,
                              IRQ_LENGTH);
  fpi_usb_transfer_submit (transfer, 0, self->irq_cancellable, irq_handler, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void
@@ -378,6 +375,10 @@ stop_irq_handler (FpImageDevice *dev, irqs_stopped_cb_fn cb)
      g_cancellable_cancel (self->irq_cancellable);
      self->irqs_stopped_cb = cb;
    }
+  else
+    {
+      cb (dev);
+    }
 }

 /***** STATE CHANGING *****/
@@ -411,22 +412,10 @@ change_state_write_reg_cb (FpiUsbTransfer *transfer,
 }

 static void
-dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
+dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
 {
  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);

-  switch (state)
-    {
-    case FP_IMAGE_DEVICE_STATE_INACTIVE:
-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
-    case FP_IMAGE_DEVICE_STATE_CAPTURE:
-      break;
-
-    default:
-      g_assert_not_reached ();
-    }
-
  self->activate_state = state;
  if (self->img_transfer != NULL)
    return;
@@ -666,7 +655,11 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
    case IMAGING_CAPTURE:
      self->img_lines_done = 0;
      self->img_block = 0;
-      fpi_usb_transfer_submit (self->img_transfer, 0, NULL, image_transfer_cb, NULL);
+      fpi_usb_transfer_submit (fpi_usb_transfer_ref (self->img_transfer),
+                               0,
+                               NULL,
+                               image_transfer_cb,
+                               NULL);

      break;

@@ -683,17 +676,17 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
          fpi_ssm_jump_to_state (ssm, IMAGING_CAPTURE);
          return;
        }
-      if (!self->profile->encryption)
+
+      /* Detect whether image is encrypted (by checking how noisy it is) */
+      dev2 = calc_dev2 (img);
+      fp_dbg ("dev2: %d", dev2);
+      if (dev2 < ENC_THRESHOLD)
        {
-          dev2 = calc_dev2 (img);
-          fp_dbg ("dev2: %d", dev2);
-          if (dev2 < ENC_THRESHOLD)
-            {
-              fpi_ssm_jump_to_state (ssm, IMAGING_REPORT_IMAGE);
-              return;
-            }
-          fp_info ("image seems to be encrypted");
+          fpi_ssm_jump_to_state (ssm, IMAGING_REPORT_IMAGE);
+          return;
        }
+      fp_info ("image seems to be encrypted");
+
      buf[0] = img->key_number;
      buf[1] = self->img_enc_seed;
      buf[2] = self->img_enc_seed >> 8;
@@ -726,7 +719,7 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
                  num_lines);
          if (flags & BLOCKF_CHANGE_KEY)
            {
-              fp_dbg ("changing encryption keys.\n");
+              fp_dbg ("changing encryption keys.");
              img->block_info[self->img_block].flags &= ~BLOCKF_CHANGE_KEY;
              img->key_number++;
              self->img_enc_seed = rand ();
@@ -772,11 +765,17 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
        }

      fpimg->flags = FPI_IMAGE_COLORS_INVERTED;
-      if (!self->profile->encryption)
+      /* NOTE: For some reason all but U4000B (or rather U4500?) flipped the
+       * image, we retain this behaviour here, but it is not clear whether it
+       * is correct.
+       * It may be that there are different models with the same USB ID that
+       * behave differently.
+       */
+      if (self->profile->image_not_flipped)
        fpimg->flags |= FPI_IMAGE_V_FLIPPED | FPI_IMAGE_H_FLIPPED;
      fpi_image_device_image_captured (dev, fpimg);

-      if (self->activate_state == FP_IMAGE_DEVICE_STATE_CAPTURE)
+      if (self->activate_state == FPI_IMAGE_DEVICE_STATE_CAPTURE)
        fpi_ssm_jump_to_state (ssm, IMAGING_CAPTURE);
      else
        fpi_ssm_mark_completed (ssm);
@@ -789,7 +788,6 @@ imaging_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);

-  fpi_ssm_free (ssm);

  /* Report error before exiting imaging loop - the error handler
   * can request state change, which needs to be postponed to end of
@@ -797,8 +795,7 @@ imaging_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
  if (error)
    fpi_image_device_session_error (FP_IMAGE_DEVICE (dev), error);

-  /* Freed by callback or cancellation */
-  self->img_transfer = NULL;
+  g_clear_pointer (&self->img_transfer, fpi_usb_transfer_unref);

  g_free (self->img_data);
  self->img_data = NULL;
@@ -833,26 +830,6 @@ enum rebootpwr_states {
  REBOOTPWR_NUM_STATES,
 };

-static void
-rebootpwr_pause_cb (FpDevice *dev,
-                    void     *data)
-{
-  FpiSsm *ssm = data;
-  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
-
-  if (!--self->rebootpwr_ctr)
-    {
-      fp_err ("could not reboot device power");
-      fpi_ssm_mark_failed (ssm,
-                           fpi_device_error_new_msg (FP_DEVICE_ERROR,
-                                                     "Could not reboot device"));
-    }
-  else
-    {
-      fpi_ssm_jump_to_state (ssm, REBOOTPWR_GET_HWSTAT);
-    }
-}
-
 static void
 rebootpwr_run_state (FpiSsm *ssm, FpDevice *_dev)
 {
@@ -879,7 +856,17 @@ rebootpwr_run_state (FpiSsm *ssm, FpDevice *_dev)
      break;

    case REBOOTPWR_PAUSE:
-      fpi_device_add_timeout (_dev, 10, rebootpwr_pause_cb, ssm);
+      if (!--self->rebootpwr_ctr)
+        {
+          fp_err ("could not reboot device power");
+          fpi_ssm_mark_failed (ssm,
+                               fpi_device_error_new_msg (FP_DEVICE_ERROR,
+                                                         "Could not reboot device"));
+        }
+      else
+        {
+          fpi_ssm_jump_to_state_delayed (ssm, 10, REBOOTPWR_GET_HWSTAT, NULL);
+        }
      break;
    }
 }
@@ -920,30 +907,6 @@ enum powerup_states {
  POWERUP_NUM_STATES,
 };

-static void
-powerup_pause_cb (FpDevice *dev,
-                  void     *data)
-{
-  FpiSsm *ssm = data;
-  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
-
-  if (!--self->powerup_ctr)
-    {
-      fp_err ("could not power device up");
-      fpi_ssm_mark_failed (ssm,
-                           fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                     "could not power device up"));
-    }
-  else if (!self->profile->auth_cr)
-    {
-      fpi_ssm_jump_to_state (ssm, POWERUP_SET_HWSTAT);
-    }
-  else
-    {
-      fpi_ssm_next_state (ssm);
-    }
-}
-
 static void
 powerup_run_state (FpiSsm *ssm, FpDevice *_dev)
 {
@@ -975,7 +938,21 @@ powerup_run_state (FpiSsm *ssm, FpDevice *_dev)
      break;

    case POWERUP_PAUSE:
-      fpi_device_add_timeout (_dev, 10, powerup_pause_cb, ssm);
+      if (!--self->powerup_ctr)
+        {
+          fp_err ("could not power device up");
+          fpi_ssm_mark_failed (ssm,
+                               fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
+                                                         "could not power device up"));
+        }
+      else if (!self->profile->auth_cr)
+        {
+          fpi_ssm_jump_to_state_delayed (ssm, POWERUP_SET_HWSTAT, 10, NULL);
+        }
+      else
+        {
+          fpi_ssm_next_state_delayed (ssm, 10, NULL);
+        }
      break;

    case POWERUP_CHALLENGE_RESPONSE:
@@ -1134,7 +1111,7 @@ init_run_state (FpiSsm *ssm, FpDevice *_dev)
      self->scanpwr_irq_timeout = fpi_device_add_timeout (_dev,
                                                          300,
                                                          init_scanpwr_timeout,
-                                                          ssm);
+                                                          ssm, NULL);
      break;

    case INIT_DONE:
@@ -1200,7 +1177,10 @@ deactivate_write_reg_cb (FpiUsbTransfer *transfer, FpDevice *dev,
 static void
 dev_deactivate (FpImageDevice *dev)
 {
-  dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE);
+  /* This is started/handled by execute_state_change in order to delay the
+   * action until after the image transfer has completed.
+   * We just need to override the function so that the complete handler is
+   * not called automatically. */
 }

 static void
@@ -1211,7 +1191,7 @@ execute_state_change (FpImageDevice *dev)

  switch (self->activate_state)
    {
-    case FP_IMAGE_DEVICE_STATE_INACTIVE:
+    case FPI_IMAGE_DEVICE_STATE_DEACTIVATING:
      fp_dbg ("deactivating");
      self->irq_cb = NULL;
      self->irq_cb_data = NULL;
@@ -1219,7 +1199,7 @@ execute_state_change (FpImageDevice *dev)
                 deactivate_write_reg_cb, NULL);
      break;

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
      fp_dbg ("wait finger on");
      if (!IRQ_HANDLER_IS_RUNNING (self))
        {
@@ -1233,7 +1213,7 @@ execute_state_change (FpImageDevice *dev)
                 change_state_write_reg_cb, NULL);
      break;

-    case FP_IMAGE_DEVICE_STATE_CAPTURE:
+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:
      fp_dbg ("starting capture");
      self->irq_cb = NULL;

@@ -1253,7 +1233,7 @@ execute_state_change (FpImageDevice *dev)
                 change_state_write_reg_cb, NULL);
      break;

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
      fp_dbg ("await finger off");
      if (!IRQ_HANDLER_IS_RUNNING (self))
        {
@@ -1266,6 +1246,12 @@ execute_state_change (FpImageDevice *dev)
      write_reg (dev, REG_MODE, MODE_AWAIT_FINGER_OFF,
                 change_state_write_reg_cb, NULL);
      break;
+
+    /* Ignored states */
+    case FPI_IMAGE_DEVICE_STATE_IDLE:
+    case FPI_IMAGE_DEVICE_STATE_ACTIVATING:
+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+      break;
    }
 }

@@ -76,16 +76,6 @@ enum v5s_cmd {

 /***** REGISTER I/O *****/

-static void
-sm_write_reg_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                 gpointer user_data, GError *error)
-{
-  if (error)
-    fpi_ssm_mark_failed (transfer->ssm, error);
-  else
-    fpi_ssm_next_state (transfer->ssm);
-}
-
 static void
 sm_write_reg (FpiSsm       *ssm,
              FpDevice     *dev,
@@ -101,19 +91,8 @@ sm_write_reg (FpiSsm       *ssm,
                                 G_USB_DEVICE_RECIPIENT_DEVICE,
                                 reg, value, 0, 0);
  transfer->ssm = ssm;
-  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, sm_write_reg_cb,
-                           NULL);
-  fpi_usb_transfer_unref (transfer);
-}
-
-static void
-sm_exec_cmd_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                gpointer user_data, GError *error)
-{
-  if (error)
-    fpi_ssm_mark_failed (transfer->ssm, error);
-  else
-    fpi_ssm_next_state (transfer->ssm);
+  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL,
+                           fpi_ssm_usb_transfer_cb, NULL);
 }

 static void
@@ -131,9 +110,8 @@ sm_exec_cmd (FpiSsm       *ssm,
                                 G_USB_DEVICE_RECIPIENT_DEVICE,
                                 cmd, param, 0, 0);
  transfer->ssm = ssm;
-  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, sm_exec_cmd_cb,
-                           NULL);
-  fpi_usb_transfer_unref (transfer);
+  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL,
+                           fpi_ssm_usb_transfer_cb, NULL);
 }

 /***** FINGER DETECTION *****/
@@ -227,7 +205,6 @@ capture_iterate (FpiSsm   *ssm,
                                   NULL);

  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, capture_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }


@@ -301,7 +278,6 @@ loopsm_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
  FpImageDevice *imgdev = FP_IMAGE_DEVICE (dev);
  FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);

-  fpi_ssm_free (ssm);
  g_object_unref (self->capture_img);
  self->capture_img = NULL;
  self->loop_running = FALSE;
@@ -42,6 +42,7 @@ async_write_callback (FpiUsbTransfer *transfer, FpDevice *device,
 }

 /* Send data to EP1, the only out endpoint */
+FP_GNUC_ACCESS (read_only, 3, 4)
 static void
 async_write (FpiSsm   *ssm,
             FpDevice *dev,
@@ -56,7 +57,6 @@ async_write (FpiSsm   *ssm,
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_submit (transfer, VFS_USB_TIMEOUT, NULL,
                           async_write_callback, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /* Callback for async_read */
@@ -108,7 +108,6 @@ async_read (FpiSsm   *ssm,

  fpi_usb_transfer_submit (transfer, VFS_USB_TIMEOUT, NULL,
                           async_read_callback, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /* Callback for async_abort */
@@ -119,9 +118,10 @@ async_abort_callback (FpiUsbTransfer *transfer, FpDevice *device,
  int ep = transfer->endpoint;

  /* In normal case endpoint is empty */
-  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) ||
+      (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0 && transfer->actual_length == 0))
    {
-      g_free (error);
+      g_clear_error (&error);
      fpi_ssm_next_state (transfer->ssm);
      return;
    }
@@ -158,9 +158,10 @@ async_abort (FpDevice *dev, FpiSsm *ssm, int ep)
  else
    fpi_usb_transfer_fill_bulk (transfer, ep, VFS_USB_BUFFER_SIZE);

+  transfer->ssm = ssm;
+
  fpi_usb_transfer_submit (transfer, VFS_USB_ABORT_TIMEOUT, NULL,
                           async_abort_callback, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /* Image processing functions */
@@ -243,6 +244,7 @@ prepare_image (FpDeviceVfs0050 *vdev)

  /* Building GSList */
  GSList *lines = NULL;
+
  for (int i = height - 1; i >= 0; --i)
    lines = g_slist_prepend (lines, vdev->lines_buffer + i);

@@ -402,7 +404,7 @@ interrupt_callback (FpiUsbTransfer *transfer, FpDevice *device,
                    gpointer user_data, GError *error)
 {
  FpDeviceVfs0050 *self = FPI_DEVICE_VFS0050 (device);
-  char *interrupt = transfer->buffer;
+  unsigned char *interrupt = transfer->buffer;

  /* we expect a cancellation error when the device is deactivating
   * go into the SSM_CLEAR_EP2 state in that case. */
@@ -467,8 +469,8 @@ receive_callback (FpiUsbTransfer *transfer, FpDevice *device,
  if (error)
    g_error_free (error);

-  /* Check if fingerprint data is over */
-  if (transfer->actual_length == 0)
+  /* Capture is done when there is no more data to transfer or device timed out */
+  if (transfer->actual_length <= 0)
    {
      fpi_ssm_next_state (transfer->ssm);
    }
@@ -476,22 +478,12 @@ receive_callback (FpiUsbTransfer *transfer, FpDevice *device,
    {
      self->bytes += transfer->actual_length;

-      /* We need more data */
+      /* Try reading more data */
      fpi_ssm_jump_to_state (transfer->ssm,
                             fpi_ssm_get_cur_state (transfer->ssm));
    }
 }

-/* SSM stub to prepare device to another scan after orange light was on */
-static void
-another_scan (FpDevice *dev,
-              void     *data)
-{
-  FpiSsm *ssm = data;
-
-  fpi_ssm_jump_to_state (ssm, SSM_TURN_ON);
-}
-
 /* Main SSM loop */
 static void
 activate_ssm (FpiSsm *ssm, FpDevice *dev)
@@ -564,7 +556,6 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
                                 0,
                                 fpi_device_get_cancellable (dev),
                                 interrupt_callback, NULL);
-        fpi_usb_transfer_unref (transfer);

        /* I've put it here to be sure that data is cleared */
        clear_data (self);
@@ -609,12 +600,11 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
        /* Receive chunk of data */
        transfer = fpi_usb_transfer_new (dev);
        fpi_usb_transfer_fill_bulk_full (transfer, 0x82,
-                                         (void *) self->lines_buffer + self->bytes,
+                                         (guint8 *) self->lines_buffer + self->bytes,
                                         VFS_USB_BUFFER_SIZE, NULL);
        transfer->ssm = ssm;
        fpi_usb_transfer_submit (transfer, VFS_USB_TIMEOUT, NULL,
                                 receive_callback, NULL);
-        fpi_usb_transfer_unref (transfer);
        break;
      }

@@ -623,8 +613,7 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
      clear_data (self);

      /* Wait for probable vdev->active changing */
-      fpi_device_add_timeout (dev, VFS_SSM_TIMEOUT,
-                              fpi_ssm_next_state_timeout_cb, ssm);
+      fpi_ssm_next_state_delayed (ssm, VFS_SSM_TIMEOUT, NULL);
      break;

    case SSM_NEXT_RECEIVE:
@@ -643,8 +632,8 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)

    case SSM_WAIT_ANOTHER_SCAN:
      /* Orange light is on now */
-      fpi_device_add_timeout (dev, VFS_SSM_ORANGE_TIMEOUT,
-                              another_scan, ssm);
+      fpi_ssm_jump_to_state_delayed (ssm, SSM_TURN_ON, VFS_SSM_ORANGE_TIMEOUT,
+                                     NULL);
      break;

    default:
@@ -669,7 +658,6 @@ dev_activate_callback (FpiSsm *ssm, FpDevice *dev, GError *error)
      g_error_free (error);
    }

-  fpi_ssm_free (ssm);
 }

 /* Activate device */
@@ -684,6 +672,7 @@ dev_activate (FpImageDevice *idev)
  self->ssm_active = 1;

  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (idev), activate_ssm, SSM_STATES);
+
  fpi_ssm_start (ssm, dev_activate_callback);
 }

@@ -710,7 +699,6 @@ dev_open_callback (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
  /* Notify open complete */
  fpi_image_device_open_complete (FP_IMAGE_DEVICE (dev), error);
-  fpi_ssm_free (ssm);
 }

 /* Open device */
@@ -728,6 +716,7 @@ dev_open (FpImageDevice *idev)

  /* Clearing previous device state */
  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (idev), activate_ssm, SSM_STATES);
+
  fpi_ssm_start (ssm, dev_open_callback);
 }

@@ -219,7 +219,6 @@ async_send (FpiSsm        *ssm,
  transfer->short_is_error = TRUE;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           async_send_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /* Callback of asynchronous recv */
@@ -282,7 +281,6 @@ async_recv (FpiSsm        *ssm,
  transfer->ssm = ssm;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           async_recv_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 static void async_load (FpiSsm        *ssm,
@@ -369,17 +367,6 @@ async_load (FpiSsm        *ssm,
  transfer->ssm = ssm;
  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
                           async_load_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
-}
-
-/* Submit asynchronous sleep */
-static void
-async_sleep (unsigned int   msec,
-             FpiSsm        *ssm,
-             FpImageDevice *dev)
-{
-  fpi_device_add_timeout (FP_DEVICE (dev), msec,
-                          fpi_ssm_next_state_timeout_cb, ssm);
 }

 /* Swap ssm states */
@@ -798,7 +785,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)

    case M_LOOP_0_SLEEP:
      /* Wait fingerprint scanning */
-      async_sleep (50, ssm, dev);
+      fpi_ssm_next_state_delayed (ssm, 50, NULL);
      break;

    case M_LOOP_0_GET_STATE:
@@ -841,7 +828,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
      img_extract (ssm, dev);

      /* Wait handling image */
-      async_sleep (10, ssm, dev);
+      fpi_ssm_next_state_delayed (ssm, 10, NULL);
      break;

    case M_LOOP_0_CHECK_ACTION:
@@ -864,7 +851,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
      if (vfs_finger_state (self) == VFS_FINGER_PRESENT)
        {
          fpi_image_device_report_finger_status (dev, TRUE);
-          async_sleep (250, ssm, dev);
+          fpi_ssm_next_state_delayed (ssm, 250, NULL);
        }
      else
        {
@@ -894,7 +881,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)

    case M_LOOP_1_SLEEP:
      /* Wait fingerprint scanning */
-      async_sleep (10, ssm, dev);
+      fpi_ssm_next_state_delayed (ssm, 10, NULL);
      break;

    case M_LOOP_2_ABORT_PRINT:
@@ -930,7 +917,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
        {
          /* Wait aborting */
          self->counter++;
-          async_sleep (100, ssm, dev);
+          fpi_ssm_next_state_delayed (ssm, 100, NULL);
        }
      else
        {
@@ -960,7 +947,6 @@ m_loop_complete (FpiSsm *ssm, FpDevice *dev, GError *error)

  self->active = FALSE;

-  fpi_ssm_free (ssm);
 }

 /* Init ssm states */
@@ -1069,7 +1055,7 @@ m_init_state (FpiSsm *ssm, FpDevice *_dev)
        {
          /* Wait aborting */
          self->counter++;
-          async_sleep (100, ssm, dev);
+          fpi_ssm_next_state_delayed (ssm, 100, NULL);
        }
      else
        {
@@ -1098,7 +1084,7 @@ m_init_state (FpiSsm *ssm, FpDevice *_dev)
            {
              /* Wait removing finger */
              self->counter++;
-              async_sleep (250, ssm, dev);
+              fpi_ssm_next_state_delayed (ssm, 250, NULL);
            }
          else
            {
@@ -1268,7 +1254,6 @@ m_init_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
    }

  /* Free sequential state machine */
-  fpi_ssm_free (ssm);
 }

 /* Activate device */
@@ -28,17 +28,6 @@ G_DEFINE_TYPE (FpDeviceVfs301, fpi_device_vfs301, FP_TYPE_IMAGE_DEVICE)

 /************************** GENERIC STUFF *************************************/

-/* Submit asynchronous sleep */
-static void
-async_sleep (unsigned int   msec,
-             FpiSsm        *ssm,
-             FpImageDevice *dev)
-{
-  /* Add timeout */
-  fpi_device_add_timeout (FP_DEVICE (dev), msec,
-                          fpi_ssm_next_state_timeout_cb, ssm);
-}
-
 static int
 submit_image (FpiSsm        *ssm,
              FpImageDevice *dev)
@@ -108,7 +97,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)

    case M_WAIT_PRINT:
      /* Wait fingerprint scanning */
-      async_sleep (200, ssm, dev);
+      fpi_ssm_next_state_delayed (ssm, 200, NULL);
      break;

    case M_CHECK_PRINT:
@@ -126,7 +115,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)

    case M_READ_PRINT_WAIT:
      /* Wait fingerprint scanning */
-      async_sleep (200, ssm, dev);
+      fpi_ssm_next_state_delayed (ssm, 200, NULL);
      break;

    case M_READ_PRINT_POLL:
@@ -158,19 +147,6 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
    }
 }

-/* Complete loop sequential state machine */
-static void
-m_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
-{
-  if (error)
-    {
-      g_warning ("State machine completed with an error: %s", error->message);
-      g_error_free (error);
-    }
-  /* Free sequential state machine */
-  fpi_ssm_free (ssm);
-}
-
 /* Exec init sequential state machine */
 static void
 m_init_state (FpiSsm *ssm, FpDevice *_dev)
@@ -188,20 +164,7 @@ m_init_state (FpiSsm *ssm, FpDevice *_dev)
 static void
 m_init_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
-  FpiSsm *ssm_loop;
-
  fpi_image_device_activate_complete (FP_IMAGE_DEVICE (dev), error);
-  if (!error)
-    {
-      /* Notify activate complete */
-
-      /* Start loop ssm */
-      ssm_loop = fpi_ssm_new (dev, m_loop_state, M_LOOP_NUM_STATES);
-      fpi_ssm_start (ssm_loop, m_loop_complete);
-    }
-
-  /* Free sequential state machine */
-  fpi_ssm_free (ssm);
 }

 /* Activate device */
@@ -226,6 +189,19 @@ dev_deactivate (FpImageDevice *dev)
  fpi_image_device_deactivate_complete (dev, NULL);
 }

+static void
+dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
+{
+  FpiSsm *ssm_loop;
+
+  if (state != FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+    return;
+
+  /* Start a capture operation. */
+  ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, M_LOOP_NUM_STATES);
+  fpi_ssm_start (ssm_loop, NULL);
+}
+
 static void
 dev_open (FpImageDevice *dev)
 {
@@ -286,6 +262,7 @@ fpi_device_vfs301_class_init (FpDeviceVfs301Class *klass)
  img_class->img_close = dev_close;
  img_class->activate = dev_activate;
  img_class->deactivate = dev_deactivate;
+  img_class->change_state = dev_change_state;

  img_class->bz3_threshold = 24;

@@ -79,7 +79,6 @@ usb_recv (FpDeviceVfs301 *dev, guint8 endpoint, int max_bytes, FpiUsbTransfer **

  fpi_usb_transfer_submit_sync (transfer, VFS301_DEFAULT_WAIT_TIMEOUT, &err);

-
 #ifdef DEBUG
  usb_print_packet (0, err, transfer->buffer, transfer->actual_length);
 #endif
@@ -94,6 +93,7 @@ usb_recv (FpDeviceVfs301 *dev, guint8 endpoint, int max_bytes, FpiUsbTransfer **
    *out = g_steal_pointer (&transfer);
 }

+FP_GNUC_ACCESS (read_only, 2, 3)
 static void
 usb_send (FpDeviceVfs301 *dev, const guint8 *data, gssize length, GError **error)
 {
@@ -178,6 +178,7 @@ translate_str (const char **srcL, gssize *len)
      src_len += tmp;
    }

+  g_assert (src_len >= 2);
  *len = src_len / 2;
  res = g_malloc0 (*len);
  dst = res;
@@ -212,11 +213,9 @@ vfs301_proto_generate (int type, int subtype, gssize *len)
        *len = 1;
        return data;
      }
-      break;

    case 0x0B:
      return vfs301_proto_generate_0B (subtype, len);
-      break;

    case 0x02D0:
      {
@@ -232,22 +231,18 @@ vfs301_proto_generate (int type, int subtype, gssize *len)
        g_assert ((int) subtype <= G_N_ELEMENTS (dataLs));
        return translate_str (dataLs[subtype - 1], len);
      }
-      break;

    case 0x0220:
      switch (subtype)
        {
        case 1:
          return translate_str (vfs301_0220_01, len);
-          break;

        case 2:
          return translate_str (vfs301_0220_02, len);
-          break;

        case 3:
          return translate_str (vfs301_0220_03, len);
-          break;

        case 0xFA00:
        case 0x2C01:
@@ -270,7 +265,6 @@ vfs301_proto_generate (int type, int subtype, gssize *len)
            field[3] = field[1];

            return data;
-            break;
          }

        default:
@@ -438,7 +432,7 @@ img_process_data (int first_block, FpDeviceVfs301 *dev, const guint8 *buf, int l
    usb_send (dev, data, len, NULL); \
  }

-#define RAW_DATA(x) x, sizeof (x)
+#define RAW_DATA(x) g_memdup (x, sizeof (x)), sizeof (x)

 #define IS_VFS301_FP_SEQ_START(b) ((b[0] == 0x01) && (b[1] == 0xfe))

@@ -471,7 +465,7 @@ int
 vfs301_proto_peek_event (FpDeviceVfs301 *dev)
 {
  g_autoptr(GError) error = NULL;
-  g_autoptr(FpiUsbTransfer) transfer = NULL;
+  FpiUsbTransfer *transfer;

  const char no_event[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  const char got_event[] = {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00};
@@ -500,7 +494,7 @@ vfs301_proto_peek_event (FpDeviceVfs301 *dev)
    usb_recv (dev, e1, l1, NULL, &error); \
    usb_recv (dev, e2, l2, NULL, NULL); \
    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
@@ -508,30 +502,30 @@ vfs301_proto_process_event_cb (FpiUsbTransfer *transfer,
                               FpDevice *device,
                               gpointer user_data, GError *error)
 {
-  FpDeviceVfs301 *dev = user_data;
+  FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (device);

  if (error)
    {
      g_warning ("Error receiving data: %s", error->message);
      g_error_free (error);
-      dev->recv_progress = VFS301_FAILURE;
+      self->recv_progress = VFS301_FAILURE;
      return;
    }
  else if (transfer->actual_length < transfer->length)
    {
      /* TODO: process the data anyway? */
-      dev->recv_progress = VFS301_ENDED;
+      self->recv_progress = VFS301_ENDED;
      return;
    }
  else
    {
      FpiUsbTransfer *new;
-      if (!vfs301_proto_process_data (dev,
+      if (!vfs301_proto_process_data (self,
                                      transfer->length == VFS301_FP_RECV_LEN_1,
                                      transfer->buffer,
                                      transfer->actual_length))
        {
-          dev->recv_progress = VFS301_ENDED;
+          self->recv_progress = VFS301_ENDED;
          return;
        }

@@ -540,7 +534,6 @@ vfs301_proto_process_event_cb (FpiUsbTransfer *transfer,
      fpi_usb_transfer_fill_bulk (new, VFS301_RECEIVE_ENDPOINT_DATA, VFS301_FP_RECV_LEN_2);
      fpi_usb_transfer_submit (new, VFS301_FP_RECV_TIMEOUT, NULL,
                               vfs301_proto_process_event_cb, NULL);
-      fpi_usb_transfer_unref (new);
      return;
    }
 }
@@ -580,7 +573,6 @@ vfs301_proto_process_event_start (FpDeviceVfs301 *dev)
  fpi_usb_transfer_fill_bulk (transfer, VFS301_RECEIVE_ENDPOINT_DATA, VFS301_FP_RECV_LEN_1);
  fpi_usb_transfer_submit (transfer, VFS301_FP_RECV_TIMEOUT, NULL,
                           vfs301_proto_process_event_cb, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 int
@@ -19,6 +19,8 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

+/* *INDENT-OFF* */
+
 /* There are many similar blocks in the data below, also the data are
 * self-similar (looks like some config blocks? pokes like in vfs101?) */

@@ -1621,56 +1623,56 @@ static const unsigned char vfs301_24[] = { /* 119 B */
 #define vfs301_02D0_ALIGNED_BLOB \
  PACKET ("0200", "8005", \
          "FF830720"  "5F820720"  "FF830720" \
-                                  "5F820720"  "FF830720"  "5F820720"  "FF830720" \
-                                                                      "5F820720"  "FF830720"  "5F820720"  "FF8B0720" \
-                                                                                                          "608A0720"  "FF930720"  "61920720"  "FF9B0720" \
-                                                                                                                                              "629A0720"  "FFA30720"  "63A20720"  "FFAB0720" \
-                                                                                                                                                                                  "64AA0720"  "FFB30720"  "65B20720"  "FFBB0720" \
-                                                                                                                                                                                                                      "66BA0720"  "FFC30720"  "67C20720"  "FFCB0720" \
-                                                                                                                                                                                                                                                          "68CA0720"  "FFD30720"  "69D20720"  "FFDB0720" \
-                                                                                                                                                                                                                                                                                              "6ADA0720"  "FFE30720"  "6BE20720"  "FFEB0720" \
-                                                                                                                                                                                                                                                                                                                                  "6CEA0720"  "FFF30720"  "6DF20720"  "FFFB0720" \
-                                                                                                                                                                                                                                                                                                                                                                      "6EFA0720"  "FF850720"  "6F840720"  "FF8D0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                          "708C0720"  "FF950720"  "71940720"  "FF9D0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                              "729C0720"  "FFA50720"  "73A40720"  "FFAD0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "74AC0720"  "FFB50720"  "75B40720"  "FFBD0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "76BC0720"  "FFC50720"  "77C40720"  "FFCD0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "78CC0720"  "FFD50720"  "79D40720"  "FFDD0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "7ADC0720"  "FFE50720"  "7BE40720"  "FFED0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "7CEC0720"  "FFF50720"  "7DF40720"  "FFFD0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "7EFC0720"  "FF870720"  "7F860720"  "FF8F0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "808E0720"  "FF970720"  "81960720"  "FF9F0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "829E0720"  "FFA70720"  "83A60720"  "FFAF0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "84AE0720"  "FFB70720"  "85B60720"  "FFBF0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "86BE0720"  "FFC70720"  "87C60720"  "FFCF0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "88CE0720"  "FFD70720"  "89D60720"  "FFDF0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "8ADE0720"  "FFE70720"  "8BE60720"  "FFEF0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "8CEE0720"  "FFF70720"  "8DF60720"  "FFFF0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "8EFE0720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFFF0720"  "8EFE0720"  "FFF70720"  "8DF60720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFEF0720"  "8CEE0720"  "FFE70720"  "8BE60720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FFDF0720"  "8ADE0720"  "FFD70720"  "89D60720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FFCF0720"  "88CE0720"  "FFC70720"  "87C60720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFBF0720"  "86BE0720"  "FFB70720"  "85B60720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFAF0720"  "84AE0720"  "FFA70720"  "83A60720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FF9F0720"  "829E0720"  "FF970720"  "81960720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FF8F0720"  "808E0720"  "FF870720"  "7F860720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFFD0720"  "7EFC0720"  "FFF50720"  "7DF40720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFED0720"  "7CEC0720"  "FFE50720"  "7BE40720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FFDD0720"  "7ADC0720"  "FFD50720"  "79D40720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FFCD0720"  "78CC0720"  "FFC50720"  "77C40720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFBD0720"  "76BC0720"  "FFB50720"  "75B40720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFAD0720"  "74AC0720"  "FFA50720"  "73A40720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FF9D0720"  "729C0720"  "FF950720"  "71940720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FF8D0720"  "708C0720"  "FF850720"  "6F840720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFFB0720"  "6EFA0720"  "FFF30720"  "6DF20720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFEB0720"  "6CEA0720"  "FFE30720"  "6BE20720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FFDB0720"  "6ADA0720"  "FFD30720"  "69D20720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FFCB0720"  "68CA0720"  "FFC30720"  "67C20720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFBB0720"  "66BA0720"  "FFB30720"  "65B20720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFAB0720"  "64AA0720"  "FFA30720"  "63A20720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FF9B0720"  "629A0720"  "FF930720"  "61920720" \
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FF8B0720"  "608A0720"  "FF830720"  "5F820720" \
+          "5F820720"  "FF830720"  "5F820720"  "FF830720" \
+          "5F820720"  "FF830720"  "5F820720"  "FF8B0720" \
+          "608A0720"  "FF930720"  "61920720"  "FF9B0720" \
+          "629A0720"  "FFA30720"  "63A20720"  "FFAB0720" \
+          "64AA0720"  "FFB30720"  "65B20720"  "FFBB0720" \
+          "66BA0720"  "FFC30720"  "67C20720"  "FFCB0720" \
+          "68CA0720"  "FFD30720"  "69D20720"  "FFDB0720" \
+          "6ADA0720"  "FFE30720"  "6BE20720"  "FFEB0720" \
+          "6CEA0720"  "FFF30720"  "6DF20720"  "FFFB0720" \
+          "6EFA0720"  "FF850720"  "6F840720"  "FF8D0720" \
+          "708C0720"  "FF950720"  "71940720"  "FF9D0720" \
+          "729C0720"  "FFA50720"  "73A40720"  "FFAD0720" \
+          "74AC0720"  "FFB50720"  "75B40720"  "FFBD0720" \
+          "76BC0720"  "FFC50720"  "77C40720"  "FFCD0720" \
+          "78CC0720"  "FFD50720"  "79D40720"  "FFDD0720" \
+          "7ADC0720"  "FFE50720"  "7BE40720"  "FFED0720" \
+          "7CEC0720"  "FFF50720"  "7DF40720"  "FFFD0720" \
+          "7EFC0720"  "FF870720"  "7F860720"  "FF8F0720" \
+          "808E0720"  "FF970720"  "81960720"  "FF9F0720" \
+          "829E0720"  "FFA70720"  "83A60720"  "FFAF0720" \
+          "84AE0720"  "FFB70720"  "85B60720"  "FFBF0720" \
+          "86BE0720"  "FFC70720"  "87C60720"  "FFCF0720" \
+          "88CE0720"  "FFD70720"  "89D60720"  "FFDF0720" \
+          "8ADE0720"  "FFE70720"  "8BE60720"  "FFEF0720" \
+          "8CEE0720"  "FFF70720"  "8DF60720"  "FFFF0720" \
+          "8EFE0720" \
+          "FFFF0720"  "8EFE0720"  "FFF70720"  "8DF60720" \
+          "FFEF0720"  "8CEE0720"  "FFE70720"  "8BE60720" \
+          "FFDF0720"  "8ADE0720"  "FFD70720"  "89D60720" \
+          "FFCF0720"  "88CE0720"  "FFC70720"  "87C60720" \
+          "FFBF0720"  "86BE0720"  "FFB70720"  "85B60720" \
+          "FFAF0720"  "84AE0720"  "FFA70720"  "83A60720" \
+          "FF9F0720"  "829E0720"  "FF970720"  "81960720" \
+          "FF8F0720"  "808E0720"  "FF870720"  "7F860720" \
+          "FFFD0720"  "7EFC0720"  "FFF50720"  "7DF40720" \
+          "FFED0720"  "7CEC0720"  "FFE50720"  "7BE40720" \
+          "FFDD0720"  "7ADC0720"  "FFD50720"  "79D40720" \
+          "FFCD0720"  "78CC0720"  "FFC50720"  "77C40720" \
+          "FFBD0720"  "76BC0720"  "FFB50720"  "75B40720" \
+          "FFAD0720"  "74AC0720"  "FFA50720"  "73A40720" \
+          "FF9D0720"  "729C0720"  "FF950720"  "71940720" \
+          "FF8D0720"  "708C0720"  "FF850720"  "6F840720" \
+          "FFFB0720"  "6EFA0720"  "FFF30720"  "6DF20720" \
+          "FFEB0720"  "6CEA0720"  "FFE30720"  "6BE20720" \
+          "FFDB0720"  "6ADA0720"  "FFD30720"  "69D20720" \
+          "FFCB0720"  "68CA0720"  "FFC30720"  "67C20720" \
+          "FFBB0720"  "66BA0720"  "FFB30720"  "65B20720" \
+          "FFAB0720"  "64AA0720"  "FFA30720"  "63A20720" \
+          "FF9B0720"  "629A0720"  "FF930720"  "61920720" \
+          "FF8B0720"  "608A0720"  "FF830720"  "5F820720" \
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () \
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () \
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () \
@@ -1871,49 +1873,49 @@ const char *vfs301_0220_01[] = {
          "A46C0420"
          "A46C0400"
          "83688420" "83688420" "83688420" "83688420"
-                                           "83688420" "83688420" "83688420" "83688420"
-                                                                            "83688420" "83688420" "83688420" "83688420"
-                                                                                                             "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                              "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                               "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                 "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                  "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                   "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                    "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                     "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                      "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                       "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "83688420" "83688420" "83688420" "83688420"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420" "83688420" "83688420"
+          "83688420" "83688420"
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
@@ -2268,55 +2270,55 @@ const char *vfs301_02D0_04[] = {
   * any troubles. */
  PACKET ("0200", "8005",
          "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                           "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                            "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                             "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                              "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                               "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                 "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                  "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                   "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                    "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                     "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                      "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                       "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFF30720" "80F20720" "FFF30720" "80F20720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
+          "FFF30720" "80F20720" "FFF30720" "80F20720"
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
@@ -2437,55 +2439,55 @@ const char *vfs301_02D0_05[] = {
   * any troubles. */
  PACKET ("0200", "8005",
          "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                           "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                            "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                             "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                              "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                               "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                 "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                  "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                   "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                    "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                     "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                      "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                       "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          "FFF34720" "80F24720" "FFF34720" "80F24720"
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
+          "FFF34720" "80F24720" "FFF34720" "80F24720"
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
          Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 () Z8 ()
@@ -168,7 +168,6 @@ usbexchange_loop (FpiSsm *ssm, FpDevice *_dev)
      transfer->short_is_error = TRUE;
      fpi_usb_transfer_submit (transfer, data->timeout, NULL,
                               async_send_cb, NULL);
-      fpi_usb_transfer_unref (transfer);
      break;

    case ACTION_RECEIVE:
@@ -180,7 +179,6 @@ usbexchange_loop (FpiSsm *ssm, FpDevice *_dev)
      transfer->ssm = ssm;
      fpi_usb_transfer_submit (transfer, data->timeout, NULL,
                               async_recv_cb, NULL);
-      fpi_usb_transfer_unref (transfer);
      break;

    default:
@@ -192,11 +190,13 @@ usbexchange_loop (FpiSsm *ssm, FpDevice *_dev)

 static void
 usb_exchange_async (FpiSsm                  *ssm,
-                    struct usbexchange_data *data)
+                    struct usbexchange_data *data,
+                    const char              *exchange_name)
 {
-  FpiSsm *subsm = fpi_ssm_new (FP_DEVICE (data->device),
-                               usbexchange_loop,
-                               data->stepcount);
+  FpiSsm *subsm = fpi_ssm_new_full (FP_DEVICE (data->device),
+                                    usbexchange_loop,
+                                    data->stepcount,
+                                    exchange_name);

  fpi_ssm_set_data (subsm, data, NULL);
  fpi_ssm_start_subsm (ssm, subsm);
@@ -212,8 +212,8 @@ vfs5011_get_deviation2 (struct fpi_line_asmbl_ctx *ctx, GSList *row1, GSList *ro
  int res = 0, mean = 0, i;
  const int size = 64;

-  buf1 = row1->data + 56;
-  buf2 = row2->data + 168;
+  buf1 = (unsigned char *) row1->data + 56;
+  buf2 = (unsigned char *) row2->data + 168;

  for (i = 0; i < size; i++)
    mean += (int) buf1[i] + (int) buf2[i];
@@ -234,7 +234,7 @@ vfs5011_get_pixel (struct fpi_line_asmbl_ctx *ctx,
                   GSList                    *row,
                   unsigned                   x)
 {
-  unsigned char *data = row->data + 8;
+  unsigned char *data = (unsigned char *) row->data + 8;

  return data[x];
 }
@@ -381,9 +381,8 @@ submit_image (FpiSsm          *ssm,
 {
  FpImage *img;

-  if (self->lines_recorded == 0)
+  if (self->lines_recorded < VFS5011_IMAGE_WIDTH)
    {
-      /* == FP_ENROLL_RETRY_TOO_SHORT */
      fpi_image_device_retry_scan (dev, FP_DEVICE_RETRY_TOO_SHORT);
      return;
    }
@@ -466,7 +465,6 @@ capture_chunk_async (FpDeviceVfs5011 *self,
  transfer->ssm = ssm;
  fpi_usb_transfer_submit (transfer, timeout, fpi_device_get_cancellable (FP_DEVICE (self)),
                           chunk_capture_callback, NULL);
-  fpi_usb_transfer_unref (transfer);
 }

 /*
@@ -687,7 +685,7 @@ activate_loop (FpiSsm *ssm, FpDevice *_dev)
        self->init_sequence.receive_buf =
          g_malloc0 (VFS5011_RECEIVE_BUF_SIZE);
      self->init_sequence.timeout = 1000;
-      usb_exchange_async (ssm, &self->init_sequence);
+      usb_exchange_async (ssm, &self->init_sequence, "ACTIVATE REQUEST");
      break;

    case DEV_ACTIVATE_INIT_COMPLETE:
@@ -707,10 +705,7 @@ activate_loop (FpiSsm *ssm, FpDevice *_dev)
      break;

    case DEV_ACTIVATE_DATA_COMPLETE:
-      fpi_device_add_timeout (_dev, 1,
-                              fpi_ssm_next_state_timeout_cb,
-                              ssm);
-
+      fpi_ssm_next_state_delayed (ssm, 1, NULL);
      break;

    case DEV_ACTIVATE_PREPARE_NEXT_CAPTURE:
@@ -722,7 +717,7 @@ activate_loop (FpiSsm *ssm, FpDevice *_dev)
        self->init_sequence.receive_buf =
          g_malloc0 (VFS5011_RECEIVE_BUF_SIZE);
      self->init_sequence.timeout = VFS5011_DEFAULT_WAIT_TIMEOUT;
-      usb_exchange_async (ssm, &self->init_sequence);
+      usb_exchange_async (ssm, &self->init_sequence, "PREPARE CAPTURE");
      break;

    }
@@ -745,7 +740,6 @@ activate_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
      submit_image (ssm, self, dev);
      fpi_image_device_report_finger_status (dev, FALSE);
    }
-  fpi_ssm_free (ssm);

  self->loop_running = FALSE;

@@ -776,7 +770,7 @@ open_loop (FpiSsm *ssm, FpDevice *_dev)
      self->init_sequence.receive_buf =
        g_malloc0 (VFS5011_RECEIVE_BUF_SIZE);
      self->init_sequence.timeout = VFS5011_DEFAULT_WAIT_TIMEOUT;
-      usb_exchange_async (ssm, &self->init_sequence);
+      usb_exchange_async (ssm, &self->init_sequence, "DEVICE OPEN");
      break;
    }
  ;
@@ -793,7 +787,6 @@ open_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
  self->init_sequence.receive_buf = NULL;

  fpi_image_device_open_complete (dev, error);
-  fpi_ssm_free (ssm);
 }

 static void
@@ -822,13 +815,11 @@ dev_close (FpImageDevice *dev)
  GError *error = NULL;
  FpDeviceVfs5011 *self = FPI_DEVICE_VFS5011 (dev);

-  ;
-
  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
                                  0, 0, &error);

  g_free (self->capture_buffer);
-  g_slist_free_full (self->rows, g_free);
+  g_slist_free_full (g_steal_pointer (&self->rows), g_free);

  fpi_image_device_close_complete (dev, error);
 }
@@ -1,5 +1,6 @@
-#ifndef __VFS5011_PROTO_H
-#define __VFS5011_PROTO_H
+#pragma once
+
+/* *INDENT-OFF* */

 #define VFS5011_LINE_SIZE 240
 #define VFS5011_IMAGE_WIDTH 160
@@ -6182,5 +6183,3 @@ static unsigned char vfs5011_prepare_04[] = { /* 2903 B */
  0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
  0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
 };
-
-#endif
@@ -0,0 +1,355 @@
+/*
+ * Socket utilities for "simple" device debugging
+ *
+ * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
+ * Copyright (C) 2020 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
+ */
+
+#define FP_COMPONENT "virtual_device_connection"
+
+#include "fpi-log.h"
+
+#include <glib/gstdio.h>
+#include <gio/gunixsocketaddress.h>
+
+#include "virtual-device-private.h"
+
+struct _FpDeviceVirtualListener
+{
+  GSocketListener                     parent_instance;
+
+  GSocketConnection                  *connection;
+  GCancellable                       *cancellable;
+  guint                               cancellable_id;
+
+  FpDeviceVirtualListenerConnectionCb ready_cb;
+  gpointer                            ready_cb_data;
+
+  gint                                socket_fd;
+  gint                                client_fd;
+};
+
+G_DEFINE_TYPE (FpDeviceVirtualListener, fp_device_virtual_listener, G_TYPE_SOCKET_LISTENER)
+
+static void start_listen (FpDeviceVirtualListener *self);
+
+FpDeviceVirtualListener *
+fp_device_virtual_listener_new (void)
+{
+  return g_object_new (fp_device_virtual_listener_get_type (), NULL);
+}
+
+static void
+fp_device_virtual_listener_dispose (GObject *object)
+{
+  FpDeviceVirtualListener *self = FP_DEVICE_VIRTUAL_LISTENER (object);
+
+  if (self->cancellable_id)
+    {
+      g_cancellable_disconnect (self->cancellable, self->cancellable_id);
+      self->cancellable_id = 0;
+    }
+
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+  g_clear_object (&self->connection);
+
+  self->ready_cb = NULL;
+
+  G_OBJECT_CLASS (fp_device_virtual_listener_parent_class)->dispose (object);
+}
+
+static void
+fp_device_virtual_listener_class_init (FpDeviceVirtualListenerClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = fp_device_virtual_listener_dispose;
+}
+
+static void
+fp_device_virtual_listener_init (FpDeviceVirtualListener *self)
+{
+}
+
+static void
+new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
+{
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualListener *self = user_data;
+  GSocketConnection *connection;
+
+  connection = g_socket_listener_accept_finish (G_SOCKET_LISTENER (source_object),
+                                                res,
+                                                NULL,
+                                                &error);
+  if (!connection)
+    {
+      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        return;
+
+      g_warning ("Error accepting a new connection: %s", error->message);
+      start_listen (self);
+      return;
+    }
+
+  /* Always allow further connections.
+   * If we get a new one, we generally just close the old connection. */
+  start_listen (self);
+  if (self->connection)
+    {
+      g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
+      g_clear_object (&self->connection);
+    }
+
+  self->connection = connection;
+  fp_dbg ("Got a new connection!");
+
+  self->ready_cb (self, self->ready_cb_data);
+}
+
+static void
+start_listen (FpDeviceVirtualListener *self)
+{
+  g_socket_listener_accept_async (G_SOCKET_LISTENER (self),
+                                  self->cancellable,
+                                  new_connection_cb,
+                                  self);
+}
+
+static void
+on_cancelled (GCancellable            *cancellable,
+              FpDeviceVirtualListener *self)
+{
+  fp_device_virtual_listener_connection_close (self);
+  g_socket_listener_close (G_SOCKET_LISTENER (self));
+  g_clear_object (&self->cancellable);
+  self->ready_cb = NULL;
+}
+
+gboolean
+fp_device_virtual_listener_start (FpDeviceVirtualListener            *self,
+                                  const char                         *address,
+                                  GCancellable                       *cancellable,
+                                  FpDeviceVirtualListenerConnectionCb cb,
+                                  gpointer                            user_data,
+                                  GError                            **error)
+{
+  g_autoptr(GSocketAddress) addr = NULL;
+  G_DEBUG_HERE ();
+
+  g_return_val_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
+  g_return_val_if_fail (cb != NULL, FALSE);
+  g_return_val_if_fail (self->ready_cb == NULL, FALSE);
+
+  self->client_fd = -1;
+
+  g_socket_listener_set_backlog (G_SOCKET_LISTENER (self), 1);
+
+  /* Remove any left over socket. */
+  g_unlink (address);
+
+  addr = g_unix_socket_address_new (address);
+
+  if (!g_socket_listener_add_address (G_SOCKET_LISTENER (self),
+                                      addr,
+                                      G_SOCKET_TYPE_STREAM,
+                                      G_SOCKET_PROTOCOL_DEFAULT,
+                                      NULL,
+                                      NULL,
+                                      error))
+    {
+      g_warning ("Could not listen on unix socket: %s", (*error)->message);
+      return FALSE;
+    }
+
+  self->ready_cb = cb;
+  self->ready_cb_data = user_data;
+  self->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
+
+  if (self->cancellable)
+    self->cancellable_id = g_cancellable_connect (self->cancellable,
+                                                  G_CALLBACK (on_cancelled), self, NULL);
+
+  start_listen (self);
+
+  return TRUE;
+}
+
+gboolean
+fp_device_virtual_listener_connection_close (FpDeviceVirtualListener *self)
+{
+  g_return_val_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
+
+  if (!self->connection)
+    return FALSE;
+
+  g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
+  g_clear_object (&self->connection);
+
+  return TRUE;
+}
+
+static void
+on_stream_read_cb (GObject      *source_object,
+                   GAsyncResult *res,
+                   gpointer      user_data)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(GTask) task = user_data;
+  FpDeviceVirtualListener *self = g_task_get_source_object (task);
+  gboolean all;
+  gboolean success;
+  gsize bytes;
+
+  all = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (task), "all"));
+
+  if (all)
+    {
+      success = g_input_stream_read_all_finish (G_INPUT_STREAM (source_object), res, &bytes, &error);
+    }
+  else
+    {
+      gssize sbytes;
+
+      sbytes = g_input_stream_read_finish (G_INPUT_STREAM (source_object), res, &error);
+      bytes = sbytes;
+      success = (sbytes >= 0);
+    }
+
+  if (g_task_return_error_if_cancelled (task))
+    return;
+
+  /* If we are cancelled, just return immediately. */
+  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CLOSED))
+    {
+      g_task_return_int (task, 0);
+      return;
+    }
+
+  /* If this error is for an old connection (that should be closed already),
+   * then just give up immediately with a CLOSED error.
+   */
+  if (self->connection &&
+      g_io_stream_get_input_stream (G_IO_STREAM (self->connection)) != G_INPUT_STREAM (source_object))
+    {
+      g_task_return_new_error (task,
+                               G_IO_ERROR,
+                               G_IO_ERROR_CLOSED,
+                               "Error on old connection, ignoring.");
+      return;
+    }
+
+  if (!success || bytes == 0)
+    {
+      /* We accept it if someone tries to read twice and just return that error. */
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING))
+        {
+          if (self->connection)
+            {
+              g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
+              g_clear_object (&self->connection);
+            }
+        }
+
+      if (error)
+        {
+          g_task_return_error (task, g_steal_pointer (&error));
+          return;
+        }
+      else
+        {
+          // g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Got empty data");
+          return;
+        }
+    }
+
+  g_task_return_int (task, bytes);
+}
+
+void
+fp_device_virtual_listener_read (FpDeviceVirtualListener *self,
+                                 gboolean                 all,
+                                 void                    *buffer,
+                                 gsize                    count,
+                                 GAsyncReadyCallback      callback,
+                                 gpointer                 user_data)
+{
+  g_autoptr(GTask) task = NULL;
+  GInputStream *stream;
+
+  g_return_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self));
+
+  task = g_task_new (self, self->cancellable, callback, user_data);
+  g_object_set_data (G_OBJECT (task), "all", GINT_TO_POINTER (all));
+
+  if (!self->connection || g_io_stream_is_closed (G_IO_STREAM (self->connection)))
+    {
+      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED,
+                               "Listener not connected to any stream");
+      return;
+    }
+
+  stream = g_io_stream_get_input_stream (G_IO_STREAM (self->connection));
+  if (all)
+    {
+      g_input_stream_read_all_async (stream, buffer, count,
+                                     G_PRIORITY_DEFAULT,
+                                     self->cancellable,
+                                     on_stream_read_cb,
+                                     g_steal_pointer (&task));
+    }
+  else
+    {
+      g_input_stream_read_async (stream, buffer, count,
+                                 G_PRIORITY_DEFAULT,
+                                 self->cancellable,
+                                 on_stream_read_cb,
+                                 g_steal_pointer (&task));
+    }
+}
+
+gsize
+fp_device_virtual_listener_read_finish (FpDeviceVirtualListener *self,
+                                        GAsyncResult            *result,
+                                        GError                 **error)
+{
+  g_return_val_if_fail (g_task_is_valid (result, self), 0);
+
+  return g_task_propagate_int (G_TASK (result), error);
+}
+
+gboolean
+fp_device_virtual_listener_write_sync (FpDeviceVirtualListener *self,
+                                       const char              *buffer,
+                                       gsize                    count,
+                                       GError                 **error)
+{
+  if (!self->connection || g_io_stream_is_closed (G_IO_STREAM (self->connection)))
+    {
+      g_set_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED,
+                   "Listener not connected to any stream");
+      return FALSE;
+    }
+
+  return g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (self->connection)),
+                                    buffer,
+                                    count,
+                                    NULL,
+                                    self->cancellable,
+                                    error);
+}
@@ -0,0 +1,109 @@
+/*
+ * Virtual driver for "simple" device debugging
+ *
+ * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
+ * Copyright (C) 2020 Bastien Nocera <hadess@hadess.net>
+ *
+ * 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
+ */
+
+/*
+ * This is a virtual driver to debug the non-image based drivers. A small
+ * python script is provided to connect to it via a socket, allowing
+ * prints to registered programmatically.
+ * Using this, it is possible to test libfprint and fprintd.
+ */
+
+#include <gio/gio.h>
+
+#include "fpi-device.h"
+
+#define MAX_LINE_LEN 1024
+
+G_DECLARE_FINAL_TYPE (FpDeviceVirtualListener, fp_device_virtual_listener, FP, DEVICE_VIRTUAL_LISTENER, GSocketListener)
+
+typedef void (*FpDeviceVirtualListenerConnectionCb) (FpDeviceVirtualListener *listener,
+                                                     gpointer                 user_data);
+
+FpDeviceVirtualListener * fp_device_virtual_listener_new (void);
+
+gboolean fp_device_virtual_listener_start (FpDeviceVirtualListener            *listener,
+                                           const char                         *address,
+                                           GCancellable                       *cancellable,
+                                           FpDeviceVirtualListenerConnectionCb cb,
+                                           gpointer                            user_data,
+                                           GError                            **error);
+
+gboolean fp_device_virtual_listener_connection_close (FpDeviceVirtualListener *listener);
+
+void fp_device_virtual_listener_read (FpDeviceVirtualListener *listener,
+                                      gboolean                 all,
+                                      void                    *buffer,
+                                      gsize                    count,
+                                      GAsyncReadyCallback      callback,
+                                      gpointer                 user_data);
+gsize fp_device_virtual_listener_read_finish (FpDeviceVirtualListener *listener,
+                                              GAsyncResult            *result,
+                                              GError                 **error);
+
+gboolean fp_device_virtual_listener_write_sync (FpDeviceVirtualListener *self,
+                                                const char              *buffer,
+                                                gsize                    count,
+                                                GError                 **error);
+
+
+struct _FpDeviceVirtualDevice
+{
+  FpDevice                 parent;
+
+  FpDeviceVirtualListener *listener;
+  GCancellable            *cancellable;
+
+  char                     recv_buf[MAX_LINE_LEN];
+
+  GPtrArray               *pending_commands;
+
+  GHashTable              *prints_storage;
+
+  guint                    wait_command_id;
+  guint                    sleep_timeout_id;
+  guint                    enroll_stages_passed;
+  gboolean                 match_reported;
+  gboolean                 supports_cancellation;
+  gboolean                 injected_synthetic_cmd;
+  gboolean                 ignore_wait;
+  gboolean                 keep_alive;
+};
+
+/* Not really final here, but we can do this to share the FpDeviceVirtualDevice
+ * contents without having to use a shared private struct instead. */
+G_DECLARE_FINAL_TYPE (FpDeviceVirtualDevice, fpi_device_virtual_device, FP, DEVICE_VIRTUAL_DEVICE, FpDevice)
+
+struct _FpDeviceVirtualDeviceStorage
+{
+  FpDeviceVirtualDevice parent;
+};
+
+G_DECLARE_FINAL_TYPE (FpDeviceVirtualDeviceStorage, fpi_device_virtual_device_storage, FP, DEVICE_VIRTUAL_DEVICE_STORAGE, FpDeviceVirtualDevice)
+
+
+char * process_cmds (FpDeviceVirtualDevice * self, gboolean scan, GError **error);
+char * start_scan_command (FpDeviceVirtualDevice *self,
+                           GError               **error);
+gboolean should_wait_for_command (FpDeviceVirtualDevice *self,
+                                  GError                *error);
+gboolean should_wait_to_sleep (FpDeviceVirtualDevice *self,
+                               const char            *scan_id,
+                               GError                *error);
@@ -0,0 +1,247 @@
+/*
+ * Virtual driver for "simple" device debugging with storage
+ *
+ * Copyright (C) 2020 Bastien Nocera <hadess@hadess.net>
+ * Copyright (C) 2020 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
+ */
+
+/*
+ * This is a virtual driver to debug the non-image based drivers. A small
+ * python script is provided to connect to it via a socket, allowing
+ * prints to registered programmatically.
+ * Using this, it is possible to test libfprint and fprintd.
+ */
+
+#define FP_COMPONENT "virtual_device_storage"
+
+#include "virtual-device-private.h"
+#include "fpi-log.h"
+
+G_DEFINE_TYPE (FpDeviceVirtualDeviceStorage, fpi_device_virtual_device_storage, fpi_device_virtual_device_get_type ())
+
+static GPtrArray * get_stored_prints (FpDeviceVirtualDevice * self);
+
+static void
+dev_identify (FpDevice *dev)
+{
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
+  g_autofree char *scan_id = NULL;
+
+  scan_id = start_scan_command (self, &error);
+  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING))
+    return;
+
+  if (scan_id)
+    {
+      g_autoptr(GPtrArray) stored = get_stored_prints (self);
+      GPtrArray *prints;
+      GVariant *data = NULL;
+      FpPrint *new_scan;
+      FpPrint *match = NULL;
+      guint idx;
+
+      new_scan = fp_print_new (dev);
+      fpi_print_set_type (new_scan, FPI_PRINT_RAW);
+      fpi_print_set_device_stored (new_scan, TRUE);
+      data = g_variant_new_string (scan_id);
+      g_object_set (new_scan, "fpi-data", data, NULL);
+
+      fpi_device_get_identify_data (dev, &prints);
+      g_debug ("Trying to identify print '%s' against a gallery of %u prints", scan_id, prints->len);
+
+      if (!g_ptr_array_find_with_equal_func (stored,
+                                             new_scan,
+                                             (GEqualFunc) fp_print_equal,
+                                             NULL))
+        error = fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND);
+      else if (g_ptr_array_find_with_equal_func (prints,
+                                                 new_scan,
+                                                 (GEqualFunc) fp_print_equal,
+                                                 &idx))
+        match = g_ptr_array_index (prints, idx);
+
+      if (!self->match_reported)
+        {
+          self->match_reported = TRUE;
+          fpi_device_identify_report (dev,
+                                      match,
+                                      new_scan,
+                                      NULL);
+        }
+    }
+  else if (error && error->domain == FP_DEVICE_RETRY)
+    {
+      fpi_device_identify_report (dev, NULL, NULL, g_steal_pointer (&error));
+    }
+
+  fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                           FP_FINGER_STATUS_NONE,
+                                           FP_FINGER_STATUS_PRESENT);
+
+  if (should_wait_to_sleep (self, scan_id, error))
+    return;
+
+  self->match_reported = FALSE;
+  fpi_device_identify_complete (dev, g_steal_pointer (&error));
+}
+
+struct ListData
+{
+  FpDevice  *dev;
+  GPtrArray *res;
+};
+
+static void
+dev_list_insert_print (gpointer key,
+                       gpointer value,
+                       gpointer user_data)
+{
+  struct ListData *data = user_data;
+  FpPrint *print = fp_print_new (data->dev);
+  GVariant *var = NULL;
+
+  fpi_print_fill_from_user_id (print, key);
+  fpi_print_set_type (print, FPI_PRINT_RAW);
+  var = g_variant_new_string (key);
+  g_object_set (print, "fpi-data", var, NULL);
+  g_object_ref_sink (print);
+
+  g_ptr_array_add (data->res, print);
+}
+
+static GPtrArray *
+get_stored_prints (FpDeviceVirtualDevice *self)
+{
+  GPtrArray * prints_list;
+  struct ListData data;
+
+  prints_list = g_ptr_array_new_full (g_hash_table_size (self->prints_storage),
+                                      g_object_unref);
+  data.dev = FP_DEVICE (self);
+  data.res = prints_list;
+
+  g_hash_table_foreach (self->prints_storage, dev_list_insert_print, &data);
+
+  return prints_list;
+}
+
+static void
+dev_list (FpDevice *dev)
+{
+  g_autoptr(GPtrArray) prints_list = NULL;
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualDevice *vdev = FP_DEVICE_VIRTUAL_DEVICE (dev);
+
+  process_cmds (vdev, FALSE, &error);
+  if (should_wait_for_command (vdev, error))
+    return;
+
+  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+    {
+      fpi_device_list_complete (dev, NULL, g_steal_pointer (&error));
+      return;
+    }
+
+  fpi_device_list_complete (dev, get_stored_prints (vdev), NULL);
+}
+
+static void
+dev_delete (FpDevice *dev)
+{
+  g_autoptr(GVariant) data = NULL;
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualDevice *vdev = FP_DEVICE_VIRTUAL_DEVICE (dev);
+  FpPrint *print = NULL;
+  const char *id = NULL;
+
+  process_cmds (vdev, FALSE, &error);
+  if (should_wait_for_command (vdev, error))
+    return;
+
+  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+    {
+      fpi_device_delete_complete (dev, g_steal_pointer (&error));
+      return;
+    }
+
+  fpi_device_get_delete_data (dev, &print);
+
+  g_object_get (print, "fpi-data", &data, NULL);
+  if (data == NULL)
+    {
+      fpi_device_delete_complete (dev,
+                                  fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
+      return;
+    }
+
+  id = g_variant_get_string (data, NULL);
+
+  fp_dbg ("Deleting print %s for user %s",
+          id,
+          fp_print_get_username (print));
+
+  if (g_hash_table_remove (vdev->prints_storage, id))
+    fpi_device_delete_complete (dev, NULL);
+  else
+    fpi_device_delete_complete (dev,
+                                fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
+}
+
+static void
+fpi_device_virtual_device_storage_init (FpDeviceVirtualDeviceStorage *self)
+{
+  FpDeviceVirtualDevice *vdev = FP_DEVICE_VIRTUAL_DEVICE (self);
+
+  vdev->prints_storage = g_hash_table_new_full (g_str_hash,
+                                                g_str_equal,
+                                                g_free,
+                                                NULL);
+}
+
+static void
+fpi_device_virtual_device_storage_finalize (GObject *object)
+{
+  FpDeviceVirtualDevice *vdev = FP_DEVICE_VIRTUAL_DEVICE (object);
+
+  G_DEBUG_HERE ();
+  g_clear_pointer (&vdev->prints_storage, g_hash_table_destroy);
+  G_OBJECT_CLASS (fpi_device_virtual_device_storage_parent_class)->finalize (object);
+}
+
+static const FpIdEntry driver_ids[] = {
+  { .virtual_envvar = "FP_VIRTUAL_DEVICE_STORAGE" },
+  { .virtual_envvar = "FP_VIRTUAL_DEVICE_IDENT" },
+  { .virtual_envvar = NULL }
+};
+
+static void
+fpi_device_virtual_device_storage_class_init (FpDeviceVirtualDeviceStorageClass *klass)
+{
+  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = fpi_device_virtual_device_storage_finalize;
+
+  dev_class->id = FP_COMPONENT;
+  dev_class->full_name = "Virtual device with storage and identification for debugging";
+  dev_class->id_table = driver_ids;
+
+  dev_class->identify = dev_identify;
+  dev_class->list = dev_list;
+  dev_class->delete = dev_delete;
+}
@@ -0,0 +1,779 @@
+/*
+ * Virtual driver for "simple" device debugging
+ *
+ * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
+ * Copyright (C) 2020 Bastien Nocera <hadess@hadess.net>
+ * Copyright (C) 2020 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
+ */
+
+/*
+ * This is a virtual driver to debug the non-image based drivers. A small
+ * python script is provided to connect to it via a socket, allowing
+ * prints to registered programmatically.
+ * Using this, it is possible to test libfprint and fprintd.
+ */
+
+#define FP_COMPONENT "virtual_device"
+
+#include "virtual-device-private.h"
+#include "fpi-log.h"
+
+G_DEFINE_TYPE (FpDeviceVirtualDevice, fpi_device_virtual_device, FP_TYPE_DEVICE)
+
+#define INSERT_CMD_PREFIX "INSERT "
+#define REMOVE_CMD_PREFIX "REMOVE "
+#define SCAN_CMD_PREFIX "SCAN "
+#define ERROR_CMD_PREFIX "ERROR "
+#define RETRY_CMD_PREFIX "RETRY "
+#define FINGER_CMD_PREFIX "FINGER "
+#define SLEEP_CMD_PREFIX "SLEEP "
+#define SET_ENROLL_STAGES_PREFIX "SET_ENROLL_STAGES "
+#define SET_SCAN_TYPE_PREFIX "SET_SCAN_TYPE "
+#define SET_CANCELLATION_PREFIX "SET_CANCELLATION_ENABLED "
+#define SET_KEEP_ALIVE_PREFIX "SET_KEEP_ALIVE "
+
+#define LIST_CMD "LIST"
+#define UNPLUG_CMD "UNPLUG"
+
+static void
+maybe_continue_current_action (FpDeviceVirtualDevice *self)
+{
+  FpDevice *dev = FP_DEVICE (self);
+
+  if (self->sleep_timeout_id)
+    return;
+
+  switch (fpi_device_get_current_action (dev))
+    {
+    case FPI_DEVICE_ACTION_ENROLL:
+      FP_DEVICE_GET_CLASS (self)->enroll (dev);
+      break;
+
+    case FPI_DEVICE_ACTION_VERIFY:
+      FP_DEVICE_GET_CLASS (self)->verify (dev);
+      break;
+
+    case FPI_DEVICE_ACTION_IDENTIFY:
+      FP_DEVICE_GET_CLASS (self)->identify (dev);
+      break;
+
+    case FPI_DEVICE_ACTION_LIST:
+      FP_DEVICE_GET_CLASS (self)->list (dev);
+      break;
+
+    case FPI_DEVICE_ACTION_DELETE:
+      FP_DEVICE_GET_CLASS (self)->delete (dev);
+      break;
+
+    case FPI_DEVICE_ACTION_OPEN:
+      FP_DEVICE_GET_CLASS (self)->open (dev);
+      break;
+
+    case FPI_DEVICE_ACTION_CLOSE:
+      FP_DEVICE_GET_CLASS (self)->close (dev);
+      break;
+
+    default:
+      break;
+    }
+}
+
+static gboolean
+sleep_timeout_cb (gpointer data)
+{
+  FpDeviceVirtualDevice *self = data;
+
+  self->sleep_timeout_id = 0;
+
+  if (g_cancellable_is_cancelled (self->cancellable))
+    return FALSE;
+
+  g_debug ("Sleeping completed");
+  maybe_continue_current_action (self);
+
+  return FALSE;
+}
+
+char *
+process_cmds (FpDeviceVirtualDevice * self,
+              gboolean                scan,
+              GError                **error)
+{
+  if (g_cancellable_is_cancelled (self->cancellable) ||
+      (fpi_device_get_current_action (FP_DEVICE (self)) != FPI_DEVICE_ACTION_NONE &&
+       g_cancellable_is_cancelled (fpi_device_get_cancellable (FP_DEVICE (self)))))
+    {
+      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CANCELLED,
+                           "Operation was cancelled");
+      return NULL;
+    }
+
+  while (self->pending_commands->len > 0)
+    {
+      gchar *cmd = g_ptr_array_index (self->pending_commands, 0);
+
+      g_debug ("Processing command %s", cmd);
+
+      /* These are always processed. */
+      if (g_str_has_prefix (cmd, INSERT_CMD_PREFIX))
+        {
+          g_assert (self->prints_storage);
+          g_hash_table_add (self->prints_storage,
+                            g_strdup (cmd + strlen (INSERT_CMD_PREFIX)));
+
+          g_ptr_array_remove_index (self->pending_commands, 0);
+          continue;
+        }
+      else if (g_str_has_prefix (cmd, REMOVE_CMD_PREFIX))
+        {
+          g_assert (self->prints_storage);
+          if (!g_hash_table_remove (self->prints_storage,
+                                    cmd + strlen (REMOVE_CMD_PREFIX)))
+            g_warning ("ID %s was not found in storage", cmd + strlen (REMOVE_CMD_PREFIX));
+
+          g_ptr_array_remove_index (self->pending_commands, 0);
+          continue;
+        }
+      else if (g_str_has_prefix (cmd, SLEEP_CMD_PREFIX))
+        {
+          guint64 sleep_ms = g_ascii_strtoull (cmd + strlen (SLEEP_CMD_PREFIX), NULL, 10);
+
+          g_debug ("Sleeping %lums", sleep_ms);
+          self->sleep_timeout_id = g_timeout_add (sleep_ms, sleep_timeout_cb, self);
+          g_ptr_array_remove_index (self->pending_commands, 0);
+
+          return NULL;
+        }
+      else if (g_str_has_prefix (cmd, ERROR_CMD_PREFIX))
+        {
+          g_propagate_error (error,
+                             fpi_device_error_new (g_ascii_strtoull (cmd + strlen (ERROR_CMD_PREFIX), NULL, 10)));
+
+          g_ptr_array_remove_index (self->pending_commands, 0);
+          return NULL;
+        }
+
+      /* If we are not scanning, then we have to stop here. */
+      if (!scan)
+        {
+          g_warning ("Could not process command: %s", cmd);
+          g_ptr_array_remove_index (self->pending_commands, 0);
+          break;
+        }
+
+      if (g_str_has_prefix (cmd, SCAN_CMD_PREFIX))
+        {
+          char *res = g_strdup (cmd + strlen (SCAN_CMD_PREFIX));
+
+          g_ptr_array_remove_index (self->pending_commands, 0);
+          return res;
+        }
+      else if (g_str_has_prefix (cmd, RETRY_CMD_PREFIX))
+        {
+          g_propagate_error (error,
+                             fpi_device_retry_new (g_ascii_strtoull (cmd + strlen (RETRY_CMD_PREFIX), NULL, 10)));
+
+          g_ptr_array_remove_index (self->pending_commands, 0);
+          return NULL;
+        }
+      else if (g_str_has_prefix (cmd, FINGER_CMD_PREFIX))
+        {
+          gboolean finger_present;
+
+          finger_present = g_ascii_strtoull (cmd + strlen (FINGER_CMD_PREFIX), NULL, 10) != 0;
+          fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                                   finger_present ? FP_FINGER_STATUS_PRESENT : FP_FINGER_STATUS_NONE,
+                                                   finger_present ? FP_FINGER_STATUS_NONE : FP_FINGER_STATUS_PRESENT);
+
+          g_ptr_array_remove_index (self->pending_commands, 0);
+          continue;
+        }
+      else
+        {
+          g_warning ("Could not process command: %s", cmd);
+          g_ptr_array_remove_index (self->pending_commands, 0);
+        }
+    }
+
+  /* No commands left, throw a timeout error. */
+  g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "No commands left that can be run!");
+  return NULL;
+}
+
+static void
+write_key_to_listener (void *key, void *val, void *user_data)
+{
+  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (user_data);
+
+  if (!fp_device_virtual_listener_write_sync (listener, key, strlen (key), NULL) ||
+      !fp_device_virtual_listener_write_sync (listener, "\n", 1, NULL))
+    g_warning ("Error writing reply to LIST command");
+}
+
+static void
+recv_instruction_cb (GObject      *source_object,
+                     GAsyncResult *res,
+                     gpointer      user_data)
+{
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
+  gsize bytes;
+
+  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);
+  fp_dbg ("Got instructions of length %ld", bytes);
+
+  if (error)
+    {
+      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        return;
+
+      g_warning ("Error receiving instruction data: %s", error->message);
+      return;
+    }
+
+  if (bytes > 0)
+    {
+      FpDeviceVirtualDevice *self;
+      g_autofree char *cmd = NULL;
+
+      self = FP_DEVICE_VIRTUAL_DEVICE (user_data);
+
+      cmd = g_strndup (self->recv_buf, bytes);
+      fp_dbg ("Received command %s", cmd);
+
+      if (g_str_has_prefix (cmd, LIST_CMD))
+        {
+          if (self->prints_storage)
+            g_hash_table_foreach (self->prints_storage, write_key_to_listener, listener);
+        }
+      else if (g_str_has_prefix (cmd, UNPLUG_CMD))
+        {
+          fpi_device_remove (FP_DEVICE (self));
+        }
+      else if (g_str_has_prefix (cmd, SET_ENROLL_STAGES_PREFIX))
+        {
+          guint stages;
+
+          stages = g_ascii_strtoull (cmd + strlen (SET_ENROLL_STAGES_PREFIX), NULL, 10);
+          fpi_device_set_nr_enroll_stages (FP_DEVICE (self), stages);
+        }
+      else if (g_str_has_prefix (cmd, SET_SCAN_TYPE_PREFIX))
+        {
+          const char *scan_type = cmd + strlen (SET_SCAN_TYPE_PREFIX);
+          g_autoptr(GEnumClass) scan_types = g_type_class_ref (fp_scan_type_get_type ());
+          GEnumValue *value = g_enum_get_value_by_nick (scan_types, scan_type);
+
+          if (value)
+            fpi_device_set_scan_type (FP_DEVICE (self), value->value);
+          else
+            g_warning ("Scan type '%s' not found", scan_type);
+        }
+      else if (g_str_has_prefix (cmd, SET_CANCELLATION_PREFIX))
+        {
+          self->supports_cancellation = g_ascii_strtoull (
+            cmd + strlen (SET_CANCELLATION_PREFIX), NULL, 10) != 0;
+
+          g_debug ("Cancellation support toggled: %d",
+                   self->supports_cancellation);
+        }
+      else if (g_str_has_prefix (cmd, SET_KEEP_ALIVE_PREFIX))
+        {
+          self->keep_alive = g_ascii_strtoull (
+            cmd + strlen (SET_KEEP_ALIVE_PREFIX), NULL, 10) != 0;
+
+          g_debug ("Keep alive toggled: %d", self->keep_alive);
+        }
+      else
+        {
+          g_ptr_array_add (self->pending_commands, g_steal_pointer (&cmd));
+          g_clear_handle_id (&self->wait_command_id, g_source_remove);
+
+          maybe_continue_current_action (self);
+        }
+    }
+
+  fp_device_virtual_listener_connection_close (listener);
+}
+
+static void
+recv_instruction (FpDeviceVirtualDevice *self)
+{
+  fp_device_virtual_listener_read (self->listener,
+                                   FALSE,
+                                   self->recv_buf,
+                                   sizeof (self->recv_buf),
+                                   recv_instruction_cb,
+                                   self);
+}
+
+static void
+on_listener_connected (FpDeviceVirtualListener *listener,
+                       gpointer                 user_data)
+{
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (user_data);
+
+  recv_instruction (self);
+}
+
+static void
+dev_init (FpDevice *dev)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(GCancellable) cancellable = NULL;
+  g_autoptr(FpDeviceVirtualListener) listener = NULL;
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
+
+  G_DEBUG_HERE ();
+
+  process_cmds (self, FALSE, &error);
+  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+    {
+      fpi_device_open_complete (dev, g_steal_pointer (&error));
+      return;
+    }
+  else if (self->sleep_timeout_id)
+    {
+      return;
+    }
+  else if (self->listener)
+    {
+      fpi_device_open_complete (dev, NULL);
+      return;
+    }
+
+  listener = fp_device_virtual_listener_new ();
+  cancellable = g_cancellable_new ();
+
+  if (!fp_device_virtual_listener_start (listener,
+                                         fpi_device_get_virtual_env (FP_DEVICE (self)),
+                                         cancellable,
+                                         on_listener_connected,
+                                         self,
+                                         &error))
+    {
+      fpi_device_open_complete (dev, g_steal_pointer (&error));
+      return;
+    }
+
+  self->listener = g_steal_pointer (&listener);
+  self->cancellable = g_steal_pointer (&cancellable);
+
+  fpi_device_open_complete (dev, NULL);
+}
+
+static gboolean
+wait_for_command_timeout (gpointer data)
+{
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (data);
+  GError *error = NULL;
+
+  self->wait_command_id = 0;
+
+  switch (fpi_device_get_current_action (FP_DEVICE (self)))
+    {
+    case FPI_DEVICE_ACTION_LIST:
+    case FPI_DEVICE_ACTION_DELETE:
+      self->ignore_wait = TRUE;
+      maybe_continue_current_action (self);
+      self->ignore_wait = FALSE;
+      return FALSE;
+
+    default:
+      break;
+    }
+
+  error = g_error_new (G_IO_ERROR, G_IO_ERROR_TIMED_OUT, "No commands arrived in time to run!");
+  fpi_device_action_error (FP_DEVICE (self), error);
+
+  return FALSE;
+}
+
+gboolean
+should_wait_for_command (FpDeviceVirtualDevice *self,
+                         GError                *error)
+{
+  if (!error && self->sleep_timeout_id)
+    return TRUE;
+
+  if (self->ignore_wait)
+    return FALSE;
+
+  if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+    return FALSE;
+
+  if (self->wait_command_id)
+    return FALSE;
+
+  self->wait_command_id = g_timeout_add (500, wait_for_command_timeout, self);
+  return TRUE;
+}
+
+char *
+start_scan_command (FpDeviceVirtualDevice *self,
+                    GError               **error)
+{
+  g_autoptr(GError) local_error = NULL;
+  g_autofree char *scan_id = NULL;
+
+  if (fp_device_get_finger_status (FP_DEVICE (self)) == FP_FINGER_STATUS_NONE)
+    self->injected_synthetic_cmd = FALSE;
+
+  scan_id = process_cmds (self, TRUE, &local_error);
+
+  if (!self->sleep_timeout_id)
+    {
+      fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                               FP_FINGER_STATUS_NEEDED,
+                                               FP_FINGER_STATUS_NONE);
+    }
+
+  if (should_wait_for_command (self, local_error))
+    {
+      g_assert (!scan_id);
+
+      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
+                           "Still waiting for command");
+      return NULL;
+    }
+
+  if (local_error)
+    g_propagate_error (error, g_steal_pointer (&local_error));
+  else
+    fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                             FP_FINGER_STATUS_PRESENT,
+                                             FP_FINGER_STATUS_NONE);
+
+  return g_steal_pointer (&scan_id);
+}
+
+gboolean
+should_wait_to_sleep (FpDeviceVirtualDevice *self,
+                      const char            *scan_id,
+                      GError                *error)
+{
+  const gchar *cmd;
+
+  if (self->sleep_timeout_id)
+    return TRUE;
+
+  if (!self->pending_commands->len)
+    return FALSE;
+
+  cmd = g_ptr_array_index (self->pending_commands, 0);
+
+  if (g_str_has_prefix (cmd, SLEEP_CMD_PREFIX))
+    {
+      g_autoptr(GError) local_error = NULL;
+      g_free (process_cmds (self, FALSE, &local_error));
+
+      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        return FALSE;
+
+      g_assert (!self->injected_synthetic_cmd);
+      g_assert (self->sleep_timeout_id != 0);
+
+      if (!self->pending_commands->len)
+        {
+          g_autofree char *injected_cmd = NULL;
+
+          if (scan_id)
+            injected_cmd = g_strconcat (SCAN_CMD_PREFIX, scan_id, NULL);
+          else if (error && error->domain == FP_DEVICE_ERROR)
+            injected_cmd = g_strdup_printf (ERROR_CMD_PREFIX " %d", error->code);
+          else if (error && error->domain == FP_DEVICE_RETRY)
+            injected_cmd = g_strdup_printf (RETRY_CMD_PREFIX " %d", error->code);
+          else
+            return TRUE;
+
+          g_debug ("Sleeping now, command queued for later: %s", injected_cmd);
+
+          g_ptr_array_insert (self->pending_commands, 0, g_steal_pointer (&injected_cmd));
+          self->injected_synthetic_cmd = TRUE;
+        }
+    }
+
+  return self->sleep_timeout_id != 0;
+}
+
+static void
+dev_verify (FpDevice *dev)
+{
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
+  g_autofree char *scan_id = NULL;
+
+  scan_id = start_scan_command (self, &error);
+  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING))
+    return;
+
+  if (scan_id)
+    {
+      GVariant *data = NULL;
+      FpPrint *new_scan;
+      FpPrint *print;
+      gboolean success;
+
+      g_debug ("Virtual device scanned print %s", scan_id);
+      fpi_device_get_verify_data (dev, &print);
+
+      new_scan = fp_print_new (dev);
+      fpi_print_set_type (new_scan, FPI_PRINT_RAW);
+      if (self->prints_storage)
+        fpi_print_set_device_stored (new_scan, TRUE);
+      data = g_variant_new_string (scan_id);
+      g_object_set (new_scan, "fpi-data", data, NULL);
+
+      if (self->prints_storage && !g_hash_table_contains (self->prints_storage, scan_id))
+        {
+          error = fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND);
+          success = FALSE;
+        }
+      else
+        {
+          success = fp_print_equal (print, new_scan);
+        }
+
+      if (!self->match_reported)
+        {
+          self->match_reported = TRUE;
+          fpi_device_verify_report (dev,
+                                    success ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL,
+                                    new_scan,
+                                    NULL);
+        }
+    }
+  else if (error)
+    {
+      g_debug ("Virtual device scan failed with error: %s", error->message);
+    }
+
+  fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                           FP_FINGER_STATUS_NONE,
+                                           FP_FINGER_STATUS_PRESENT);
+
+  if (error && error->domain == FP_DEVICE_RETRY)
+    fpi_device_verify_report (dev, FPI_MATCH_ERROR, NULL, g_steal_pointer (&error));
+
+  if (should_wait_to_sleep (self, scan_id, error))
+    return;
+
+  self->match_reported = FALSE;
+  fpi_device_verify_complete (dev, g_steal_pointer (&error));
+}
+
+static void
+dev_enroll (FpDevice *dev)
+{
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
+  FpPrint *print = NULL;
+  g_autofree char *id = NULL;
+
+  id = start_scan_command (self, &error);
+  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING))
+    return;
+
+  fpi_device_get_enroll_data (dev, &print);
+
+  if (id)
+    {
+      GVariant *data;
+      gboolean completed;
+
+      if (self->prints_storage && g_hash_table_contains (self->prints_storage, id))
+        {
+          if (should_wait_to_sleep (self, id, error))
+            return;
+
+          fpi_device_enroll_complete (dev, NULL,
+                                      fpi_device_error_new (FP_DEVICE_ERROR_DATA_DUPLICATE));
+          return;
+        }
+
+      if (self->enroll_stages_passed == 0)
+        {
+          fpi_print_set_type (print, FPI_PRINT_RAW);
+          data = g_variant_new_string (id);
+          g_object_set (print, "fpi-data", data, NULL);
+        }
+      else
+        {
+          gboolean changed;
+
+          g_object_get (print, "fpi-data", &data, NULL);
+          changed = !g_str_equal (id, g_variant_get_string (data, NULL));
+          g_variant_unref (data);
+
+          if (changed)
+            {
+              g_set_error (&error, FP_DEVICE_RETRY, FP_DEVICE_RETRY_GENERAL, "ID Mismatch");
+              fpi_device_enroll_progress (dev, self->enroll_stages_passed, NULL,
+                                          g_steal_pointer (&error));
+
+              if (!should_wait_to_sleep (self, id, error))
+                self->sleep_timeout_id = g_idle_add (sleep_timeout_cb, self);
+              return;
+            }
+        }
+
+      self->enroll_stages_passed++;
+      completed = self->enroll_stages_passed == fp_device_get_nr_enroll_stages (FP_DEVICE (self));
+      fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                               completed ?
+                                               FP_FINGER_STATUS_NEEDED :
+                                               FP_FINGER_STATUS_NONE,
+                                               FP_FINGER_STATUS_PRESENT);
+
+      fpi_device_enroll_progress (dev, self->enroll_stages_passed, print, NULL);
+
+      if (completed)
+        {
+          if (self->prints_storage)
+            {
+              fpi_print_set_device_stored (print, TRUE);
+              g_hash_table_add (self->prints_storage, g_strdup (id));
+            }
+
+          fpi_device_enroll_complete (dev, g_object_ref (print), NULL);
+          self->enroll_stages_passed = 0;
+        }
+      else if (!should_wait_to_sleep (self, id, error))
+        {
+          self->sleep_timeout_id = g_idle_add (sleep_timeout_cb, self);
+        }
+    }
+  else
+    {
+      fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                               FP_FINGER_STATUS_NONE,
+                                               FP_FINGER_STATUS_PRESENT);
+
+      if (error && error->domain == FP_DEVICE_RETRY)
+        {
+          fpi_device_enroll_progress (dev, self->enroll_stages_passed, NULL, g_steal_pointer (&error));
+
+          if (!should_wait_to_sleep (self, id, error))
+            self->sleep_timeout_id = g_idle_add (sleep_timeout_cb, self);
+        }
+      else
+        {
+          if (should_wait_to_sleep (self, id, error))
+            return;
+
+          self->enroll_stages_passed = 0;
+          fpi_device_enroll_complete (dev, NULL, g_steal_pointer (&error));
+        }
+    }
+}
+
+static void
+dev_cancel (FpDevice *dev)
+{
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
+
+  if (self->injected_synthetic_cmd)
+    {
+      self->injected_synthetic_cmd = FALSE;
+      g_ptr_array_remove_index (self->pending_commands, 0);
+    }
+
+  if (!self->supports_cancellation)
+    return;
+
+  g_debug ("Got cancellation!");
+  g_clear_handle_id (&self->sleep_timeout_id, g_source_remove);
+
+  maybe_continue_current_action (self);
+}
+
+static void
+stop_listener (FpDeviceVirtualDevice *self)
+{
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+  g_clear_object (&self->listener);
+}
+
+static void
+dev_deinit (FpDevice *dev)
+{
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
+
+  process_cmds (self, FALSE, &error);
+  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+    {
+      fpi_device_close_complete (dev, g_steal_pointer (&error));
+      return;
+    }
+  else if (self->sleep_timeout_id)
+    {
+      return;
+    }
+
+  g_clear_handle_id (&self->wait_command_id, g_source_remove);
+  g_clear_handle_id (&self->sleep_timeout_id, g_source_remove);
+
+  if (!self->keep_alive)
+    stop_listener (self);
+
+  fpi_device_close_complete (dev, NULL);
+}
+
+static void
+fpi_device_virtual_device_finalize (GObject *object)
+{
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (object);
+
+  G_DEBUG_HERE ();
+  stop_listener (self);
+  g_clear_pointer (&self->pending_commands, g_ptr_array_unref);
+  G_OBJECT_CLASS (fpi_device_virtual_device_parent_class)->finalize (object);
+}
+
+static void
+fpi_device_virtual_device_init (FpDeviceVirtualDevice *self)
+{
+  self->supports_cancellation = TRUE;
+  self->pending_commands = g_ptr_array_new_with_free_func (g_free);
+}
+
+static const FpIdEntry driver_ids[] = {
+  { .virtual_envvar = "FP_VIRTUAL_DEVICE", },
+  { .virtual_envvar = NULL }
+};
+
+static void
+fpi_device_virtual_device_class_init (FpDeviceVirtualDeviceClass *klass)
+{
+  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = fpi_device_virtual_device_finalize;
+
+  dev_class->id = FP_COMPONENT;
+  dev_class->full_name = "Virtual device for debugging";
+  dev_class->type = FP_DEVICE_TYPE_VIRTUAL;
+  dev_class->id_table = driver_ids;
+  dev_class->nr_enroll_stages = 5;
+
+  dev_class->open = dev_init;
+  dev_class->close = dev_deinit;
+  dev_class->verify = dev_verify;
+  dev_class->enroll = dev_enroll;
+  dev_class->cancel = dev_cancel;
+}
@@ -21,7 +21,7 @@
 /*
 * This is a virtual driver to debug the image based drivers. A small
 * python script is provided to connect to it via a socket, allowing
- * prints to be sent to this device programatically.
+ * prints to be sent to this device programmatically.
 * Using this it is possible to test libfprint and fprintd.
 */

@@ -29,34 +29,27 @@

 #include "fpi-log.h"

+#include "virtual-device-private.h"
+
 #include "../fpi-image.h"
 #include "../fpi-image-device.h"

-#include <glib/gstdio.h>
-#include <gio/gio.h>
-#include <gio/gunixsocketaddress.h>
-
 struct _FpDeviceVirtualImage
 {
-  FpImageDevice      parent;
+  FpImageDevice            parent;

-  GSocketListener   *listener;
-  GSocketConnection *connection;
-  GCancellable      *cancellable;
+  FpDeviceVirtualListener *listener;
+  GCancellable            *cancellable;

-  gint               socket_fd;
-  gint               client_fd;
-
-  FpImage           *recv_img;
-  gint               recv_img_hdr[2];
+  gboolean                 automatic_finger;
+  FpImage                 *recv_img;
+  gint                     recv_img_hdr[2];
 };

 G_DECLARE_FINAL_TYPE (FpDeviceVirtualImage, fpi_device_virtual_image, FPI, DEVICE_VIRTUAL_IMAGE, FpImageDevice)
 G_DEFINE_TYPE (FpDeviceVirtualImage, fpi_device_virtual_image, FP_TYPE_IMAGE_DEVICE)

-static void start_listen (FpDeviceVirtualImage *dev);
-static void recv_image (FpDeviceVirtualImage *dev,
-                        GInputStream         *stream);
+static void recv_image (FpDeviceVirtualImage *self);

 static void
 recv_image_img_recv_cb (GObject      *source_object,
@@ -64,36 +57,28 @@ recv_image_img_recv_cb (GObject      *source_object,
                        gpointer      user_data)
 {
  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
  FpDeviceVirtualImage *self;
  FpImageDevice *device;
-  gssize bytes;
+  gsize bytes;

-  bytes = g_input_stream_read_finish (G_INPUT_STREAM (source_object), res, &error);
+  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);

-  if (bytes <= 0)
-    {
-      if (bytes < 0)
-        {
-          g_warning ("Error receiving header for image data: %s", error->message);
-          if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-            return;
-        }
-
-      self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
-      g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
-      self->connection = NULL;
-      return;
-    }
+  if (!bytes || g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ||
+      g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED))
+    return;

  self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
  device = FP_IMAGE_DEVICE (self);

-  fpi_image_device_report_finger_status (device, TRUE);
+  if (self->automatic_finger)
+    fpi_image_device_report_finger_status (device, TRUE);
  fpi_image_device_image_captured (device, g_steal_pointer (&self->recv_img));
-  fpi_image_device_report_finger_status (device, FALSE);
+  if (self->automatic_finger)
+    fpi_image_device_report_finger_status (device, FALSE);

  /* And, listen for more images from the same client. */
-  recv_image (self, G_INPUT_STREAM (source_object));
+  recv_image (self);
 }

 static void
@@ -103,31 +88,30 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 {
  g_autoptr(GError) error = NULL;
  FpDeviceVirtualImage *self;
-  gssize bytes;
+  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
+  gsize bytes;

-  bytes = g_input_stream_read_finish (G_INPUT_STREAM (source_object), res, &error);
+  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);

-  if (bytes <= 0)
+  if (error)
    {
-      if (bytes < 0)
-        {
-          g_warning ("Error receiving header for image data: %s", error->message);
-          if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-            return;
-        }
+      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ||
+          g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED) ||
+          g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING))
+        return;

-      self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
-      g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
-      self->connection = NULL;
+      g_warning ("Error receiving header for image data: %s", error->message);
      return;
    }

+  if (!bytes)
+    return;
+
  self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
  if (self->recv_img_hdr[0] > 5000 || self->recv_img_hdr[1] > 5000)
    {
      g_warning ("Image header suggests an unrealistically large image, disconnecting client.");
-      g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
-      self->connection = NULL;
+      fp_device_virtual_listener_connection_close (listener);
    }

  if (self->recv_img_hdr[0] < 0 || self->recv_img_hdr[1] < 0)
@@ -145,130 +129,101 @@ recv_image_hdr_recv_cb (GObject      *source_object,
                                          fpi_device_error_new (self->recv_img_hdr[1]));
          break;

+        case -3:
+          /* -3 sets/clears automatic finger detection for images */
+          self->automatic_finger = !!self->recv_img_hdr[1];
+          break;
+
+        case -4:
+          /* -4 submits a finger detection report */
+          fpi_image_device_report_finger_status (FP_IMAGE_DEVICE (self),
+                                                 !!self->recv_img_hdr[1]);
+          break;
+
+        case -5:
+          /* -5 causes the device to disappear (no further data) */
+          fpi_device_remove (FP_DEVICE (self));
+          break;
+
        default:
          /* disconnect client, it didn't play fair */
-          g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
-          self->connection = NULL;
+          fp_device_virtual_listener_connection_close (listener);
        }

      /* And, listen for more images from the same client. */
-      recv_image (self, G_INPUT_STREAM (source_object));
+      recv_image (self);
      return;
    }

  self->recv_img = fp_image_new (self->recv_img_hdr[0], self->recv_img_hdr[1]);
  g_debug ("image data: %p", self->recv_img->data);
-  g_input_stream_read_async (G_INPUT_STREAM (source_object),
-                             (guint8 *) self->recv_img->data,
-                             self->recv_img->width * self->recv_img->height,
-                             G_PRIORITY_DEFAULT,
-                             self->cancellable,
-                             recv_image_img_recv_cb,
-                             self);
+  fp_device_virtual_listener_read (listener,
+                                   TRUE,
+                                   (guint8 *) self->recv_img->data,
+                                   self->recv_img->width * self->recv_img->height,
+                                   recv_image_img_recv_cb,
+                                   self);
 }

 static void
-recv_image (FpDeviceVirtualImage *dev, GInputStream *stream)
+recv_image (FpDeviceVirtualImage *self)
 {
-  g_input_stream_read_async (stream,
-                             dev->recv_img_hdr,
-                             sizeof (dev->recv_img_hdr),
-                             G_PRIORITY_DEFAULT,
-                             dev->cancellable,
-                             recv_image_hdr_recv_cb,
-                             dev);
+  fp_device_virtual_listener_read (self->listener,
+                                   TRUE,
+                                   self->recv_img_hdr,
+                                   sizeof (self->recv_img_hdr),
+                                   recv_image_hdr_recv_cb,
+                                   self);
 }

 static void
-new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
+on_listener_connected (FpDeviceVirtualListener *listener,
+                       gpointer                 user_data)
 {
-  g_autoptr(GError) error = NULL;
-  GSocketConnection *connection;
-  GInputStream *stream;
-  FpDeviceVirtualImage *dev = user_data;
+  FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
+  FpiImageDeviceState state;

-  connection = g_socket_listener_accept_finish (G_SOCKET_LISTENER (source_object),
-                                                res,
-                                                NULL,
-                                                &error);
-  if (!connection)
-    {
-      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-        return;
+  self->automatic_finger = TRUE;

-      g_warning ("Error accepting a new connection: %s", error->message);
-      start_listen (dev);
-    }
+  g_object_get (self,
+                "fpi-image-device-state", &state,
+                NULL);
+  /* Only read if we are in AWAIT_FINGER_* or CAPTURE states */
+  if (state <= FPI_IMAGE_DEVICE_STATE_DEACTIVATING)
+    return;

-  /* Always further connections (but we disconnect them immediately
-   * if we already have a connection). */
-  start_listen (dev);
-  if (dev->connection)
-    {
-      g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
-      return;
-    }
-
-  dev->connection = connection;
-  stream = g_io_stream_get_input_stream (G_IO_STREAM (connection));
-
-  recv_image (dev, stream);
-
-  fp_dbg ("Got a new connection!");
-}
-
-static void
-start_listen (FpDeviceVirtualImage *dev)
-{
-  g_socket_listener_accept_async (dev->listener,
-                                  dev->cancellable,
-                                  new_connection_cb,
-                                  dev);
+  recv_image (self);
 }

 static void
 dev_init (FpImageDevice *dev)
 {
  g_autoptr(GError) error = NULL;
-  g_autoptr(GSocketListener) listener = NULL;
+  g_autoptr(FpDeviceVirtualListener) listener = NULL;
+  g_autoptr(GCancellable) cancellable = NULL;
  FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (dev);
-  const char *env;
-  g_autoptr(GSocketAddress) addr = NULL;
+
  G_DEBUG_HERE ();

-  self->client_fd = -1;
+  listener = fp_device_virtual_listener_new ();
+  cancellable = g_cancellable_new ();

-  env = fpi_device_get_virtual_env (FP_DEVICE (self));
-
-  listener = g_socket_listener_new ();
-  g_socket_listener_set_backlog (listener, 1);
-
-  /* Remove any left over socket. */
-  g_unlink (env);
-
-  addr = g_unix_socket_address_new (env);
-
-  if (!g_socket_listener_add_address (listener,
-                                      addr,
-                                      G_SOCKET_TYPE_STREAM,
-                                      G_SOCKET_PROTOCOL_DEFAULT,
-                                      NULL,
-                                      NULL,
-                                      &error))
+  if (!fp_device_virtual_listener_start (listener,
+                                         fpi_device_get_virtual_env (FP_DEVICE (self)),
+                                         cancellable,
+                                         on_listener_connected,
+                                         self,
+                                         &error))
    {
-      g_warning ("Could not listen on unix socket: %s", error->message);
-
-      fpi_image_device_open_complete (FP_IMAGE_DEVICE (dev), g_steal_pointer (&error));
-
+      fpi_image_device_open_complete (dev, g_steal_pointer (&error));
      return;
    }

  self->listener = g_steal_pointer (&listener);
-  self->cancellable = g_cancellable_new ();
+  self->cancellable = g_steal_pointer (&cancellable);

-  start_listen (self);
-
-  fpi_image_device_open_complete (dev, NULL);
+  /* Delay result to open up the possibility of testing race conditions. */
+  fpi_device_add_timeout (FP_DEVICE (dev), 100, (FpTimeoutFunc) fpi_image_device_open_complete, NULL, NULL);
 }

 static void
@@ -281,14 +236,58 @@ dev_deinit (FpImageDevice *dev)
  g_cancellable_cancel (self->cancellable);
  g_clear_object (&self->cancellable);
  g_clear_object (&self->listener);
-  g_clear_object (&self->connection);

-  fpi_image_device_close_complete (dev, NULL);
+  /* Delay result to open up the possibility of testing race conditions. */
+  fpi_device_add_timeout (FP_DEVICE (dev), 100, (FpTimeoutFunc) fpi_image_device_close_complete, NULL, NULL);
+}
+
+static void
+dev_activate (FpImageDevice *dev)
+{
+  FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (dev);
+
+  /* Start reading (again). */
+  recv_image (self);
+
+  fpi_image_device_activate_complete (dev, NULL);
+}
+
+static void
+dev_deactivate (FpImageDevice *dev)
+{
+  fpi_image_device_deactivate_complete (dev, NULL);
+}
+
+static void
+dev_notify_removed_cb (FpDevice *dev)
+{
+  FpiImageDeviceState state;
+  gboolean removed;
+
+  g_object_get (dev,
+                "fpi-image-device-state", &state,
+                "removed", &removed,
+                NULL);
+
+  if (!removed || state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
+    return;
+
+  /* This error will be converted to an FP_DEVICE_ERROR_REMOVED by the
+   * surrounding layers. */
+  fpi_image_device_session_error (FP_IMAGE_DEVICE (dev),
+                                  fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
 }

 static void
 fpi_device_virtual_image_init (FpDeviceVirtualImage *self)
 {
+  /* NOTE: This is not nice, but we can generally rely on the underlying
+   *       system to throw errors on the transport layer.
+   */
+  g_signal_connect (self,
+                    "notify::removed",
+                    G_CALLBACK (dev_notify_removed_cb),
+                    NULL);
 }

 static const FpIdEntry driver_ids[] = {
@@ -309,4 +308,7 @@ fpi_device_virtual_image_class_init (FpDeviceVirtualImageClass *klass)

  img_class->img_open = dev_init;
  img_class->img_close = dev_deinit;
+
+  img_class->activate = dev_activate;
+  img_class->deactivate = dev_deactivate;
 }
@@ -0,0 +1,676 @@
+/*
+ * Virtual driver for SDCP device debugging
+ *
+ * Copyright (C) 2020 Benjamin Berg <bberg@redhat.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
+ */
+
+/*
+ * This is a virtual test driver to test the basic SDCP functionality.
+ * It uses the test binaries from Microsoft, which were extended to allow
+ * a simple chat with the device.
+ * The environment variable contains the to be executed binary including
+ * arguments. This binary should be compiled from the code in
+ *   https://github.com/Microsoft/SecureDeviceConnectionProtocol
+ * or, until it is merged upstream
+ *   https://github.com/benzea/SecureDeviceConnectionProtocol
+ *
+ * Note that using this as an external executable has the advantage that we
+ * do not need to link against mbedtls or any other crypto library.
+ */
+
+#define FP_COMPONENT "virtual_sdcp"
+
+#include "fpi-log.h"
+#include "fpi-ssm.h"
+
+#include "../fpi-sdcp-device.h"
+
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+
+struct _FpDeviceVirtualSdcp
+{
+  FpSdcpDevice   parent;
+
+  GSubprocess   *proc;
+  GOutputStream *proc_stdin;
+  GInputStream  *proc_stdout;
+
+  /* Only valid while a read/write is pending */
+  GByteArray *msg_out;
+  GByteArray *msg_in;
+
+  GByteArray *connect_msg;
+};
+
+G_DECLARE_FINAL_TYPE (FpDeviceVirtualSdcp, fpi_device_virtual_sdcp, FPI, DEVICE_VIRTUAL_SDCP, FpSdcpDevice)
+G_DEFINE_TYPE (FpDeviceVirtualSdcp, fpi_device_virtual_sdcp, FP_TYPE_SDCP_DEVICE)
+
+guint8 ca_1[] = {
+  0x30, 0x82, 0x03, 0xFD, 0x30, 0x82, 0x03, 0x82, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x13, 0x33,
+  0x00, 0x00, 0x00, 0x07, 0xE8, 0x9D, 0x61, 0x62, 0x4D, 0x46, 0x0F, 0x95, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x07, 0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02, 0x30, 0x81,
+  0x84, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13,
+  0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6E, 0x67,
+  0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65,
+  0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x15,
+  0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72,
+  0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x2E, 0x30, 0x2C, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x25,
+  0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x53, 0x65,
+  0x63, 0x75, 0x72, 0x65, 0x20, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x50, 0x43, 0x41,
+  0x20, 0x32, 0x30, 0x31, 0x38, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x38, 0x30, 0x31, 0x33, 0x31, 0x31,
+  0x39, 0x35, 0x34, 0x35, 0x33, 0x5A, 0x17, 0x0D, 0x32, 0x38, 0x30, 0x31, 0x33, 0x31, 0x32, 0x30,
+  0x30, 0x34, 0x35, 0x33, 0x5A, 0x30, 0x7D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06,
+  0x13, 0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A, 0x57,
+  0x61, 0x73, 0x68, 0x69, 0x6E, 0x67, 0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03, 0x55,
+  0x04, 0x07, 0x13, 0x07, 0x52, 0x65, 0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C, 0x06,
+  0x03, 0x55, 0x04, 0x0A, 0x13, 0x15, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20,
+  0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x27, 0x30, 0x25, 0x06,
+  0x03, 0x55, 0x04, 0x03, 0x13, 0x1E, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x48, 0x65,
+  0x6C, 0x6C, 0x6F, 0x20, 0x31, 0x39, 0x42, 0x39, 0x32, 0x39, 0x36, 0x35, 0x20, 0x43, 0x41, 0x20,
+  0x32, 0x30, 0x31, 0x38, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02,
+  0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04, 0xBE,
+  0x4B, 0x90, 0x6E, 0x24, 0xFC, 0xA1, 0x53, 0xC8, 0xA7, 0x3C, 0x70, 0xE8, 0x97, 0xCD, 0x1B, 0x31,
+  0xE4, 0x95, 0x91, 0x7A, 0x58, 0xA2, 0x86, 0xA8, 0x70, 0xF6, 0x09, 0x30, 0x77, 0x99, 0x3D, 0x10,
+  0xDF, 0xF7, 0x95, 0x0F, 0x68, 0x83, 0xE6, 0xA4, 0x11, 0x7C, 0xDA, 0x82, 0xE7, 0x0B, 0x8B, 0xF2,
+  0x9D, 0x6B, 0x5B, 0xF5, 0x3E, 0x77, 0xB4, 0xC1, 0x0E, 0x49, 0x00, 0x83, 0xBA, 0x94, 0xF8, 0xA3,
+  0x82, 0x01, 0xD7, 0x30, 0x82, 0x01, 0xD3, 0x30, 0x10, 0x06, 0x09, 0x2B, 0x06, 0x01, 0x04, 0x01,
+  0x82, 0x37, 0x15, 0x01, 0x04, 0x03, 0x02, 0x01, 0x00, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E,
+  0x04, 0x16, 0x04, 0x14, 0x13, 0x93, 0xC8, 0xCD, 0xF2, 0x23, 0x9A, 0x2D, 0xC6, 0x9B, 0x2A, 0xEB,
+  0x9A, 0xAB, 0x99, 0x0B, 0x56, 0x04, 0x5E, 0x7C, 0x30, 0x65, 0x06, 0x03, 0x55, 0x1D, 0x20, 0x04,
+  0x5E, 0x30, 0x5C, 0x30, 0x06, 0x06, 0x04, 0x55, 0x1D, 0x20, 0x00, 0x30, 0x52, 0x06, 0x0C, 0x2B,
+  0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x4C, 0x83, 0x7D, 0x01, 0x01, 0x30, 0x42, 0x30, 0x40, 0x06,
+  0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x34, 0x68, 0x74, 0x74, 0x70, 0x3A,
+  0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E,
+  0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73, 0x2F, 0x44, 0x6F, 0x63, 0x73, 0x2F,
+  0x52, 0x65, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x6F, 0x72, 0x79, 0x2E, 0x68, 0x74, 0x6D, 0x00, 0x30,
+  0x19, 0x06, 0x09, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x14, 0x02, 0x04, 0x0C, 0x1E, 0x0A,
+  0x00, 0x53, 0x00, 0x75, 0x00, 0x62, 0x00, 0x43, 0x00, 0x41, 0x30, 0x0B, 0x06, 0x03, 0x55, 0x1D,
+  0x0F, 0x04, 0x04, 0x03, 0x02, 0x01, 0x86, 0x30, 0x0F, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01,
+  0xFF, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xFF, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04,
+  0x18, 0x30, 0x16, 0x80, 0x14, 0xDA, 0xCA, 0x4B, 0xD0, 0x4C, 0x56, 0x03, 0x27, 0x5F, 0x97, 0xEB,
+  0x75, 0xA3, 0x02, 0xC3, 0xBF, 0x45, 0x9C, 0xF8, 0xB1, 0x30, 0x68, 0x06, 0x03, 0x55, 0x1D, 0x1F,
+  0x04, 0x61, 0x30, 0x5F, 0x30, 0x5D, 0xA0, 0x5B, 0xA0, 0x59, 0x86, 0x57, 0x68, 0x74, 0x74, 0x70,
+  0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74,
+  0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73, 0x2F, 0x63, 0x72, 0x6C, 0x2F,
+  0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x25, 0x32, 0x30, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x25,
+  0x32, 0x30, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x25, 0x32, 0x30, 0x44, 0x65, 0x76, 0x69, 0x63,
+  0x65, 0x73, 0x25, 0x32, 0x30, 0x50, 0x43, 0x41, 0x25, 0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x2E,
+  0x63, 0x72, 0x6C, 0x30, 0x75, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04,
+  0x69, 0x30, 0x67, 0x30, 0x65, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86,
+  0x59, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72,
+  0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73,
+  0x2F, 0x63, 0x65, 0x72, 0x74, 0x73, 0x2F, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x25, 0x32,
+  0x30, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x25, 0x32, 0x30, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x25,
+  0x32, 0x30, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x25, 0x32, 0x30, 0x50, 0x43, 0x41, 0x25,
+  0x32, 0x30, 0x32, 0x30, 0x31, 0x38, 0x2E, 0x63, 0x72, 0x74, 0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86,
+  0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02, 0x03, 0x69, 0x00, 0x30, 0x66, 0x02, 0x31, 0x00, 0x87, 0xB6,
+  0x82, 0xF3, 0xDA, 0xBE, 0xB1, 0x7B, 0x98, 0x7D, 0x3D, 0x0A, 0x90, 0xA8, 0xF5, 0xBF, 0x15, 0xC3,
+  0xEE, 0x8A, 0x4E, 0xC0, 0x7B, 0x10, 0x1D, 0xA9, 0xE3, 0x0B, 0xEC, 0x2C, 0x53, 0x4E, 0xA7, 0xBD,
+  0xF1, 0x6C, 0xAD, 0x18, 0x55, 0xBA, 0x25, 0x73, 0x55, 0xB7, 0x5B, 0x12, 0x24, 0xF4, 0x02, 0x31,
+  0x00, 0xAF, 0x02, 0x9C, 0x4B, 0x92, 0xD0, 0x72, 0xA5, 0x80, 0xCA, 0x69, 0x2B, 0x38, 0x50, 0x64,
+  0xD8, 0x58, 0x9E, 0xEA, 0xD6, 0x35, 0xCF, 0x68, 0x98, 0x92, 0x81, 0x09, 0x61, 0xC2, 0xBD, 0xB1,
+  0x4C, 0x7F, 0xAE, 0x55, 0x7B, 0xFC, 0x22, 0xDD, 0xD6, 0xB7, 0x7C, 0xB5, 0xA8, 0x18, 0x5D, 0x33,
+  0x04
+};
+guint8 ca_2[] = {
+  0x30, 0x82, 0x04, 0x56, 0x30, 0x82, 0x03, 0xDC, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x13, 0x33,
+  0x00, 0x00, 0x00, 0x03, 0x6C, 0xCF, 0xED, 0xE2, 0x44, 0x70, 0x19, 0xBF, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x03, 0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03, 0x30, 0x81,
+  0x94, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13,
+  0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6E, 0x67,
+  0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65,
+  0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x15,
+  0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72,
+  0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x3E, 0x30, 0x3C, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x35,
+  0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x45, 0x43, 0x43, 0x20, 0x44, 0x65,
+  0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x52, 0x6F, 0x6F, 0x74, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69,
+  0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x74, 0x79,
+  0x20, 0x32, 0x30, 0x31, 0x37, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x38, 0x30, 0x31, 0x32, 0x35, 0x31,
+  0x39, 0x34, 0x39, 0x33, 0x38, 0x5A, 0x17, 0x0D, 0x33, 0x33, 0x30, 0x31, 0x32, 0x35, 0x31, 0x39,
+  0x35, 0x39, 0x33, 0x38, 0x5A, 0x30, 0x81, 0x84, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
+  0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0A,
+  0x57, 0x61, 0x73, 0x68, 0x69, 0x6E, 0x67, 0x74, 0x6F, 0x6E, 0x31, 0x10, 0x30, 0x0E, 0x06, 0x03,
+  0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65, 0x64, 0x6D, 0x6F, 0x6E, 0x64, 0x31, 0x1E, 0x30, 0x1C,
+  0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x15, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74,
+  0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x31, 0x2E, 0x30, 0x2C,
+  0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x25, 0x57, 0x69, 0x6E, 0x64, 0x6F, 0x77, 0x73, 0x20, 0x48,
+  0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x44, 0x65, 0x76, 0x69,
+  0x63, 0x65, 0x73, 0x20, 0x50, 0x43, 0x41, 0x20, 0x32, 0x30, 0x31, 0x38, 0x30, 0x76, 0x30, 0x10,
+  0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22,
+  0x03, 0x62, 0x00, 0x04, 0x1D, 0xDD, 0x08, 0x02, 0x03, 0x25, 0x75, 0x20, 0xE2, 0x71, 0x8B, 0xAD,
+  0x28, 0x09, 0x82, 0xE9, 0x06, 0xEE, 0x83, 0xC5, 0x3A, 0x6C, 0x4B, 0x71, 0x92, 0x50, 0x4E, 0x20,
+  0xE9, 0x72, 0xB4, 0xFC, 0x53, 0x2A, 0xEF, 0x5D, 0xCC, 0x9A, 0xB4, 0xCD, 0x76, 0xB8, 0x94, 0x97,
+  0x44, 0xB2, 0x71, 0x0E, 0xC9, 0xB1, 0x16, 0x03, 0xA1, 0x65, 0x2B, 0xB9, 0xE8, 0x5D, 0x5F, 0xF2,
+  0x30, 0x2E, 0xDD, 0xB1, 0x2B, 0x20, 0xFC, 0xBE, 0x00, 0x88, 0xEA, 0x1F, 0xA7, 0x7F, 0x99, 0x84,
+  0x98, 0x7C, 0x71, 0x3E, 0x4D, 0x34, 0x83, 0x69, 0x9B, 0x08, 0xCB, 0x78, 0xB2, 0x4B, 0xBD, 0xD7,
+  0x3E, 0xBE, 0x67, 0xA0, 0xA3, 0x82, 0x01, 0xFC, 0x30, 0x82, 0x01, 0xF8, 0x30, 0x10, 0x06, 0x09,
+  0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x15, 0x01, 0x04, 0x03, 0x02, 0x01, 0x00, 0x30, 0x1D,
+  0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04, 0x14, 0xDA, 0xCA, 0x4B, 0xD0, 0x4C, 0x56, 0x03,
+  0x27, 0x5F, 0x97, 0xEB, 0x75, 0xA3, 0x02, 0xC3, 0xBF, 0x45, 0x9C, 0xF8, 0xB1, 0x30, 0x65, 0x06,
+  0x03, 0x55, 0x1D, 0x20, 0x04, 0x5E, 0x30, 0x5C, 0x30, 0x06, 0x06, 0x04, 0x55, 0x1D, 0x20, 0x00,
+  0x30, 0x52, 0x06, 0x0C, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x4C, 0x83, 0x7D, 0x01, 0x01,
+  0x30, 0x42, 0x30, 0x40, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x34,
+  0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F,
+  0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73, 0x2F,
+  0x44, 0x6F, 0x63, 0x73, 0x2F, 0x52, 0x65, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x6F, 0x72, 0x79, 0x2E,
+  0x68, 0x74, 0x6D, 0x00, 0x30, 0x19, 0x06, 0x09, 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x14,
+  0x02, 0x04, 0x0C, 0x1E, 0x0A, 0x00, 0x53, 0x00, 0x75, 0x00, 0x62, 0x00, 0x43, 0x00, 0x41, 0x30,
+  0x0B, 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x04, 0x04, 0x03, 0x02, 0x01, 0x86, 0x30, 0x0F, 0x06, 0x03,
+  0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xFF, 0x30, 0x1F, 0x06,
+  0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x14, 0xDA, 0x5B, 0xF1, 0x0E, 0x66,
+  0x47, 0xD1, 0x5D, 0x13, 0x5F, 0x5B, 0x7A, 0xEB, 0xEB, 0x5F, 0x01, 0x08, 0xB5, 0x49, 0x30, 0x7A,
+  0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x73, 0x30, 0x71, 0x30, 0x6F, 0xA0, 0x6D, 0xA0, 0x6B, 0x86,
+  0x69, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72,
+  0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73,
+  0x2F, 0x63, 0x72, 0x6C, 0x2F, 0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x25, 0x32,
+  0x30, 0x45, 0x43, 0x43, 0x25, 0x32, 0x30, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x25, 0x32,
+  0x30, 0x52, 0x6F, 0x6F, 0x74, 0x25, 0x32, 0x30, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63,
+  0x61, 0x74, 0x65, 0x25, 0x32, 0x30, 0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x74, 0x79, 0x25,
+  0x32, 0x30, 0x32, 0x30, 0x31, 0x37, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x81, 0x87, 0x06, 0x08, 0x2B,
+  0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x7B, 0x30, 0x79, 0x30, 0x77, 0x06, 0x08, 0x2B,
+  0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86, 0x6B, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F,
+  0x77, 0x77, 0x77, 0x2E, 0x6D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x2E, 0x63, 0x6F,
+  0x6D, 0x2F, 0x70, 0x6B, 0x69, 0x6F, 0x70, 0x73, 0x2F, 0x63, 0x65, 0x72, 0x74, 0x73, 0x2F, 0x4D,
+  0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x25, 0x32, 0x30, 0x45, 0x43, 0x43, 0x25, 0x32,
+  0x30, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x25, 0x32, 0x30, 0x52, 0x6F, 0x6F, 0x74, 0x25,
+  0x32, 0x30, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x25, 0x32, 0x30,
+  0x41, 0x75, 0x74, 0x68, 0x6F, 0x72, 0x69, 0x74, 0x79, 0x25, 0x32, 0x30, 0x32, 0x30, 0x31, 0x37,
+  0x2E, 0x63, 0x72, 0x74, 0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03,
+  0x03, 0x68, 0x00, 0x30, 0x65, 0x02, 0x30, 0x56, 0x2A, 0xAD, 0x72, 0x4C, 0xB9, 0x8C, 0xB3, 0x23,
+  0x80, 0xF5, 0x5F, 0xF8, 0x21, 0x94, 0x66, 0x0F, 0x76, 0x77, 0xE2, 0x7B, 0x03, 0xDD, 0x30, 0x5E,
+  0xCB, 0x90, 0xCA, 0x78, 0xE6, 0x0B, 0x2D, 0x12, 0xE5, 0xF7, 0x67, 0x31, 0x58, 0x71, 0xE6, 0xF3,
+  0x64, 0xC1, 0x04, 0xB3, 0x8B, 0xE9, 0xE2, 0x02, 0x31, 0x00, 0xB9, 0x20, 0x61, 0xB9, 0xD0, 0x5E,
+  0x3A, 0xA4, 0xA2, 0x8A, 0xFE, 0x1D, 0xFC, 0x27, 0x61, 0x0B, 0x98, 0x16, 0x8C, 0x02, 0x9C, 0x20,
+  0x7F, 0xEE, 0xF3, 0xCB, 0x1F, 0x0A, 0x37, 0x62, 0xB1, 0x8E, 0xCE, 0xD9, 0x9A, 0x9E, 0xAC, 0xE6,
+  0x1A, 0xD4, 0xB8, 0xF1, 0xA8, 0x2B, 0xB1, 0xB4, 0x40, 0x9B
+};
+
+
+static void
+msg_written_cb (GObject      *source_object,
+                GAsyncResult *res,
+                gpointer      user_data)
+{
+  GError *error = NULL;
+  GOutputStream *stream = G_OUTPUT_STREAM (source_object);
+  FpiSsm *ssm = user_data;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (fpi_ssm_get_device (ssm));
+
+  g_clear_pointer (&self->msg_out, g_byte_array_unref);
+  g_assert (self->msg_out == NULL);
+
+  if (!g_output_stream_write_all_finish (stream, res, NULL, &error))
+    {
+      fpi_ssm_mark_failed (ssm, error);
+      return;
+    }
+
+  fpi_ssm_next_state (ssm);
+}
+
+static void
+msg_received_cb (GObject      *source_object,
+                 GAsyncResult *res,
+                 gpointer      user_data)
+{
+  GError *error = NULL;
+  GInputStream *stream = G_INPUT_STREAM (source_object);
+  FpiSsm *ssm = user_data;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (fpi_ssm_get_device (ssm));
+  gsize read;
+
+  g_assert (self->msg_out == NULL);
+
+  if (!g_input_stream_read_all_finish (stream, res, &read, &error) ||
+      read != self->msg_in->len)
+    {
+      g_clear_pointer (&self->msg_in, g_byte_array_unref);
+
+      if (!error)
+        error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                          "Received EOF while reading from test binary.");
+
+      fpi_ssm_mark_failed (ssm, error);
+      return;
+    }
+
+  fpi_ssm_next_state (ssm);
+}
+
+enum {
+  SEND_MESSAGE,
+  RECV_MESSAGE,
+  SEND_RECV_STATES
+};
+
+static void
+send_recv_ssm (FpiSsm *ssm, FpDevice *dev)
+{
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+
+  switch (fpi_ssm_get_cur_state (ssm))
+    {
+    case SEND_MESSAGE:
+      g_output_stream_write_all_async (self->proc_stdin,
+                                       self->msg_out->data,
+                                       self->msg_out->len,
+                                       G_PRIORITY_DEFAULT,
+                                       fpi_device_get_cancellable (FP_DEVICE (dev)),
+                                       msg_written_cb,
+                                       ssm);
+      break;
+
+    case RECV_MESSAGE:
+      g_input_stream_read_all_async (self->proc_stdout,
+                                     self->msg_in->data,
+                                     self->msg_in->len,
+                                     G_PRIORITY_DEFAULT,
+                                     fpi_device_get_cancellable (FP_DEVICE (dev)),
+                                     msg_received_cb,
+                                     ssm);
+      break;
+    }
+}
+
+static void
+connect_2_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
+{
+  g_autoptr(GBytes) recv_data = NULL;
+  g_autoptr(GBytes) r_d = NULL;
+  g_autoptr(FpiSdcpClaim) claim = NULL;
+  g_autoptr(GBytes) mac = NULL;
+  g_autoptr(GBytes) ca_1_bytes = NULL, ca_2_bytes = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+  guint16 cert_size;
+
+  if (error)
+    {
+      fpi_sdcp_device_connect_complete (FP_SDCP_DEVICE (dev), NULL, NULL, NULL, error);
+      g_clear_pointer (&self->connect_msg, g_byte_array_unref);
+      return;
+    }
+
+  memcpy (&cert_size, self->connect_msg->data + 32, 2);
+  g_byte_array_append (self->connect_msg, self->msg_in->data, self->msg_in->len);
+  g_clear_pointer (&self->msg_in, g_byte_array_unref);
+  /* Double check that the size is correct. */
+  g_assert (self->connect_msg->len == 32 + (2 + cert_size + 65 + 65 + 32 + 64 + 64) + 32);
+  recv_data = g_byte_array_free_to_bytes (g_steal_pointer (&self->connect_msg));
+
+  claim = fpi_sdcp_claim_new ();
+  r_d = g_bytes_new_from_bytes (recv_data, 0, 32);
+  claim->cert_m = g_bytes_new_from_bytes (recv_data, 34, cert_size);
+  claim->pk_d = g_bytes_new_from_bytes (recv_data, 34 + cert_size, 65);
+  claim->pk_f = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65, 65);
+  claim->h_f = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65 + 65, 32);
+  claim->s_m = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65 + 65 + 32, 64);
+  claim->s_d = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65 + 65 + 32 + 64, 64);
+  mac = g_bytes_new_from_bytes (recv_data, 34 + cert_size + 65 + 65 + 32 + 64 + 64, 32);
+
+  ca_1_bytes = g_bytes_new_static (ca_1, G_N_ELEMENTS (ca_1));
+  ca_2_bytes = g_bytes_new_static (ca_2, G_N_ELEMENTS (ca_2));
+
+  fpi_sdcp_device_set_intermediat_cas (FP_SDCP_DEVICE (dev),
+                                       ca_1_bytes,
+                                       ca_2_bytes);
+
+  fpi_sdcp_device_connect_complete (FP_SDCP_DEVICE (dev), r_d, claim, mac, NULL);
+}
+
+static void
+connect_1_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
+{
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+  guint16 cert_size;
+
+  if (error)
+    {
+      fpi_sdcp_device_connect_complete (FP_SDCP_DEVICE (dev), NULL, NULL, NULL, error);
+      return;
+    }
+
+  g_clear_pointer (&self->connect_msg, g_byte_array_unref);
+  self->connect_msg = g_steal_pointer (&self->msg_in);
+
+  memcpy (&cert_size, self->connect_msg->data + 32, 2);
+
+  /* Nothing to send and the rest to receive. */
+  self->msg_out = g_byte_array_new ();
+  self->msg_in = g_byte_array_new ();
+  g_byte_array_set_size (self->msg_in, 32 + (2 + cert_size + 65 + 65 + 32 + 64 + 64) + 32 - self->connect_msg->len);
+
+  /* New SSM */
+  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "connect 2");
+  fpi_ssm_start (ssm, connect_2_cb);
+}
+
+static void
+connect (FpSdcpDevice *dev)
+{
+  g_autoptr(GBytes) r_h = NULL;
+  g_autoptr(GBytes) pk_h = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+  FpiSsm *ssm;
+
+  G_DEBUG_HERE ();
+
+  g_assert (self->proc);
+  g_assert (self->connect_msg == NULL);
+
+  fpi_sdcp_device_get_connect_data (dev, &r_h, &pk_h);
+
+  self->msg_out = g_byte_array_new ();
+  g_byte_array_append (self->msg_out, (const guint8 *) "C", 1);
+  g_byte_array_append (self->msg_out,
+                       g_bytes_get_data (r_h, NULL),
+                       g_bytes_get_size (r_h));
+  g_byte_array_append (self->msg_out,
+                       g_bytes_get_data (pk_h, NULL),
+                       g_bytes_get_size (pk_h));
+
+  self->msg_in = g_byte_array_new ();
+  g_byte_array_set_size (self->msg_in, 34);
+
+  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "connect");
+  fpi_ssm_start (ssm, connect_1_cb);
+}
+
+static void
+reconnect_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
+{
+  g_autoptr(GBytes) mac = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+
+  if (error)
+    {
+      fpi_sdcp_device_reconnect_complete (FP_SDCP_DEVICE (dev), mac, error);
+      return;
+    }
+
+  mac = g_byte_array_free_to_bytes (g_steal_pointer (&self->msg_in));
+
+  fpi_sdcp_device_reconnect_complete (FP_SDCP_DEVICE (dev), mac, NULL);
+}
+
+static void
+reconnect (FpSdcpDevice *dev)
+{
+  g_autoptr(GBytes) r_h = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+  FpiSsm *ssm;
+
+  G_DEBUG_HERE ();
+
+  g_assert (self->proc);
+
+  fpi_sdcp_device_get_reconnect_data (dev, &r_h);
+
+  self->msg_out = g_byte_array_new ();
+  g_byte_array_append (self->msg_out, (const guint8 *) "R", 1);
+  g_byte_array_append (self->msg_out,
+                       g_bytes_get_data (r_h, NULL),
+                       g_bytes_get_size (r_h));
+
+  self->msg_in = g_byte_array_new ();
+  g_byte_array_set_size (self->msg_in, 32);
+
+  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "connect 2");
+  fpi_ssm_start (ssm, reconnect_cb);
+}
+
+static void
+enroll_begin_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
+{
+  g_autoptr(GBytes) nonce = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+
+  if (error)
+    {
+      fpi_sdcp_device_enroll_ready (FP_SDCP_DEVICE (dev), error);
+      return;
+    }
+
+  nonce = g_byte_array_free_to_bytes (g_steal_pointer (&self->msg_in));
+
+  fpi_sdcp_device_enroll_set_nonce (FP_SDCP_DEVICE (dev), nonce);
+
+  /* Claim that we completed one enroll step. */
+  fpi_device_enroll_progress (dev, 1, NULL, NULL);
+
+  /* And signal that we are ready to commit. */
+  fpi_sdcp_device_enroll_ready (FP_SDCP_DEVICE (dev), NULL);
+}
+
+static void
+enroll_begin (FpSdcpDevice *dev)
+{
+  g_autoptr(GBytes) r_h = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+  FpiSsm *ssm;
+
+  G_DEBUG_HERE ();
+
+  g_assert (self->proc);
+
+  fpi_sdcp_device_get_reconnect_data (dev, &r_h);
+
+  self->msg_out = g_byte_array_new ();
+  g_byte_array_append (self->msg_out, (const guint8 *) "E", 1);
+
+  /* Expect 32 byte nonce */
+  self->msg_in = g_byte_array_new ();
+  g_byte_array_set_size (self->msg_in, 32);
+
+  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "enroll_begin");
+  fpi_ssm_start (ssm, enroll_begin_cb);
+}
+
+static void
+enroll_commit_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
+{
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+
+  g_clear_pointer (&self->msg_in, g_byte_array_unref);
+
+  if (error)
+    {
+      fpi_sdcp_device_enroll_ready (FP_SDCP_DEVICE (dev), error);
+      return;
+    }
+
+  /* Signal that we have committed. We don't expect a response
+   * from the virtual device (even though that is kind of broken).
+   */
+  fpi_sdcp_device_enroll_commit_complete (FP_SDCP_DEVICE (dev), NULL);
+}
+
+static void
+enroll_commit (FpSdcpDevice *dev, GBytes *id_in)
+{
+  g_autoptr(GBytes) r_h = NULL;
+  g_autoptr(GBytes) id = id_in;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+  FpiSsm *ssm;
+
+  G_DEBUG_HERE ();
+
+  g_assert (self->proc);
+
+  fpi_sdcp_device_get_reconnect_data (dev, &r_h);
+
+  self->msg_out = g_byte_array_new ();
+  self->msg_in = g_byte_array_new ();
+  if (id)
+    {
+      g_byte_array_append (self->msg_out, (const guint8 *) "F", 1);
+      g_byte_array_append (self->msg_out,
+                           g_bytes_get_data (id, NULL),
+                           g_bytes_get_size (id));
+
+      /* NOTE: No response from device, assume commit works. */
+    }
+  else
+    {
+      /* Cancel enroll (does not receive a reply) */
+      g_byte_array_append (self->msg_out, (const guint8 *) "G", 1);
+
+      /* NOTE: No response from device, assume cancellation works. */
+    }
+
+  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "enroll_commit");
+  fpi_ssm_start (ssm, enroll_commit_cb);
+}
+
+static void
+identify_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
+{
+  g_autoptr(GBytes) reply = NULL;
+  g_autoptr(GBytes) id = NULL;
+  g_autoptr(GBytes) mac = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+
+  if (error)
+    {
+      fpi_sdcp_device_identify_complete (FP_SDCP_DEVICE (dev), NULL, NULL, error);
+      return;
+    }
+
+  reply = g_byte_array_free_to_bytes (g_steal_pointer (&self->msg_in));
+  id = g_bytes_new_from_bytes (reply, 0, 32);
+  mac = g_bytes_new_from_bytes (reply, 32, 32);
+
+  fpi_sdcp_device_identify_complete (FP_SDCP_DEVICE (self), id, mac, NULL);
+}
+
+static void
+identify (FpSdcpDevice *dev)
+{
+  g_autoptr(GBytes) nonce = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+  FpiSsm *ssm;
+
+  G_DEBUG_HERE ();
+
+  g_assert (self->proc);
+
+  fpi_sdcp_device_get_identify_data (dev, &nonce);
+
+  self->msg_out = g_byte_array_new ();
+  g_byte_array_append (self->msg_out, (const guint8 *) "I", 1);
+  g_byte_array_append (self->msg_out, g_bytes_get_data (nonce, NULL), g_bytes_get_size (nonce));
+
+  /* Expect 64 byte nonce */
+  self->msg_in = g_byte_array_new ();
+  g_byte_array_set_size (self->msg_in, 64);
+
+  ssm = fpi_ssm_new_full (FP_DEVICE (dev), send_recv_ssm, SEND_RECV_STATES, "identify");
+  fpi_ssm_start (ssm, identify_cb);
+}
+
+static void
+probe (FpDevice *dev)
+{
+  g_auto(GStrv) argv = NULL;
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (dev);
+  GError *error = NULL;
+  const char *env;
+
+  /* We launch the test binary alread at probe time and quit only when
+   * the object is finalized. This allows testing reconnect properly.
+   *
+   * Also, we'll fail probe if something goes wrong executing it.
+   */
+  env = fpi_device_get_virtual_env (FP_DEVICE (self));
+
+  if (!g_shell_parse_argv (env, NULL, &argv, &error))
+    goto out;
+
+  self->proc = g_subprocess_newv ((const char * const *) argv,
+                                  G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE,
+                                  &error);
+  if (!self->proc)
+    goto out;
+
+  self->proc_stdin = g_object_ref (g_subprocess_get_stdin_pipe (self->proc));
+  self->proc_stdout = g_object_ref (g_subprocess_get_stdout_pipe (self->proc));
+
+
+out:
+  fpi_device_probe_complete (dev, "virtual-sdcp", NULL, error);
+}
+
+static void
+dev_close (FpDevice *dev)
+{
+  /* No-op, needs to be defined. */
+  fpi_device_close_complete (dev, NULL);
+}
+
+static void
+fpi_device_virtual_sdcp_init (FpDeviceVirtualSdcp *self)
+{
+}
+
+static void
+fpi_device_virtual_sdcp_finalize (GObject *obj)
+{
+  FpDeviceVirtualSdcp *self = FPI_DEVICE_VIRTUAL_SDCP (obj);
+
+  /* Just kill the subprocess, no need to be graceful here. */
+  if (self->proc)
+    g_subprocess_force_exit (self->proc);
+
+  g_clear_object (&self->proc);
+  g_clear_object (&self->proc_stdin);
+  g_clear_object (&self->proc_stdout);
+
+  G_OBJECT_CLASS (fpi_device_virtual_sdcp_parent_class)->finalize (obj);
+}
+
+static const FpIdEntry driver_ids[] = {
+  { .virtual_envvar = "FP_VIRTUAL_SDCP" },
+  { .virtual_envvar = NULL }
+};
+
+static void
+fpi_device_virtual_sdcp_class_init (FpDeviceVirtualSdcpClass *klass)
+{
+  GObjectClass *obj_class = G_OBJECT_CLASS (klass);
+  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+  FpSdcpDeviceClass *sdcp_class = FP_SDCP_DEVICE_CLASS (klass);
+
+  obj_class->finalize = fpi_device_virtual_sdcp_finalize;
+
+  dev_class->id = FP_COMPONENT;
+  dev_class->full_name = "Virtual SDCP device talking to MS test code";
+  dev_class->type = FP_DEVICE_TYPE_VIRTUAL;
+  dev_class->id_table = driver_ids;
+  dev_class->nr_enroll_stages = 1;
+
+  /* The SDCP base class may need to override this in the long run */
+  dev_class->probe = probe;
+  dev_class->close = dev_close;
+
+  sdcp_class->connect = connect;
+  sdcp_class->reconnect = reconnect;
+
+  sdcp_class->enroll_begin = enroll_begin;
+  sdcp_class->enroll_commit = enroll_commit;
+
+  sdcp_class->identify = identify;
+}
@@ -2,6 +2,7 @@
 * Driver API definitions
 * Copyright (C) 2007-2008 Daniel Drake <dsd@gentoo.org>
 * Copyright (C) 2018 Bastien Nocera <hadess@hadess.net>
+ * Copyright (C) 2019 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
@@ -18,17 +19,14 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __DRIVERS_API_H__
-#define __DRIVERS_API_H__
-
-#include <config.h>
-
-#include "fp_internal.h"
+#pragma once

+#include "fpi-compat.h"
+#include "fpi-assembling.h"
+#include "fpi-device.h"
+#include "fpi-image-device.h"
+#include "fpi-image.h"
 #include "fpi-log.h"
+#include "fpi-print.h"
 #include "fpi-usb-transfer.h"
 #include "fpi-ssm.h"
-#include "fpi-assembling.h"
-#include "fpi-image-device.h"
-
-#endif
@@ -57,6 +57,89 @@ enum {
 };
 static guint signals[LAST_SIGNAL] = { 0 };

+static const char *
+get_drivers_whitelist_env (void)
+{
+  return g_getenv ("FP_DRIVERS_WHITELIST");
+}
+
+static gboolean
+is_driver_allowed (const gchar *driver)
+{
+  g_auto(GStrv) whitelisted_drivers = NULL;
+  const char *fp_drivers_whitelist_env;
+  int i;
+
+  g_return_val_if_fail (driver, TRUE);
+
+  fp_drivers_whitelist_env = get_drivers_whitelist_env ();
+
+  if (!fp_drivers_whitelist_env)
+    return TRUE;
+
+  whitelisted_drivers = g_strsplit (fp_drivers_whitelist_env, ":", -1);
+
+  for (i = 0; whitelisted_drivers[i]; ++i)
+    if (g_strcmp0 (driver, whitelisted_drivers[i]) == 0)
+      return TRUE;
+
+  return FALSE;
+}
+
+typedef struct
+{
+  FpContext *context;
+  FpDevice  *device;
+} RemoveDeviceData;
+
+static gboolean
+remove_device_idle_cb (RemoveDeviceData *data)
+{
+  FpContextPrivate *priv = fp_context_get_instance_private (data->context);
+  guint idx = 0;
+
+  g_return_val_if_fail (g_ptr_array_find (priv->devices, data->device, &idx), G_SOURCE_REMOVE);
+
+  g_signal_emit (data->context, signals[DEVICE_REMOVED_SIGNAL], 0, data->device);
+  g_ptr_array_remove_index_fast (priv->devices, idx);
+
+  g_free (data);
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+remove_device (FpContext *context, FpDevice *device)
+{
+  RemoveDeviceData *data;
+
+  data = g_new (RemoveDeviceData, 1);
+  data->context = context;
+  data->device = device;
+
+  g_idle_add ((GSourceFunc) remove_device_idle_cb, data);
+}
+
+static void
+device_remove_on_notify_open_cb (FpContext *context, GParamSpec *pspec, FpDevice *device)
+{
+  remove_device (context, device);
+}
+
+static void
+device_removed_cb (FpContext *context, FpDevice *device)
+{
+  gboolean open = FALSE;
+
+  g_object_get (device, "open", &open, NULL);
+
+  /* Wait for device close if the device is currently still open. */
+  if (open)
+    g_signal_connect_swapped (device, "notify::open", (GCallback) device_remove_on_notify_open_cb, context);
+  else
+    remove_device (context, device);
+}
+
 static void
 async_device_init_done_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 {
@@ -65,23 +148,25 @@ async_device_init_done_cb (GObject *source_object, GAsyncResult *res, gpointer u
  FpContext *context;
  FpContextPrivate *priv;

-  device = (FpDevice *) g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, &error);
-  if (!device)
-    {
-      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-        return;
-
-      context = FP_CONTEXT (user_data);
-      priv = fp_context_get_instance_private (context);
-      priv->pending_devices--;
-      g_message ("Ignoring device due to initialization error: %s", error->message);
-      return;
-    }
+  device = FP_DEVICE (g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
+                                                   res, &error));
+  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+    return;

  context = FP_CONTEXT (user_data);
  priv = fp_context_get_instance_private (context);
  priv->pending_devices--;
+
+  if (error)
+    {
+      g_message ("Ignoring device due to initialization error: %s", error->message);
+      return;
+    }
+
  g_ptr_array_add (priv->devices, device);
+
+  g_signal_connect_swapped (device, "removed", (GCallback) device_removed_cb, context);
+
  g_signal_emit (context, signals[DEVICE_ADDED_SIGNAL], 0, device);
 }

@@ -102,14 +187,11 @@ usb_device_added_cb (FpContext *self, GUsbDevice *device, GUsbContext *usb_ctx)
  for (i = 0; i < priv->drivers->len; i++)
    {
      GType driver = g_array_index (priv->drivers, GType, i);
-      FpDeviceClass *cls = FP_DEVICE_CLASS (g_type_class_ref (driver));
+      g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
      const FpIdEntry *entry;

      if (cls->type != FP_DEVICE_TYPE_USB)
-        {
-          g_type_class_unref (cls);
-          continue;
-        }
+        continue;

      for (entry = cls->id_table; entry->pid; entry++)
        {
@@ -129,13 +211,11 @@ usb_device_added_cb (FpContext *self, GUsbDevice *device, GUsbContext *usb_ctx)
          found_driver = driver;
          found_entry = entry;
        }
-
-      g_type_class_unref (cls);
    }

  if (found_driver == G_TYPE_NONE)
    {
-      g_debug ("No driver found for USB device %04X:%04X", pid, vid);
+      g_debug ("No driver found for USB device %04X:%04X", vid, pid);
      return;
    }

@@ -145,8 +225,8 @@ usb_device_added_cb (FpContext *self, GUsbDevice *device, GUsbContext *usb_ctx)
                              priv->cancellable,
                              async_device_init_done_cb,
                              self,
-                              "fp-usb-device", device,
-                              "fp-driver-data", found_entry->driver_data,
+                              "fpi-usb-device", device,
+                              "fpi-driver-data", found_entry->driver_data,
                              NULL);
 }

@@ -166,12 +246,7 @@ usb_device_removed_cb (FpContext *self, GUsbDevice *device, GUsbContext *usb_ctx
        continue;

      if (fpi_device_get_usb_device (dev) == device)
-        {
-          g_signal_emit (self, signals[DEVICE_REMOVED_SIGNAL], 0, dev);
-          g_ptr_array_remove_index_fast (priv->devices, i);
-
-          return;
-        }
+        fpi_device_remove (dev);
    }
 }

@@ -186,6 +261,9 @@ fp_context_finalize (GObject *object)
  g_cancellable_cancel (priv->cancellable);
  g_clear_object (&priv->cancellable);
  g_clear_pointer (&priv->drivers, g_array_unref);
+
+  if (priv->usb_ctx)
+    g_object_run_dispose (G_OBJECT (priv->usb_ctx));
  g_clear_object (&priv->usb_ctx);

  G_OBJECT_CLASS (fp_context_parent_class)->finalize (object);
@@ -222,6 +300,10 @@ fp_context_class_init (FpContextClass *klass)
   * @device: A #FpDevice
   *
   * This signal is emitted when a fingerprint reader is removed.
+   *
+   * It is guaranteed that the device has been closed before this signal
+   * is emitted. See the #FpDevice removed signal documentation for more
+   * information.
   **/
  signals[DEVICE_REMOVED_SIGNAL] = g_signal_new ("device-removed",
                                                 G_TYPE_FROM_CLASS (klass),
@@ -240,9 +322,23 @@ fp_context_init (FpContext *self)
 {
  g_autoptr(GError) error = NULL;
  FpContextPrivate *priv = fp_context_get_instance_private (self);
+  guint i;

-  priv->drivers = g_array_new (TRUE, FALSE, sizeof (GType));
-  fpi_get_driver_types (priv->drivers);
+  priv->drivers = fpi_get_driver_types ();
+
+  if (get_drivers_whitelist_env ())
+    {
+      for (i = 0; i < priv->drivers->len;)
+        {
+          GType driver = g_array_index (priv->drivers, GType, i);
+          g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
+
+          if (!is_driver_allowed (cls->id))
+            g_array_remove_index (priv->drivers, i);
+          else
+            ++i;
+        }
+    }

  priv->devices = g_ptr_array_new_with_free_func (g_object_unref);

@@ -250,7 +346,7 @@ fp_context_init (FpContext *self)
  priv->usb_ctx = g_usb_context_new (&error);
  if (!priv->usb_ctx)
    {
-      fp_warn ("Could not initialise USB Subsystem: %s", error->message);
+      g_message ("Could not initialise USB Subsystem: %s", error->message);
    }
  else
    {
@@ -303,13 +399,14 @@ fp_context_enumerate (FpContext *context)
  priv->enumerated = TRUE;

  /* USB devices are handled from callbacks */
-  g_usb_context_enumerate (priv->usb_ctx);
+  if (priv->usb_ctx)
+    g_usb_context_enumerate (priv->usb_ctx);

  /* Handle Virtual devices based on environment variables */
  for (i = 0; i < priv->drivers->len; i++)
    {
      GType driver = g_array_index (priv->drivers, GType, i);
-      FpDeviceClass *cls = FP_DEVICE_CLASS (g_type_class_ref (driver));
+      g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
      const FpIdEntry *entry;

      if (cls->type != FP_DEVICE_TYPE_VIRTUAL)
@@ -330,13 +427,11 @@ fp_context_enumerate (FpContext *context)
                                      priv->cancellable,
                                      async_device_init_done_cb,
                                      context,
-                                      "fp-environ", val,
-                                      "fp-driver-data", entry->driver_data,
+                                      "fpi-environ", val,
+                                      "fpi-driver-data", entry->driver_data,
                                      NULL);
          g_debug ("created");
        }
-
-      g_type_class_unref (cls);
    }

  while (priv->pending_devices)
@@ -0,0 +1,84 @@
+/*
+ * FpDevice - A fingerprint reader device
+ * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
+ * Copyright (C) 2019 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
+ */
+
+#pragma once
+
+#include "fpi-device.h"
+
+typedef struct
+{
+  FpDeviceType type;
+
+  GUsbDevice  *usb_device;
+  const gchar *virtual_env;
+
+  gboolean     is_removed;
+  gboolean     is_open;
+
+  gchar       *device_id;
+  gchar       *device_name;
+  FpScanType   scan_type;
+
+  guint64      driver_data;
+
+  gint         nr_enroll_stages;
+  GSList      *sources;
+
+  /* We always make sure that only one task is run at a time. */
+  FpiDeviceAction     current_action;
+  GTask              *current_task;
+  GAsyncReadyCallback current_user_cb;
+  gulong              current_cancellable_id;
+  GSource            *current_idle_cancel_source;
+  GSource            *current_task_idle_return_source;
+
+  /* State for tasks */
+  gboolean            wait_for_finger;
+  FpFingerStatusFlags finger_status;
+} FpDevicePrivate;
+
+
+typedef struct
+{
+  FpPrint         *print;
+
+  FpEnrollProgress enroll_progress_cb;
+  gpointer         enroll_progress_data;
+  GDestroyNotify   enroll_progress_destroy;
+} FpEnrollData;
+
+void enroll_data_free (FpEnrollData *enroll_data);
+
+typedef struct
+{
+  FpPrint       *enrolled_print;   /* verify */
+  GPtrArray     *gallery;   /* identify */
+
+  gboolean       result_reported;
+  FpPrint       *match;
+  FpPrint       *print;
+  GError        *error;
+
+  FpMatchCb      match_cb;
+  gpointer       match_data;
+  GDestroyNotify match_destroy;
+} FpMatchData;
+
+void match_data_free (FpMatchData *match_data);
@@ -79,7 +79,7 @@ typedef enum {

 /**
 * FpDeviceError:
- * @FP_DEVICE_ERROR_GENERAL: A general error occured.
+ * @FP_DEVICE_ERROR_GENERAL: A general error occurred.
 * @FP_DEVICE_ERROR_NOT_SUPPORTED: The device does not support the requested
 *  operation.
 * @FP_DEVICE_ERROR_NOT_OPEN: The device needs to be opened to start this
@@ -90,6 +90,9 @@ typedef enum {
 * @FP_DEVICE_ERROR_DATA_INVALID: The passed data is invalid
 * @FP_DEVICE_ERROR_DATA_NOT_FOUND: Requested print was not found on device
 * @FP_DEVICE_ERROR_DATA_FULL: No space on device available for operation
+ * @FP_DEVICE_ERROR_DATA_DUPLICATE: Enrolling template duplicates storaged templates
+ * @FP_DEVICE_ERROR_REMOVED: The device has been removed.
+ * @FP_DEVICE_ERROR_UNTRUSTED: Device cannot be trusted
 *
 * Error codes for device operations. More specific errors from other domains
 * such as #G_IO_ERROR or #G_USB_DEVICE_ERROR may also be reported.
@@ -104,6 +107,10 @@ typedef enum {
  FP_DEVICE_ERROR_DATA_INVALID,
  FP_DEVICE_ERROR_DATA_NOT_FOUND,
  FP_DEVICE_ERROR_DATA_FULL,
+  FP_DEVICE_ERROR_DATA_DUPLICATE,
+  /* Leave some room to add more DATA related errors */
+  FP_DEVICE_ERROR_REMOVED = 0x100,
+  FP_DEVICE_ERROR_UNTRUSTED,
 } FpDeviceError;

 GQuark fp_device_retry_quark (void);
@@ -113,8 +120,8 @@ GQuark fp_device_error_quark (void);
 * FpEnrollProgress:
 * @device: a #FpDevice
 * @completed_stages: Number of completed stages
- * @print: (nullable): The last scaned print
- * @user_data: (nullable): User provided data
+ * @print: (nullable) (transfer none): The last scanned print
+ * @user_data: (nullable) (transfer none): User provided data
 * @error: (nullable) (transfer none): #GError or %NULL
 *
 * The passed error is guaranteed to be of type %FP_DEVICE_RETRY if set.
@@ -125,11 +132,50 @@ typedef void (*FpEnrollProgress) (FpDevice *device,
                                  gpointer  user_data,
                                  GError   *error);

+/**
+ * FpMatchCb:
+ * @device: a #FpDevice
+ * @match: (nullable) (transfer none): The matching print if any matched @print
+ * @print: (nullable) (transfer none): The newly scanned print
+ * @user_data: (nullable) (transfer none): User provided data
+ * @error: (nullable) (transfer none): #GError or %NULL
+ *
+ * Report the result of a match (identify or verify) operation.
+ *
+ * If @match is non-%NULL, then it is set to the matching #FpPrint as passed
+ * to the match operation. In this case @error will always be %NULL.
+ *
+ * If @error is not %NULL then its domain is guaranteed to be
+ * %FP_DEVICE_RETRY. All other error conditions will not be reported using
+ * this callback. If such an error occurs before a match/no-match decision
+ * can be made, then this callback will not be called. Should an error
+ * happen afterwards, then you will get a match report through this callback
+ * and an error when the operation finishes.
+ *
+ * If @match and @error are %NULL, then a finger was presented but it did not
+ * match any known print.
+ *
+ * @print represents the newly scanned print. The driver may or may not
+ * provide this information. Image based devices will provide it and it
+ * allows access to the raw data.
+ *
+ * This callback exists because it makes sense for drivers to wait e.g. on
+ * finger removal before completing the match operation. However, the
+ * success/failure can often be reported at an earlier time, and there is
+ * no need to make the user wait.
+ */
+typedef void (*FpMatchCb) (FpDevice *device,
+                           FpPrint  *match,
+                           FpPrint  *print,
+                           gpointer  user_data,
+                           GError   *error);

 const gchar *fp_device_get_driver (FpDevice *device);
 const gchar *fp_device_get_device_id (FpDevice *device);
 const gchar *fp_device_get_name (FpDevice *device);
+gboolean     fp_device_is_open (FpDevice *device);
 FpScanType   fp_device_get_scan_type (FpDevice *device);
+FpFingerStatusFlags fp_device_get_finger_status (FpDevice *device);
 gint         fp_device_get_nr_enroll_stages (FpDevice *device);

 gboolean     fp_device_supports_identify (FpDevice *device);
@@ -159,12 +205,18 @@ void fp_device_enroll (FpDevice           *device,
 void fp_device_verify (FpDevice           *device,
                       FpPrint            *enrolled_print,
                       GCancellable       *cancellable,
+                       FpMatchCb           match_cb,
+                       gpointer            match_data,
+                       GDestroyNotify      match_destroy,
                       GAsyncReadyCallback callback,
                       gpointer            user_data);

 void fp_device_identify (FpDevice           *device,
                         GPtrArray          *prints,
                         GCancellable       *cancellable,
+                         FpMatchCb           match_cb,
+                         gpointer            match_data,
+                         GDestroyNotify      match_destroy,
                         GAsyncReadyCallback callback,
                         gpointer            user_data);

@@ -230,12 +282,16 @@ FpPrint * fp_device_enroll_sync (FpDevice        *device,
 gboolean fp_device_verify_sync (FpDevice     *device,
                                FpPrint      *enrolled_print,
                                GCancellable *cancellable,
+                                FpMatchCb     match_cb,
+                                gpointer      match_data,
                                gboolean     *match,
                                FpPrint     **print,
                                GError      **error);
 gboolean fp_device_identify_sync (FpDevice     *device,
                                  GPtrArray    *prints,
                                  GCancellable *cancellable,
+                                  FpMatchCb     match_cb,
+                                  gpointer      match_data,
                                  FpPrint     **match,
                                  FpPrint     **print,
                                  GError      **error);
@@ -0,0 +1,45 @@
+/*
+ * FpImageDevice - An image based fingerprint reader device
+ * Copyright (C) 2019 Benjamin Berg <bberg@redhat.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
+ */
+
+#pragma once
+
+#include "fpi-image-device.h"
+
+#define IMG_ENROLL_STAGES 5
+
+typedef struct
+{
+  FpiImageDeviceState state;
+  gboolean            active;
+
+  gboolean            finger_present;
+
+  gint                enroll_stage;
+
+  gboolean            minutiae_scan_active;
+  GError             *action_error;
+  FpImage            *capture_image;
+
+  gint                bz3_threshold;
+} FpImageDevicePrivate;
+
+
+void fpi_image_device_activate (FpImageDevice *image_device);
+void fpi_image_device_deactivate (FpImageDevice *image_device,
+                                  gboolean       cancelling);
@@ -20,13 +20,9 @@
 #define FP_COMPONENT "image_device"
 #include "fpi-log.h"

-#include "fpi-image-device.h"
-#include "fpi-print.h"
-#include "fpi-image.h"
+#include "fp-image-device-private.h"

-#define MIN_ACCEPTABLE_MINUTIAE 10
 #define BOZORTH3_DEFAULT_THRESHOLD 40
-#define IMG_ENROLL_STAGES 5

 /**
 * SECTION: fp-image-device
@@ -36,30 +32,23 @@
 * This is a helper class for the commonly found image based devices.
 */

-/**
- * SECTION: fpi-image-device
- * @title: Internal FpImageDevice
- * @short_description: Internal image device routines
- *
- * See #FpImageDeviceClass for more details. Also see the public
- * #FpImageDevice routines.
- */
-
-typedef struct
-{
-  FpImageDeviceState state;
-  gboolean           active;
-
-  gint               enroll_stage;
-
-  guint              pending_activation_timeout_id;
-  gboolean           pending_activation_timeout_waiting_finger_off;
-
-  gint               bz3_threshold;
-} FpImageDevicePrivate;
-
 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (FpImageDevice, fp_image_device, FP_TYPE_DEVICE)

+enum {
+  PROP_0,
+  PROP_FPI_STATE,
+  N_PROPS
+};
+
+static GParamSpec *properties[N_PROPS];
+
+enum {
+  FPI_STATE_CHANGED,
+
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };

 /*******************************************************/

@@ -67,98 +56,6 @@ G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (FpImageDevice, fp_image_device, FP_TYPE_DEV
 * - sanitize_image seems a bit odd, in particular the sizing stuff.
 **/

-/* Static helper functions */
-
-static void
-fp_image_device_change_state (FpImageDevice *self, FpImageDeviceState state)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
-
-  /* Cannot change to inactive using this function. */
-  g_assert (state != FP_IMAGE_DEVICE_STATE_INACTIVE);
-
-  /* We might have been waiting for the finger to go OFF to start the
-   * next operation. */
-  if (priv->pending_activation_timeout_id)
-    {
-      g_source_remove (priv->pending_activation_timeout_id);
-      priv->pending_activation_timeout_id = 0;
-    }
-
-  fp_dbg ("Image device internal state change from %d to %d\n", priv->state, state);
-
-  priv->state = state;
-
-  /* change_state is the only callback which is optional and does not
-   * have a default implementation. */
-  if (cls->change_state)
-    cls->change_state (self, state);
-}
-
-static void
-fp_image_device_activate (FpImageDevice *self)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
-
-  g_assert (!priv->active);
-
-  /* We don't have a neutral ACTIVE state, but we always will
-   * go into WAIT_FINGER_ON afterwards. */
-  priv->state = FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
-
-  /* We might have been waiting for deactivation to finish before
-   * starting the next operation. */
-  if (priv->pending_activation_timeout_id)
-    {
-      g_source_remove (priv->pending_activation_timeout_id);
-      priv->pending_activation_timeout_id = 0;
-    }
-
-  fp_dbg ("Activating image device\n");
-  cls->activate (self);
-}
-
-static void
-fp_image_device_deactivate (FpDevice *device)
-{
-  FpImageDevice *self = FP_IMAGE_DEVICE (device);
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (device);
-
-  if (!priv->active)
-    {
-      /* XXX: We currently deactivate both from minutiae scan result
-       *      and finger off report. */
-      fp_dbg ("Already deactivated, ignoring request.");
-      return;
-    }
-  priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
-
-  fp_dbg ("Deactivating image device\n");
-  cls->deactivate (self);
-}
-
-static gboolean
-pending_activation_timeout (gpointer user_data)
-{
-  FpImageDevice *self = FP_IMAGE_DEVICE (user_data);
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-
-  priv->pending_activation_timeout_id = 0;
-
-  if (priv->pending_activation_timeout_waiting_finger_off)
-    fpi_device_action_error (FP_DEVICE (self),
-                             fpi_device_retry_new_msg (FP_DEVICE_RETRY_REMOVE_FINGER,
-                                                       "Remove finger before requesting another scan operation"));
-  else
-    fpi_device_action_error (FP_DEVICE (self),
-                             fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
-
-  return G_SOURCE_REMOVE;
-}
-
 /* Callbacks/vfuncs */
 static void
 fp_image_device_open (FpDevice *device)
@@ -177,44 +74,25 @@ fp_image_device_close (FpDevice *device)
  FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);

-  /* In the close case we may need to wait/force deactivation first.
-   * Three possible cases:
-   *  1. We are inactive
-   *     -> immediately close
-   *  2. We are waiting for finger off
-   *     -> imediately deactivate
-   *  3. We are deactivating
-   *     -> handled by deactivate_complete */
-
-  if (!priv->active)
-    cls->img_close (self);
-  else if (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE)
-    fp_image_device_deactivate (device);
+  g_assert (priv->active == FALSE);
+  cls->img_close (self);
 }

 static void
 fp_image_device_cancel_action (FpDevice *device)
 {
  FpImageDevice *self = FP_IMAGE_DEVICE (device);
-  FpDeviceAction action;
+  FpiDeviceAction action;

  action = fpi_device_get_current_action (device);

  /* We can only cancel capture operations, in that case, deactivate and return
   * an error immediately. */
-  if (action == FP_DEVICE_ACTION_ENROLL ||
-      action == FP_DEVICE_ACTION_VERIFY ||
-      action == FP_DEVICE_ACTION_IDENTIFY ||
-      action == FP_DEVICE_ACTION_CAPTURE)
-    {
-      fp_image_device_deactivate (FP_DEVICE (self));
-
-      /* XXX: Some nicer way of doing this would be good. */
-      fpi_device_action_error (FP_DEVICE (self),
-                               g_error_new (G_IO_ERROR,
-                                            G_IO_ERROR_CANCELLED,
-                                            "Device operation was cancelled"));
-    }
+  if (action == FPI_DEVICE_ACTION_ENROLL ||
+      action == FPI_DEVICE_ACTION_VERIFY ||
+      action == FPI_DEVICE_ACTION_IDENTIFY ||
+      action == FPI_DEVICE_ACTION_CAPTURE)
+    fpi_image_device_deactivate (self, TRUE);
 }

 static void
@@ -222,14 +100,14 @@ fp_image_device_start_capture_action (FpDevice *device)
 {
  FpImageDevice *self = FP_IMAGE_DEVICE (device);
  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
+  FpiDeviceAction action;

  /* There is just one action that we cannot support out
   * of the box, which is a capture without first waiting
   * for a finger to be on the device.
   */
  action = fpi_device_get_current_action (device);
-  if (action == FP_DEVICE_ACTION_CAPTURE)
+  if (action == FPI_DEVICE_ACTION_CAPTURE)
    {
      gboolean wait_for_finger;

@@ -241,39 +119,22 @@ fp_image_device_start_capture_action (FpDevice *device)
          return;
        }
    }
-  else if (action == FP_DEVICE_ACTION_ENROLL)
+  else if (action == FPI_DEVICE_ACTION_ENROLL)
    {
      FpPrint *enroll_print = NULL;

      fpi_device_get_enroll_data (device, &enroll_print);
-      fpi_print_set_type (enroll_print, FP_PRINT_NBIS);
+      fpi_print_set_type (enroll_print, FPI_PRINT_NBIS);
    }

  priv->enroll_stage = 0;
-
-  /* The device might still be deactivating from a previous call.
-   * In that situation, try to wait for a bit before reporting back an
-   * error (which will usually say that the user should remove the
-   * finger).
-   */
-  if (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE || priv->active)
-    {
-      g_debug ("Got a new request while the device was still active");
-      g_assert (priv->pending_activation_timeout_id == 0);
-      priv->pending_activation_timeout_id =
-        g_timeout_add (100, pending_activation_timeout, device);
-
-      if (priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
-        priv->pending_activation_timeout_waiting_finger_off = TRUE;
-      else
-        priv->pending_activation_timeout_waiting_finger_off = FALSE;
-
-      return;
-    }
+  /* The internal state machine guarantees both of these. */
+  g_assert (!priv->finger_present);
+  g_assert (!priv->minutiae_scan_active);

  /* And activate the device; we rely on fpi_image_device_activate_complete()
   * to be called when done (or immediately). */
-  fp_image_device_activate (self);
+  fpi_image_device_activate (self);
 }


@@ -302,6 +163,43 @@ fp_image_device_default_deactivate (FpImageDevice *self)
  fpi_image_device_deactivate_complete (self, NULL);
 }

+static void
+fp_image_device_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+  FpImageDevice *self = FP_IMAGE_DEVICE (object);
+  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
+
+  switch (prop_id)
+    {
+    case PROP_FPI_STATE:
+      g_value_set_enum (value, priv->state);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+fp_image_device_constructed (GObject *obj)
+{
+  FpImageDevice *self = FP_IMAGE_DEVICE (obj);
+  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
+  FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
+
+  /* Set default values. */
+  fpi_device_set_nr_enroll_stages (FP_DEVICE (self), IMG_ENROLL_STAGES);
+
+  priv->bz3_threshold = BOZORTH3_DEFAULT_THRESHOLD;
+  if (cls->bz3_threshold > 0)
+    priv->bz3_threshold = cls->bz3_threshold;
+
+  G_OBJECT_CLASS (fp_image_device_parent_class)->constructed (obj);
+}
+
 static void
 fp_image_device_class_init (FpImageDeviceClass *klass)
 {
@@ -309,6 +207,8 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
  FpDeviceClass *fp_device_class = FP_DEVICE_CLASS (klass);

  object_class->finalize = fp_image_device_finalize;
+  object_class->get_property = fp_image_device_get_property;
+  object_class->constructed = fp_image_device_constructed;

  fp_device_class->open = fp_image_device_open;
  fp_device_class->close = fp_image_device_close;
@@ -322,474 +222,43 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
  /* Default implementations */
  klass->activate = fp_image_device_default_activate;
  klass->deactivate = fp_image_device_default_deactivate;
+
+  /**
+   * FpImageDevice::fpi-image-device-state: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
+  properties[PROP_FPI_STATE] =
+    g_param_spec_enum ("fpi-image-device-state",
+                       "Image Device State",
+                       "Private: The state of the image device",
+                       FPI_TYPE_IMAGE_DEVICE_STATE,
+                       FPI_IMAGE_DEVICE_STATE_INACTIVE,
+                       G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
+
+  /**
+   * FpImageDevice::fpi-image-device-state-changed: (skip)
+   * @image_device: A #FpImageDevice
+   * @new_state: The new state of the device
+   *
+   * This signal is only for internal purposes.
+   *
+   * Stability: private
+   */
+  signals[FPI_STATE_CHANGED] =
+    g_signal_new ("fpi-image-device-state-changed",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (FpImageDeviceClass, change_state),
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 1, FPI_TYPE_IMAGE_DEVICE_STATE);
+
+  g_object_class_install_properties (object_class, N_PROPS, properties);
 }

 static void
 fp_image_device_init (FpImageDevice *self)
 {
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
-
-  /* Set default values. */
-  fpi_device_set_nr_enroll_stages (FP_DEVICE (self), IMG_ENROLL_STAGES);
-
-  priv->bz3_threshold = BOZORTH3_DEFAULT_THRESHOLD;
-  if (cls->bz3_threshold > 0)
-    priv->bz3_threshold = cls->bz3_threshold;
-
-}
-
-static void
-fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, gpointer user_data)
-{
-  g_autoptr(FpImage) image = FP_IMAGE (source_object);
-  GError *error = NULL;
-  FpPrint *print = NULL;
-  FpDevice *device = FP_DEVICE (user_data);
-  FpImageDevicePrivate *priv;
-  FpDeviceAction action;
-
-  /* Note: We rely on the device to not disappear during an operation. */
-
-  if (!fp_image_detect_minutiae_finish (image, res, &error))
-    {
-      /* Cancel operation . */
-      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-        {
-          fpi_device_action_error (device, g_steal_pointer (&error));
-          fp_image_device_deactivate (device);
-          return;
-        }
-
-      /* Replace error with a retry condition. */
-      g_warning ("Failed to detect minutiae: %s", error->message);
-      g_clear_pointer (&error, g_error_free);
-
-      error = fpi_device_retry_new_msg (FP_DEVICE_RETRY_GENERAL, "Minutiae detection failed, please retry");
-    }
-
-  priv = fp_image_device_get_instance_private (FP_IMAGE_DEVICE (device));
-  action = fpi_device_get_current_action (device);
-
-  if (action == FP_DEVICE_ACTION_CAPTURE)
-    {
-      fpi_device_capture_complete (device, g_steal_pointer (&image), error);
-      fp_image_device_deactivate (device);
-      return;
-    }
-
-  if (!error)
-    {
-      print = fp_print_new (device);
-      fpi_print_set_type (print, FP_PRINT_NBIS);
-      if (!fpi_print_add_from_image (print, image, &error))
-        g_clear_object (&print);
-    }
-
-  if (action == FP_DEVICE_ACTION_ENROLL)
-    {
-      FpPrint *enroll_print;
-      fpi_device_get_enroll_data (device, &enroll_print);
-
-      if (print)
-        {
-          fpi_print_add_print (enroll_print, print);
-          priv->enroll_stage += 1;
-        }
-
-      fpi_device_enroll_progress (device, priv->enroll_stage, print, error);
-
-      if (priv->enroll_stage == IMG_ENROLL_STAGES)
-        {
-          fpi_device_enroll_complete (device, g_object_ref (enroll_print), NULL);
-          fp_image_device_deactivate (device);
-        }
-    }
-  else if (action == FP_DEVICE_ACTION_VERIFY)
-    {
-      FpPrint *template;
-      FpiMatchResult result;
-
-      fpi_device_get_verify_data (device, &template);
-      if (print)
-        result = fpi_print_bz3_match (template, print, priv->bz3_threshold, &error);
-      else
-        result = FPI_MATCH_ERROR;
-
-      fpi_device_verify_complete (device, result, print, error);
-      fp_image_device_deactivate (device);
-    }
-  else if (action == FP_DEVICE_ACTION_IDENTIFY)
-    {
-      gint i;
-      GPtrArray *templates;
-      FpPrint *result = NULL;
-
-      fpi_device_get_identify_data (device, &templates);
-      for (i = 0; !error && i < templates->len; i++)
-        {
-          FpPrint *template = g_ptr_array_index (templates, i);
-
-          if (fpi_print_bz3_match (template, print, priv->bz3_threshold, &error) == FPI_MATCH_SUCCESS)
-            {
-              result = g_object_ref (template);
-              break;
-            }
-        }
-
-      fpi_device_identify_complete (device, result, print, error);
-      fp_image_device_deactivate (device);
-    }
-  else
-    {
-      /* XXX: This can be hit currently due to a race condition in the enroll code!
-       *      In that case we scan a further image even though the minutiae for the previous
-       *      one have not yet been detected.
-       *      We need to keep track on the pending minutiae detection and the fact that
-       *      it will finish eventually (or we may need to retry on error and activate the
-       *      device again). */
-      g_assert_not_reached ();
-    }
-}
-
-/*********************************************************/
-/* Private API */
-
-/**
- * fpi_image_device_set_bz3_threshold:
- * @self: a #FpImageDevice imaging fingerprint device
- * @bz3_threshold: BZ3 threshold to use
- *
- * Dynamically adjust the bz3 threshold. This is only needed for drivers
- * that support devices with different properties. It should generally be
- * called from the probe callback, but is acceptable to call from the open
- * callback.
- */
-void
-fpi_image_device_set_bz3_threshold (FpImageDevice *self,
-                                    gint           bz3_threshold)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-
-  g_return_if_fail (FP_IS_IMAGE_DEVICE (self));
-  g_return_if_fail (bz3_threshold > 0);
-
-  priv->bz3_threshold = bz3_threshold;
-}
-
-/**
- * fpi_image_device_report_finger_status:
- * @self: a #FpImageDevice imaging fingerprint device
- * @present: whether the finger is present on the sensor
- *
- * Reports from the driver whether the user's finger is on
- * the sensor.
- */
-void
-fpi_image_device_report_finger_status (FpImageDevice *self,
-                                       gboolean       present)
-{
-  FpDevice *device = FP_DEVICE (self);
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
-
-  action = fpi_device_get_current_action (device);
-
-  if (priv->state == FP_IMAGE_DEVICE_STATE_INACTIVE)
-    {
-      /* Do we really want to always ignore such reports? We could
-       * also track the state in case the user had the finger on
-       * the device at initialisation time and the driver reports
-       * this early.
-       */
-      g_debug ("Ignoring finger presence report as the device is not active!");
-      return;
-    }
-
-  action = fpi_device_get_current_action (device);
-
-  g_assert (action != FP_DEVICE_ACTION_OPEN);
-  g_assert (action != FP_DEVICE_ACTION_CLOSE);
-
-  g_debug ("Image device reported finger status: %s", present ? "on" : "off");
-
-  if (present && priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
-    {
-      fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_CAPTURE);
-    }
-  else if (!present && priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
-    {
-      /* We need to deactivate or continue to await finger */
-
-      /* There are three possible situations:
-       *  1. We are deactivating the device and the action is still in progress
-       *     (minutiae detection).
-       *  2. We are still deactivating the device after an action completed
-       *  3. We were waiting for finger removal to start the new action
-       * Either way, we always end up deactivating except for the enroll case.
-       * XXX: This is not quite correct though, as we assume we need another finger
-       *      scan even though we might be processing the last one (successfully).
-       */
-      if (action != FP_DEVICE_ACTION_ENROLL)
-        fp_image_device_deactivate (device);
-      else
-        fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
-    }
-}
-
-/**
- * fpi_image_device_image_captured:
- * @self: a #FpImageDevice imaging fingerprint device
- * @image: whether the finger is present on the sensor
- *
- * Reports an image capture. Only use this function if the image was
- * captured successfully. If there was an issue where the user should
- * retry, use fpi_image_device_retry_scan() to report the retry condition.
- *
- * In the event of a fatal error for the operation use
- * fpi_image_device_session_error(). This will abort the entire operation
- * including e.g. an enroll operation which captures multiple images during
- * one session.
- */
-void
-fpi_image_device_image_captured (FpImageDevice *self, FpImage *image)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
-
-  action = fpi_device_get_current_action (FP_DEVICE (self));
-
-  g_return_if_fail (image != NULL);
-  g_return_if_fail (priv->state == FP_IMAGE_DEVICE_STATE_CAPTURE);
-  g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL ||
-                    action == FP_DEVICE_ACTION_VERIFY ||
-                    action == FP_DEVICE_ACTION_IDENTIFY ||
-                    action == FP_DEVICE_ACTION_CAPTURE);
-
-  fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
-
-  g_debug ("Image device captured an image");
-
-  /* XXX: We also detect minutiae in capture mode, we solely do this
-   *      to normalize the image which will happen as a by-product. */
-  fp_image_detect_minutiae (image,
-                            fpi_device_get_cancellable (FP_DEVICE (self)),
-                            fpi_image_device_minutiae_detected,
-                            self);
-}
-
-/**
- * fpi_image_device_retry_scan:
- * @self: a #FpImageDevice imaging fingerprint device
- * @retry: The #FpDeviceRetry error code to report
- *
- * Reports a scan failure to the user. This may or may not abort the
- * current session. It is the equivalent of fpi_image_device_image_captured()
- * in the case of a retryable error condition (e.g. short swipe).
- */
-void
-fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
-  GError *error;
-
-  action = fpi_device_get_current_action (FP_DEVICE (self));
-
-  /* We might be waiting for a finger at this point, so just accept
-   * all but INACTIVE */
-  g_return_if_fail (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE);
-  g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL ||
-                    action == FP_DEVICE_ACTION_VERIFY ||
-                    action == FP_DEVICE_ACTION_IDENTIFY ||
-                    action == FP_DEVICE_ACTION_CAPTURE);
-
-  error = fpi_device_retry_new (retry);
-
-  if (action == FP_DEVICE_ACTION_ENROLL)
-    {
-      g_debug ("Reporting retry during enroll");
-      fpi_device_enroll_progress (FP_DEVICE (self), priv->enroll_stage, NULL, error);
-    }
-  else
-    {
-      /* We abort the operation and let the surrounding code retry in the
-       * non-enroll case (this is identical to a session error). */
-      g_debug ("Abort current operation due to retry (non-enroll case)");
-      fp_image_device_deactivate (FP_DEVICE (self));
-      fpi_device_action_error (FP_DEVICE (self), error);
-    }
-}
-
-/**
- * fpi_image_device_session_error:
- * @self: a #FpImageDevice imaging fingerprint device
- * @error: The #GError to report
- *
- * Report an error while interacting with the device. This effectively
- * aborts the current ongoing action.
- */
-void
-fpi_image_device_session_error (FpImageDevice *self, GError *error)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-
-  g_return_if_fail (self);
-
-  if (!error)
-    {
-      g_warning ("Driver did not provide an error, generating a generic one");
-      error = g_error_new (FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL, "Driver reported session error without an error");
-    }
-
-  if (!priv->active)
-    {
-      FpDeviceAction action = fpi_device_get_current_action (FP_DEVICE (self));
-      g_warning ("Driver reported session error, but device is inactive.");
-
-      if (action != FP_DEVICE_ACTION_NONE)
-        {
-          g_warning ("Translating to activation failure!");
-          fpi_image_device_activate_complete (self, error);
-          return;
-        }
-    }
-  else if (priv->state == FP_IMAGE_DEVICE_STATE_INACTIVE)
-    {
-      g_warning ("Driver reported session error; translating to deactivation failure.");
-      fpi_image_device_deactivate_complete (self, error);
-      return;
-    }
-
-  if (error->domain == FP_DEVICE_RETRY)
-    g_warning ("Driver should report retries using fpi_image_device_retry_scan!");
-
-  fp_image_device_deactivate (FP_DEVICE (self));
-  fpi_device_action_error (FP_DEVICE (self), error);
-}
-
-/**
- * fpi_image_device_activate_complete:
- * @self: a #FpImageDevice imaging fingerprint device
- * @error: A #GError or %NULL on success
- *
- * Reports completion of device activation.
- */
-void
-fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
-
-  action = fpi_device_get_current_action (FP_DEVICE (self));
-
-  g_return_if_fail (priv->active == FALSE);
-  g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL ||
-                    action == FP_DEVICE_ACTION_VERIFY ||
-                    action == FP_DEVICE_ACTION_IDENTIFY ||
-                    action == FP_DEVICE_ACTION_CAPTURE);
-
-  if (error)
-    {
-      g_debug ("Image device activation failed");
-      fpi_device_action_error (FP_DEVICE (self), error);
-      return;
-    }
-
-  g_debug ("Image device activation completed");
-
-  priv->active = TRUE;
-
-  /* We always want to capture at this point, move to AWAIT_FINGER
-   * state. */
-  fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
-}
-
-/**
- * fpi_image_device_deactivate_complete:
- * @self: a #FpImageDevice imaging fingerprint device
- * @error: A #GError or %NULL on success
- *
- * Reports completion of device deactivation.
- */
-void
-fpi_image_device_deactivate_complete (FpImageDevice *self, GError *error)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
-  FpDeviceAction action;
-
-  g_return_if_fail (priv->active == TRUE);
-  g_return_if_fail (priv->state == FP_IMAGE_DEVICE_STATE_INACTIVE);
-
-  g_debug ("Image device deactivation completed");
-
-  priv->active = FALSE;
-
-  /* Deactivation completed. As we deactivate in the background
-   * there may already be a new task pending. Check whether we
-   * need to do anything. */
-  action = fpi_device_get_current_action (FP_DEVICE (self));
-
-  /* Special case, if we should be closing, but didn't due to a running
-   * deactivation, then do so now. */
-  if (action == FP_DEVICE_ACTION_CLOSE)
-    {
-      cls->img_close (self);
-      return;
-    }
-
-  /* We might be waiting to be able to activate again. */
-  if (priv->pending_activation_timeout_id)
-    fp_image_device_activate (self);
-}
-
-/**
- * fpi_image_device_open_complete:
- * @self: a #FpImageDevice imaging fingerprint device
- * @error: A #GError or %NULL on success
- *
- * Reports completion of open operation.
- */
-void
-fpi_image_device_open_complete (FpImageDevice *self, GError *error)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
-
-  action = fpi_device_get_current_action (FP_DEVICE (self));
-
-  g_return_if_fail (priv->active == FALSE);
-  g_return_if_fail (action == FP_DEVICE_ACTION_OPEN);
-
-  g_debug ("Image device open completed");
-
-  priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
-
-  fpi_device_open_complete (FP_DEVICE (self), error);
-}
-
-/**
- * fpi_image_device_close_complete:
- * @self: a #FpImageDevice imaging fingerprint device
- * @error: A #GError or %NULL on success
- *
- * Reports completion of close operation.
- */
-void
-fpi_image_device_close_complete (FpImageDevice *self, GError *error)
-{
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
-
-  action = fpi_device_get_current_action (FP_DEVICE (self));
-
-  g_debug ("Image device close completed");
-
-  g_return_if_fail (priv->active == FALSE);
-  g_return_if_fail (action == FP_DEVICE_ACTION_CLOSE);
-
-  priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
-
-  fpi_device_close_complete (FP_DEVICE (self), error);
 }
@@ -19,7 +19,7 @@

 #pragma once

-#include <fp-device.h>
+#include "fp-device.h"

 G_BEGIN_DECLS

@@ -18,13 +18,12 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

+#define FP_COMPONENT "image"
+
 #include "fpi-image.h"
+#include "fpi-log.h"

-#include "nbis/include/lfs.h"
-
-#if HAVE_PIXMAN
-#include <pixman.h>
-#endif
+#include <nbis.h>

 /**
 * SECTION: fp-image
@@ -35,15 +34,6 @@
 * this object allows accessing this data.
 */

-/**
- * SECTION: fpi-image
- * @title: Internal FpImage
- * @short_description: Internal image handling routines
- *
- * Internal image handling routines. Also see the public <ulink
- * url="libfprint-FpImage.html">FpImage routines</ulink>.
- */
-
 G_DEFINE_TYPE (FpImage, fp_image, G_TYPE_OBJECT)

 enum {
@@ -194,10 +184,8 @@ fp_image_detect_minutiae_cb (GObject      *source_object,
  GTask *task = G_TASK (res);
  FpImage *image;
  DetectMinutiaeData *data = g_task_get_task_data (task);
-  GCancellable *cancellable;

-  cancellable = g_task_get_cancellable (task);
-  if (!cancellable || !g_cancellable_is_cancelled (cancellable))
+  if (!g_task_had_error (task))
    {
      gint i;
      image = FP_IMAGE (source_object);
@@ -293,6 +281,7 @@ fp_image_detect_minutiae_thread_func (GTask        *task,
  gint map_w, map_h;
  gint bw, bh, bd;
  gint r;
+  g_autofree LFSPARMS *lfsparms = NULL;

  /* Normalize the image first */
  if (data->flags & FPI_IMAGE_H_FLIPPED)
@@ -306,12 +295,15 @@ fp_image_detect_minutiae_thread_func (GTask        *task,

  data->flags &= ~(FPI_IMAGE_H_FLIPPED | FPI_IMAGE_V_FLIPPED | FPI_IMAGE_COLORS_INVERTED);

+  lfsparms = g_memdup (&g_lfsparms_V2, sizeof (LFSPARMS));
+  lfsparms->remove_perimeter_pts = data->flags & FPI_IMAGE_PARTIAL ? TRUE : FALSE;
+
  timer = g_timer_new ();
  r = get_minutiae (&minutiae, &quality_map, &direction_map,
                    &low_contrast_map, &low_flow_map, &high_curve_map,
                    &map_w, &map_h, &bdata, &bw, &bh, &bd,
                    data->image, data->width, data->height, 8,
-                    data->ppmm, &g_lfsparms_V2);
+                    data->ppmm, lfsparms);
  g_timer_stop (timer);
  fp_dbg ("Minutiae scan completed in %f secs", g_timer_elapsed (timer, NULL));

@@ -326,6 +318,14 @@ fp_image_detect_minutiae_thread_func (GTask        *task,
      return;
    }

+  if (!data->minutiae || data->minutiae->num == 0)
+    {
+      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
+                               "No minutiae found");
+      g_object_unref (task);
+      return;
+    }
+
  g_task_return_boolean (task, TRUE);
  g_object_unref (task);
 }
@@ -478,78 +478,6 @@ fp_image_detect_minutiae_finish (FpImage      *self,
  return g_task_propagate_boolean (G_TASK (result), error);
 }

-
-
-/**
- * fpi_std_sq_dev:
- * @buf: buffer (usually bitmap, one byte per pixel)
- * @size: size of @buffer
- *
- * Calculates the squared standard deviation of the individual
- * pixels in the buffer, as per the following formula:
- * |[<!-- -->
- *    mean = sum (buf[0..size]) / size
- *    sq_dev = sum ((buf[0.size] - mean) ^ 2)
- * ]|
- * This function is usually used to determine whether image
- * is empty.
- *
- * Returns: the squared standard deviation for @buffer
- */
-gint
-fpi_std_sq_dev (const guint8 *buf,
-                gint          size)
-{
-  guint64 res = 0, mean = 0;
-  gint i;
-
-  for (i = 0; i < size; i++)
-    mean += buf[i];
-
-  mean /= size;
-
-  for (i = 0; i < size; i++)
-    {
-      int dev = (int) buf[i] - mean;
-      res += dev * dev;
-    }
-
-  return res / size;
-}
-
-/**
- * fpi_mean_sq_diff_norm:
- * @buf1: buffer (usually bitmap, one byte per pixel)
- * @buf2: buffer (usually bitmap, one byte per pixel)
- * @size: buffer size of smallest buffer
- *
- * This function calculates the normalized mean square difference of
- * two buffers, usually two lines, as per the following formula:
- * |[<!-- -->
- *    sq_diff = sum ((buf1[0..size] - buf2[0..size]) ^ 2) / size
- * ]|
- *
- * This functions is usually used to get numerical difference
- * between two images.
- *
- * Returns: the normalized mean squared difference between @buf1 and @buf2
- */
-gint
-fpi_mean_sq_diff_norm (const guint8 *buf1,
-                       const guint8 *buf2,
-                       gint          size)
-{
-  int res = 0, i;
-
-  for (i = 0; i < size; i++)
-    {
-      int dev = (int) buf1[i] - (int) buf2[i];
-      res += dev * dev;
-    }
-
-  return res / size;
-}
-
 /**
 * fp_minutia_get_coords:
 * @min: A #FpMinutia
@@ -567,44 +495,3 @@ fp_minutia_get_coords (FpMinutia *min, gint *x, gint *y)
  if (y)
    *y = min->y;
 }
-
-#if HAVE_PIXMAN
-FpImage *
-fpi_image_resize (FpImage *orig_img,
-                  guint    w_factor,
-                  guint    h_factor)
-{
-  int new_width = orig_img->width * w_factor;
-  int new_height = orig_img->height * h_factor;
-  pixman_image_t *orig, *resized;
-  pixman_transform_t transform;
-  FpImage *newimg;
-
-  orig = pixman_image_create_bits (PIXMAN_a8, orig_img->width, orig_img->height, (uint32_t *) orig_img->data, orig_img->width);
-  resized = pixman_image_create_bits (PIXMAN_a8, new_width, new_height, NULL, new_width);
-
-  pixman_transform_init_identity (&transform);
-  pixman_transform_scale (NULL, &transform, pixman_int_to_fixed (w_factor), pixman_int_to_fixed (h_factor));
-  pixman_image_set_transform (orig, &transform);
-  pixman_image_set_filter (orig, PIXMAN_FILTER_BILINEAR, NULL, 0);
-  pixman_image_composite32 (PIXMAN_OP_SRC,
-                            orig, /* src */
-                            NULL, /* mask */
-                            resized, /* dst */
-                            0, 0, /* src x y */
-                            0, 0, /* mask x y */
-                            0, 0, /* dst x y */
-                            new_width, new_height /* width height */
-                           );
-
-  newimg = fp_image_new (new_width, new_height);
-  newimg->flags = orig_img->flags;
-
-  memcpy (newimg->data, pixman_image_get_data (resized), new_width * new_height);
-
-  pixman_image_unref (orig);
-  pixman_image_unref (resized);
-
-  return newimg;
-}
-#endif
@@ -1,6 +1,7 @@
 /*
- * Driver IDs
- * Copyright (C) 2012 Vasily Khoruzhick <anarsoul@gmail.com>
+ * FPrint Print handling
+ * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -17,31 +18,29 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __DRIVER_IDS
-#define __DRIVER_IDS
+#include "fpi-print.h"
+#include "fpi-image.h"

-enum {
-  UPEKTS_ID       = 1,
-  URU4000_ID      = 2,
-  AES4000_ID      = 3,
-  AES2501_ID      = 4,
-  UPEKTC_ID       = 5,
-  AES1610_ID      = 6,
-  /* FDU2000_ID	= 7, */
-  VCOM5S_ID       = 8,
-  UPEKSONLY_ID    = 9,
-  VFS101_ID       = 10,
-  VFS301_ID       = 11,
-  AES2550_ID      = 12,
-  /* UPEKE2_ID = 13 */
-  AES1660_ID      = 14,
-  AES2660_ID      = 15,
-  AES3500_ID      = 16,
-  UPEKTC_IMG_ID   = 17,
-  ETES603_ID      = 18,
-  VFS5011_ID      = 19,
-  VFS0050_ID      = 20,
-  ELAN_ID         = 21,
+#include <nbis.h>
+
+struct _FpPrint
+{
+  GInitiallyUnowned parent_instance;
+
+  FpiPrintType      type;
+
+  gchar            *driver;
+  gchar            *device_id;
+  gboolean          device_stored;
+
+  FpImage          *image;
+
+  /* Metadata */
+  FpFinger   finger;
+  gchar     *username;
+  gchar     *description;
+  GDate     *enroll_date;
+
+  GVariant  *data;
+  GPtrArray *prints;
 };
-
-#endif
@@ -18,12 +18,11 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#include "fpi-print.h"
-#include "fpi-image.h"
-#include "fpi-device.h"
+#define FP_COMPONENT "print"

-#include "nbis/include/bozorth.h"
-#include "nbis/include/lfs.h"
+#include "fp-print-private.h"
+#include "fpi-compat.h"
+#include "fpi-log.h"

 /**
 * SECTION: fp-print
@@ -42,28 +41,6 @@
 * #FpPrint routines.
 */

-struct _FpPrint
-{
-  GInitiallyUnowned parent_instance;
-
-  FpPrintType       type;
-
-  gchar            *driver;
-  gchar            *device_id;
-  gboolean          device_stored;
-
-  FpImage          *image;
-
-  /* Metadata */
-  FpFinger   finger;
-  gchar     *username;
-  gchar     *description;
-  GDate     *enroll_date;
-
-  GVariant  *data;
-  GPtrArray *prints;
-};
-
 G_DEFINE_TYPE (FpPrint, fp_print, G_TYPE_INITIALLY_UNOWNED)

 enum {
@@ -74,7 +51,7 @@ enum {
  PROP_IMAGE,

  /* The following is metadata that is stored by default for each print.
-   * Drivers may make use of these during enrollment (e.g. to additionaly store
+   * Drivers may make use of these during enrollment (e.g. to additionally store
   * the metadata on the device). */
  PROP_FINGER,
  PROP_USERNAME,
@@ -101,6 +78,7 @@ fp_print_finalize (GObject *object)
  g_clear_pointer (&self->description, g_free);
  g_clear_pointer (&self->enroll_date, g_date_free);
  g_clear_pointer (&self->data, g_variant_unref);
+  g_clear_pointer (&self->prints, g_ptr_array_unref);

  G_OBJECT_CLASS (fp_print_parent_class)->finalize (object);
 }
@@ -206,7 +184,7 @@ fp_print_set_property (GObject      *object,
      break;

    case PROP_FPI_DATA:
-      g_clear_pointer (&self->description, g_variant_unref);
+      g_clear_pointer (&self->data, g_variant_unref);
      self->data = g_value_dup_variant (value);
      break;

@@ -291,16 +269,30 @@ fp_print_class_init (FpPrintClass *klass)
                        G_TYPE_DATE,
                        G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);

+  /**
+   * FpPrint::fpi-type: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
  properties[PROP_FPI_TYPE] =
-    g_param_spec_enum ("fp-type",
+    g_param_spec_enum ("fpi-type",
                       "Type",
                       "Private: The type of the print data",
-                       FP_TYPE_PRINT_TYPE,
-                       FP_PRINT_RAW,
+                       FPI_TYPE_PRINT_TYPE,
+                       FPI_PRINT_UNDEFINED,
                       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);

+  /**
+   * FpPrint::fpi-data: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
  properties[PROP_FPI_DATA] =
-    g_param_spec_variant ("fp-data",
+    g_param_spec_variant ("fpi-data",
                          "Raw Data",
                          "The raw data for internal use only",
                          G_VARIANT_TYPE_ANY,
@@ -534,228 +526,11 @@ fp_print_set_enroll_date (FpPrint     *print,

  g_clear_pointer (&print->enroll_date, g_date_free);
  if (enroll_date)
-    {
-      /* XXX: Should use g_date_copy, but that is new in 2.56. */
-      print->enroll_date = g_date_new ();
-      *print->enroll_date = *enroll_date;
-    }
+    print->enroll_date = g_date_copy (enroll_date);
+
  g_object_notify_by_pspec (G_OBJECT (print), properties[PROP_ENROLL_DATE]);
 }

-
-
-/**
- * fpi_print_add_print:
- * @print: A #FpPrint
- * @add: Print to append to @print
- *
- * Appends the single #FP_PRINT_NBIS print from @add to the collection of
- * prints in @print. Both print objects need to be of type #FP_PRINT_NBIS
- * for this to work.
- */
-void
-fpi_print_add_print (FpPrint *print, FpPrint *add)
-{
-  g_return_if_fail (print->type == FP_PRINT_NBIS);
-  g_return_if_fail (add->type == FP_PRINT_NBIS);
-
-  g_assert (add->prints->len == 1);
-  g_ptr_array_add (print->prints, g_memdup (add->prints->pdata[0], sizeof (struct xyt_struct)));
-}
-
-/**
- * fpi_print_set_type:
- * @print: A #FpPrint
- * @type: The newly type of the print data
- *
- * This function can only be called exactly once. Drivers should
- * call it after creating a new print, or to initialize the template
- * print passed during enrollment.
- */
-void
-fpi_print_set_type (FpPrint    *print,
-                    FpPrintType type)
-{
-  g_return_if_fail (FP_IS_PRINT (print));
-  /* We only allow setting this once! */
-  g_return_if_fail (print->type == FP_PRINT_UNDEFINED);
-
-  print->type = type;
-  if (print->type == FP_PRINT_NBIS)
-    print->prints = g_ptr_array_new_with_free_func (g_free);
-  g_object_notify_by_pspec (G_OBJECT (print), properties[PROP_FPI_TYPE]);
-}
-
-/**
- * fpi_print_set_device_stored:
- * @print: A #FpPrint
- * @device_stored: Whether the print is stored on the device or not
- *
- * Drivers must set this to %TRUE for any print that is really a handle
- * for data that is stored on the device itself.
- */
-void
-fpi_print_set_device_stored (FpPrint *print,
-                             gboolean device_stored)
-{
-  g_return_if_fail (FP_IS_PRINT (print));
-
-  print->device_stored = device_stored;
-  g_object_notify_by_pspec (G_OBJECT (print), properties[PROP_DEVICE_STORED]);
-}
-
-/* XXX: This is the old version, but wouldn't it be smarter to instead
- * use the highest quality mintutiae? Possibly just using bz_prune from
- * upstream? */
-static void
-minutiae_to_xyt (struct fp_minutiae *minutiae,
-                 int                 bwidth,
-                 int                 bheight,
-                 struct xyt_struct  *xyt)
-{
-  int i;
-  struct fp_minutia *minutia;
-  struct minutiae_struct c[MAX_FILE_MINUTIAE];
-
-  /* struct xyt_struct uses arrays of MAX_BOZORTH_MINUTIAE (200) */
-  int nmin = min (minutiae->num, MAX_BOZORTH_MINUTIAE);
-
-  for (i = 0; i < nmin; i++)
-    {
-      minutia = minutiae->list[i];
-
-      lfs2nist_minutia_XYT (&c[i].col[0], &c[i].col[1], &c[i].col[2],
-                            minutia, bwidth, bheight);
-      c[i].col[3] = sround (minutia->reliability * 100.0);
-
-      if (c[i].col[2] > 180)
-        c[i].col[2] -= 360;
-    }
-
-  qsort ((void *) &c, (size_t) nmin, sizeof (struct minutiae_struct),
-         sort_x_y);
-
-  for (i = 0; i < nmin; i++)
-    {
-      xyt->xcol[i]     = c[i].col[0];
-      xyt->ycol[i]     = c[i].col[1];
-      xyt->thetacol[i] = c[i].col[2];
-    }
-  xyt->nrows = nmin;
-}
-
-/**
- * fpi_print_add_from_image:
- * @print: A #FpPrint
- * @image: A #FpImage
- * @error: Return location for error
- *
- * Extracts the minutiae from the given image and adds it to @print of
- * type #FP_PRINT_NBIS.
- *
- * The @image will be kept so that API users can get retrieve it e.g.
- * for debugging purposes.
- *
- * Returns: %TRUE on success
- */
-gboolean
-fpi_print_add_from_image (FpPrint *print,
-                          FpImage *image,
-                          GError **error)
-{
-  GPtrArray *minutiae;
-  struct fp_minutiae _minutiae;
-  struct xyt_struct *xyt;
-
-  if (print->type != FP_PRINT_NBIS || !image)
-    {
-      g_set_error (error,
-                   G_IO_ERROR,
-                   G_IO_ERROR_INVALID_DATA,
-                   "Cannot add print data from image!");
-      return FALSE;
-    }
-
-  minutiae = fp_image_get_minutiae (image);
-  if (!minutiae || minutiae->len == 0)
-    {
-      g_set_error (error,
-                   G_IO_ERROR,
-                   G_IO_ERROR_INVALID_DATA,
-                   "No minutiae found in image or not yet detected!");
-      return FALSE;
-    }
-
-  _minutiae.num = minutiae->len;
-  _minutiae.list = (struct fp_minutia **) minutiae->pdata;
-  _minutiae.alloc = minutiae->len;
-
-  xyt = g_new0 (struct xyt_struct, 1);
-  minutiae_to_xyt (&_minutiae, image->width, image->height, xyt);
-  g_ptr_array_add (print->prints, xyt);
-
-  g_clear_object (&print->image);
-  print->image = g_object_ref (image);
-  g_object_notify_by_pspec (G_OBJECT (print), properties[PROP_IMAGE]);
-
-  return TRUE;
-}
-
-/**
- * fpi_print_bz3_match:
- * @template: A #FpPrint containing one or more prints
- * @print: A newly scanned #FpPrint to test
- * @bz3_threshold: The BZ3 match threshold
- * @error: Return location for error
- *
- * Match the newly scanned @print (containing exactly one print) against the
- * prints contained in @template which will have been stored during enrollment.
- *
- * Both @template and @print need to be of type #FP_PRINT_NBIS for this to
- * work.
- *
- * Returns: Whether the prints match, @error will be set if #FPI_MATCH_ERROR is returned
- */
-FpiMatchResult
-fpi_print_bz3_match (FpPrint *template, FpPrint *print, gint bz3_threshold, GError **error)
-{
-  struct xyt_struct *pstruct;
-  gint probe_len;
-  gint i;
-
-  /* XXX: Use a different error type? */
-  if (template->type != FP_PRINT_NBIS || print->type != FP_PRINT_NBIS)
-    {
-      *error = fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
-                                         "It is only possible to match NBIS type print data");
-      return FPI_MATCH_ERROR;
-    }
-
-  if (print->prints->len != 1)
-    {
-      *error = fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                         "New print contains more than one print!");
-      return FPI_MATCH_ERROR;
-    }
-
-  pstruct = g_ptr_array_index (print->prints, 0);
-  probe_len = bozorth_probe_init (pstruct);
-
-  for (i = 0; i < template->prints->len; i++)
-    {
-      struct xyt_struct *gstruct;
-      gint score;
-      gstruct = g_ptr_array_index (template->prints, i);
-      score = bozorth_to_gallery (probe_len, pstruct, gstruct);
-      fp_dbg ("score %d", score);
-
-      if (score >= bz3_threshold)
-        return FPI_MATCH_SUCCESS;
-    }
-
-  return FPI_MATCH_FAIL;
-}
-
 /**
 * fp_print_compatible:
 * @self: A #FpPrint
@@ -795,8 +570,8 @@ fp_print_equal (FpPrint *self, FpPrint *other)
 {
  g_return_val_if_fail (FP_IS_PRINT (self), FALSE);
  g_return_val_if_fail (FP_IS_PRINT (other), FALSE);
-  g_return_val_if_fail (self->type != FP_PRINT_UNDEFINED, FALSE);
-  g_return_val_if_fail (other->type != FP_PRINT_UNDEFINED, FALSE);
+  g_return_val_if_fail (self->type != FPI_PRINT_UNDEFINED, FALSE);
+  g_return_val_if_fail (other->type != FPI_PRINT_UNDEFINED, FALSE);

  if (self->type != other->type)
    return FALSE;
@@ -807,13 +582,13 @@ fp_print_equal (FpPrint *self, FpPrint *other)
  if (g_strcmp0 (self->device_id, other->device_id))
    return FALSE;

-  if (self->type == FP_PRINT_RAW)
+  if (self->type == FPI_PRINT_RAW || self->type == FPI_PRINT_SDCP)
    {
      return g_variant_equal (self->data, other->data);
    }
-  else if (self->type == FP_PRINT_NBIS)
+  else if (self->type == FPI_PRINT_NBIS)
    {
-      gint i;
+      guint i;

      if (self->prints->len != other->prints->len)
        return FALSE;
@@ -835,7 +610,7 @@ fp_print_equal (FpPrint *self, FpPrint *other)
    }
 }

-#define FP_PRINT_VARIANT_TYPE G_VARIANT_TYPE ("(issbymsmsia{sv}v)")
+#define FPI_PRINT_VARIANT_TYPE G_VARIANT_TYPE ("(issbymsmsia{sv}v)")

 G_STATIC_ASSERT (sizeof (((struct xyt_struct *) NULL)->xcol[0]) == 4);

@@ -858,7 +633,7 @@ fp_print_serialize (FpPrint *print,
                    GError **error)
 {
  g_autoptr(GVariant) result = NULL;
-  GVariantBuilder builder = G_VARIANT_BUILDER_INIT (FP_PRINT_VARIANT_TYPE);
+  GVariantBuilder builder = G_VARIANT_BUILDER_INIT (FPI_PRINT_VARIANT_TYPE);
  gsize len;

  g_assert (data);
@@ -883,43 +658,33 @@ fp_print_serialize (FpPrint *print,
  g_variant_builder_close (&builder);

  /* Insert NBIS print data for type NBIS, otherwise the GVariant directly */
-  if (print->type == FP_PRINT_NBIS)
+  if (print->type == FPI_PRINT_NBIS)
    {
      GVariantBuilder nested = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("(a(aiaiai))"));
-      gint i;
+      guint i;

      g_variant_builder_open (&nested, G_VARIANT_TYPE ("a(aiaiai)"));
      for (i = 0; i < print->prints->len; i++)
        {
          struct xyt_struct *xyt = g_ptr_array_index (print->prints, i);
-          gint j;
-          gint32 *col = g_new (gint32, xyt->nrows);

          g_variant_builder_open (&nested, G_VARIANT_TYPE ("(aiaiai)"));

-          for (j = 0; j < xyt->nrows; j++)
-            col[j] = GINT32_TO_LE (xyt->xcol[j]);
          g_variant_builder_add_value (&nested,
                                       g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
-                                                                  col,
+                                                                  xyt->xcol,
                                                                  xyt->nrows,
-                                                                  sizeof (col[0])));
-
-          for (j = 0; j < xyt->nrows; j++)
-            col[j] = GINT32_TO_LE (xyt->ycol[j]);
+                                                                  sizeof (xyt->xcol[0])));
          g_variant_builder_add_value (&nested,
                                       g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
-                                                                  col,
+                                                                  xyt->ycol,
                                                                  xyt->nrows,
-                                                                  sizeof (col[0])));
-
-          for (j = 0; j < xyt->nrows; j++)
-            col[j] = GINT32_TO_LE (xyt->thetacol[j]);
+                                                                  sizeof (xyt->ycol[0])));
          g_variant_builder_add_value (&nested,
                                       g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
-                                                                  col,
+                                                                  xyt->thetacol,
                                                                  xyt->nrows,
-                                                                  sizeof (col[0])));
+                                                                  sizeof (xyt->thetacol[0])));
          g_variant_builder_close (&nested);
        }

@@ -976,18 +741,18 @@ fp_print_deserialize (const guchar *data,
  g_autoptr(FpPrint) result = NULL;
  g_autoptr(GVariant) raw_value = NULL;
  g_autoptr(GVariant) value = NULL;
+  g_autoptr(GVariant) print_data = NULL;
+  g_autoptr(GDate) date = NULL;
  guchar *aligned_data = NULL;
-  GDate *date = NULL;
  guint8 finger_int8;
  FpFinger finger;
  g_autofree gchar *username = NULL;
  g_autofree gchar *description = NULL;
  gint julian_date;
-  FpPrintType type;
+  FpiPrintType type;
  const gchar *driver;
  const gchar *device_id;
  gboolean device_stored;
-  GVariant *print_data;

  g_assert (data);
  g_assert (length > 3);
@@ -1005,9 +770,9 @@ fp_print_deserialize (const guchar *data,
   * longer. */
  aligned_data = g_malloc (length - 3);
  memcpy (aligned_data, data + 3, length - 3);
-  raw_value = g_variant_new_from_data (FP_PRINT_VARIANT_TYPE,
+  raw_value = g_variant_new_from_data (FPI_PRINT_VARIANT_TYPE,
                                       aligned_data, length - 3,
-                                       FALSE, g_free, NULL);
+                                       FALSE, g_free, aligned_data);

  if (!raw_value)
    goto invalid_format;
@@ -1018,7 +783,7 @@ fp_print_deserialize (const guchar *data,
    value = g_variant_get_normal_form (raw_value);

  g_variant_get (value,
-                 "(issbymsmsi@a{sv}v)",
+                 "(i&s&sbymsmsi@a{sv}v)",
                 &type,
                 &driver,
                 &device_id,
@@ -1033,20 +798,21 @@ fp_print_deserialize (const guchar *data,
  finger = finger_int8;

  /* Assume data is valid at this point if the values are somewhat sane. */
-  if (type == FP_PRINT_NBIS)
+  if (type == FPI_PRINT_NBIS)
    {
      g_autoptr(GVariant) prints = g_variant_get_child_value (print_data, 0);
-      gint i;
+      guint i;

      result = g_object_new (FP_TYPE_PRINT,
                             "driver", driver,
                             "device-id", device_id,
                             "device-stored", device_stored,
                             NULL);
-      fpi_print_set_type (result, FP_PRINT_NBIS);
+      g_object_ref_sink (result);
+      fpi_print_set_type (result, FPI_PRINT_NBIS);
      for (i = 0; i < g_variant_n_children (prints); i++)
        {
-          struct xyt_struct *xyt = g_new0 (struct xyt_struct, 1);
+          g_autofree struct xyt_struct *xyt = NULL;
          const gint32 *xcol, *ycol, *thetacol;
          gsize xlen, ylen, thetalen;
          g_autoptr(GVariant) xyt_data = NULL;
@@ -1072,25 +838,27 @@ fp_print_deserialize (const guchar *data,
          if (xlen > G_N_ELEMENTS (xyt->xcol))
            goto invalid_format;

+          xyt = g_new0 (struct xyt_struct, 1);
          xyt->nrows = xlen;
          memcpy (xyt->xcol, xcol, sizeof (xcol[0]) * xlen);
          memcpy (xyt->ycol, ycol, sizeof (xcol[0]) * xlen);
          memcpy (xyt->thetacol, thetacol, sizeof (xcol[0]) * xlen);

-          g_ptr_array_add (result->prints, xyt);
+          g_ptr_array_add (result->prints, g_steal_pointer (&xyt));
        }
    }
-  else if (type == FP_PRINT_RAW)
+  else if (type == FPI_PRINT_RAW || type == FPI_PRINT_SDCP)
    {
      g_autoptr(GVariant) fp_data = g_variant_get_child_value (print_data, 0);

      result = g_object_new (FP_TYPE_PRINT,
-                             "fp-type", type,
+                             "fpi-type", type,
                             "driver", driver,
                             "device-id", device_id,
                             "device-stored", device_stored,
-                             "fp-data", fp_data,
+                             "fpi-data", fp_data,
                             NULL);
+      g_object_ref_sink (result);
    }
  else
    {
@@ -1106,13 +874,10 @@ fp_print_deserialize (const guchar *data,
                "enroll_date", date,
                NULL);

-  g_date_free (date);
-
  return g_steal_pointer (&result);

 invalid_format:
-  *error = g_error_new_literal (G_IO_ERROR,
-                                G_IO_ERROR_INVALID_DATA,
-                                "Data could not be parsed");
-  return FALSE;
+  g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
+               "Data could not be parsed");
+  return NULL;
 }
@@ -28,6 +28,9 @@ G_BEGIN_DECLS
 #define FP_TYPE_PRINT (fp_print_get_type ())
 G_DECLARE_FINAL_TYPE (FpPrint, fp_print, FP, PRINT, GInitiallyUnowned)

+#define FP_FINGER_IS_VALID(finger) \
+  ((finger) >= FP_FINGER_FIRST && (finger) <= FP_FINGER_LAST)
+
 #include "fp-device.h"

 /**
@@ -43,6 +46,8 @@ G_DECLARE_FINAL_TYPE (FpPrint, fp_print, FP, PRINT, GInitiallyUnowned)
 * @FP_FINGER_RIGHT_MIDDLE: Right middle finger
 * @FP_FINGER_RIGHT_RING: Right ring finger
 * @FP_FINGER_RIGHT_LITTLE: Right little finger
+ * @FP_FINGER_FIRST: The first finger in the fp-print order
+ * @FP_FINGER_LAST: The last finger in the fp-print order
 */
 typedef enum {
  FP_FINGER_UNKNOWN = 0,
@@ -56,14 +61,24 @@ typedef enum {
  FP_FINGER_RIGHT_MIDDLE,
  FP_FINGER_RIGHT_RING,
  FP_FINGER_RIGHT_LITTLE,
+
+  FP_FINGER_FIRST = FP_FINGER_LEFT_THUMB,
+  FP_FINGER_LAST = FP_FINGER_RIGHT_LITTLE,
 } FpFinger;

-FpPrint *fp_print_new (FpDevice *device);
+/**
+ * FpFingerStatusFlags:
+ * @FP_FINGER_STATUS_NONE: Sensor has not the finger on it, nor requires it
+ * @FP_FINGER_STATUS_NEEDED: Sensor waits for the finger
+ * @FP_FINGER_STATUS_PRESENT: Sensor has the finger on it
+ */
+typedef enum {
+  FP_FINGER_STATUS_NONE    = 0,
+  FP_FINGER_STATUS_NEEDED  = 1 << 0,
+  FP_FINGER_STATUS_PRESENT = 1 << 1,
+} FpFingerStatusFlags;

-FpPrint *fp_print_new_from_data (guchar *data,
-                                 gsize   length);
-gboolean fp_print_to_data (guchar **data,
-                           gsize    length);
+FpPrint *fp_print_new (FpDevice *device);

 const gchar *fp_print_get_driver (FpPrint *print);
 const gchar *fp_print_get_device_id (FpPrint *print);
@@ -0,0 +1,58 @@
+/*
+ * FpSdcpDevice - A base class for SDCP enabled devices
+ * Copyright (C) 2020 Benjamin Berg <bberg@redhat.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
+ */
+
+#pragma once
+
+#include "fpi-sdcp-device.h"
+
+#include <nss.h>
+#include <keyhi.h>
+#include <keythi.h>
+#include <pk11pub.h>
+
+typedef struct
+{
+  GError *enroll_pre_commit_error;
+
+  /* XXX: Do we want a separate SDCP session object?
+   */
+
+  GPtrArray *intermediate_cas;
+
+  /* Host random for the connection */
+  guint8            host_random[32];
+
+  NSSInitContext   *nss_init_context;
+  PK11SlotInfo     *slot;
+  SECKEYPrivateKey *host_key_private;
+  SECKEYPublicKey  *host_key_public;
+
+  /* Master secret is required for reconnects.
+   * TODO: We probably want to serialize this to disk so it can survive
+   *       fprintd idle shutdown. */
+  PK11SymKey *master_secret;
+  PK11SymKey *mac_secret;
+
+} FpSdcpDevicePrivate;
+
+void fpi_sdcp_device_connect (FpSdcpDevice *self);
+void fpi_sdcp_device_reconnect (FpSdcpDevice *self);
+
+void fpi_sdcp_device_enroll (FpSdcpDevice *self);
+void fpi_sdcp_device_identify (FpSdcpDevice *self);
@@ -0,0 +1,141 @@
+/*
+ * FpSdcpDevice - A base class for SDCP enabled devices
+ * Copyright (C) 2020 Benjamin Berg <bberg@redhat.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 "sdcp_device"
+#include "fpi-log.h"
+
+#include "fp-sdcp-device-private.h"
+
+/**
+ * SECTION: fp-sdcp-device
+ * @title: FpSdcpDevice
+ * @short_description: SDCP device subclass
+ *
+ * This is a base class for devices implementing the SDCP security protocol.
+ */
+
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (FpSdcpDevice, fp_sdcp_device, FP_TYPE_DEVICE)
+
+#if 0
+/* XXX: We'll very likely want/need some properties on this class. */
+enum {
+  PROP_0,
+  N_PROPS
+};
+
+static GParamSpec *properties[N_PROPS];
+#endif
+
+/*******************************************************/
+
+/* Callbacks/vfuncs */
+static void
+fp_sdcp_device_open (FpDevice *device)
+{
+  FpSdcpDevice *self = FP_SDCP_DEVICE (device);
+  FpSdcpDevicePrivate *priv = fp_sdcp_device_get_instance_private (self);
+
+  /* Try a reconnect if we still have the mac secret. */
+  if (priv->mac_secret)
+    fpi_sdcp_device_reconnect (self);
+  else
+    fpi_sdcp_device_connect (self);
+}
+
+static void
+fp_sdcp_device_enroll (FpDevice *device)
+{
+  FpSdcpDevice *self = FP_SDCP_DEVICE (device);
+
+  fpi_sdcp_device_enroll (self);
+}
+
+static void
+fp_sdcp_device_identify (FpDevice *device)
+{
+  FpSdcpDevice *self = FP_SDCP_DEVICE (device);
+
+  fpi_sdcp_device_identify (self);
+}
+
+/*********************************************************/
+
+static void
+fp_sdcp_device_finalize (GObject *object)
+{
+  FpSdcpDevice *self = (FpSdcpDevice *) object;
+  FpSdcpDevicePrivate *priv = fp_sdcp_device_get_instance_private (self);
+
+  g_clear_pointer (&priv->intermediate_cas, g_ptr_array_unref);
+  g_clear_pointer (&priv->slot, PK11_FreeSlot);
+  g_clear_pointer (&priv->host_key_private, SECKEY_DestroyPrivateKey);
+  g_clear_pointer (&priv->host_key_public, SECKEY_DestroyPublicKey);
+  g_clear_pointer (&priv->master_secret, PK11_FreeSymKey);
+  g_clear_pointer (&priv->mac_secret, PK11_FreeSymKey);
+  g_clear_pointer (&priv->nss_init_context, NSS_ShutdownContext);
+
+  G_OBJECT_CLASS (fp_sdcp_device_parent_class)->finalize (object);
+}
+
+static void
+fp_sdcp_device_get_property (GObject    *object,
+                             guint       prop_id,
+                             GValue     *value,
+                             GParamSpec *pspec)
+{
+  switch (prop_id)
+    {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+fp_sdcp_device_constructed (GObject *obj)
+{
+  G_OBJECT_CLASS (fp_sdcp_device_parent_class)->constructed (obj);
+}
+
+static void
+fp_sdcp_device_class_init (FpSdcpDeviceClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  FpDeviceClass *fp_device_class = FP_DEVICE_CLASS (klass);
+
+  object_class->finalize = fp_sdcp_device_finalize;
+  object_class->get_property = fp_sdcp_device_get_property;
+  object_class->constructed = fp_sdcp_device_constructed;
+
+  fp_device_class->open = fp_sdcp_device_open;
+  fp_device_class->enroll = fp_sdcp_device_enroll;
+  fp_device_class->verify = fp_sdcp_device_identify;
+  fp_device_class->identify = fp_sdcp_device_identify;
+
+#if 0
+  g_object_class_install_properties (object_class, N_PROPS, properties);
+#endif
+}
+
+static void
+fp_sdcp_device_init (FpSdcpDevice *self)
+{
+  FpSdcpDevicePrivate *priv = fp_sdcp_device_get_instance_private (self);
+
+  priv->intermediate_cas = g_ptr_array_new_with_free_func ((GDestroyNotify) g_bytes_unref);
+}
@@ -0,0 +1,29 @@
+/*
+ * FpSdcpDevice - A base class for SDCP enabled devices
+ * Copyright (C) 2020 Benjamin Berg <bberg@redhat.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
+ */
+
+#pragma once
+
+#include <fp-device.h>
+
+G_BEGIN_DECLS
+
+#define FP_TYPE_SDCP_DEVICE (fp_sdcp_device_get_type ())
+G_DECLARE_DERIVABLE_TYPE (FpSdcpDevice, fp_sdcp_device, FP, SDCP_DEVICE, FpDevice)
+
+G_END_DECLS
@@ -21,7 +21,8 @@

 #define FP_COMPONENT "assembling"

-#include "fp_internal.h"
+#include "fpi-log.h"
+#include "fpi-image.h"

 #include <string.h>

@@ -51,6 +52,9 @@ calc_error (struct fpi_frame_asmbl_ctx *ctx,
  width = ctx->frame_width - (dx > 0 ? dx : -dx);
  height = ctx->frame_height - dy;

+  if (height == 0 || width == 0)
+    return INT_MAX;
+
  y1 = 0;
  y2 = dy;
  i = 0;
@@ -85,9 +89,6 @@ calc_error (struct fpi_frame_asmbl_ctx *ctx,
  err *= (ctx->frame_height * ctx->frame_width);
  err /= (height * width);

-  if (err == 0)
-    return INT_MAX;
-
  return err;
 }

@@ -98,6 +99,8 @@ static void
 find_overlap (struct fpi_frame_asmbl_ctx *ctx,
              struct fpi_frame           *first_frame,
              struct fpi_frame           *second_frame,
+              int                        *dx_out,
+              int                        *dy_out,
              unsigned int               *min_error)
 {
  int dx, dy;
@@ -119,8 +122,8 @@ find_overlap (struct fpi_frame_asmbl_ctx *ctx,
          if (err < *min_error)
            {
              *min_error = err;
-              second_frame->delta_x = -dx;
-              second_frame->delta_y = dy;
+              *dx_out = -dx;
+              *dy_out = dy;
            }
        }
    }
@@ -132,7 +135,7 @@ do_movement_estimation (struct fpi_frame_asmbl_ctx *ctx,
 {
  GSList *l;
  GTimer *timer;
-  guint num_frames = 0;
+  guint num_frames = 1;
  struct fpi_frame *prev_stripe;
  unsigned int min_error;
  /* Max error is width * height * 255, for AES2501 which has the largest
@@ -142,20 +145,27 @@ do_movement_estimation (struct fpi_frame_asmbl_ctx *ctx,
  unsigned long long total_error = 0;

  timer = g_timer_new ();
+
+  /* Skip the first frame */
  prev_stripe = stripes->data;
-  for (l = stripes; l != NULL; l = l->next, num_frames++)
+
+  for (l = stripes->next; l != NULL; l = l->next, num_frames++)
    {
      struct fpi_frame *cur_stripe = l->data;

      if (reverse)
        {
-          find_overlap (ctx, prev_stripe, cur_stripe, &min_error);
+          find_overlap (ctx, prev_stripe, cur_stripe,
+                        &cur_stripe->delta_x, &cur_stripe->delta_y,
+                        &min_error);
          cur_stripe->delta_y = -cur_stripe->delta_y;
          cur_stripe->delta_x = -cur_stripe->delta_x;
        }
      else
        {
-          find_overlap (ctx, cur_stripe, prev_stripe, &min_error);
+          find_overlap (ctx, cur_stripe, prev_stripe,
+                        &cur_stripe->delta_x, &cur_stripe->delta_y,
+                        &min_error);
        }
      total_error += min_error;

@@ -327,19 +337,10 @@ fpi_assemble_frames (struct fpi_frame_asmbl_ctx *ctx,
    {
      fpi_frame = l->data;

-      if(reverse)
-        {
-          y += fpi_frame->delta_y;
-          x += fpi_frame->delta_x;
-        }
+      y += fpi_frame->delta_y;
+      x += fpi_frame->delta_x;

      aes_blit_stripe (ctx, img, fpi_frame, x, y);
-
-      if(!reverse)
-        {
-          y += fpi_frame->delta_y;
-          x += fpi_frame->delta_x;
-        }
    }

  return img;
@@ -385,8 +386,10 @@ median_filter (int *data, int size, int filtersize)

 static void
 interpolate_lines (struct fpi_line_asmbl_ctx *ctx,
-                   GSList *line1, float y1, GSList *line2,
-                   float y2, unsigned char *output, float yi, int size)
+                   GSList *line1, gint32 y1_f,
+                   GSList *line2, gint32 y2_f,
+                   unsigned char *output, gint32 yi_f,
+                   int size)
 {
  int i;
  unsigned char p1, p2;
@@ -396,10 +399,12 @@ interpolate_lines (struct fpi_line_asmbl_ctx *ctx,

  for (i = 0; i < size; i++)
    {
+      gint unscaled;
      p1 = ctx->get_pixel (ctx, line1, i);
      p2 = ctx->get_pixel (ctx, line2, i);
-      output[i] = (float) p1
-                  + (yi - y1) / (y2 - y1) * (p2 - p1);
+
+      unscaled = (yi_f - y1_f) * p2 + (y2_f - yi_f) * p1;
+      output[i] = (unscaled) / (y2_f - y1_f);
    }
 }

@@ -424,7 +429,13 @@ fpi_assemble_lines (struct fpi_line_asmbl_ctx *ctx,
  /* Number of output lines per distance between two scanners */
  int i;
  GSList *row1, *row2;
-  float y = 0.0;
+  /* The y coordinate is tracked as a 16.16 fixed point number. All
+   * variables postfixed with _f follow this format here and in
+   * interpolate_lines.
+   * We could also use floating point here, but using fixed point means
+   * we get consistent results across architectures.
+   */
+  gint32 y_f = 0;
  int line_ind = 0;
  int *offsets = g_new0 (int, num_lines / 2);
  unsigned char *output = g_malloc0 (ctx->line_width * ctx->max_height);
@@ -476,21 +487,21 @@ fpi_assemble_lines (struct fpi_line_asmbl_ctx *ctx,
      int offset = offsets[i / 2];
      if (offset > 0)
        {
-          float ynext = y + (float) ctx->resolution / offset;
-          while (line_ind < ynext)
+          gint32 ynext_f = y_f + (ctx->resolution << 16) / offset;
+          while ((line_ind << 16) < ynext_f)
            {
              if (line_ind > ctx->max_height - 1)
                goto out;
              interpolate_lines (ctx,
-                                 row1, y,
+                                 row1, y_f,
                                 g_slist_next (row1),
-                                 ynext,
+                                 ynext_f,
                                 output + line_ind * ctx->line_width,
-                                 line_ind,
+                                 line_ind << 16,
                                 ctx->line_width);
              line_ind++;
            }
-          y = ynext;
+          y_f = ynext_f;
        }
    }
 out:
@@ -17,8 +17,7 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#ifndef __FPI_ASSEMBLING_H__
-#define __FPI_ASSEMBLING_H__
+#pragma once

 #include <fprint.h>

@@ -116,5 +115,3 @@ struct fpi_line_asmbl_ctx
 FpImage *fpi_assemble_lines (struct fpi_line_asmbl_ctx *ctx,
                             GSList                    *lines,
                             size_t                     num_lines);
-
-#endif
@@ -19,8 +19,7 @@
 * Boston, MA 02110-1301, USA.
 */

-#ifndef __FPI_BYTE_READER_H__
-#define __FPI_BYTE_READER_H__
+#pragma once

 #include <glib.h>
 #include "fpi-byte-utils.h"
@@ -676,5 +675,3 @@ fpi_byte_reader_skip_inline (FpiByteReader * reader, guint nbytes)
 #endif /* FPI_BYTE_READER_DISABLE_INLINES */

 G_END_DECLS
-
-#endif /* __FPI_BYTE_READER_H__ */
@@ -21,9 +21,7 @@
 * Boston, MA 02110-1301, USA.
 */

-
-#ifndef __FP_UTILS_H__
-#define __FP_UTILS_H__
+#pragma once

 #include <glib.h>

@@ -485,4 +483,3 @@ FP_WRITE_DOUBLE_BE(guint8 *data, gdouble num)
 G_END_DECLS

 #endif /* __GTK_DOC_IGNORE__ */
-#endif /* __FP_UTILS_H__ */
@@ -18,8 +18,7 @@
 * Boston, MA 02110-1301, USA.
 */

-#ifndef __FPI_BYTE_WRITER_H__
-#define __FPI_BYTE_WRITER_H__
+#pragma once

 #include "fpi-byte-reader.h"
 #include <string.h>
@@ -409,5 +408,3 @@ fpi_byte_writer_fill_inline (FpiByteWriter * writer, guint8 value, guint size)
 #endif

 G_END_DECLS
-
-#endif /* __FPI_BYTE_WRITER_H__ */
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 Benjamin Berg <bberg@redhat.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
+ */
+
+#pragma once
+
+#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  __GNUC__ > 10 || (__GNUC__ == 10 && __GNUC_MINOR__ >= 1)
+#define FP_GNUC_ACCESS(m, p, s) __attribute__((access (m, p, s)))
+#else
+#define FP_GNUC_ACCESS(m, p, s)
+#endif
@@ -20,14 +20,16 @@

 #include <gusb.h>
 #include "fp-context.h"
+#include "fpi-compat.h"

 /**
 * fpi_get_driver_types:
- * @drivers: #GArray to be filled with all driver types
 *
 * This function is purely for private used. It is solely part of the public
 * API as it is useful during build time.
 *
 * Stability: private
+ * Returns: (element-type GType) (transfer container): a #GArray filled with
+ *   all driver types
 */
-void fpi_get_driver_types (GArray *drivers);
+GArray *fpi_get_driver_types (void);
--- a/Show More
+++ b/Show More