WIP: shut-up uncrustify

Has 2 variants, one that supports identify, one that doesn't.

The mode of operation for this device is:
- Run fprintd with "FP_VIRTUAL_DEVICE=/tmp/fprint.socket"
- As root:
FP_VIRTUAL_DEVICE=/tmp/fprint.socket ./sendvirtcmd.py "ADD left-middle testuser success"
FP_VIRTUAL_DEVICE=/tmp/fprint.socket ./sendvirtcmd.py "ADD right-middle testuser failure"
- As testuser:
fprintd-enroll -f left-middle-finger
fprintd-enroll -f right-middle-finger

Now, across fprintd restarts (as it has its own storage), verification
will always succeed for user "testuser" with the "left-middle-finger".

Using the FP_VIRTUAL_DEVICE_IDENT envvar instead will allow
identification, with the first found "successful" finger being presented
as the identified one.

.gitignore

@@ -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

.gitlab-ci.yml

@@ -1,20 +1,22 @@
-variables:
-  FEDORA_TAG: rawhide
-  FEDORA_VERSION: rawhide
-  FEDORA_IMAGE: "$CI_REGISTRY/libfprint/$CI_PROJECT_NAME/fedora/$FEDORA_VERSION:$FEDORA_TAG"
-  BUNDLE: "org.freedesktop.libfprint.Demo.flatpak"
-  LAST_ABI_BREAK: "056ea541ddc97f5806cffbd99a12dc87e4da3546"
-
 include:
+  - local: '.gitlab-ci/libfprint-templates.yaml'
   - project: 'wayland/ci-templates'
     ref: master
     file: '/templates/fedora.yml'
 
+variables:
+  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
-  - flatpack
+  - flatpak
 
 image: "$FEDORA_IMAGE"
 
@@ -57,6 +59,7 @@ test:
     - ninja -C _build
     - 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
@@ -105,10 +108,7 @@ test_indent:
 
 .flatpak_master_template: &flatpak_master
     image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:3.32
-    stage: flatpack
-    except:
-      variables:
-        - $CI_PIPELINE_SOURCE == "schedule"
+    stage: flatpak
     variables:
         MANIFEST_PATH: "demo/org.freedesktop.libfprint.Demo.json"
         # From demo/org.freedesktop.libfprint.Demo.json
@@ -128,40 +128,19 @@ flatpak-manual master:
     <<: *flatpak_master
     when: manual
     except:
-      - tags
-      - master
+      refs:
+        - tags
+        - master
+      variables:
+        - $CI_PIPELINE_SOURCE == "schedule"
 
 # CONTAINERS creation stage
 container_fedora_build:
-  extends: .fedora@container-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
-    FEDORA_RPMS:
-      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
+    FDO_DISTRIBUTION_PACKAGES: $LIBFPRINT_DEPENDENCIES

.gitlab-ci/libfprint-templates.yaml

@@ -0,0 +1,26 @@
+.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

NEWS

@@ -1,6 +1,41 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
+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

doc/libfprint-sections.txt

@@ -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
@@ -129,7 +130,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 +160,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>
@@ -173,7 +176,7 @@ fpi_image_resize
 <SECTION>
 <FILE>fpi-image-device</FILE>
 <TITLE>FpImageDevice</TITLE>
-FpImageDeviceState
+FpiImageDeviceState
 FpImageDeviceClass
 fpi_image_device_session_error
 fpi_image_device_open_complete
@@ -197,13 +200,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>

doc/libfprint-sections.txt-new-manual

@@ -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>
-
-

doc/meson.build

@@ -4,7 +4,6 @@ private_headers = [
     'config.h',
     'nbis-helpers.h',
     'fprint.h',
-    'fp_internal.h',
 
     # Subdirectories to ignore
     'drivers',
@@ -24,16 +23,13 @@ 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',
+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,
-    scan_args: [
-        #'--rebuild-sections',
-        '--ignore-headers=' + ' '.join(private_headers),
-    ],
+    ignore_headers: private_headers,
     fixxref_args: [
         '--html-dir=@0@'.format(docpath),
         '--extra-dir=@0@'.format(join_paths(glib_docpath, 'glib')),

doc/xml/meson.build

@@ -1,8 +1,8 @@
 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())

examples/enroll.c

@@ -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);
 }
@@ -135,11 +142,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 +204,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);

examples/manage-prints.c

@@ -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>
@@ -197,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);
             }
         }
 

examples/sendvirtcmd.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+
+# This script can be used together with the virtual_imgdev to simulate an
+# image based fingerprint reader.
+#
+# To use, set the FP_VIRTUAL_IMAGE environment variable for both the
+# libfprint using program (e.g. fprintd) and this script.
+#
+# Usually this would work by adding it into the systemd unit file. The
+# best way of doing so is to create
+#  /etc/systemd/system/fprintd.service.d/fprintd-test.conf
+#
+# [Service]
+# RuntimeDirectory=fprint
+# Environment=FP_VIRTUAL_DEVICE=/run/fprint/virtdev_sock
+# Environment=G_MESSAGES_DEBUG=all
+# ReadWritePaths=$RUNTIME_DIR
+#
+# After that run:
+#
+#   systemctl daemon-reload
+#   systemctl restart fprintd.service
+#
+# You may also need to disable selinux.
+#
+# Then run this script with e.g.
+# FP_VIRTUAL_DEVICE=/run/fprint/virtdev_sock ./sendvirtimg.py "ADD <username> <finger> <success|failure>"
+
+
+
+import cairo
+import sys
+import os
+import socket
+import struct
+
+if len(sys.argv) != 2:
+    sys.stderr.write('You need to pass commands!\n')
+    sys.stderr.write('Usage: ./sendvirtimg.py "ADD <finger> <username> <success|failure>"\n')
+    sys.exit(1)
+
+command = sys.argv[1]
+
+# Send image through socket
+sockaddr = os.environ['FP_VIRTUAL_DEVICE']
+if not sockaddr:
+    sockaddr = os.environ['FP_VIRTUAL_DEVICE_IDENT']
+
+sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+sock.connect(sockaddr)
+
+sock.sendall(command.encode('utf-8'))
+

examples/storage.c

@@ -19,7 +19,10 @@
  * 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>
@@ -57,7 +60,7 @@ load_data (void)
 {
   GVariantDict *res;
   GVariant *var;
-  g_autofree gchar *contents = NULL;
+  gchar *contents = NULL;
   gsize length = 0;
 
   if (!g_file_get_contents (STORAGE_FILE, &contents, &length, NULL))
@@ -66,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);
@@ -129,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 ();
@@ -140,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)
@@ -156,8 +164,8 @@ 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);
@@ -167,7 +175,6 @@ 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;
 }
@@ -213,7 +220,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);

examples/storage.h

@@ -18,9 +18,7 @@
  * 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);
@@ -30,5 +28,3 @@ FpPrint * print_create_template (FpDevice *dev,
                                  FpFinger  finger);
 gboolean print_image_save (FpPrint    *print,
                            const char *path);
-
-#endif /* __STORAGE_H */

examples/utilities.c

@@ -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;
 }

examples/utilities.h

@@ -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 */

examples/verify.c

@@ -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);
 }
@@ -55,6 +62,19 @@ on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
   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,65 @@ 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_device_supports_capture (dev) &&
+      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 void
@@ -143,7 +193,7 @@ on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_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;
         }
 
@@ -151,28 +201,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;
     }
 
@@ -196,12 +250,13 @@ start_verification (FpDevice *dev, VerifyData *verify_data)
           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,
+                        NULL, NULL, NULL,
                         (GAsyncReadyCallback) on_verify_completed,
                         verify_data);
     }
@@ -217,7 +272,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;
     }
 
@@ -226,6 +281,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)
 {
@@ -256,8 +321,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);

libfprint/drivers/aes1610.c

@@ -138,7 +138,7 @@ generic_read_ignore_data (FpiSsm *ssm, FpDevice *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_full (transfer, EP_IN, data, bytes, g_free);
   transfer->ssm = ssm;
   transfer->short_is_error = TRUE;
   fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,

libfprint/drivers/aes1660.h

@@ -18,8 +18,7 @@
  * 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
 
@@ -1986,5 +1985,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

libfprint/drivers/aes2501.h

@@ -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 */

libfprint/drivers/aes2550.h

@@ -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

libfprint/drivers/aes2660.h

@@ -17,8 +17,7 @@
  * 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
 
@@ -1960,5 +1959,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

libfprint/drivers/aeslib.c

@@ -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

libfprint/drivers/aeslib.h

@@ -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

libfprint/drivers/elan.c

@@ -73,18 +73,18 @@ 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            deactivating;
+  FpiImageDeviceState dev_state;
+  FpiImageDeviceState 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;
   /* end state */
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceElan, fpi_device_elan, FPI, DEVICE_ELAN,
@@ -321,6 +321,8 @@ elan_submit_image (FpImageDevice *dev)
   fpi_do_movement_estimation (&assembling_ctx, frames);
   img = fpi_assemble_frames (&assembling_ctx, frames);
 
+  g_slist_free_full (frames, g_free);
+
   fpi_image_device_image_captured (dev, img);
 }
 
@@ -479,7 +481,7 @@ stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 
 
   /* The device is inactive at this point. */
-  self->dev_state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+  self->dev_state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
 
   if (self->deactivating)
     {
@@ -536,7 +538,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
       break;
 
     case CAPTURE_READ_DATA:
-      self->dev_state = FP_IMAGE_DEVICE_STATE_CAPTURE;
+      self->dev_state = FPI_IMAGE_DEVICE_STATE_CAPTURE;
 
       /* 0x55 - finger present
        * 0xff - device not calibrated (probably) */
@@ -547,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;
 
@@ -579,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) &&
@@ -729,7 +733,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;
 
@@ -771,7 +775,7 @@ calibrate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 
   if (error)
     {
-      self->dev_state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+      self->dev_state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
       fpi_image_device_session_error (FP_IMAGE_DEVICE (dev), error);
     }
   else
@@ -949,7 +953,7 @@ elan_change_state (FpImageDevice *idev)
 {
   FpDevice *dev = FP_DEVICE (idev);
   FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-  FpImageDeviceState next_state = self->dev_state_next;
+  FpiImageDeviceState next_state = self->dev_state_next;
 
   if (self->dev_state == next_state)
     {
@@ -963,18 +967,18 @@ elan_change_state (FpImageDevice *idev)
 
   switch (next_state)
     {
-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
       /* activation completed or another enroll stage started */
-      self->dev_state = FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
+      self->dev_state = FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
       elan_calibrate (dev);
       break;
 
-    case FP_IMAGE_DEVICE_STATE_CAPTURE:
+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:
       /* not used */
       break;
 
-    case FP_IMAGE_DEVICE_STATE_INACTIVE:
-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
       elan_stop_capture (dev);
       break;
     }
@@ -989,7 +993,7 @@ elan_change_state_async (FpDevice *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;
@@ -997,17 +1001,17 @@ dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
   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 (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
+    state = FPI_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: {
+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: {
         char *name;
 
         /* schedule state change instead of calling it directly to allow all actions
@@ -1024,7 +1028,7 @@ dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
         break;
       }
 
-    case FP_IMAGE_DEVICE_STATE_CAPTURE:
+    case FPI_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;
@@ -1042,7 +1046,7 @@ dev_deactivate (FpImageDevice *dev)
 
   G_DEBUG_HERE ();
 
-  if (self->dev_state == FP_IMAGE_DEVICE_STATE_INACTIVE)
+  if (self->dev_state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
     {
       /* The device is inactive already, complete the operation immediately. */
       fpi_image_device_deactivate_complete (dev, NULL);
@@ -1053,7 +1057,7 @@ dev_deactivate (FpImageDevice *dev)
        * 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);
+      dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);
     }
 }
 

libfprint/drivers/elan.h

@@ -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>
 
@@ -222,7 +221,5 @@ static void elan_cmd_read (FpiSsm   *ssm,
 static void elan_calibrate (FpDevice *dev);
 static void elan_capture (FpDevice *dev);
 
-static void dev_change_state (FpImageDevice     *dev,
-                              FpImageDeviceState state);
-
-#endif
+static void dev_change_state (FpImageDevice      *dev,
+                              FpiImageDeviceState state);

libfprint/drivers/etes603.c

@@ -859,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);
         }

libfprint/drivers/synaptics/bmkt.h

@@ -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_ */

libfprint/drivers/synaptics/bmkt_message.h

@@ -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_ */

libfprint/drivers/synaptics/bmkt_response.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_ */

libfprint/drivers/synaptics/sensor.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_ */

libfprint/drivers/synaptics/synaptics.c

@@ -35,7 +35,7 @@ static const FpIdEntry id_table[] = {
 
 
 static void
-cmd_recieve_cb (FpiUsbTransfer *transfer,
+cmd_receive_cb (FpiUsbTransfer *transfer,
                 FpDevice       *device,
                 gpointer        user_data,
                 GError         *error)
@@ -234,7 +234,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;
@@ -279,17 +279,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);
 }
 
 static void
@@ -328,7 +321,7 @@ 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)
     {
@@ -517,45 +510,12 @@ list_msg_cb (FpiDeviceSynaptics *self,
                                 get_enroll_templates_resp->templates[n].finger_id,
                                 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", 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);
-            }
+          fpi_print_fill_from_user_id (print, userid);
 
           g_ptr_array_add (self->list_result, g_object_ref_sink (print));
         }
@@ -582,6 +542,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,
@@ -592,16 +568,13 @@ 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;
     }
 
@@ -620,39 +593,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);
+      fpi_device_verify_complete (device, NULL);
       break;
     }
 }
@@ -670,13 +644,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;
     }
@@ -726,7 +698,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)
@@ -791,8 +763,6 @@ enroll_msg_cb (FpiDeviceSynaptics *self,
     }
 }
 
-#define TEMPLATE_ID_SIZE 20
-
 static void
 enroll (FpDevice *device)
 {
@@ -800,52 +770,21 @@ enroll (FpDevice *device)
   FpPrint *print = NULL;
   GVariant *data = NULL;
   GVariant *uid = NULL;
-  const gchar *username;
   guint finger;
   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 = g_date_get_year (date);
-      m = g_date_get_month (date);
-      d = g_date_get_day (date);
-    }
-  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,
@@ -856,9 +795,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);
@@ -927,7 +866,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))
     {
@@ -969,10 +908,10 @@ dev_probe (FpDevice *device)
       return;
     }
 
-  if (!g_usb_device_reset (fpi_device_get_usb_device (device), &error))
+  if (!g_usb_device_reset (usb_dev, &error))
     goto err_close;
 
-  if (!g_usb_device_claim_interface (fpi_device_get_usb_device (device), 0, 0, &error))
+  if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
     goto err_close;
 
   /* TODO: Do not do this synchronous. */
@@ -1025,7 +964,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;
     }

libfprint/drivers/synaptics/synaptics.h

@@ -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,6 @@ struct _FpiDeviceSynaptics
   FpiSsm               *cmd_ssm;
   FpiUsbTransfer       *cmd_pending_transfer;
   gboolean              cmd_complete_on_removal;
-  GError               *cmd_complete_error;
-  void                 *cmd_complete_data;
 
   bmkt_sensor_version_t mis_version;
 
@@ -126,5 +123,3 @@ struct _FpiDeviceSynaptics
   struct syna_enroll_resp_data enroll_resp_data;
   syna_state_t                 state;
 };
-
-#endif //__synaptics_h__

libfprint/drivers/upektc.h

@@ -19,8 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef __UPEKTC_H
-#define __UPEKTC_H
+#pragma once
 
 #define UPEKTC_CMD_LEN 0x40
 #define IMAGE_WIDTH 208
@@ -1936,5 +1935,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

libfprint/drivers/upektc_img.h

@@ -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

libfprint/drivers/upekts.c

@@ -902,8 +902,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,
@@ -1117,7 +1119,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);
 
@@ -1126,7 +1127,7 @@ e_handle_resp02 (FpDevice *dev, unsigned char *data,
                                            data_len - sizeof (scan_comp),
                                            1);
 
-      g_object_set (print, "fp-data", fp_data, NULL);
+      g_object_set (print, "fpi-data", fp_data, NULL);
       g_object_ref (print);
     }
 
@@ -1225,8 +1226,7 @@ enroll (FpDevice *dev)
 
 typedef struct
 {
-  FpiMatchResult res;
-  GError        *error;
+  GError *error;
 } VerifyStopData;
 
 static void
@@ -1244,7 +1244,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);
+  if (data->error)
+    fpi_device_verify_complete (dev, data->error);
+  else
+    fpi_device_verify_complete (dev, g_steal_pointer (&error));
+
+  g_error_free (error);
 }
 
 static void
@@ -1253,8 +1258,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);
@@ -1293,7 +1301,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 (dev, "fpi-data", &fp_data, NULL);
 
       data = g_variant_get_fixed_array (fp_data, &data_len, 1);
 

libfprint/drivers/uru4000.c

@@ -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;
 
@@ -408,16 +408,16 @@ 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:
+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:
       break;
 
     default:
@@ -773,7 +773,7 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
         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);
@@ -1176,7 +1176,7 @@ deactivate_write_reg_cb (FpiUsbTransfer *transfer, FpDevice *dev,
 static void
 dev_deactivate (FpImageDevice *dev)
 {
-  dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE);
+  dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);
 }
 
 static void
@@ -1187,7 +1187,7 @@ execute_state_change (FpImageDevice *dev)
 
   switch (self->activate_state)
     {
-    case FP_IMAGE_DEVICE_STATE_INACTIVE:
+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
       fp_dbg ("deactivating");
       self->irq_cb = NULL;
       self->irq_cb_data = NULL;
@@ -1195,7 +1195,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))
         {
@@ -1209,7 +1209,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;
 
@@ -1229,7 +1229,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))
         {

libfprint/drivers/vfs0050.c

@@ -119,7 +119,7 @@ async_abort_callback (FpiUsbTransfer *transfer, FpDevice *device,
   /* In normal case endpoint is empty */
   if (g_error_matches (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_TIMED_OUT))
     {
-      g_free (error);
+      g_error_free (error);
       fpi_ssm_next_state (transfer->ssm);
       return;
     }

libfprint/drivers/vfs5011_proto.h

@@ -1,5 +1,4 @@
-#ifndef __VFS5011_PROTO_H
-#define __VFS5011_PROTO_H
+#pragma once
 
 #define VFS5011_LINE_SIZE 240
 #define VFS5011_IMAGE_WIDTH 160
@@ -6182,5 +6181,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

libfprint/drivers/virtual-device.c

@@ -0,0 +1,456 @@
+/*
+ * 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.
+ */
+
+#define FP_COMPONENT "virtual_device"
+
+#include "fpi-log.h"
+
+#include "../fpi-device.h"
+
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+#include <gio/gunixsocketaddress.h>
+
+#define MAX_LINE_LEN 1024
+
+enum {
+  VIRTUAL_DEVICE,
+  VIRTUAL_DEVICE_IDENT
+};
+
+struct _FpDeviceVirtualDevice
+{
+  FpDevice           parent;
+
+  GSocketListener   *listener;
+  GSocketConnection *connection;
+  GCancellable      *cancellable;
+
+  gint               socket_fd;
+  gint               client_fd;
+  guint              line[MAX_LINE_LEN];
+
+  GHashTable        *pending_prints; /* key: finger+username value: gboolean */
+};
+
+G_DECLARE_FINAL_TYPE (FpDeviceVirtualDevice, fpi_device_virtual_device, FP, DEVICE_VIRTUAL_DEVICE, FpDevice)
+G_DEFINE_TYPE (FpDeviceVirtualDevice, fpi_device_virtual_device, FP_TYPE_DEVICE)
+
+static void start_listen (FpDeviceVirtualDevice *self);
+
+#define ADD_CMD_PREFIX "ADD "
+
+static FpFinger
+str_to_finger (const char *str)
+{
+  g_autoptr(GEnumClass) eclass;
+  GEnumValue *value;
+
+  eclass = g_type_class_ref (FP_TYPE_FINGER);
+  value = g_enum_get_value_by_nick (eclass, str);
+
+  if (value == NULL)
+    return FP_FINGER_UNKNOWN;
+
+  return value->value;
+}
+
+static const char *
+finger_to_str (FpFinger finger)
+{
+  GEnumClass *eclass;
+  GEnumValue *value;
+
+  eclass = g_type_class_ref (FP_TYPE_FINGER);
+  value = g_enum_get_value (eclass, finger);
+  g_type_class_unref (eclass);
+
+  if (value == NULL)
+    return NULL;
+
+  return value->value_nick;
+}
+
+static gboolean
+parse_code (const char *str)
+{
+  if (g_strcmp0 (str, "1") == 0 ||
+      g_strcmp0 (str, "success") == 0 ||
+      g_strcmp0 (str, "SUCCESS") == 0 ||
+      g_strcmp0 (str, "FPI_MATCH_SUCCESS") == 0)
+    return FPI_MATCH_SUCCESS;
+
+  return FPI_MATCH_FAIL;
+}
+
+static void
+handle_command_line (FpDeviceVirtualDevice *self,
+                     const char            *line)
+{
+  if (g_str_has_prefix (line, ADD_CMD_PREFIX))
+    {
+      g_auto(GStrv) elems;
+      FpPrint *print;
+      FpFinger finger;
+      gboolean success;
+      g_autofree char *description = NULL;
+      char *key;
+
+      /* Syntax: ADD <finger> <username> <error when used> */
+      elems = g_strsplit (line + strlen (ADD_CMD_PREFIX), " ", 3);
+      if (g_strv_length (elems) != 3)
+        {
+          g_warning ("Malformed command: %s", line);
+          return;
+        }
+      finger = str_to_finger (elems[0]);
+      if (finger == FP_FINGER_UNKNOWN)
+        {
+          g_warning ("Unknown finger '%s'", elems[0]);
+          return;
+        }
+      print = fp_print_new (FP_DEVICE (self));
+      fp_print_set_finger (print, finger);
+      fp_print_set_username (print, elems[1]);
+      description = g_strdup_printf ("Fingerprint finger '%s' for user '%s'",
+                                     elems[0], elems[1]);
+      fp_print_set_description (print, description);
+      success = parse_code (elems[2]);
+
+      key = g_strdup_printf ("%s-%s", elems[0], elems[1]);
+      g_hash_table_insert (self->pending_prints,
+                           key, GINT_TO_POINTER (success));
+
+      fp_dbg ("Added pending print %s for user %s (code: %s)",
+              elems[0], elems[1], success ? "FPI_MATCH_SUCCESS" : "FPI_MATCH_FAIL");
+    }
+  else
+    {
+      g_warning ("Unhandled command sent: '%s'", line);
+    }
+}
+
+static void
+recv_instruction_cb (GObject      *source_object,
+                     GAsyncResult *res,
+                     gpointer      user_data)
+{
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualDevice *self;
+  gboolean success;
+  gsize bytes;
+
+  success = g_input_stream_read_all_finish (G_INPUT_STREAM (source_object), res, &bytes, &error);
+
+  if (!success || bytes == 0)
+    {
+      if (!success)
+        {
+          if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ||
+              g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CLOSED))
+            return;
+          g_warning ("Error receiving instruction data: %s", error->message);
+        }
+
+      self = FP_DEVICE_VIRTUAL_DEVICE (user_data);
+      goto out;
+    }
+
+  self = FP_DEVICE_VIRTUAL_DEVICE (user_data);
+  handle_command_line (self, (const char *) self->line);
+
+out:
+  g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
+  g_clear_object (&self->connection);
+
+  start_listen (self);
+}
+
+static void
+recv_instruction (FpDeviceVirtualDevice *self,
+                  GInputStream          *stream)
+{
+  memset (&self->line, 0, sizeof (self->line));
+  g_input_stream_read_all_async (stream,
+                                 self->line,
+                                 sizeof (self->line),
+                                 G_PRIORITY_DEFAULT,
+                                 self->cancellable,
+                                 recv_instruction_cb,
+                                 self);
+}
+
+static void
+new_connection_cb (GObject      *source_object,
+                   GAsyncResult *res,
+                   gpointer      user_data)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(GSocketConnection) connection = NULL;
+  GInputStream *stream;
+  FpDeviceVirtualDevice *self = user_data;
+
+  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 further connections (but we disconnect them immediately
+   * if we already have a connection). */
+  if (self->connection)
+    {
+      g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
+      start_listen (self);
+      return;
+    }
+
+  self->connection = g_steal_pointer (&connection);
+  stream = g_io_stream_get_input_stream (G_IO_STREAM (connection));
+
+  recv_instruction (self, stream);
+
+  fp_dbg ("Got a new connection!");
+}
+
+static void
+start_listen (FpDeviceVirtualDevice *self)
+{
+  fp_dbg ("Starting a new listener");
+  g_socket_listener_accept_async (self->listener,
+                                  self->cancellable,
+                                  new_connection_cb,
+                                  self);
+}
+
+static void
+dev_init (FpDevice *dev)
+{
+  fpi_device_open_complete (dev, NULL);
+}
+
+static void
+dev_verify (FpDevice *dev)
+{
+  FpPrint *print;
+
+  g_autoptr(GVariant) data = NULL;
+  gboolean success;
+
+  fpi_device_get_verify_data (dev, &print);
+  g_object_get (print, "fpi-data", &data, NULL);
+  success = g_variant_get_boolean (data);
+
+  fpi_device_verify_report (dev,
+                            success ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL,
+                            NULL, NULL);
+  fpi_device_verify_complete (dev, NULL);
+}
+
+static void
+dev_enroll (FpDevice *dev)
+{
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
+  gpointer success_ptr;
+  FpPrint *print = NULL;
+  g_autofree char *key = NULL;
+
+  fpi_device_get_enroll_data (dev, &print);
+  key = g_strdup_printf ("%s-%s",
+                         finger_to_str (fp_print_get_finger (print)),
+                         fp_print_get_username (print));
+
+  if (g_hash_table_lookup_extended (self->pending_prints, key, NULL, &success_ptr))
+    {
+      gboolean success = GPOINTER_TO_INT (success_ptr);
+      GVariant *fp_data;
+
+      fp_data = g_variant_new_boolean (success);
+      fpi_print_set_type (print, FPI_PRINT_RAW);
+      if (fpi_device_get_driver_data (dev) == VIRTUAL_DEVICE_IDENT)
+        fpi_print_set_device_stored (print, TRUE);
+      g_object_set (print, "fpi-data", fp_data, NULL);
+      fpi_device_enroll_complete (dev, g_object_ref (print), NULL);
+    }
+  else
+    {
+      fpi_device_enroll_complete (dev, NULL,
+                                  fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                            "No pending result for this username/finger combination"));
+    }
+}
+
+static void
+dev_deinit (FpDevice *dev)
+{
+  fpi_device_close_complete (dev, NULL);
+}
+
+static gboolean
+dev_supports_identify (FpDevice *dev)
+{
+  return fpi_device_get_driver_data (dev) == VIRTUAL_DEVICE_IDENT;
+}
+
+static void
+dev_identify (FpDevice *dev)
+{
+  GPtrArray *templates;
+  FpPrint *result = NULL;
+  guint i;
+
+  g_assert (fpi_device_get_driver_data (dev) == VIRTUAL_DEVICE_IDENT);
+
+  fpi_device_get_identify_data (dev, &templates);
+
+  for (i = 0; i < templates->len; i++)
+    {
+      FpPrint *template = g_ptr_array_index (templates, i);
+      g_autoptr(GVariant) data = NULL;
+      gboolean success;
+
+      g_object_get (dev, "fpi-data", &template, NULL);
+      success = g_variant_get_boolean (data);
+      if (success)
+        {
+          result = template;
+          break;
+        }
+    }
+
+  if (result)
+    fpi_device_identify_report (dev, result, NULL, NULL);
+  fpi_device_identify_complete (dev, NULL);
+}
+
+static void
+fpi_device_virtual_device_finalize (GObject *object)
+{
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (object);
+
+  G_DEBUG_HERE ();
+
+  g_cancellable_cancel (self->cancellable);
+  g_clear_object (&self->cancellable);
+  g_clear_object (&self->listener);
+  g_clear_object (&self->connection);
+  g_hash_table_destroy (self->pending_prints);
+}
+
+static void
+fpi_device_virtual_device_constructed (GObject *object)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(GSocketListener) listener = NULL;
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (object);
+  const char *env;
+  g_autoptr(GSocketAddress) addr = NULL;
+  G_DEBUG_HERE ();
+
+  self->client_fd = -1;
+
+  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))
+    {
+      g_warning ("Could not listen on unix socket: %s", error->message);
+
+      fpi_device_open_complete (FP_DEVICE (self), g_steal_pointer (&error));
+
+      return;
+    }
+
+  self->listener = g_steal_pointer (&listener);
+  self->cancellable = g_cancellable_new ();
+  self->pending_prints = g_hash_table_new_full (g_str_hash,
+                                                g_str_equal,
+                                                g_free,
+                                                NULL);
+
+  if (G_OBJECT_CLASS (fpi_device_virtual_device_parent_class)->constructed)
+    G_OBJECT_CLASS (fpi_device_virtual_device_parent_class)->constructed (object);
+
+  start_listen (self);
+}
+
+static void
+fpi_device_virtual_device_init (FpDeviceVirtualDevice *self)
+{
+}
+
+static const FpIdEntry driver_ids[] = {
+  { .virtual_envvar = "FP_VIRTUAL_DEVICE", .driver_data = VIRTUAL_DEVICE },
+  { .virtual_envvar = "FP_VIRTUAL_DEVICE_IDENT", .driver_data = VIRTUAL_DEVICE_IDENT },
+  { .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->constructed = fpi_device_virtual_device_constructed;
+  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->identify = dev_identify;
+  dev_class->supports_identify = dev_supports_identify;
+}

libfprint/drivers/virtual-image.c

@@ -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.
  */
 
@@ -215,6 +215,7 @@ new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data
 
       g_warning ("Error accepting a new connection: %s", error->message);
       start_listen (dev);
+      return;
     }
 
   /* Always further connections (but we disconnect them immediately
@@ -277,7 +278,7 @@ dev_init (FpImageDevice *dev)
     {
       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;
     }

libfprint/drivers_api.h

@@ -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

libfprint/fp-context.c

@@ -94,22 +94,21 @@ 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_emit (context, signals[DEVICE_ADDED_SIGNAL], 0, device);
 }
@@ -131,8 +130,7 @@ 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);
-      g_autoptr(GTypeClass) type_class = g_type_class_ref (driver);
-      FpDeviceClass *cls = FP_DEVICE_CLASS (type_class);
+      g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
       const FpIdEntry *entry;
 
       if (cls->type != FP_DEVICE_TYPE_USB)
@@ -160,7 +158,7 @@ usb_device_added_cb (FpContext *self, GUsbDevice *device, GUsbContext *usb_ctx)
 
   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;
     }
 
@@ -170,8 +168,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);
 }
 
@@ -276,8 +274,7 @@ fp_context_init (FpContext *self)
       for (i = 0; i < priv->drivers->len;)
         {
           GType driver = g_array_index (priv->drivers, GType, i);
-          g_autoptr(GTypeClass) type_class = g_type_class_ref (driver);
-          FpDeviceClass *cls = FP_DEVICE_CLASS (type_class);
+          g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
 
           if (!is_driver_allowed (cls->id))
             g_array_remove_index (priv->drivers, i);
@@ -351,8 +348,7 @@ fp_context_enumerate (FpContext *context)
   for (i = 0; i < priv->drivers->len; i++)
     {
       GType driver = g_array_index (priv->drivers, GType, i);
-      g_autoptr(GTypeClass) type_class = g_type_class_ref (driver);
-      FpDeviceClass *cls = FP_DEVICE_CLASS (type_class);
+      g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
       const FpIdEntry *entry;
 
       if (cls->type != FP_DEVICE_TYPE_VIRTUAL)
@@ -373,8 +369,8 @@ 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");
         }

libfprint/fp-device-private.h

@@ -41,7 +41,7 @@ typedef struct
   GSList      *sources;
 
   /* We always make sure that only one task is run at a time. */
-  FpDeviceAction      current_action;
+  FpiDeviceAction     current_action;
   GTask              *current_task;
   GAsyncReadyCallback current_user_cb;
   gulong              current_cancellable_id;
@@ -63,3 +63,20 @@ typedef struct
 } 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);

libfprint/fp-device.c

@@ -28,7 +28,7 @@
  * @title: Internal FpDevice
  * @short_description: Internal device routines
  *
- * The methods that are availabe for drivers to manipulate a device. See
+ * The methods that are available for drivers to manipulate a device. See
  * #FpDeviceClass for more information. Also note that most of these are
  * not relevant for image based devices, see #FpImageDeviceClass in that
  * case.
@@ -81,7 +81,7 @@ fp_device_cancel_in_idle_cb (gpointer user_data)
   FpDevicePrivate *priv = fp_device_get_instance_private (self);
 
   g_assert (cls->cancel);
-  g_assert (priv->current_action != FP_DEVICE_ACTION_NONE);
+  g_assert (priv->current_action != FPI_DEVICE_ACTION_NONE);
 
   g_debug ("Idle cancelling on ongoing operation!");
 
@@ -148,7 +148,7 @@ fp_device_finalize (GObject *object)
   FpDevice *self = (FpDevice *) object;
   FpDevicePrivate *priv = fp_device_get_instance_private (self);
 
-  g_assert (priv->current_action == FP_DEVICE_ACTION_NONE);
+  g_assert (priv->current_action == FPI_DEVICE_ACTION_NONE);
   g_assert (priv->current_task == NULL);
   if (priv->is_open)
     g_warning ("User destroyed open device! Not cleaning up properly!");
@@ -268,7 +268,7 @@ fp_device_async_initable_init_async (GAsyncInitable     *initable,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_PROBE;
+  priv->current_action = FPI_DEVICE_ACTION_PROBE;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (self, cancellable);
 
@@ -339,25 +339,46 @@ fp_device_class_init (FpDeviceClass *klass)
   properties[PROP_OPEN] =
     g_param_spec_boolean ("open",
                           "Opened",
-                          "Wether the device is open or not", FALSE,
+                          "Whether the device is open or not", FALSE,
                           G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
 
+  /**
+   * FpDevice::fpi-environ: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
   properties[PROP_FPI_ENVIRON] =
-    g_param_spec_string ("fp-environ",
+    g_param_spec_string ("fpi-environ",
                          "Virtual Environment",
                          "Private: The environment variable for the virtual device",
                          NULL,
                          G_PARAM_STATIC_STRINGS | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
 
+  /**
+   * FpDevice::fpi-usb-device: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
   properties[PROP_FPI_USB_DEVICE] =
-    g_param_spec_object ("fp-usb-device",
+    g_param_spec_object ("fpi-usb-device",
                          "USB Device",
                          "Private: The USB device for the device",
                          G_USB_TYPE_DEVICE,
                          G_PARAM_STATIC_STRINGS | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
 
+  /**
+   * FpDevice::fpi-driver-data: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
   properties[PROP_FPI_DRIVER_DATA] =
-    g_param_spec_uint64 ("fp-driver-data",
+    g_param_spec_uint64 ("fpi-driver-data",
                          "Driver Data",
                          "Private: The driver data from the ID table entry",
                          0,
@@ -486,6 +507,9 @@ fp_device_supports_identify (FpDevice *device)
 
   g_return_val_if_fail (FP_IS_DEVICE (device), FALSE);
 
+  if (cls->supports_identify != NULL)
+    return cls->supports_identify (device);
+
   return cls->identify != NULL;
 }
 
@@ -584,7 +608,7 @@ fp_device_open (FpDevice           *device,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_OPEN;
+  priv->current_action = FPI_DEVICE_ACTION_OPEN;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
@@ -648,7 +672,7 @@ fp_device_close (FpDevice           *device,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_CLOSE;
+  priv->current_action = FPI_DEVICE_ACTION_CLOSE;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
@@ -709,7 +733,7 @@ fp_device_enroll (FpDevice           *device,
   g_autoptr(GTask) task = NULL;
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
   FpEnrollData *data;
-  FpPrintType print_type;
+  FpiPrintType print_type;
 
   task = g_task_new (device, cancellable, callback, user_data);
   if (g_task_return_error_if_cancelled (task))
@@ -737,8 +761,8 @@ fp_device_enroll (FpDevice           *device,
       return;
     }
 
-  g_object_get (template_print, "fp-type", &print_type, NULL);
-  if (print_type != FP_PRINT_UNDEFINED)
+  g_object_get (template_print, "fpi-type", &print_type, NULL);
+  if (print_type != FPI_PRINT_UNDEFINED)
     {
       g_warning ("Passed print template must be newly created and blank!");
       g_task_return_error (task,
@@ -746,7 +770,7 @@ fp_device_enroll (FpDevice           *device,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_ENROLL;
+  priv->current_action = FPI_DEVICE_ACTION_ENROLL;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
@@ -754,6 +778,7 @@ fp_device_enroll (FpDevice           *device,
   data->print = g_object_ref_sink (template_print);
   data->enroll_progress_cb = progress_cb;
   data->enroll_progress_data = progress_data;
+  data->enroll_progress_destroy = progress_destroy;
 
   // Attach the progress data as task data so that it is destroyed
   g_task_set_task_data (priv->current_task, data, (GDestroyNotify) enroll_data_free);
@@ -787,10 +812,13 @@ fp_device_enroll_finish (FpDevice     *device,
  * @device: a #FpDevice
  * @enrolled_print: a #FpPrint to verify
  * @cancellable: (nullable): a #GCancellable, or %NULL
+ * @match_cb: (nullable) (scope notified): match reporting callback
+ * @match_data: (closure match_cb): user data for @match_cb
+ * @match_destroy: (destroy match_data): Destroy notify for @match_data
  * @callback: the function to call on completion
  * @user_data: the data to pass to @callback
  *
- * Start an asynchronous operation to close the device. The callback will
+ * Start an asynchronous operation to verify a print. The callback will
  * be called once the operation has finished. Retrieve the result with
  * fp_device_verify_finish().
  */
@@ -798,11 +826,15 @@ 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)
 {
   g_autoptr(GTask) task = NULL;
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpMatchData *data;
 
   task = g_task_new (device, cancellable, callback, user_data);
   if (g_task_return_error_if_cancelled (task))
@@ -822,13 +854,18 @@ fp_device_verify (FpDevice           *device,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_VERIFY;
+  priv->current_action = FPI_DEVICE_ACTION_VERIFY;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
-  g_task_set_task_data (priv->current_task,
-                        g_object_ref (enrolled_print),
-                        g_object_unref);
+  data = g_new0 (FpMatchData, 1);
+  data->enrolled_print = g_object_ref (enrolled_print);
+  data->match_cb = match_cb;
+  data->match_data = match_data;
+  data->match_destroy = match_destroy;
+
+  // Attach the match data as task data so that it is destroyed
+  g_task_set_task_data (priv->current_task, data, (GDestroyNotify) match_data_free);
 
   FP_DEVICE_GET_CLASS (device)->verify (device);
 }
@@ -864,7 +901,11 @@ fp_device_verify_finish (FpDevice     *device,
 
   if (print)
     {
-      *print = g_object_get_data (G_OBJECT (result), "print");
+      FpMatchData *data;
+
+      data = g_task_get_task_data (G_TASK (result));
+
+      *print = data->print;
       if (*print)
         g_object_ref (*print);
     }
@@ -880,6 +921,9 @@ fp_device_verify_finish (FpDevice     *device,
  * @device: a #FpDevice
  * @prints: (element-type FpPrint) (transfer none): #GPtrArray of #FpPrint
  * @cancellable: (nullable): a #GCancellable, or %NULL
+ * @match_cb: (nullable) (scope notified): match reporting callback
+ * @match_data: (closure match_cb): user data for @match_cb
+ * @match_destroy: (destroy match_data): Destroy notify for @match_data
  * @callback: the function to call on completion
  * @user_data: the data to pass to @callback
  *
@@ -891,16 +935,27 @@ void
 fp_device_identify (FpDevice           *device,
                     GPtrArray          *prints,
                     GCancellable       *cancellable,
+                    FpMatchCb           match_cb,
+                    gpointer            match_data,
+                    GDestroyNotify      match_destroy,
                     GAsyncReadyCallback callback,
                     gpointer            user_data)
 {
   g_autoptr(GTask) task = NULL;
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpMatchData *data;
 
   task = g_task_new (device, cancellable, callback, user_data);
   if (g_task_return_error_if_cancelled (task))
     return;
 
+  if (!fp_device_supports_identify (device))
+    {
+      g_task_return_error (task,
+                           fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED));
+      return;
+    }
+
   if (!priv->is_open)
     {
       g_task_return_error (task,
@@ -915,13 +970,18 @@ fp_device_identify (FpDevice           *device,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_IDENTIFY;
+  priv->current_action = FPI_DEVICE_ACTION_IDENTIFY;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
-  g_task_set_task_data (priv->current_task,
-                        g_ptr_array_ref (prints),
-                        (GDestroyNotify) g_ptr_array_unref);
+  data = g_new0 (FpMatchData, 1);
+  data->gallery = g_ptr_array_ref (prints);
+  data->match_cb = match_cb;
+  data->match_data = match_data;
+  data->match_destroy = match_destroy;
+
+  // Attach the match data as task data so that it is destroyed
+  g_task_set_task_data (priv->current_task, data, (GDestroyNotify) match_data_free);
 
   FP_DEVICE_GET_CLASS (device)->identify (device);
 }
@@ -952,15 +1012,19 @@ fp_device_identify_finish (FpDevice     *device,
                            FpPrint     **print,
                            GError      **error)
 {
+  FpMatchData *data;
+
+  data = g_task_get_task_data (G_TASK (result));
+
   if (print)
     {
-      *print = g_object_get_data (G_OBJECT (result), "print");
+      *print = data->print;
       if (*print)
         g_object_ref (*print);
     }
   if (match)
     {
-      *match = g_object_get_data (G_OBJECT (result), "match");
+      *match = data->match;
       if (*match)
         g_object_ref (*match);
     }
@@ -1008,7 +1072,7 @@ fp_device_capture (FpDevice           *device,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_CAPTURE;
+  priv->current_action = FPI_DEVICE_ACTION_CAPTURE;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
@@ -1089,7 +1153,7 @@ fp_device_delete_print (FpDevice           *device,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_DELETE;
+  priv->current_action = FPI_DEVICE_ACTION_DELETE;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
@@ -1159,7 +1223,15 @@ fp_device_list_prints (FpDevice           *device,
       return;
     }
 
-  priv->current_action = FP_DEVICE_ACTION_LIST;
+  if (!fp_device_has_storage (device))
+    {
+      g_task_return_error (task,
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
+                                                     "Device has no storage"));
+      return;
+    }
+
+  priv->current_action = FPI_DEVICE_ACTION_LIST;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
 
@@ -1287,6 +1359,8 @@ fp_device_enroll_sync (FpDevice        *device,
  * @device: a #FpDevice
  * @enrolled_print: a #FpPrint to verify
  * @cancellable: (nullable): a #GCancellable, or %NULL
+ * @match_cb: (nullable) (scope call): match reporting callback
+ * @match_data: (closure match_cb): user data for @match_cb
  * @match: (out): Whether the user presented the correct finger
  * @print: (out) (transfer full) (nullable): Location to store the scanned print, or %NULL to ignore
  * @error: Return location for errors, or %NULL to ignore
@@ -1299,6 +1373,8 @@ gboolean
 fp_device_verify_sync (FpDevice     *device,
                        FpPrint      *enrolled_print,
                        GCancellable *cancellable,
+                       FpMatchCb     match_cb,
+                       gpointer      match_data,
                        gboolean     *match,
                        FpPrint     **print,
                        GError      **error)
@@ -1310,6 +1386,7 @@ fp_device_verify_sync (FpDevice     *device,
   fp_device_verify (device,
                     enrolled_print,
                     cancellable,
+                    match_cb, match_data, NULL,
                     async_result_ready, &task);
   while (!task)
     g_main_context_iteration (NULL, TRUE);
@@ -1322,6 +1399,8 @@ fp_device_verify_sync (FpDevice     *device,
  * @device: a #FpDevice
  * @prints: (element-type FpPrint) (transfer none): #GPtrArray of #FpPrint
  * @cancellable: (nullable): a #GCancellable, or %NULL
+ * @match_cb: (nullable) (scope call): match reporting callback
+ * @match_data: (closure match_cb): user data for @match_cb
  * @match: (out) (transfer full) (nullable): Location for the matched #FpPrint, or %NULL
  * @print: (out) (transfer full) (nullable): Location for the new #FpPrint, or %NULL
  * @error: Return location for errors, or %NULL to ignore
@@ -1334,6 +1413,8 @@ gboolean
 fp_device_identify_sync (FpDevice     *device,
                          GPtrArray    *prints,
                          GCancellable *cancellable,
+                         FpMatchCb     match_cb,
+                         gpointer      match_data,
                          FpPrint     **match,
                          FpPrint     **print,
                          GError      **error)
@@ -1345,6 +1426,7 @@ fp_device_identify_sync (FpDevice     *device,
   fp_device_identify (device,
                       prints,
                       cancellable,
+                      match_cb, match_data, NULL,
                       async_result_ready, &task);
   while (!task)
     g_main_context_iteration (NULL, TRUE);

libfprint/fp-device.h

@@ -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
@@ -113,7 +113,7 @@ GQuark fp_device_error_quark (void);
  * FpEnrollProgress:
  * @device: a #FpDevice
  * @completed_stages: Number of completed stages
- * @print: (nullable) (transfer none): The last scaned print
+ * @print: (nullable) (transfer none): The last scanned print
  * @user_data: (nullable) (transfer none): User provided data
  * @error: (nullable) (transfer none): #GError or %NULL
  *
@@ -125,6 +125,43 @@ 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);
@@ -160,12 +197,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);
 
@@ -231,12 +274,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);

libfprint/fp-image-device-private.h

@@ -25,17 +25,17 @@
 
 typedef struct
 {
-  FpImageDeviceState state;
-  gboolean           active;
-  gboolean           cancelling;
+  FpiImageDeviceState state;
+  gboolean            active;
+  gboolean            cancelling;
 
-  gboolean           enroll_await_on_pending;
-  gint               enroll_stage;
+  gboolean            enroll_await_on_pending;
+  gint                enroll_stage;
 
-  guint              pending_activation_timeout_id;
-  gboolean           pending_activation_timeout_waiting_finger_off;
+  guint               pending_activation_timeout_id;
+  gboolean            pending_activation_timeout_waiting_finger_off;
 
-  gint               bz3_threshold;
+  gint                bz3_threshold;
 } FpImageDevicePrivate;
 
 

libfprint/fp-image-device.c

@@ -100,13 +100,13 @@ fp_image_device_close (FpDevice *device)
    *  1. We are inactive
    *     -> immediately close
    *  2. We are waiting for finger off
-   *     -> imediately deactivate
+   *     -> immediately 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)
+  else if (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE)
     fpi_image_device_deactivate (self);
 }
 
@@ -115,16 +115,16 @@ fp_image_device_cancel_action (FpDevice *device)
 {
   FpImageDevice *self = FP_IMAGE_DEVICE (device);
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  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)
+  if (action == FPI_DEVICE_ACTION_ENROLL ||
+      action == FPI_DEVICE_ACTION_VERIFY ||
+      action == FPI_DEVICE_ACTION_IDENTIFY ||
+      action == FPI_DEVICE_ACTION_CAPTURE)
     {
       priv->cancelling = TRUE;
       fpi_image_device_deactivate (self);
@@ -143,14 +143,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;
 
@@ -162,12 +162,12 @@ 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;
@@ -178,14 +178,14 @@ fp_image_device_start_capture_action (FpDevice *device)
    * error (which will usually say that the user should remove the
    * finger).
    */
-  if (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE || priv->active)
+  if (priv->state != FPI_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)
+      if (priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
         priv->pending_activation_timeout_waiting_finger_off = TRUE;
       else
         priv->pending_activation_timeout_waiting_finger_off = FALSE;
@@ -245,6 +245,23 @@ fp_image_device_get_property (GObject    *object,
     }
 }
 
+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)
 {
@@ -253,6 +270,7 @@ fp_image_device_class_init (FpImageDeviceClass *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;
@@ -267,21 +285,37 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
   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 ("fp-image-device-state",
+    g_param_spec_enum ("fpi-image-device-state",
                        "Image Device State",
                        "Private: The state of the image device",
-                       FP_TYPE_IMAGE_DEVICE_STATE,
-                       FP_IMAGE_DEVICE_STATE_INACTIVE,
+                       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 ("fp-image-device-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, FP_TYPE_IMAGE_DEVICE_STATE);
+                  G_TYPE_NONE, 1, FPI_TYPE_IMAGE_DEVICE_STATE);
 
   g_object_class_install_properties (object_class, N_PROPS, properties);
 }
@@ -289,13 +323,4 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
 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;
 }

libfprint/fp-image.c

@@ -184,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);
@@ -316,6 +314,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);
 }

libfprint/fp-print-private.h

@@ -27,7 +27,7 @@ struct _FpPrint
 {
   GInitiallyUnowned parent_instance;
 
-  FpPrintType       type;
+  FpiPrintType      type;
 
   gchar            *driver;
   gchar            *device_id;

libfprint/fp-print.c

@@ -21,6 +21,7 @@
 #define FP_COMPONENT "print"
 
 #include "fp-print-private.h"
+#include "fpi-compat.h"
 #include "fpi-log.h"
 
 /**
@@ -50,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,
@@ -268,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_RAW,
                        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,
@@ -555,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;
@@ -567,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)
     {
       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;
@@ -595,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);
 
@@ -618,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);
@@ -643,10 +658,10 @@ 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++)
@@ -738,14 +753,14 @@ fp_print_deserialize (const guchar *data,
   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;
@@ -766,7 +781,7 @@ 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, aligned_data);
 
@@ -794,17 +809,17 @@ 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);
+      fpi_print_set_type (result, FPI_PRINT_NBIS);
       for (i = 0; i < g_variant_n_children (prints); i++)
         {
           g_autofree struct xyt_struct *xyt = g_new0 (struct xyt_struct, 1);
@@ -841,16 +856,16 @@ fp_print_deserialize (const guchar *data,
           g_ptr_array_add (result->prints, g_steal_pointer (&xyt));
         }
     }
-  else if (type == FP_PRINT_RAW)
+  else if (type == FPI_PRINT_RAW)
     {
       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);
     }
   else
@@ -867,8 +882,6 @@ fp_print_deserialize (const guchar *data,
                 "enroll_date", date,
                 NULL);
 
-  g_date_free (date);
-
   return g_steal_pointer (&result);
 
 invalid_format:

libfprint/fp-print.h

@@ -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,6 +61,9 @@ 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);

libfprint/fpi-assembling.c

@@ -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;

libfprint/fpi-assembling.h

@@ -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

libfprint/fpi-byte-reader.h

@@ -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__ */

libfprint/fpi-byte-utils.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__ */

libfprint/fpi-byte-writer.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__ */

libfprint/fpi-compat.h

@@ -1,6 +1,5 @@
 /*
- * Internal/private definitions for libfprint
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
+ * 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
@@ -19,7 +18,22 @@
 
 #pragma once
 
-#include "fpi-log.h"
-#include "fpi-image.h"
-#include "fpi-image-device.h"
-#include "fpi-minutiae.h"
+#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 (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

libfprint/fpi-context.h

@@ -20,6 +20,7 @@
 
 #include <gusb.h>
 #include "fp-context.h"
+#include "fpi-compat.h"
 
 /**
  * fpi_get_driver_types:

libfprint/fpi-device.c

@@ -28,7 +28,7 @@
  * @title: Internal FpDevice
  * @short_description: Internal device routines
  *
- * The methods that are availabe for drivers to manipulate a device. See
+ * The methods that are available for drivers to manipulate a device. See
  * #FpDeviceClass for more information. Also note that most of these are
  * not relevant for image based devices, see #FpImageDeviceClass in that
  * case.
@@ -100,7 +100,7 @@ fpi_device_error_new (FpDeviceError error)
   switch (error)
     {
     case FP_DEVICE_ERROR_GENERAL:
-      msg = "An unspecified error occured!";
+      msg = "An unspecified error occurred!";
       break;
 
     case FP_DEVICE_ERROR_NOT_SUPPORTED:
@@ -138,7 +138,7 @@ fpi_device_error_new (FpDeviceError error)
     default:
       g_warning ("Unsupported error, returning general error instead!");
       error = FP_DEVICE_ERROR_GENERAL;
-      msg = "An unspecified error occured!";
+      msg = "An unspecified error occurred!";
     }
 
   return g_error_new_literal (FP_DEVICE_ERROR, error, msg);
@@ -350,21 +350,21 @@ fpi_device_get_virtual_env (FpDevice *device)
  * fpi_device_get_current_action:
  * @device: The #FpDevice
  *
- * Get the currently ongoing action or %FP_DEVICE_ACTION_NONE if there
+ * Get the currently ongoing action or %FPI_DEVICE_ACTION_NONE if there
  * is no operation at this time.
  *
  * This is useful for drivers that might share code paths between different
  * actions (e.g. verify and identify) and want to find out again later which
  * action was started in the beginning.
  *
- * Returns: The ongoing #FpDeviceAction
+ * Returns: The ongoing #FpiDeviceAction
  */
-FpDeviceAction
+FpiDeviceAction
 fpi_device_get_current_action (FpDevice *device)
 {
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
-  g_return_val_if_fail (FP_IS_DEVICE (device), FP_DEVICE_ACTION_NONE);
+  g_return_val_if_fail (FP_IS_DEVICE (device), FPI_DEVICE_ACTION_NONE);
 
   return priv->current_action;
 }
@@ -387,7 +387,7 @@ fpi_device_action_is_cancelled (FpDevice *device)
   GCancellable *cancellable;
 
   g_return_val_if_fail (FP_IS_DEVICE (device), TRUE);
-  g_return_val_if_fail (priv->current_action != FP_DEVICE_ACTION_NONE, TRUE);
+  g_return_val_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE, TRUE);
 
   cancellable = g_task_get_cancellable (priv->current_task);
 
@@ -420,6 +420,23 @@ enroll_data_free (FpEnrollData *data)
   g_free (data);
 }
 
+void
+match_data_free (FpMatchData *data)
+{
+  g_clear_object (&data->print);
+  g_clear_object (&data->match);
+  g_clear_error (&data->error);
+
+  if (data->match_destroy)
+    data->match_destroy (data->match_data);
+  data->match_data = NULL;
+
+  g_clear_object (&data->enrolled_print);
+  g_clear_pointer (&data->gallery, g_ptr_array_unref);
+
+  g_free (data);
+}
+
 /**
  * fpi_device_get_enroll_data:
  * @device: The #FpDevice
@@ -435,7 +452,7 @@ fpi_device_get_enroll_data (FpDevice *device,
   FpEnrollData *data;
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_ENROLL);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_ENROLL);
 
   data = g_task_get_task_data (priv->current_task);
   g_assert (data);
@@ -458,7 +475,7 @@ fpi_device_get_capture_data (FpDevice *device,
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_CAPTURE);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_CAPTURE);
 
   if (wait_for_finger)
     *wait_for_finger = priv->wait_for_finger;
@@ -476,12 +493,16 @@ fpi_device_get_verify_data (FpDevice *device,
                             FpPrint **print)
 {
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpMatchData *data;
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_VERIFY);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_VERIFY);
+
+  data = g_task_get_task_data (priv->current_task);
+  g_assert (data);
 
   if (print)
-    *print = g_task_get_task_data (priv->current_task);
+    *print = data->enrolled_print;
 }
 
 /**
@@ -496,12 +517,16 @@ fpi_device_get_identify_data (FpDevice   *device,
                               GPtrArray **prints)
 {
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpMatchData *data;
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_IDENTIFY);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_IDENTIFY);
+
+  data = g_task_get_task_data (priv->current_task);
+  g_assert (data);
 
   if (prints)
-    *prints = g_task_get_task_data (priv->current_task);
+    *prints = data->gallery;
 }
 
 /**
@@ -518,7 +543,7 @@ fpi_device_get_delete_data (FpDevice *device,
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_DELETE);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_DELETE);
 
   if (print)
     *print = g_task_get_task_data (priv->current_task);
@@ -542,7 +567,7 @@ fpi_device_get_cancellable (FpDevice *device)
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_val_if_fail (FP_IS_DEVICE (device), NULL);
-  g_return_val_if_fail (priv->current_action != FP_DEVICE_ACTION_NONE, NULL);
+  g_return_val_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE, NULL);
 
   return g_task_get_cancellable (priv->current_task);
 }
@@ -564,7 +589,7 @@ fpi_device_action_error (FpDevice *device,
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action != FP_DEVICE_ACTION_NONE);
+  g_return_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE);
 
   if (error != NULL)
     {
@@ -579,44 +604,44 @@ fpi_device_action_error (FpDevice *device,
 
   switch (priv->current_action)
     {
-    case FP_DEVICE_ACTION_PROBE:
+    case FPI_DEVICE_ACTION_PROBE:
       fpi_device_probe_complete (device, NULL, NULL, error);
       break;
 
-    case FP_DEVICE_ACTION_OPEN:
+    case FPI_DEVICE_ACTION_OPEN:
       fpi_device_open_complete (device, error);
       break;
 
-    case FP_DEVICE_ACTION_CLOSE:
+    case FPI_DEVICE_ACTION_CLOSE:
       fpi_device_close_complete (device, error);
       break;
 
-    case FP_DEVICE_ACTION_ENROLL:
+    case FPI_DEVICE_ACTION_ENROLL:
       fpi_device_enroll_complete (device, NULL, error);
       break;
 
-    case FP_DEVICE_ACTION_VERIFY:
-      fpi_device_verify_complete (device, FPI_MATCH_ERROR, NULL, error);
+    case FPI_DEVICE_ACTION_VERIFY:
+      fpi_device_verify_complete (device, error);
       break;
 
-    case FP_DEVICE_ACTION_IDENTIFY:
-      fpi_device_identify_complete (device, NULL, NULL, error);
+    case FPI_DEVICE_ACTION_IDENTIFY:
+      fpi_device_identify_complete (device, error);
       break;
 
-    case FP_DEVICE_ACTION_CAPTURE:
+    case FPI_DEVICE_ACTION_CAPTURE:
       fpi_device_capture_complete (device, NULL, error);
       break;
 
-    case FP_DEVICE_ACTION_DELETE:
+    case FPI_DEVICE_ACTION_DELETE:
       fpi_device_delete_complete (device, error);
       break;
 
-    case FP_DEVICE_ACTION_LIST:
+    case FPI_DEVICE_ACTION_LIST:
       fpi_device_list_complete (device, NULL, error);
       break;
 
     default:
-    case FP_DEVICE_ACTION_NONE:
+    case FPI_DEVICE_ACTION_NONE:
       g_return_if_reached ();
       break;
     }
@@ -663,7 +688,7 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
   g_debug ("Completing action %d in idle!", priv->current_action);
 
   task = g_steal_pointer (&priv->current_task);
-  priv->current_action = FP_DEVICE_ACTION_NONE;
+  priv->current_action = FPI_DEVICE_ACTION_NONE;
   priv->current_task_idle_return_source = NULL;
 
   switch (data->type)
@@ -746,7 +771,7 @@ fpi_device_probe_complete (FpDevice    *device,
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_PROBE);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_PROBE);
 
   g_debug ("Device reported probe completion");
 
@@ -788,7 +813,7 @@ fpi_device_open_complete (FpDevice *device, GError *error)
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_OPEN);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_OPEN);
 
   g_debug ("Device reported open completion");
 
@@ -821,13 +846,11 @@ fpi_device_close_complete (FpDevice *device, GError *error)
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_CLOSE);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_CLOSE);
 
   g_debug ("Device reported close completion");
 
   clear_device_cancel_action (device);
-  priv->is_open = FALSE;
-  g_object_notify (G_OBJECT (device), "open");
 
   switch (priv->type)
     {
@@ -852,10 +875,16 @@ fpi_device_close_complete (FpDevice *device, GError *error)
     }
 
   if (!error)
-    fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_BOOL,
-                                    GUINT_TO_POINTER (TRUE));
+    {
+      priv->is_open = FALSE;
+      g_object_notify (G_OBJECT (device), "open");
+      fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_BOOL,
+                                      GUINT_TO_POINTER (TRUE));
+    }
   else
-    fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
+    {
+      fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
+    }
 }
 
 /**
@@ -873,7 +902,7 @@ fpi_device_enroll_complete (FpDevice *device, FpPrint *print, GError *error)
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_ENROLL);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_ENROLL);
 
   g_debug ("Device reported enroll completion");
 
@@ -907,64 +936,68 @@ fpi_device_enroll_complete (FpDevice *device, FpPrint *print, GError *error)
 /**
  * fpi_device_verify_complete:
  * @device: The #FpDevice
- * @result: The #FpiMatchResult of the operation
- * @print: The scanned #FpPrint
  * @error: A #GError if result is %FPI_MATCH_ERROR
  *
  * Finish an ongoing verify operation. The returned print should be
  * representing the new scan and not the one passed for verification.
+ *
+ * Note that @error should only be set for actual errors. In the case
+ * of retry errors, report these using fpi_device_verify_report()
+ * and then call this function without any error argument.
  */
 void
-fpi_device_verify_complete (FpDevice      *device,
-                            FpiMatchResult result,
-                            FpPrint       *print,
-                            GError        *error)
+fpi_device_verify_complete (FpDevice *device,
+                            GError   *error)
 {
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpMatchData *data;
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_VERIFY);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_VERIFY);
 
   g_debug ("Device reported verify completion");
 
-  clear_device_cancel_action (device);
+  data = g_task_get_task_data (priv->current_task);
 
-  g_object_set_data_full (G_OBJECT (priv->current_task),
-                          "print",
-                          print,
-                          g_object_unref);
+  clear_device_cancel_action (device);
 
   if (!error)
     {
-      if (result != FPI_MATCH_ERROR)
+      if (!data->result_reported)
         {
-          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_INT,
-                                          GINT_TO_POINTER (result));
+          g_warning ("Driver reported successful verify complete but did not report the result earlier. Reporting error instead");
+          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR,
+                                          fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+        }
+      else if (data->error)
+        {
+          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, g_steal_pointer (&data->error));
         }
       else
         {
-          g_warning ("Driver did not provide an error for a failed verify operation!");
-          error = fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                            "Driver failed to provide an error!");
-          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
+          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_INT,
+                                          GINT_TO_POINTER (data->match != NULL ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL));
         }
     }
   else
     {
-      fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
-      if (result != FPI_MATCH_ERROR)
+      /* Replace a retry error with a general error, this is a driver bug. */
+      if (error->domain == FP_DEVICE_RETRY)
         {
-          g_warning ("Driver passed an error but also provided a match result, returning error!");
-          g_object_unref (print);
+          g_warning ("Driver reported a retry error to fpi_device_verify_complete. "
+                     "This is not permissible and needs to be reported using "
+                     "fpi_device_verify_report, reporting general verification "
+                     "failure instead.");
+          g_clear_error (&error);
+          error = fpi_device_error_new (FP_DEVICE_ERROR_GENERAL);
         }
+      fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
     }
 }
 
 /**
  * fpi_device_identify_complete:
  * @device: The #FpDevice
- * @match: The matching #FpPrint from the passed gallery, or %NULL if none matched
- * @print: The scanned #FpPrint, may be %NULL
  * @error: The #GError or %NULL on success
  *
  * Finish an ongoing identify operation. The match that was identified is
@@ -973,40 +1006,50 @@ fpi_device_verify_complete (FpDevice      *device,
  */
 void
 fpi_device_identify_complete (FpDevice *device,
-                              FpPrint  *match,
-                              FpPrint  *print,
                               GError   *error)
 {
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpMatchData *data;
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_IDENTIFY);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_IDENTIFY);
 
   g_debug ("Device reported identify completion");
 
+  data = g_task_get_task_data (priv->current_task);
+
   clear_device_cancel_action (device);
 
-  g_object_set_data_full (G_OBJECT (priv->current_task),
-                          "print",
-                          print,
-                          g_object_unref);
-  g_object_set_data_full (G_OBJECT (priv->current_task),
-                          "match",
-                          match,
-                          g_object_unref);
   if (!error)
     {
-      fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_BOOL,
-                                      GUINT_TO_POINTER (TRUE));
+      if (!data->result_reported)
+        {
+          g_warning ("Driver reported successful identify complete but did not report the result earlier. Reporting error instead");
+          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR,
+                                          fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+        }
+      else if (data->error)
+        {
+          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, g_steal_pointer (&data->error));
+        }
+      else
+        {
+          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_INT, GINT_TO_POINTER (TRUE));
+        }
     }
   else
     {
-      fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
-      if (match)
+      /* Replace a retry error with a general error, this is a driver bug. */
+      if (error->domain == FP_DEVICE_RETRY)
         {
-          g_warning ("Driver passed an error but also provided a match result, returning error!");
-          g_clear_object (&match);
+          g_warning ("Driver reported a retry error to fpi_device_identify_complete. "
+                     "This is not permissible and needs to be reported using "
+                     "fpi_device_identify_report, reporting general identification "
+                     "failure instead.");
+          g_clear_error (&error);
+          error = fpi_device_error_new (FP_DEVICE_ERROR_GENERAL);
         }
+      fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
     }
 }
 
@@ -1027,7 +1070,7 @@ fpi_device_capture_complete (FpDevice *device,
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_CAPTURE);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_CAPTURE);
 
   g_debug ("Device reported capture completion");
 
@@ -1072,7 +1115,7 @@ fpi_device_delete_complete (FpDevice *device,
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_DELETE);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_DELETE);
 
   g_debug ("Device reported deletion completion");
 
@@ -1106,7 +1149,7 @@ fpi_device_list_complete (FpDevice  *device,
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_LIST);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_LIST);
 
   g_debug ("Device reported listing completion");
 
@@ -1134,7 +1177,7 @@ fpi_device_list_complete (FpDevice  *device,
  * fpi_device_enroll_progress:
  * @device: The #FpDevice
  * @completed_stages: The number of stages that are completed at this point
- * @print: (transfer full): The #FpPrint for the newly completed stage or %NULL on failure
+ * @print: (transfer floating): The #FpPrint for the newly completed stage or %NULL on failure
  * @error: (transfer full): The #GError or %NULL on success
  *
  * Notify about the progress of the enroll operation. This is important for UI interaction.
@@ -1150,11 +1193,14 @@ fpi_device_enroll_progress (FpDevice *device,
   FpEnrollData *data;
 
   g_return_if_fail (FP_IS_DEVICE (device));
-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_ENROLL);
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_ENROLL);
   g_return_if_fail (error == NULL || error->domain == FP_DEVICE_RETRY);
 
   g_debug ("Device reported enroll progress, reported %i of %i have been completed", completed_stages, priv->nr_enroll_stages);
 
+  if (print)
+    g_object_ref_sink (print);
+
   if (error && print)
     {
       g_warning ("Driver passed an error and also provided a print, returning error!");
@@ -1175,3 +1221,151 @@ fpi_device_enroll_progress (FpDevice *device,
   g_clear_error (&error);
   g_clear_object (&print);
 }
+
+/**
+ * fpi_device_verify_report:
+ * @device: The #FpDevice
+ * @result: The #FpiMatchResult of the operation
+ * @print: (transfer floating) The scanned #FpPrint
+ * @error: A #GError if result is %FPI_MATCH_ERROR
+ *
+ * Report the result of a verify operation. Note that the passed @error must be
+ * a retry error with the %FP_DEVICE_RETRY domain. For all other error cases,
+ * the error should passed to fpi_device_verify_complete().
+ */
+void
+fpi_device_verify_report (FpDevice      *device,
+                          FpiMatchResult result,
+                          FpPrint       *print,
+                          GError        *error)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpMatchData *data = g_task_get_task_data (priv->current_task);
+  gboolean call_cb = TRUE;
+
+  g_return_if_fail (FP_IS_DEVICE (device));
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_VERIFY);
+  g_return_if_fail (data->result_reported == FALSE);
+
+  data->result_reported = TRUE;
+
+  g_debug ("Device reported verify result");
+
+  if (print)
+    print = g_object_ref_sink (print);
+
+  if (error || result == FPI_MATCH_ERROR)
+    {
+      if (result != FPI_MATCH_ERROR)
+        g_warning ("Driver reported an error code without setting match result to error!");
+
+      if (error == NULL)
+        {
+          g_warning ("Driver reported an error without specifying a retry code, assuming general retry error!");
+          error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL);
+        }
+
+      if (print)
+        {
+          g_warning ("Driver reported a print together with an error!");
+          g_clear_object (&print);
+        }
+
+      data->error = error;
+
+      if (error->domain != FP_DEVICE_RETRY)
+        {
+          g_warning ("Driver reported a verify error that was not in the retry domain, delaying report!");
+          call_cb = FALSE;
+        }
+    }
+  else
+    {
+      if (result == FPI_MATCH_SUCCESS)
+        {
+          fpi_device_get_verify_data (device, &data->match);
+          g_object_ref (data->match);
+        }
+
+      data->print = g_steal_pointer (&print);
+    }
+
+  if (call_cb && data->match_cb)
+    data->match_cb (device, data->match, data->print, data->match_data, data->error);
+}
+
+/**
+ * fpi_device_identify_report:
+ * @device: The #FpDevice
+ * @match: (transfer none): The #FpPrint from the gallery that matched
+ * @print: (transfer floating): The scanned #FpPrint
+ * @error: A #GError if result is %FPI_MATCH_ERROR
+ *
+ * Report the result of a identify operation. Note that the passed @error must be
+ * a retry error with the %FP_DEVICE_RETRY domain. For all other error cases,
+ * the error should passed to fpi_device_identify_complete().
+ */
+void
+fpi_device_identify_report (FpDevice *device,
+                            FpPrint  *match,
+                            FpPrint  *print,
+                            GError   *error)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpMatchData *data = g_task_get_task_data (priv->current_task);
+  gboolean call_cb = TRUE;
+
+  g_return_if_fail (FP_IS_DEVICE (device));
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_IDENTIFY);
+  g_return_if_fail (data->result_reported == FALSE);
+
+  data->result_reported = TRUE;
+
+  if (match)
+    g_object_ref (match);
+
+  if (print)
+    print = g_object_ref_sink (print);
+
+  if (match && !g_ptr_array_find (data->gallery, match, NULL))
+    {
+      g_warning ("Driver reported a match to a print that was not in the gallery, ignoring match.");
+      g_clear_object (&match);
+    }
+
+  g_debug ("Device reported identify result");
+
+  if (error)
+    {
+      if (match != NULL)
+        {
+          g_warning ("Driver reported an error code but also provided a match!");
+          g_clear_object (&match);
+        }
+
+      if (print)
+        {
+          g_warning ("Driver reported a print together with an error!");
+          g_clear_object (&print);
+        }
+
+      data->error = error;
+
+      if (error->domain != FP_DEVICE_RETRY)
+        {
+          g_warning ("Driver reported a verify error that was not in the retry domain, delaying report!");
+          call_cb = FALSE;
+        }
+    }
+  else
+    {
+      if (match)
+        data->match = g_steal_pointer (&match);
+
+      if (print)
+        data->print = g_steal_pointer (&print);
+    }
+
+  if (call_cb && data->match_cb)
+    data->match_cb (device, data->match, data->print, data->match_data, data->error);
+}

libfprint/fpi-device.h

@@ -65,10 +65,10 @@ struct _FpIdEntry
  * @probe: Called immediately for all devices. Most drivers will not need to
  *   implement this. Drivers should setup the device identifier from the probe
  *   callback which will be used to verify the compatibility of stored
- *   #FpPrint's. It is permissable to temporarily open the USB device if this
+ *   #FpPrint's. It is permissible to temporarily open the USB device if this
  *   is required for the operation. If an error is returned, then the device
  *   will be destroyed again immediately and never reported to the API user.
- * @open: Open the device for futher operations. Any of the normal actions are
+ * @open: Open the device for further operations. Any of the normal actions are
  *   guaranteed to only happen when the device is open (this includes delete).
  * @close: Close the device again
  * @enroll: Start an enroll operation
@@ -79,6 +79,7 @@ struct _FpIdEntry
  * @delete: Delete a print from the device
  * @cancel: Called on cancellation, this is a convenience to not need to handle
  *   the #GCancellable directly by using fpi_device_get_cancellable().
+ * @supports_identify: Whether identify operations are supported.
  *
  * NOTE: If your driver is image based, then you should subclass #FpImageDevice
  * instead. #FpImageDevice based drivers use a different way of interacting
@@ -128,7 +129,9 @@ struct _FpDeviceClass
   void (*list)     (FpDevice *device);
   void (*delete)   (FpDevice * device);
 
-  void (*cancel)   (FpDevice *device);
+  void     (*cancel)   (FpDevice *device);
+
+  gboolean (*supports_identify) (FpDevice *device);
 };
 
 /**
@@ -142,39 +145,39 @@ typedef void (*FpTimeoutFunc) (FpDevice *device,
                                gpointer  user_data);
 
 /**
- * FpDeviceAction:
- * @FP_DEVICE_ACTION_NONE: No action is active.
- * @FP_DEVICE_ACTION_PROBE: Probe device for support and information.
- * @FP_DEVICE_ACTION_OPEN: Device is currently being opened.
- * @FP_DEVICE_ACTION_CLOSE: Device is currently being closed.
- * @FP_DEVICE_ACTION_ENROLL: Device is currently enrolling.
- * @FP_DEVICE_ACTION_VERIFY: Device is currently verifying.
- * @FP_DEVICE_ACTION_IDENTIFY: Device is currently identifying.
- * @FP_DEVICE_ACTION_CAPTURE: Device is currently capturing an image.
- * @FP_DEVICE_ACTION_LIST: Device stored prints are being queried.
- * @FP_DEVICE_ACTION_DELETE: Device stored print is being deleted.
+ * FpiDeviceAction:
+ * @FPI_DEVICE_ACTION_NONE: No action is active.
+ * @FPI_DEVICE_ACTION_PROBE: Probe device for support and information.
+ * @FPI_DEVICE_ACTION_OPEN: Device is currently being opened.
+ * @FPI_DEVICE_ACTION_CLOSE: Device is currently being closed.
+ * @FPI_DEVICE_ACTION_ENROLL: Device is currently enrolling.
+ * @FPI_DEVICE_ACTION_VERIFY: Device is currently verifying.
+ * @FPI_DEVICE_ACTION_IDENTIFY: Device is currently identifying.
+ * @FPI_DEVICE_ACTION_CAPTURE: Device is currently capturing an image.
+ * @FPI_DEVICE_ACTION_LIST: Device stored prints are being queried.
+ * @FPI_DEVICE_ACTION_DELETE: Device stored print is being deleted.
  *
  * Current active action of the device. A driver can retrieve the action.
  */
 typedef enum {
-  FP_DEVICE_ACTION_NONE = 0,
-  FP_DEVICE_ACTION_PROBE,
-  FP_DEVICE_ACTION_OPEN,
-  FP_DEVICE_ACTION_CLOSE,
-  FP_DEVICE_ACTION_ENROLL,
-  FP_DEVICE_ACTION_VERIFY,
-  FP_DEVICE_ACTION_IDENTIFY,
-  FP_DEVICE_ACTION_CAPTURE,
-  FP_DEVICE_ACTION_LIST,
-  FP_DEVICE_ACTION_DELETE,
-} FpDeviceAction;
+  FPI_DEVICE_ACTION_NONE = 0,
+  FPI_DEVICE_ACTION_PROBE,
+  FPI_DEVICE_ACTION_OPEN,
+  FPI_DEVICE_ACTION_CLOSE,
+  FPI_DEVICE_ACTION_ENROLL,
+  FPI_DEVICE_ACTION_VERIFY,
+  FPI_DEVICE_ACTION_IDENTIFY,
+  FPI_DEVICE_ACTION_CAPTURE,
+  FPI_DEVICE_ACTION_LIST,
+  FPI_DEVICE_ACTION_DELETE,
+} FpiDeviceAction;
 
 GUsbDevice  *fpi_device_get_usb_device (FpDevice *device);
 const gchar *fpi_device_get_virtual_env (FpDevice *device);
 //const gchar *fpi_device_get_spi_dev (FpDevice *device);
 
 
-FpDeviceAction fpi_device_get_current_action (FpDevice *device);
+FpiDeviceAction fpi_device_get_current_action (FpDevice *device);
 gboolean fpi_device_action_is_cancelled (FpDevice *device);
 
 GError * fpi_device_retry_new (FpDeviceRetry error);
@@ -229,13 +232,9 @@ void fpi_device_close_complete (FpDevice *device,
 void fpi_device_enroll_complete (FpDevice *device,
                                  FpPrint  *print,
                                  GError   *error);
-void fpi_device_verify_complete (FpDevice      *device,
-                                 FpiMatchResult result,
-                                 FpPrint       *print,
-                                 GError        *error);
+void fpi_device_verify_complete (FpDevice *device,
+                                 GError   *error);
 void fpi_device_identify_complete (FpDevice *device,
-                                   FpPrint  *match,
-                                   FpPrint  *print,
                                    GError   *error);
 void fpi_device_capture_complete (FpDevice *device,
                                   FpImage  *image,
@@ -250,5 +249,13 @@ void fpi_device_enroll_progress (FpDevice *device,
                                  gint      completed_stages,
                                  FpPrint  *print,
                                  GError   *error);
+void fpi_device_verify_report (FpDevice      *device,
+                               FpiMatchResult result,
+                               FpPrint       *print,
+                               GError        *error);
+void fpi_device_identify_report (FpDevice *device,
+                                 FpPrint  *match,
+                                 FpPrint  *print,
+                                 GError   *error);
 
 G_END_DECLS

libfprint/fpi-image-device.c

@@ -54,8 +54,8 @@ fpi_image_device_activate (FpImageDevice *self)
 
   /* 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;
-  g_object_notify (G_OBJECT (self), "fp-image-device-state");
+  priv->state = FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
+  g_object_notify (G_OBJECT (self), "fpi-image-device-state");
 
   /* We might have been waiting for deactivation to finish before
    * starting the next operation. */
@@ -79,11 +79,11 @@ fpi_image_device_deactivate (FpImageDevice *self)
       fp_dbg ("Already deactivated, ignoring request.");
       return;
     }
-  if (!priv->cancelling && priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+  if (!priv->cancelling && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
     g_warning ("Deactivating image device while waiting for finger, this should not happen.");
 
-  priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
-  g_object_notify (G_OBJECT (self), "fp-image-device-state");
+  priv->state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
+  g_object_notify (G_OBJECT (self), "fpi-image-device-state");
 
   fp_dbg ("Deactivating image device\n");
   cls->deactivate (self);
@@ -92,12 +92,12 @@ fpi_image_device_deactivate (FpImageDevice *self)
 /* Static helper functions */
 
 static void
-fp_image_device_change_state (FpImageDevice *self, FpImageDeviceState state)
+fp_image_device_change_state (FpImageDevice *self, FpiImageDeviceState state)
 {
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
 
   /* Cannot change to inactive using this function. */
-  g_assert (state != FP_IMAGE_DEVICE_STATE_INACTIVE);
+  g_assert (state != FPI_IMAGE_DEVICE_STATE_INACTIVE);
 
   /* We might have been waiting for the finger to go OFF to start the
    * next operation. */
@@ -106,8 +106,8 @@ fp_image_device_change_state (FpImageDevice *self, FpImageDeviceState state)
   fp_dbg ("Image device internal state change from %d to %d\n", priv->state, state);
 
   priv->state = state;
-  g_object_notify (G_OBJECT (self), "fp-image-device-state");
-  g_signal_emit_by_name (self, "fp-image-device-state-changed", priv->state);
+  g_object_notify (G_OBJECT (self), "fpi-image-device-state");
+  g_signal_emit_by_name (self, "fpi-image-device-state-changed", priv->state);
 }
 
 static void
@@ -118,7 +118,7 @@ fp_image_device_enroll_maybe_await_finger_on (FpImageDevice *self)
   if (priv->enroll_await_on_pending)
     {
       priv->enroll_await_on_pending = FALSE;
-      fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
+      fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
     }
   else
     {
@@ -135,7 +135,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
   FpImageDevice *self = FP_IMAGE_DEVICE (user_data);
   FpDevice *device = FP_DEVICE (self);
   FpImageDevicePrivate *priv;
-  FpDeviceAction action;
+  FpiDeviceAction action;
 
   /* Note: We rely on the device to not disappear during an operation. */
 
@@ -159,7 +159,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
   priv = fp_image_device_get_instance_private (FP_IMAGE_DEVICE (device));
   action = fpi_device_get_current_action (device);
 
-  if (action == FP_DEVICE_ACTION_CAPTURE)
+  if (action == FPI_DEVICE_ACTION_CAPTURE)
     {
       fpi_device_capture_complete (device, g_steal_pointer (&image), error);
       fpi_image_device_deactivate (self);
@@ -169,12 +169,21 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
   if (!error)
     {
       print = fp_print_new (device);
-      fpi_print_set_type (print, FP_PRINT_NBIS);
+      fpi_print_set_type (print, FPI_PRINT_NBIS);
       if (!fpi_print_add_from_image (print, image, &error))
-        g_clear_object (&print);
+        {
+          g_clear_object (&print);
+
+          if (error->domain != FP_DEVICE_RETRY)
+            {
+              fpi_device_action_error (device, error);
+              fpi_image_device_deactivate (self);
+              return;
+            }
+        }
     }
 
-  if (action == FP_DEVICE_ACTION_ENROLL)
+  if (action == FPI_DEVICE_ACTION_ENROLL)
     {
       FpPrint *enroll_print;
       fpi_device_get_enroll_data (device, &enroll_print);
@@ -199,7 +208,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
           fp_image_device_enroll_maybe_await_finger_on (FP_IMAGE_DEVICE (device));
         }
     }
-  else if (action == FP_DEVICE_ACTION_VERIFY)
+  else if (action == FPI_DEVICE_ACTION_VERIFY)
     {
       FpPrint *template;
       FpiMatchResult result;
@@ -210,10 +219,12 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
       else
         result = FPI_MATCH_ERROR;
 
-      fpi_device_verify_complete (device, result, g_steal_pointer (&print), error);
+      if (!error || error->domain == FP_DEVICE_RETRY)
+        fpi_device_verify_report (device, result, g_steal_pointer (&print), g_steal_pointer (&error));
+      fpi_device_verify_complete (device, error);
       fpi_image_device_deactivate (self);
     }
-  else if (action == FP_DEVICE_ACTION_IDENTIFY)
+  else if (action == FPI_DEVICE_ACTION_IDENTIFY)
     {
       gint i;
       GPtrArray *templates;
@@ -226,12 +237,14 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
 
           if (fpi_print_bz3_match (template, print, priv->bz3_threshold, &error) == FPI_MATCH_SUCCESS)
             {
-              result = g_object_ref (template);
+              result = template;
               break;
             }
         }
 
-      fpi_device_identify_complete (device, result, g_steal_pointer (&print), error);
+      if (!error || error->domain == FP_DEVICE_RETRY)
+        fpi_device_identify_report (device, result, g_steal_pointer (&print), g_steal_pointer (&error));
+      fpi_device_identify_complete (device, error);
       fpi_image_device_deactivate (self);
     }
   else
@@ -285,9 +298,9 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
 {
   FpDevice *device = FP_DEVICE (self);
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
+  FpiDeviceAction action;
 
-  if (priv->state == FP_IMAGE_DEVICE_STATE_INACTIVE)
+  if (priv->state == FPI_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
@@ -300,16 +313,16 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
 
   action = fpi_device_get_current_action (device);
 
-  g_assert (action != FP_DEVICE_ACTION_OPEN);
-  g_assert (action != FP_DEVICE_ACTION_CLOSE);
+  g_assert (action != FPI_DEVICE_ACTION_OPEN);
+  g_assert (action != FPI_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)
+  if (present && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
     {
-      fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_CAPTURE);
+      fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_CAPTURE);
     }
-  else if (!present && priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
+  else if (!present && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
     {
       /* We need to deactivate or continue to await finger */
 
@@ -324,7 +337,7 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
        * minutiae detection to prevent deactivation (without cancellation)
        * from the AWAIT_FINGER_ON state.
        */
-      if (action != FP_DEVICE_ACTION_ENROLL)
+      if (action != FPI_DEVICE_ACTION_ENROLL)
         fpi_image_device_deactivate (self);
       else
         fp_image_device_enroll_maybe_await_finger_on (self);
@@ -349,18 +362,18 @@ void
 fpi_image_device_image_captured (FpImageDevice *self, FpImage *image)
 {
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
+  FpiDeviceAction 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);
+  g_return_if_fail (priv->state == FPI_IMAGE_DEVICE_STATE_CAPTURE);
+  g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
+                    action == FPI_DEVICE_ACTION_VERIFY ||
+                    action == FPI_DEVICE_ACTION_IDENTIFY ||
+                    action == FPI_DEVICE_ACTION_CAPTURE);
 
-  fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
+  fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
 
   g_debug ("Image device captured an image");
 
@@ -385,32 +398,55 @@ void
 fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry)
 {
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
+  FpiDeviceAction 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);
+  g_return_if_fail (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE);
+  g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
+                    action == FPI_DEVICE_ACTION_VERIFY ||
+                    action == FPI_DEVICE_ACTION_IDENTIFY ||
+                    action == FPI_DEVICE_ACTION_CAPTURE);
 
   error = fpi_device_retry_new (retry);
 
-  if (action == FP_DEVICE_ACTION_ENROLL)
+  if (action == FPI_DEVICE_ACTION_ENROLL)
     {
       g_debug ("Reporting retry during enroll");
       fpi_device_enroll_progress (FP_DEVICE (self), priv->enroll_stage, NULL, error);
+
+      /* Wait for finger removal and re-touch.
+       * TODO: Do we need to check that the finger is already off? */
+      priv->enroll_await_on_pending = TRUE;
+      fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
+    }
+  else if (action == FPI_DEVICE_ACTION_VERIFY)
+    {
+      fpi_device_verify_report (FP_DEVICE (self), FPI_MATCH_ERROR, NULL, error);
+      priv->cancelling = TRUE;
+      fpi_image_device_deactivate (self);
+      priv->cancelling = FALSE;
+      fpi_device_verify_complete (FP_DEVICE (self), NULL);
+    }
+  else if (action == FPI_DEVICE_ACTION_IDENTIFY)
+    {
+      fpi_device_identify_report (FP_DEVICE (self), NULL, NULL, error);
+      priv->cancelling = TRUE;
+      fpi_image_device_deactivate (self);
+      priv->cancelling = FALSE;
+      fpi_device_identify_complete (FP_DEVICE (self), NULL);
     }
   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)");
+      priv->cancelling = TRUE;
       fpi_image_device_deactivate (self);
+      priv->cancelling = FALSE;
       fpi_device_action_error (FP_DEVICE (self), error);
     }
 }
@@ -421,7 +457,9 @@ fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry)
  * @error: The #GError to report
  *
  * Report an error while interacting with the device. This effectively
- * aborts the current ongoing action.
+ * aborts the current ongoing action. Note that doing so will result in
+ * the deactivation handler to be called and this function must not be
+ * used to report an error during deactivation.
  */
 void
 fpi_image_device_session_error (FpImageDevice *self, GError *error)
@@ -438,27 +476,39 @@ fpi_image_device_session_error (FpImageDevice *self, GError *error)
 
   if (!priv->active)
     {
-      FpDeviceAction action = fpi_device_get_current_action (FP_DEVICE (self));
+      FpiDeviceAction 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)
+      if (action != FPI_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)
+  else if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) &&
+           fpi_device_action_is_cancelled (FP_DEVICE (self)))
     {
-      g_warning ("Driver reported session error; translating to deactivation failure.");
-      fpi_image_device_deactivate_complete (self, error);
+      /* Ignore cancellation errors here, as we will explicitly deactivate
+       * anyway (or, may already have done so at this point).
+       */
+      g_debug ("Driver reported a cancellation error, this is expected but not required. Ignoring.");
+      g_clear_error (&error);
+      return;
+    }
+  else if (priv->state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
+    {
+      g_warning ("Driver reported session error while deactivating already, ignoring. This indicates a driver bug.");
+      g_clear_error (&error);
       return;
     }
 
   if (error->domain == FP_DEVICE_RETRY)
     g_warning ("Driver should report retries using fpi_image_device_retry_scan!");
 
+  priv->cancelling = TRUE;
   fpi_image_device_deactivate (self);
+  priv->cancelling = FALSE;
   fpi_device_action_error (FP_DEVICE (self), error);
 }
 
@@ -473,15 +523,15 @@ void
 fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
 {
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
+  FpiDeviceAction 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);
+  g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
+                    action == FPI_DEVICE_ACTION_VERIFY ||
+                    action == FPI_DEVICE_ACTION_IDENTIFY ||
+                    action == FPI_DEVICE_ACTION_CAPTURE);
 
   if (error)
     {
@@ -496,7 +546,7 @@ fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
 
   /* 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);
+  fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
 }
 
 /**
@@ -511,10 +561,10 @@ 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;
+  FpiDeviceAction action;
 
   g_return_if_fail (priv->active == TRUE);
-  g_return_if_fail (priv->state == FP_IMAGE_DEVICE_STATE_INACTIVE);
+  g_return_if_fail (priv->state == FPI_IMAGE_DEVICE_STATE_INACTIVE);
 
   g_debug ("Image device deactivation completed");
 
@@ -527,7 +577,7 @@ fpi_image_device_deactivate_complete (FpImageDevice *self, GError *error)
 
   /* 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)
+  if (action == FPI_DEVICE_ACTION_CLOSE)
     {
       cls->img_close (self);
       return;
@@ -553,17 +603,17 @@ void
 fpi_image_device_open_complete (FpImageDevice *self, GError *error)
 {
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
+  FpiDeviceAction 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_return_if_fail (action == FPI_DEVICE_ACTION_OPEN);
 
   g_debug ("Image device open completed");
 
-  priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
-  g_object_notify (G_OBJECT (self), "fp-image-device-state");
+  priv->state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
+  g_object_notify (G_OBJECT (self), "fpi-image-device-state");
 
   fpi_device_open_complete (FP_DEVICE (self), error);
 }
@@ -579,17 +629,17 @@ void
 fpi_image_device_close_complete (FpImageDevice *self, GError *error)
 {
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpDeviceAction action;
+  FpiDeviceAction 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);
+  g_return_if_fail (action == FPI_DEVICE_ACTION_CLOSE);
 
-  priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
-  g_object_notify (G_OBJECT (self), "fp-image-device-state");
+  priv->state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
+  g_object_notify (G_OBJECT (self), "fpi-image-device-state");
 
   fpi_device_close_complete (FP_DEVICE (self), error);
 }

libfprint/fpi-image-device.h

@@ -23,11 +23,11 @@
 #include "fp-image-device.h"
 
 /**
- * FpImageDeviceState:
- * @FP_IMAGE_DEVICE_STATE_INACTIVE: inactive
- * @FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: waiting for the finger to be pressed or swiped
- * @FP_IMAGE_DEVICE_STATE_CAPTURE: capturing an image
- * @FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: waiting for the finger to be removed
+ * FpiImageDeviceState:
+ * @FPI_IMAGE_DEVICE_STATE_INACTIVE: inactive
+ * @FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: waiting for the finger to be pressed or swiped
+ * @FPI_IMAGE_DEVICE_STATE_CAPTURE: capturing an image
+ * @FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: waiting for the finger to be removed
  *
  * The state of an imaging device while doing a capture. The state is
  * passed through to the driver using the ::activate() or ::change_state() vfuncs.
@@ -37,11 +37,11 @@
  * unconditionally if the device supports raw capturing.
  */
 typedef enum {
-  FP_IMAGE_DEVICE_STATE_INACTIVE,
-  FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON,
-  FP_IMAGE_DEVICE_STATE_CAPTURE,
-  FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF,
-} FpImageDeviceState;
+  FPI_IMAGE_DEVICE_STATE_INACTIVE,
+  FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON,
+  FPI_IMAGE_DEVICE_STATE_CAPTURE,
+  FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF,
+} FpiImageDeviceState;
 
 /**
  * FpImageDeviceClass:
@@ -90,8 +90,8 @@ struct _FpImageDeviceClass
   void          (*img_open)     (FpImageDevice *dev);
   void          (*img_close)    (FpImageDevice *dev);
   void          (*activate)     (FpImageDevice *dev);
-  void          (*change_state) (FpImageDevice     *dev,
-                                 FpImageDeviceState state);
+  void          (*change_state) (FpImageDevice      *dev,
+                                 FpiImageDeviceState state);
   void          (*deactivate)   (FpImageDevice *dev);
 };
 

libfprint/fpi-log.h

@@ -17,8 +17,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef __FPI_LOG_H__
-#define __FPI_LOG_H__
+#pragma once
 
 /**
  * SECTION:fpi-log
@@ -94,5 +93,3 @@
  * Same as BUG_ON() but is always true.
  */
 #define BUG() BUG_ON (1)
-
-#endif

libfprint/fpi-print.c

@@ -23,6 +23,7 @@
 
 #include "fp-print-private.h"
 #include "fpi-device.h"
+#include "fpi-compat.h"
 
 /**
  * SECTION: fpi-print
@@ -38,15 +39,15 @@
  * @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
+ * Appends the single #FPI_PRINT_NBIS print from @add to the collection of
+ * prints in @print. Both print objects need to be of type #FPI_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_return_if_fail (print->type == FPI_PRINT_NBIS);
+  g_return_if_fail (add->type == FPI_PRINT_NBIS);
 
   g_assert (add->prints->len == 1);
   g_ptr_array_add (print->prints, g_memdup (add->prints->pdata[0], sizeof (struct xyt_struct)));
@@ -62,20 +63,20 @@ fpi_print_add_print (FpPrint *print, FpPrint *add)
  * print passed during enrollment.
  */
 void
-fpi_print_set_type (FpPrint    *print,
-                    FpPrintType type)
+fpi_print_set_type (FpPrint     *print,
+                    FpiPrintType type)
 {
   g_return_if_fail (FP_IS_PRINT (print));
   /* We only allow setting this once! */
-  g_return_if_fail (print->type == FP_PRINT_UNDEFINED);
+  g_return_if_fail (print->type == FPI_PRINT_UNDEFINED);
 
   print->type = type;
-  if (print->type == FP_PRINT_NBIS)
+  if (print->type == FPI_PRINT_NBIS)
     {
       g_assert_null (print->prints);
       print->prints = g_ptr_array_new_with_free_func (g_free);
     }
-  g_object_notify (G_OBJECT (print), "fp-type");
+  g_object_notify (G_OBJECT (print), "fpi-type");
 }
 
 /**
@@ -143,7 +144,7 @@ minutiae_to_xyt (struct fp_minutiae *minutiae,
  * @error: Return location for error
  *
  * Extracts the minutiae from the given image and adds it to @print of
- * type #FP_PRINT_NBIS.
+ * type #FPI_PRINT_NBIS.
  *
  * The @image will be kept so that API users can get retrieve it e.g.
  * for debugging purposes.
@@ -159,7 +160,7 @@ fpi_print_add_from_image (FpPrint *print,
   struct fp_minutiae _minutiae;
   struct xyt_struct *xyt;
 
-  if (print->type != FP_PRINT_NBIS || !image)
+  if (print->type != FPI_PRINT_NBIS || !image)
     {
       g_set_error (error,
                    G_IO_ERROR,
@@ -203,7 +204,7 @@ fpi_print_add_from_image (FpPrint *print,
  * 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
+ * Both @template and @print need to be of type #FPI_PRINT_NBIS for this to
  * work.
  *
  * Returns: Whether the prints match, @error will be set if #FPI_MATCH_ERROR is returned
@@ -216,7 +217,7 @@ fpi_print_bz3_match (FpPrint *template, FpPrint *print, gint bz3_threshold, GErr
   gint i;
 
   /* XXX: Use a different error type? */
-  if (template->type != FP_PRINT_NBIS || print->type != FP_PRINT_NBIS)
+  if (template->type != FPI_PRINT_NBIS || print->type != FPI_PRINT_NBIS)
     {
       *error = fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
                                          "It is only possible to match NBIS type print data");
@@ -247,3 +248,115 @@ fpi_print_bz3_match (FpPrint *template, FpPrint *print, gint bz3_threshold, GErr
 
   return FPI_MATCH_FAIL;
 }
+
+/**
+ * fpi_print_generate_user_id:
+ * @print: #FpPrint to generate the ID for
+ *
+ * Generates a string identifier for the represented print. This identifier
+ * encodes some metadata about the print. It also includes a random string
+ * and may be assumed to be unique.
+ *
+ * This is useful if devices are able to store a string identifier, but more
+ * storing more metadata may be desirable. In effect, this means the driver
+ * can provide somewhat more meaningful data to fp_device_list_prints().
+ *
+ * The generated ID may be truncated after 23 characters. However, more space
+ * is required to include the username, and it is recommended to store at
+ * at least 31 bytes.
+ *
+ * The generated format may change in the future. It is versioned though and
+ * decoding should remain functional.
+ *
+ * Returns: A unique string of 23 + strlen(username) characters
+ */
+gchar *
+fpi_print_generate_user_id (FpPrint *print)
+{
+  const gchar *username = NULL;
+  gchar *user_id = NULL;
+  const GDate *date;
+  gint y = 0, m = 0, d = 0;
+  gint32 rand_id = 0;
+
+  g_assert (print);
+  date = fp_print_get_enroll_date (print);
+  if (date && g_date_valid (date))
+    {
+      y = g_date_get_year (date);
+      m = g_date_get_month (date);
+      d = g_date_get_day (date);
+    }
+
+  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);
+
+  return user_id;
+
+}
+
+/**
+ * fpi_print_fill_from_user_id:
+ * @print: #FpPrint to fill metadata into
+ * @user_id: An ID that was likely encoded using fpi_print_generate_user_id()
+ *
+ * This is the reverse operation of fpi_print_generate_user_id(), allowing
+ * the driver to encode some print metadata in a string.
+ *
+ * Returns: Whether a valid ID was found
+ */
+gboolean
+fpi_print_fill_from_user_id (FpPrint *print, const char *user_id)
+{
+  g_return_val_if_fail (user_id, FALSE);
+
+  /* The format has 24 bytes at the start and some dashes in the right places */
+  if (g_str_has_prefix (user_id, "FP1-") && strlen (user_id) >= 24 &&
+      user_id[12] == '-' && user_id[14] == '-' && user_id[23] == '-')
+    {
+      g_autofree gchar *copy = g_strdup (user_id);
+      g_autoptr(GDate) date = NULL;
+      gint32 date_ymd;
+      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);
+
+      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);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}

libfprint/fpi-print.h

@@ -7,20 +7,20 @@
 G_BEGIN_DECLS
 
 /**
- * FpPrintType:
- * @FP_PRINT_UNDEFINED: Undefined type, this happens prior to enrollment
- * @FP_PRINT_RAW: A raw print where the data is directly compared
- * @FP_PRINT_NBIS: NBIS minutiae comparison
+ * FpiPrintType:
+ * @FPI_PRINT_UNDEFINED: Undefined type, this happens prior to enrollment
+ * @FPI_PRINT_RAW: A raw print where the data is directly compared
+ * @FPI_PRINT_NBIS: NBIS minutiae comparison
  */
 typedef enum {
-  FP_PRINT_UNDEFINED = 0,
-  FP_PRINT_RAW,
-  FP_PRINT_NBIS,
-} FpPrintType;
+  FPI_PRINT_UNDEFINED = 0,
+  FPI_PRINT_RAW,
+  FPI_PRINT_NBIS,
+} FpiPrintType;
 
 /**
  * FpiMatchResult:
- * @FPI_MATCH_ERROR: An error occured during matching
+ * @FPI_MATCH_ERROR: An error occurred during matching
  * @FPI_MATCH_FAIL: The prints did not match
  * @FPI_MATCH_SUCCESS: The prints matched
  */
@@ -33,8 +33,8 @@ typedef enum {
 void     fpi_print_add_print (FpPrint *print,
                               FpPrint *add);
 
-void     fpi_print_set_type (FpPrint    *print,
-                             FpPrintType type);
+void     fpi_print_set_type (FpPrint     *print,
+                             FpiPrintType type);
 void     fpi_print_set_device_stored (FpPrint *print,
                                       gboolean device_stored);
 
@@ -47,4 +47,9 @@ FpiMatchResult fpi_print_bz3_match (FpPrint * template,
                                     gint bz3_threshold,
                                     GError **error);
 
+/* Helpers to encode metadata into user ID strings. */
+gchar *  fpi_print_generate_user_id (FpPrint *print);
+gboolean fpi_print_fill_from_user_id (FpPrint    *print,
+                                      const char *user_id);
+
 G_END_DECLS

libfprint/fpi-ssm.h

@@ -22,7 +22,6 @@
 #pragma once
 
 #include "fp-device.h"
-#include "fpi-usb-transfer.h"
 
 /* async drv <--> lib comms */
 
@@ -101,6 +100,8 @@ int fpi_ssm_get_cur_state (FpiSsm *machine);
 /* Callbacks to be used by the driver instead of implementing their own
  * logic.
  */
+typedef struct _FpiUsbTransfer FpiUsbTransfer;
+
 void fpi_ssm_usb_transfer_cb (FpiUsbTransfer *transfer,
                               FpDevice       *device,
                               gpointer        unused_data,

libfprint/fpi-usb-transfer.c

@@ -366,7 +366,7 @@ transfer_finish_cb (GObject *source_object, GAsyncResult *res, gpointer user_dat
  *
  * Note that #FpiUsbTransfer will be stolen when this function is called.
  * So that all associated data will be free'ed automatically, after the
- * callback ran unless fpi_usb_transfer_ref() is explictly called.
+ * callback ran unless fpi_usb_transfer_ref() is explicitly called.
  */
 void
 fpi_usb_transfer_submit (FpiUsbTransfer        *transfer,

libfprint/fpi-usb-transfer.h

@@ -30,8 +30,7 @@ G_BEGIN_DECLS
 #define FPI_USB_ENDPOINT_OUT 0x00
 
 typedef struct _FpiUsbTransfer FpiUsbTransfer;
-
-#include "fpi-ssm.h"
+typedef struct _FpiSsm         FpiSsm;
 
 typedef void (*FpiUsbTransferCallback)(FpiUsbTransfer *transfer,
                                        FpDevice       *dev,
@@ -62,7 +61,7 @@ typedef enum  {
  * @length: The requested length of the transfer in bytes.
  * @actual_length: The actual length of the transfer
  *  (see also fpi_usb_transfer_set_short_error())
- * @buffer: The transfered data.
+ * @buffer: The transferred data.
  *
  * Helper for handling USB transfers.
  */

libfprint/fprint-list-supported-devices.c

@@ -2,7 +2,7 @@
  * Copyright (C) 2009 Red Hat <mjg@redhat.com>
  * Copyright (C) 2008 Bastien Nocera <hadess@hadess.net>
  * Copyright (C) 2008 Timo Hoenig <thoenig@suse.de>, <thoenig@nouse.net>
- * Coypright (C) 2019 Benjamin Berg <bberg@redhat.com>
+ * 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
@@ -38,8 +38,7 @@ insert_drivers (GList *list)
   for (i = 0; i < drivers->len; i++)
     {
       GType driver = g_array_index (drivers, GType, i);
-      g_autoptr(GTypeClass) type_class = g_type_class_ref (driver);
-      FpDeviceClass *cls = FP_DEVICE_CLASS (type_class);
+      g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
       const FpIdEntry *entry;
 
       if (cls->type != FP_DEVICE_TYPE_USB)

libfprint/fprint-list-udev-rules.c

@@ -2,7 +2,7 @@
  * Copyright (C) 2009 Red Hat <mjg@redhat.com>
  * Copyright (C) 2008 Bastien Nocera <hadess@hadess.net>
  * Copyright (C) 2008 Timo Hoenig <thoenig@suse.de>, <thoenig@nouse.net>
- * Coypright (C) 2019 Benjamin Berg <bberg@redhat.com>
+ * 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
@@ -104,8 +104,7 @@ main (int argc, char **argv)
   for (i = 0; i < drivers->len; i++)
     {
       GType driver = g_array_index (drivers, GType, i);
-      g_autoptr(GTypeClass) type_class = g_type_class_ref (driver);
-      FpDeviceClass *cls = FP_DEVICE_CLASS (type_class);
+      g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
 
       if (cls->type != FP_DEVICE_TYPE_USB)
         continue;

libfprint/meson.build

@@ -8,32 +8,39 @@ libfprint_sources = [
 
 libfprint_private_sources = [
     'fpi-assembling.c',
+    'fpi-byte-reader.c',
+    'fpi-byte-writer.c',
     'fpi-device.c',
-    'fpi-image.c',
     'fpi-image-device.c',
+    'fpi-image.c',
     'fpi-print.c',
     'fpi-ssm.c',
     'fpi-usb-transfer.c',
-    'fpi-byte-reader.c',
-    'fpi-byte-writer.c',
 ]
 
 libfprint_public_headers = [
     'fp-context.h',
     'fp-device.h',
+    'fp-image-device.h',
     'fp-image.h',
     'fp-print.h',
 ]
 
 libfprint_private_headers = [
     'fpi-assembling.h',
-    'fpi-device.h',
-    'fpi-image.h',
-    'fpi-image-device.h',
-    'fpi-print.h',
     'fpi-byte-reader.h',
-    'fpi-byte-writer.h',
     'fpi-byte-utils.h',
+    'fpi-byte-writer.h',
+    'fpi-compat.h',
+    'fpi-context.h',
+    'fpi-device.h',
+    'fpi-image-device.h',
+    'fpi-image.h',
+    'fpi-log.h',
+    'fpi-minutiae.h',
+    'fpi-print.h',
+    'fpi-usb-transfer.h',
+    'fpi-ssm.h',
 ]
 
 nbis_sources = [
@@ -148,6 +155,9 @@ foreach driver: drivers
     if driver == 'virtual_image'
         drivers_sources += [ 'drivers/virtual-image.c' ]
     endif
+    if driver == 'virtual_device'
+        drivers_sources += [ 'drivers/virtual-device.c' ]
+    endif
     if driver == 'synaptics'
     drivers_sources += [
         'drivers/synaptics/synaptics.c',
@@ -170,14 +180,21 @@ other_sources = []
 
 fp_enums = gnome.mkenums_simple('fp-enums',
     sources: libfprint_public_headers,
-    install_header : true)
+    install_header: true,
+    install_dir: get_option('includedir') / versioned_libname,
+)
 fp_enums_h = fp_enums[1]
 
 fpi_enums = gnome.mkenums_simple('fpi-enums',
     sources: libfprint_private_headers,
-    install_header : true)
+    install_header: false,
+)
 fpi_enums_h = fpi_enums[1]
 
+enums_dep = declare_dependency(
+    sources: [ fp_enums_h, fpi_enums_h ]
+)
+
 drivers_sources += configure_file(input: 'empty_file',
     output: 'fpi-drivers.c',
     capture: true,
@@ -186,8 +203,21 @@ drivers_sources += configure_file(input: 'empty_file',
         '\n'.join(drivers_type_list + [] + drivers_type_func)
     ])
 
-deps = [ mathlib_dep, glib_dep, gusb_dep, nss_dep, imaging_dep, gio_dep ]
+deps = [
+    enums_dep,
+    gio_dep,
+    glib_dep,
+    gobject_dep,
+    gusb_dep,
+    imaging_dep,
+    mathlib_dep,
+    nss_dep,
+]
 
+# These are empty and only exist so that the include directories are created
+# in the build tree. This silences a build time warning.
+subdir('nbis/include')
+subdir('nbis/libfprint-include')
 deps += declare_dependency(include_directories: [
     root_inc,
     include_directories('nbis/include'),
@@ -205,13 +235,16 @@ libnbis = static_library('nbis',
     install: false)
 
 libfprint_private = static_library('fprint-private',
-    sources: libfprint_private_sources + fpi_enums,
+    sources: [
+        fpi_enums,
+        libfprint_private_sources,
+    ],
     dependencies: deps,
     link_with: libnbis,
     install: false)
 
 libfprint_drivers = static_library('fprint-drivers',
-    sources: drivers_sources + [ fp_enums_h ],
+    sources: drivers_sources,
     c_args: drivers_cflags,
     dependencies: deps,
     link_with: libfprint_private,
@@ -220,26 +253,33 @@ libfprint_drivers = static_library('fprint-drivers',
 mapfile = files('libfprint.ver')
 vflag = '-Wl,--version-script,@0@/@1@'.format(meson.source_root(), mapfile[0])
 
-libfprint = library('fprint',
-    sources: libfprint_sources + fp_enums + other_sources,
+libfprint = library(versioned_libname.split('lib')[1],
+    sources: [
+        fp_enums,
+        libfprint_sources,
+        other_sources,
+    ],
     soversion: soversion,
     version: libversion,
     link_args : vflag,
     link_depends : mapfile,
-    link_with: [libfprint_private, libfprint_drivers],
+    link_with: [libfprint_drivers, libfprint_private],
     dependencies: deps,
     install: true)
 
 libfprint_dep = declare_dependency(link_with: libfprint,
-    sources: [ fp_enums_h ],
     include_directories: root_inc,
     dependencies: [
+        enums_dep,
         gio_dep,
         glib_dep,
+        gobject_dep,
         gusb_dep,
     ])
 
-install_headers(['fprint.h'] + libfprint_public_headers, subdir: 'libfprint')
+install_headers(['fprint.h'] + libfprint_public_headers,
+    subdir: versioned_libname
+)
 
 libfprint_private_dep = declare_dependency(
     include_directories: include_directories('.'),
@@ -258,7 +298,7 @@ udev_rules = executable('fprint-list-udev-rules',
 
 if get_option('udev_rules')
     custom_target('udev-rules',
-        output: '60-fprint-autosuspend.rules',
+        output: '60-@0@-autosuspend.rules'.format(versioned_libname),
         capture: true,
         command: [ udev_rules ],
         install: true,
@@ -279,7 +319,7 @@ if get_option('introspection')
             libfprint_public_headers,
             libfprint_sources,
         ],
-        nsversion : '2.0',
+        nsversion : '@0@.0'.format(soversion),
         namespace : 'FPrint',
         symbol_prefix : 'fp_',
         identifier_prefix : 'Fp',
@@ -290,6 +330,7 @@ if get_option('introspection')
         link_with : libfprint,
         dependencies : [
             gio_dep,
+            gobject_dep,
             gusb_dep,
         ],
         includes : [

meson.build

@@ -1,12 +1,12 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.90.0',
+    version: '1.90.1',
     license: 'LGPLv2.1+',
     default_options: [
         'buildtype=debugoptimized',
         'warning_level=1',
-        'c_std=c99',
+        'c_std=gnu99',
     ],
-    meson_version: '>= 0.46.0')
+    meson_version: '>= 0.49.0')
 
 gnome = import('gnome')
 
@@ -53,10 +53,9 @@ common_cflags = cc.get_supported_arguments([
     '-DGLIB_VERSION_MIN_REQUIRED=' + glib_version_def,
     '-DGLIB_VERSION_MAX_ALLOWED=' + glib_version_def,
     '-D_GNU_SOURCE',
-    '-DG_LOG_DOMAIN="libfprint"',
+    '-DG_LOG_DOMAIN="@0@"'.format(meson.project_name()),
 ])
 c_cflags = cc.get_supported_arguments([
-    '-std=gnu99',
     '-Wimplicit-function-declaration',
     '-Wmissing-prototypes',
     '-Wnested-externs',
@@ -75,16 +74,21 @@ soversion = 2
 current = 0
 revision = 0
 libversion = '@0@.@1@.@2@'.format(soversion, current, revision)
+versioned_libname = meson.project_name() + '-' + soversion.to_string()
 
 # Dependencies
 glib_dep = dependency('glib-2.0', version: '>=' + glib_min_version)
 gio_dep = dependency('gio-unix-2.0', version: '>=' + glib_min_version)
-gusb_dep = dependency('gusb', version: '>= 0.3.0')
+gobject_dep = dependency('gobject-2.0', version: '>=' + glib_min_version)
+gusb_dep = dependency('gusb', version: '>= 0.2.0')
 mathlib_dep = cc.find_library('m', required: false)
 
+# The following dependencies are only used for tests
+cairo_dep = dependency('cairo', required: false)
+
 # Drivers
 drivers = get_option('drivers').split(',')
-virtual_drivers = [ 'virtual_image' ]
+virtual_drivers = [ 'virtual_image', 'virtual_device' ]
 default_drivers = [
     'upektc_img',
     'vfs5011',
@@ -203,10 +207,11 @@ subdir('tests')
 
 pkgconfig = import('pkgconfig')
 pkgconfig.generate(
-    name: 'libfprint',
+    name: versioned_libname,
     description: 'Generic C API for fingerprint reader access',
     version: meson.project_version(),
     libraries: libfprint,
-    subdirs: 'libfprint',
-    filebase: 'libfprint2',
-    install_dir: join_paths(get_option('libdir'), 'pkgconfig'))
+    requires: [gio_dep, gobject_dep],
+    subdirs: versioned_libname,
+    filebase: versioned_libname,
+)

tests/README-umockdev

@@ -21,4 +21,33 @@ To create a new umockdev test, you should:
 Please note, there is no need to use a real finger print in this case. If
 you would like to avoid submitting your own fingerprint then please just
 use e.g. the side of your finger, arm, or anything else that will produce
-an image with the device.
+an image with the device.
+
+
+Note that umockdev-record groups URBs aggressively. In most cases, manual
+intervention is unfortunately required. In most cases, drivers do a chain
+of commands like e.g. A then B each with a different reply. Umockdev will
+create a file like:
+
+A
+ reply 1
+ reply 2
+B
+ reply 1
+ reply 2
+
+which then needs to be re-ordered to be:
+
+A
+ reply 1
+B
+ reply 1
+A
+ reply 2
+B
+ reply 2
+
+Other changes may be needed to get everything working. For example the elan
+driver relies on a timeout that is not reported correctly. In this case the
+driver works around it by interpreting the protocol error differently in
+the virtual environment.

tests/capture.py

@@ -17,6 +17,7 @@ c.enumerate()
 devices = c.get_devices()
 
 d = devices[0]
+del devices
 
 d.open_sync()
 
@@ -24,6 +25,9 @@ img = d.capture_sync(True)
 
 d.close_sync()
 
+del d
+del c
+
 width = img.get_width()
 height = img.get_height()
 

tests/elan/device

@@ -0,0 +1,284 @@
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-4/1-4.4
+N: bus/usb/001/094=1201000200000008F304260C40010102000109023E0001010080320904000005FF0000000921100100012215000705810240000107050102400001070582024000010705830240000107050302400001
+E: DEVNAME=/dev/bus/usb/001/094
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=4f3/c26/140
+E: TYPE=0/0/0
+E: BUSNUM=001
+E: DEVNUM=094
+E: MAJOR=189
+E: MINOR=93
+E: SUBSYSTEM=usb
+E: ID_VENDOR=ELAN
+E: ID_VENDOR_ENC=ELAN
+E: ID_VENDOR_ID=04f3
+E: ID_MODEL=ELAN:Fingerprint
+E: ID_MODEL_ENC=ELAN:Fingerprint
+E: ID_MODEL_ID=0c26
+E: ID_REVISION=0140
+E: ID_SERIAL=ELAN_ELAN:Fingerprint
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:ff0000:
+E: ID_VENDOR_FROM_DATABASE=Elan Microelectronics Corp.
+E: ID_PATH=pci-0000:00:14.0-usb-0:4.4
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_4_4
+E: LIBFPRINT_DRIVER=ElanTech Fingerprint Sensor
+A: authorized=1
+A: avoid_reset_quirk=0
+A: bConfigurationValue=1
+A: bDeviceClass=00
+A: bDeviceProtocol=00
+A: bDeviceSubClass=00
+A: bMaxPacketSize0=8
+A: bMaxPower=100mA
+A: bNumConfigurations=1
+A: bNumInterfaces= 1
+A: bcdDevice=0140
+A: bmAttributes=80
+A: busnum=1
+A: configuration=
+H: descriptors=1201000200000008F304260C40010102000109023E0001010080320904000005FF0000000921100100012215000705810240000107050102400001070582024000010705830240000107050302400001
+A: dev=189:93
+A: devnum=94
+A: devpath=4.4
+L: driver=../../../../../../bus/usb/drivers/usb
+A: idProduct=0c26
+A: idVendor=04f3
+A: ltm_capable=no
+A: manufacturer=ELAN
+A: maxchild=0
+L: port=../1-4:1.0/1-4-port4
+A: power/active_duration=4747
+A: power/autosuspend=2
+A: power/autosuspend_delay_ms=2000
+A: power/connected_duration=54012
+A: power/control=auto
+A: power/level=auto
+A: power/persist=1
+A: power/runtime_active_time=4721
+A: power/runtime_status=active
+A: power/runtime_suspended_time=49114
+A: product=ELAN:Fingerprint
+A: quirks=0x0
+A: removable=removable
+A: rx_lanes=1
+A: speed=12
+A: tx_lanes=1
+A: urbnum=13
+A: version= 2.00
+
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-4
+N: bus/usb/001/083=1201100209000140EF17181084520102000109021900010100E0000904000001090000000705810301000C
+E: DEVNAME=/dev/bus/usb/001/083
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=17ef/1018/5284
+E: TYPE=9/0/1
+E: BUSNUM=001
+E: DEVNUM=083
+E: MAJOR=189
+E: MINOR=82
+E: SUBSYSTEM=usb
+E: ID_VENDOR=VIA_Labs__Inc.
+E: ID_VENDOR_ENC=VIA\x20Labs\x2c\x20Inc.\x20\x20\x20\x20\x20\x20\x20\x20\x20
+E: ID_VENDOR_ID=17ef
+E: ID_MODEL=USB2.0_Hub
+E: ID_MODEL_ENC=USB2.0\x20Hub\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20
+E: ID_MODEL_ID=1018
+E: ID_REVISION=5284
+E: ID_SERIAL=VIA_Labs__Inc._USB2.0_Hub
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:090000:
+E: ID_VENDOR_FROM_DATABASE=Lenovo
+E: ID_PATH=pci-0000:00:14.0-usb-0:4
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_4
+E: ID_FOR_SEAT=usb-pci-0000_00_14_0-usb-0_4
+E: TAGS=:seat:
+A: authorized=1
+A: avoid_reset_quirk=0
+A: bConfigurationValue=1
+A: bDeviceClass=09
+A: bDeviceProtocol=01
+A: bDeviceSubClass=00
+A: bMaxPacketSize0=64
+A: bMaxPower=0mA
+A: bNumConfigurations=1
+A: bNumInterfaces= 1
+A: bcdDevice=5284
+A: bmAttributes=e0
+A: busnum=1
+A: configuration=
+H: descriptors=1201100209000140EF17181084520102000109021900010100E0000904000001090000000705810301000C
+A: dev=189:82
+A: devnum=83
+A: devpath=4
+L: driver=../../../../../bus/usb/drivers/usb
+A: idProduct=1018
+A: idVendor=17ef
+A: ltm_capable=no
+A: manufacturer=VIA Labs, Inc.
+A: maxchild=4
+L: port=../1-0:1.0/usb1-port4
+A: power/active_duration=11223581
+A: power/autosuspend=0
+A: power/autosuspend_delay_ms=0
+A: power/connected_duration=11223581
+A: power/control=auto
+A: power/level=auto
+A: power/runtime_active_time=11223333
+A: power/runtime_status=active
+A: power/runtime_suspended_time=0
+A: power/wakeup=disabled
+A: power/wakeup_abort_count=
+A: power/wakeup_active=
+A: power/wakeup_active_count=
+A: power/wakeup_count=
+A: power/wakeup_expire_count=
+A: power/wakeup_last_time_ms=
+A: power/wakeup_max_time_ms=
+A: power/wakeup_total_time_ms=
+A: product=USB2.0 Hub
+A: quirks=0x0
+A: removable=removable
+A: rx_lanes=1
+A: speed=480
+A: tx_lanes=1
+A: urbnum=106
+A: version= 2.10
+
+P: /devices/pci0000:00/0000:00:14.0/usb1
+N: bus/usb/001/001=12010002090001406B1D020003050302010109021900010100E0000904000001090000000705810304000C
+E: DEVNAME=/dev/bus/usb/001/001
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=1d6b/2/503
+E: TYPE=9/0/1
+E: BUSNUM=001
+E: DEVNUM=001
+E: MAJOR=189
+E: MINOR=0
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Linux_5.3.8-300.fc31.x86_64_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x205.3.8-300.fc31.x86_64\x20xhci-hcd
+E: ID_VENDOR_ID=1d6b
+E: ID_MODEL=xHCI_Host_Controller
+E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
+E: ID_MODEL_ID=0002
+E: ID_REVISION=0503
+E: ID_SERIAL=Linux_5.3.8-300.fc31.x86_64_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_SERIAL_SHORT=0000:00:14.0
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:090000:
+E: ID_VENDOR_FROM_DATABASE=Linux Foundation
+E: ID_MODEL_FROM_DATABASE=2.0 root hub
+E: ID_PATH=pci-0000:00:14.0
+E: ID_PATH_TAG=pci-0000_00_14_0
+E: ID_FOR_SEAT=usb-pci-0000_00_14_0
+E: TAGS=:seat:
+A: authorized=1
+A: authorized_default=1
+A: avoid_reset_quirk=0
+A: bConfigurationValue=1
+A: bDeviceClass=09
+A: bDeviceProtocol=01
+A: bDeviceSubClass=00
+A: bMaxPacketSize0=64
+A: bMaxPower=0mA
+A: bNumConfigurations=1
+A: bNumInterfaces= 1
+A: bcdDevice=0503
+A: bmAttributes=e0
+A: busnum=1
+A: configuration=
+H: descriptors=12010002090001406B1D020003050302010109021900010100E0000904000001090000000705810304000C
+A: dev=189:0
+A: devnum=1
+A: devpath=0
+L: driver=../../../../bus/usb/drivers/usb
+A: idProduct=0002
+A: idVendor=1d6b
+A: interface_authorized_default=1
+A: ltm_capable=no
+A: manufacturer=Linux 5.3.8-300.fc31.x86_64 xhci-hcd
+A: maxchild=12
+A: power/active_duration=2372569822
+A: power/autosuspend=0
+A: power/autosuspend_delay_ms=0
+A: power/connected_duration=2405642105
+A: power/control=auto
+A: power/level=auto
+A: power/runtime_active_time=2372599414
+A: power/runtime_status=active
+A: power/runtime_suspended_time=33016992
+A: power/wakeup=disabled
+A: power/wakeup_abort_count=
+A: power/wakeup_active=
+A: power/wakeup_active_count=
+A: power/wakeup_count=
+A: power/wakeup_expire_count=
+A: power/wakeup_last_time_ms=
+A: power/wakeup_max_time_ms=
+A: power/wakeup_total_time_ms=
+A: product=xHCI Host Controller
+A: quirks=0x0
+A: removable=unknown
+A: rx_lanes=1
+A: serial=0000:00:14.0
+A: speed=480
+A: tx_lanes=1
+A: urbnum=19225
+A: version= 2.00
+
+P: /devices/pci0000:00/0000:00:14.0
+E: DRIVER=xhci_hcd
+E: PCI_CLASS=C0330
+E: PCI_ID=8086:9D2F
+E: PCI_SUBSYS_ID=17AA:2238
+E: PCI_SLOT_NAME=0000:00:14.0
+E: MODALIAS=pci:v00008086d00009D2Fsv000017AAsd00002238bc0Csc03i30
+E: SUBSYSTEM=pci
+E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
+E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
+E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
+E: ID_VENDOR_FROM_DATABASE=Intel Corporation
+E: ID_MODEL_FROM_DATABASE=Sunrise Point-LP USB 3.0 xHCI Controller
+A: ari_enabled=0
+A: broken_parity_status=0
+A: class=0x0c0330
+H: config=86802F9D060490022130030C00008000040022E1000000000000000000000000000000000000000000000000AA1738220000000070000000000000000B010000
+A: consistent_dma_mask_bits=64
+A: d3cold_allowed=1
+A: dbc=disabled
+A: device=0x9d2f
+A: dma_mask_bits=64
+L: driver=../../../bus/pci/drivers/xhci_hcd
+A: driver_override=(null)
+A: enable=1
+A: irq=125
+A: local_cpulist=0-3
+A: local_cpus=f
+A: modalias=pci:v00008086d00009D2Fsv000017AAsd00002238bc0Csc03i30
+A: msi_bus=1
+A: msi_irqs/125=msi
+A: numa_node=-1
+A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts   37   38 2112 38\nxHCI ring segments  116  120 4096 120\nbuffer-2048         3    6 2048  3\nbuffer-512          0    0  512  0\nbuffer-128         30   32  128  1\nbuffer-32           0    0   32  0
+A: power/control=on
+A: power/runtime_active_time=2405617003
+A: power/runtime_status=active
+A: power/runtime_suspended_time=0
+A: power/wakeup=enabled
+A: power/wakeup_abort_count=0
+A: power/wakeup_active=0
+A: power/wakeup_active_count=0
+A: power/wakeup_count=0
+A: power/wakeup_expire_count=0
+A: power/wakeup_last_time_ms=0
+A: power/wakeup_max_time_ms=0
+A: power/wakeup_total_time_ms=0
+A: resource=0x00000000e1220000 0x00000000e122ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000
+A: revision=0x21
+A: subsystem_device=0x2238
+A: subsystem_vendor=0x17aa
+A: vendor=0x8086
+

tests/meson.build

@@ -4,7 +4,7 @@ envs.set('G_DEBUG', 'fatal-warnings')
 envs.set('G_MESSAGES_DEBUG', 'all')
 
 # Setup paths
-envs.set('MESON_SOURCE_ROOT', meson.build_root())
+envs.set('MESON_SOURCE_ROOT', meson.source_root())
 envs.prepend('LD_LIBRARY_PATH', join_paths(meson.build_root(), 'libfprint'))
 
 # Set FP_DEVICE_EMULATION so that drivers can adapt (e.g. to use fixed
@@ -16,34 +16,83 @@ envs.set('FP_DRIVERS_WHITELIST', 'virtual_image')
 
 envs.set('NO_AT_BRIDGE', '1')
 
+drivers_tests = [
+    'elan',
+    'vfs5011',
+    'synaptics',
+]
+
 if get_option('introspection')
     envs.prepend('GI_TYPELIB_PATH', join_paths(meson.build_root(), 'libfprint'))
 
     if 'virtual_image' in drivers
+        python3 = find_program('python3')
+        unittest_inspector = find_program('unittest_inspector.py')
+        base_args = files('virtual-image.py')
+        suite = []
+
+        r = run_command(unittest_inspector, files('virtual-image.py'))
+        unit_tests = r.stdout().strip().split('\n')
+
+        if r.returncode() == 0 and unit_tests.length() > 0
+            suite += 'virtual-image'
+        else
+            unit_tests = ['virtual-image']
+        endif
+
+        foreach ut: unit_tests
+            ut_suite = suite
+            ut_args = base_args
+            if unit_tests.length() > 1
+                ut_args += ut
+                ut_suite += ut.split('.')[0]
+            endif
+            test(ut,
+                python3,
+                args: ut_args,
+                suite: ut_suite,
+                depends: libfprint_typelib,
+                env: envs,
+            )
+        endforeach
+    else
         test('virtual-image',
-            find_program('virtual-image.py'),
-            args: '--verbose',
-            env: envs,
-            depends: libfprint_typelib,
+            find_program('sh'),
+            args: ['-c', 'exit 77']
         )
     endif
 
-    drivers_tests = [
-        'vfs5011',
-        'synaptics',
-    ]
-
     foreach driver_test: drivers_tests
         driver_envs = envs
         driver_envs.set('FP_DRIVERS_WHITELIST', driver_test)
 
+        if driver_test in drivers and gusb_dep.version().version_compare('>= 0.3.0')
+            test(driver_test,
+                find_program('umockdev-test.py'),
+                args: join_paths(meson.current_source_dir(), driver_test),
+                env: driver_envs,
+                suite: ['drivers'],
+                timeout: 10,
+                depends: libfprint_typelib,
+            )
+        else
+            test(driver_test,
+                find_program('sh'),
+                args: ['-c', 'exit 77']
+            )
+        endif
+    endforeach
+else
+    warning('Skipping all driver tests as introspection bindings are missing')
+    test('virtual-image',
+        find_program('sh'),
+        args: ['-c', 'exit 77']
+    )
+
+    foreach driver_test: drivers_tests
         test(driver_test,
-            find_program('umockdev-test.py'),
-            args: join_paths(meson.current_source_dir(), driver_test),
-            env: driver_envs,
-            suite: ['drivers'],
-            timeout: 10,
-            depends: libfprint_typelib,
+            find_program('sh'),
+            args: ['-c', 'exit 77']
         )
     endforeach
 endif
@@ -59,6 +108,7 @@ test_utils = static_library('fprint-test-utils',
 unit_tests = [
     'fpi-device',
     'fpi-ssm',
+    'fpi-assembling',
 ]
 
 if 'virtual_image' in drivers
@@ -68,11 +118,41 @@ if 'virtual_image' in drivers
     ]
 endif
 
+unit_tests_deps = { 'fpi-assembling' : [cairo_dep] }
+
+test_config = configuration_data()
+test_config.set_quoted('SOURCE_ROOT', meson.source_root())
+test_config_h = configure_file(output: 'test-config.h', configuration: test_config)
+
 foreach test_name: unit_tests
+    if unit_tests_deps.has_key(test_name)
+        missing_deps = false
+        foreach dep: unit_tests_deps[test_name]
+            if not dep.found()
+                missing_deps = true
+                break
+            endif
+        endforeach
+
+        if missing_deps
+            # Create a dummy test that always skips instead
+            warning('Test @0@ cannot be compiled due to missing dependencies'.format(test_name))
+            test(test_name,
+                find_program('sh'),
+                suite: ['unit-tests'],
+                args: ['-c', 'exit 77'],
+            )
+            continue
+        endif
+        extra_deps = unit_tests_deps[test_name]
+    else
+        extra_deps = []
+    endif
+
     basename = 'test-' + test_name
     test_exe = executable(basename,
-        sources: basename + '.c',
-        dependencies: libfprint_private_dep,
+        sources: [basename + '.c', test_config_h],
+        dependencies: [ libfprint_private_dep ] + extra_deps,
         c_args: common_cflags,
         link_with: test_utils,
     )

tests/synaptics/custom.py

@@ -11,6 +11,7 @@ c.enumerate()
 devices = c.get_devices()
 
 d = devices[0]
+del devices
 
 assert d.get_driver() == "synaptics"
 
@@ -40,3 +41,6 @@ print("deleting")
 d.delete_print_sync(p)
 print("delete done")
 d.close_sync()
+
+del d
+del c

tests/test-device-fake.c

@@ -35,9 +35,15 @@ fpi_device_fake_probe (FpDevice *device)
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_PROBE);
-
   fake_dev->last_called_function = fpi_device_fake_probe;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_PROBE);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
   fpi_device_probe_complete (device, dev_class->id, dev_class->full_name,
                              fake_dev->ret_error);
 }
@@ -47,9 +53,15 @@ fpi_device_fake_open (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_OPEN);
-
   fake_dev->last_called_function = fpi_device_fake_open;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_OPEN);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
   fpi_device_open_complete (device, fake_dev->ret_error);
 }
 
@@ -58,9 +70,15 @@ fpi_device_fake_close (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_CLOSE);
-
   fake_dev->last_called_function = fpi_device_fake_close;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_CLOSE);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
   fpi_device_close_complete (device, fake_dev->ret_error);
 }
 
@@ -70,14 +88,23 @@ fpi_device_fake_enroll (FpDevice *device)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *print = fake_dev->ret_print;
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_ENROLL);
+  fake_dev->last_called_function = fpi_device_fake_enroll;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_ENROLL);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
   fpi_device_get_enroll_data (device, (FpPrint **) &fake_dev->action_data);
 
   if (!print && !fake_dev->ret_error)
     fpi_device_get_enroll_data (device, &print);
 
-  fake_dev->last_called_function = fpi_device_fake_enroll;
-  fpi_device_enroll_complete (device, print, fake_dev->ret_error);
+  fpi_device_enroll_complete (device,
+                              print ? g_object_ref (print) : NULL,
+                              fake_dev->ret_error);
 }
 
 static void
@@ -86,15 +113,29 @@ fpi_device_fake_verify (FpDevice *device)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *print = fake_dev->ret_print;
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_VERIFY);
+  fake_dev->last_called_function = fpi_device_fake_verify;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_VERIFY);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
   fpi_device_get_verify_data (device, (FpPrint **) &fake_dev->action_data);
 
   if (!print && !fake_dev->ret_error)
     fpi_device_get_verify_data (device, &print);
 
-  fake_dev->last_called_function = fpi_device_fake_verify;
-  fpi_device_verify_complete (device, fake_dev->ret_result, print,
-                              fake_dev->ret_error);
+  if (!fake_dev->ret_error || fake_dev->ret_error->domain == FP_DEVICE_RETRY)
+    {
+      fpi_device_verify_report (device, fake_dev->ret_result, print, fake_dev->ret_error);
+      fpi_device_verify_complete (device, NULL);
+    }
+  else
+    {
+      fpi_device_verify_complete (device, fake_dev->ret_error);
+    }
 }
 
 static void
@@ -103,7 +144,15 @@ fpi_device_fake_identify (FpDevice *device)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *match = fake_dev->ret_match;
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_IDENTIFY);
+  fake_dev->last_called_function = fpi_device_fake_identify;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_IDENTIFY);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
   fpi_device_get_identify_data (device, (GPtrArray **) &fake_dev->action_data);
 
   if (!match && !fake_dev->ret_error)
@@ -125,20 +174,34 @@ fpi_device_fake_identify (FpDevice *device)
         }
     }
 
-  fake_dev->last_called_function = fpi_device_fake_identify;
-  fpi_device_identify_complete (device, match, fake_dev->ret_print,
-                                fake_dev->ret_error);
+  if (!fake_dev->ret_error || fake_dev->ret_error->domain == FP_DEVICE_RETRY)
+    {
+      fpi_device_identify_report (device, match, fake_dev->ret_print, fake_dev->ret_error);
+      fpi_device_identify_complete (device, NULL);
+    }
+  else
+    {
+      fpi_device_identify_complete (device, fake_dev->ret_error);
+    }
 }
 
 static void
 fpi_device_fake_capture (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
-
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_CAPTURE);
-  fpi_device_get_capture_data (device, (gboolean *) &fake_dev->action_data);
+  gboolean wait_for_finger;
 
   fake_dev->last_called_function = fpi_device_fake_capture;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_CAPTURE);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
+  fpi_device_get_capture_data (device, &wait_for_finger);
+  fake_dev->action_data = GINT_TO_POINTER (wait_for_finger);
   fpi_device_capture_complete (device, fake_dev->ret_image, fake_dev->ret_error);
 }
 
@@ -147,9 +210,15 @@ fpi_device_fake_list (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_LIST);
-
   fake_dev->last_called_function = fpi_device_fake_list;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_LIST);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
   fpi_device_list_complete (device, fake_dev->ret_list, fake_dev->ret_error);
 }
 
@@ -158,10 +227,16 @@ fpi_device_fake_delete (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_DELETE);
-  fpi_device_get_delete_data (device, (gpointer) & fake_dev->action_data);
-
   fake_dev->last_called_function = fpi_device_fake_delete;
+  g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_DELETE);
+
+  if (fake_dev->return_action_error)
+    {
+      fpi_device_action_error (device, fake_dev->ret_error);
+      return;
+    }
+
+  fpi_device_get_delete_data (device, (FpPrint **) (&fake_dev->action_data));
   fpi_device_delete_complete (device, fake_dev->ret_error);
 }
 
@@ -170,9 +245,8 @@ fpi_device_fake_cancel (FpDevice *device)
 {
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  g_assert_cmpuint (fpi_device_get_current_action (device), !=, FP_DEVICE_ACTION_NONE);
-
   fake_dev->last_called_function = fpi_device_fake_cancel;
+  g_assert_cmpuint (fpi_device_get_current_action (device), !=, FPI_DEVICE_ACTION_NONE);
 }
 
 static void

tests/test-device-fake.h

@@ -30,6 +30,7 @@ struct _FpiDeviceFake
   FpDevice       parent;
 
   gpointer       last_called_function;
+  gboolean       return_action_error;
 
   GError        *ret_error;
   FpPrint       *ret_print;

tests/test-fp-context.c

@@ -49,7 +49,7 @@ test_context_has_virtual_device (void)
   GPtrArray *devices;
   unsigned int i;
 
-  fpt_setup_virtual_device_environment ();
+  fpt_setup_virtual_device_environment (FPT_VIRTUAL_DEVICE_IMAGE);
 
   context = fp_context_new ();
   devices = fp_context_get_devices (context);
@@ -70,7 +70,7 @@ test_context_has_virtual_device (void)
 
   g_assert_true (FP_IS_DEVICE (virtual_device));
 
-  fpt_teardown_virtual_device_environment ();
+  fpt_teardown_virtual_device_environment (FPT_VIRTUAL_DEVICE_IMAGE);
 }
 
 static void
@@ -81,7 +81,7 @@ test_context_enumerates_new_devices (void)
 
   context = fp_context_new ();
 
-  fpt_setup_virtual_device_environment ();
+  fpt_setup_virtual_device_environment (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_context_enumerate (context);
   devices = fp_context_get_devices (context);
@@ -89,7 +89,7 @@ test_context_enumerates_new_devices (void)
   g_assert_nonnull (devices);
   g_assert_cmpuint (devices->len, ==, 1);
 
-  fpt_teardown_virtual_device_environment ();
+  fpt_teardown_virtual_device_environment (FPT_VIRTUAL_DEVICE_IMAGE);
 }
 
 int

tests/test-fp-device.c

@@ -36,7 +36,7 @@ on_device_opened (FpDevice *dev, GAsyncResult *res, FptContext *tctx)
 static void
 test_device_open_async (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open (tctx->device, NULL, (GAsyncReadyCallback) on_device_opened, tctx);
 
@@ -59,7 +59,7 @@ on_device_closed (FpDevice *dev, GAsyncResult *res, FptContext *tctx)
 static void
 test_device_close_async (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open (tctx->device, NULL, (GAsyncReadyCallback) on_device_opened, tctx);
   while (!tctx->user_data)
@@ -76,7 +76,7 @@ static void
 test_device_open_sync (void)
 {
   g_autoptr(GError) error = NULL;
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, &error);
   g_assert_no_error (error);
@@ -97,7 +97,7 @@ static void
 test_device_open_sync_notify (void)
 {
   g_autoptr(GError) error = NULL;
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   g_signal_connect (tctx->device, "notify::open", G_CALLBACK (on_open_notify), tctx);
   fp_device_open_sync (tctx->device, NULL, &error);
@@ -109,7 +109,7 @@ static void
 test_device_close_sync (void)
 {
   g_autoptr(GError) error = NULL;
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   fp_device_close_sync (tctx->device, NULL, &error);
@@ -131,7 +131,7 @@ static void
 test_device_close_sync_notify (void)
 {
   g_autoptr(GError) error = NULL;
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
 
@@ -144,7 +144,7 @@ test_device_close_sync_notify (void)
 static void
 test_device_get_driver (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   g_assert_cmpstr (fp_device_get_driver (tctx->device), ==, "virtual_image");
@@ -153,7 +153,7 @@ test_device_get_driver (void)
 static void
 test_device_get_device_id (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   g_assert_cmpstr (fp_device_get_device_id (tctx->device), ==, "0");
@@ -162,7 +162,7 @@ test_device_get_device_id (void)
 static void
 test_device_get_name (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   g_assert_cmpstr (fp_device_get_name (tctx->device), ==,
@@ -172,7 +172,7 @@ test_device_get_name (void)
 static void
 test_device_get_scan_type (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   g_assert_cmpint (fp_device_get_scan_type (tctx->device), ==, FP_SCAN_TYPE_SWIPE);
@@ -181,7 +181,7 @@ test_device_get_scan_type (void)
 static void
 test_device_get_nr_enroll_stages (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   g_assert_cmpuint (fp_device_get_nr_enroll_stages (tctx->device), ==, 5);
@@ -190,7 +190,7 @@ test_device_get_nr_enroll_stages (void)
 static void
 test_device_supports_identify (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   g_assert_true (fp_device_supports_identify (tctx->device));
@@ -199,7 +199,7 @@ test_device_supports_identify (void)
 static void
 test_device_supports_capture (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   g_assert_true (fp_device_supports_capture (tctx->device));
@@ -208,7 +208,7 @@ test_device_supports_capture (void)
 static void
 test_device_has_storage (void)
 {
-  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
 
   fp_device_open_sync (tctx->device, NULL, NULL);
   g_assert_false (fp_device_has_storage (tctx->device));

tests/test-fpi-assembling.c

@@ -0,0 +1,135 @@
+/*
+ * Example fingerprint device prints listing and deletion
+ * Enrolls your right index finger and saves the print to disk
+ * 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
+ */
+
+#include <glib.h>
+#include <cairo.h>
+#include "fpi-assembling.h"
+#include "fpi-image.h"
+#include "test-config.h"
+
+typedef struct
+{
+  struct fpi_frame frame;
+  cairo_surface_t *surf;
+  guchar          *data;
+  guint            stride;
+  guint            width;
+  guint            height;
+  guint            x;
+  guint            y;
+} cairo_frame;
+
+static unsigned char
+cairo_get_pixel (struct fpi_frame_asmbl_ctx *ctx,
+                 struct fpi_frame           *frame,
+                 unsigned int                x,
+                 unsigned int                y)
+{
+  cairo_frame *c_frame = (void *) frame; /* Indirect cast to avoid alignment warning. */
+
+  x = x + c_frame->x;
+  y = y + c_frame->y;
+
+  g_assert (x < c_frame->width);
+  g_assert (y < c_frame->height);
+
+  return c_frame->data[x * 4 + y * c_frame->stride + 1];
+}
+
+static void
+test_frame_assembling (void)
+{
+  g_autofree char *path = NULL;
+  cairo_surface_t *img = NULL;
+  int width, height, stride, offset;
+  int test_height;
+  guchar *data;
+  struct fpi_frame_asmbl_ctx ctx = { 0, };
+
+  g_autoptr(FpImage) fp_img = NULL;
+  GSList *frames = NULL;
+
+  g_assert_false (SOURCE_ROOT == NULL);
+  path = g_build_path (G_DIR_SEPARATOR_S, SOURCE_ROOT, "tests", "vfs5011", "capture.png", NULL);
+
+  img = cairo_image_surface_create_from_png (path);
+  data = cairo_image_surface_get_data (img);
+  width = cairo_image_surface_get_width (img);
+  height = cairo_image_surface_get_height (img);
+  stride = cairo_image_surface_get_stride (img);
+  g_assert_cmpint (cairo_image_surface_get_format (img), ==, CAIRO_FORMAT_RGB24);
+
+  ctx.get_pixel = cairo_get_pixel;
+  ctx.frame_width = width;
+  ctx.frame_height = 20;
+  ctx.image_width = width;
+
+  offset = 10;
+  test_height = height - (height - ctx.frame_height) % offset;
+
+  /* for now, fixed offset */
+  for (int y = 0; y + ctx.frame_height < height; y += offset)
+    {
+      cairo_frame *frame = g_new0 (cairo_frame, 1);
+
+      frame->surf = img;
+      frame->width = width;
+      frame->height = height;
+      frame->stride = stride;
+      frame->data = data;
+      frame->x = 0;
+      frame->y = y;
+      //frame->y = test_height - ctx.frame_height - y;
+
+      frames = g_slist_append (frames, frame);
+    }
+  //offset = -offset;
+
+  fpi_do_movement_estimation (&ctx, frames);
+  for (GSList *l = frames->next; l != NULL; l = l->next)
+    {
+      cairo_frame * frame = l->data;
+
+      g_assert_cmpint (frame->frame.delta_x, ==, 0);
+      g_assert_cmpint (frame->frame.delta_y, ==, offset);
+    }
+
+  fp_img = fpi_assemble_frames (&ctx, frames);
+  g_assert_cmpint (fp_img->height, ==, test_height);
+
+  /* The FpImage and cairo surface need to be identical in the test area */
+  for (int y = 0; y < test_height; y++)
+    for (int x = 0; x < width; x++)
+      g_assert_cmpint (data[x * 4 + y * stride + 1], ==, fp_img->data[x + y * width]);
+
+  g_slist_free_full (frames, g_free);
+  cairo_surface_destroy (img);
+  g_assert (1);
+}
+
+int
+main (int argc, char *argv[])
+{
+  g_test_init (&argc, &argv, NULL);
+
+  g_test_add_func ("/assembling/frames", test_frame_assembling);
+
+  return g_test_run ();
+}

tests/test-fpi-ssm.c

@@ -39,6 +39,14 @@ typedef struct
   gboolean     expected_last_state;
 } FpiSsmTestData;
 
+static gboolean
+fpi_ssm_test_nullify_pointer (gpointer * nullify_location)
+{
+  *nullify_location = NULL;
+
+  return G_SOURCE_REMOVE;
+}
+
 static FpiSsmTestData *
 fpi_ssm_test_data_new (void)
 {
@@ -334,7 +342,7 @@ test_ssm_next_with_delayed (void)
   fpi_ssm_next_state (ssm);
   g_test_assert_expected_messages ();
 
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &timeout_tracker);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
   while (timeout_tracker)
     g_main_context_iteration (NULL, TRUE);
 
@@ -442,7 +450,7 @@ test_ssm_jump_to_state_with_delayed (void)
   fpi_ssm_jump_to_state (ssm, FPI_TEST_SSM_STATE_2);
   g_test_assert_expected_messages ();
 
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &timeout_tracker);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
   while (timeout_tracker)
     g_main_context_iteration (NULL, TRUE);
 
@@ -559,7 +567,7 @@ test_ssm_mark_completed_with_delayed (void)
   fpi_ssm_mark_completed (g_steal_pointer (&ssm));
   g_test_assert_expected_messages ();
 
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &timeout_tracker);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
   while (timeout_tracker)
     g_main_context_iteration (NULL, TRUE);
 
@@ -623,7 +631,7 @@ test_ssm_mark_failed_with_delayed (void)
                        fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
   g_test_assert_expected_messages ();
 
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &timeout_tracker);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
   while (timeout_tracker)
     g_main_context_iteration (NULL, TRUE);
 
@@ -680,7 +688,7 @@ test_ssm_delayed_next_cancel (void)
   g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
 
   g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_delayed_action_delayed, ssm, NULL);
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &timeout_tracker);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
 
   while (timeout_tracker)
     g_main_context_iteration (NULL, TRUE);
@@ -875,7 +883,7 @@ test_ssm_delayed_jump_to_state_cancel (void)
   g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
 
   g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_delayed_action_delayed, ssm, NULL);
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &timeout_tracker);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
 
   while (timeout_tracker)
     g_main_context_iteration (NULL, TRUE);
@@ -1058,7 +1066,7 @@ test_ssm_delayed_mark_completed_not_started (void)
   fpi_ssm_mark_completed_delayed (ssm, 10, NULL);
   g_test_assert_expected_messages ();
 
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &ssm);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &ssm);
 
   g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
   while (ssm != NULL)
@@ -1088,7 +1096,7 @@ test_ssm_delayed_mark_completed_cancel (void)
   g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
 
   g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_delayed_action_delayed, ssm, NULL);
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &timeout_tracker);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
 
   while (timeout_tracker)
     g_main_context_iteration (NULL, TRUE);
@@ -1312,7 +1320,7 @@ test_ssm_subssm_start_with_delayed (void)
   fpi_ssm_start_subsm (ssm, subssm);
   g_test_assert_expected_messages ();
 
-  g_timeout_add (100, (GSourceFunc) g_nullify_pointer, &timeout_tracker);
+  g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
   while (timeout_tracker)
     g_main_context_iteration (NULL, TRUE);
 

tests/test-utils.c

@@ -22,41 +22,60 @@
 
 #include "test-utils.h"
 
-void
-fpt_teardown_virtual_device_environment (void)
+struct
 {
-  const char *path = g_getenv ("FP_VIRTUAL_IMAGE");
+  const char *envvar;
+  const char *driver_id;
+  const char *device_id;
+} devtype_vars[FPT_NUM_VIRTUAL_DEVICE_TYPES] = {
+  { "FP_VIRTUAL_IMAGE", "virtual_image", "virtual_image" },               /* FPT_VIRTUAL_DEVICE_IMAGE */
+  { "FP_VIRTUAL_DEVICE", "virtual_device", "virtual_device" },            /* FPT_VIRTUAL_DEVICE */
+  { "FP_VIRTUAL_DEVICE_IDENT", "virtual_device", "virtual_device_ident" } /* FPT_VIRTUAL_DEVICE_IDENT */
+};
+
+void
+fpt_teardown_virtual_device_environment (FptVirtualDeviceType devtype)
+{
+  const char *path;
+
+  path = g_getenv (devtype_vars[devtype].envvar);
 
   if (path)
     {
       g_autofree char *temp_dir = g_path_get_dirname (path);
 
-      g_unsetenv ("FP_VIRTUAL_IMAGE");
+      g_unsetenv (devtype_vars[devtype].envvar);
       g_unlink (path);
       g_rmdir (temp_dir);
     }
 }
 
+static FptVirtualDeviceType global_devtype;
+
 static void
 on_signal_event (int sig)
 {
-  fpt_teardown_virtual_device_environment ();
+  fpt_teardown_virtual_device_environment (global_devtype);
 }
 
 void
-fpt_setup_virtual_device_environment (void)
+fpt_setup_virtual_device_environment (FptVirtualDeviceType devtype)
 {
   g_autoptr(GError) error = NULL;
   g_autofree char *temp_dir = NULL;
   g_autofree char *temp_path = NULL;
+  g_autofree char *filename = NULL;
 
-  g_assert_null (g_getenv ("FP_VIRTUAL_IMAGE"));
+  g_assert_null (g_getenv (devtype_vars[devtype].envvar));
 
   temp_dir = g_dir_make_tmp ("libfprint-XXXXXX", &error);
   g_assert_no_error (error);
 
-  temp_path = g_build_filename (temp_dir, "virtual-image.socket", NULL);
-  g_setenv ("FP_VIRTUAL_IMAGE", temp_path, TRUE);
+  filename = g_strdup_printf ("%s.socket", devtype_vars[devtype].device_id);
+  temp_path = g_build_filename (temp_dir, filename, NULL);
+  g_setenv (devtype_vars[devtype].envvar, temp_path, TRUE);
+
+  global_devtype = devtype;
 
   signal (SIGKILL, on_signal_event);
   signal (SIGABRT, on_signal_event);
@@ -78,13 +97,16 @@ fpt_context_new (void)
 }
 
 FptContext *
-fpt_context_new_with_virtual_imgdev (void)
+fpt_context_new_with_virtual_device (FptVirtualDeviceType devtype)
 {
   FptContext *tctx;
   GPtrArray *devices;
   unsigned int i;
 
-  fpt_setup_virtual_device_environment ();
+  g_assert_true (devtype >= FPT_VIRTUAL_DEVICE_IMAGE &&
+                 devtype < FPT_NUM_VIRTUAL_DEVICE_TYPES);
+
+  fpt_setup_virtual_device_environment (devtype);
 
   tctx = fpt_context_new ();
   devices = fp_context_get_devices (tctx->fp_context);
@@ -96,7 +118,7 @@ fpt_context_new_with_virtual_imgdev (void)
     {
       FpDevice *device = devices->pdata[i];
 
-      if (g_strcmp0 (fp_device_get_driver (device), "virtual_image") == 0)
+      if (g_strcmp0 (fp_device_get_driver (device), devtype_vars[devtype].driver_id) == 0)
         {
           tctx->device = device;
           break;
@@ -105,6 +127,7 @@ fpt_context_new_with_virtual_imgdev (void)
 
   g_assert_true (FP_IS_DEVICE (tctx->device));
   g_object_add_weak_pointer (G_OBJECT (tctx->device), (gpointer) & tctx->device);
+  g_object_set_data (G_OBJECT (tctx->fp_context), "devtype", GUINT_TO_POINTER (devtype));
 
   return tctx;
 }
@@ -112,6 +135,10 @@ fpt_context_new_with_virtual_imgdev (void)
 void
 fpt_context_free (FptContext *tctx)
 {
+  FptVirtualDeviceType devtype;
+
+  devtype = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (tctx->fp_context), "devtype"));
+
   if (tctx->device && fp_device_is_open (tctx->device))
     {
       g_autoptr(GError) error = NULL;
@@ -123,5 +150,5 @@ fpt_context_free (FptContext *tctx)
   g_clear_object (&tctx->fp_context);
   g_free (tctx);
 
-  fpt_teardown_virtual_device_environment ();
+  fpt_teardown_virtual_device_environment (devtype);
 }

tests/test-utils.h

@@ -19,8 +19,15 @@
 
 #include <glib.h>
 
-void fpt_setup_virtual_device_environment (void);
-void fpt_teardown_virtual_device_environment (void);
+typedef enum {
+  FPT_VIRTUAL_DEVICE_IMAGE = 0,
+  FPT_VIRTUAL_DEVICE,
+  FPT_VIRTUAL_DEVICE_IDENTIFY,
+  FPT_NUM_VIRTUAL_DEVICE_TYPES
+} FptVirtualDeviceType;
+
+void fpt_setup_virtual_device_environment (FptVirtualDeviceType devtype);
+void fpt_teardown_virtual_device_environment (FptVirtualDeviceType devtype);
 
 typedef struct _FptContext
 {
@@ -30,7 +37,7 @@ typedef struct _FptContext
 } FptContext;
 
 FptContext * fpt_context_new (void);
-FptContext * fpt_context_new_with_virtual_imgdev (void);
+FptContext * fpt_context_new_with_virtual_device (FptVirtualDeviceType devtype);
 
 void fpt_context_free (FptContext *test_context);
 

tests/unittest_inspector.py

@@ -0,0 +1,46 @@
+#! /usr/bin/env python3
+# Copyright © 2020, Canonical Ltd
+#
+# This program 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 program 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, see <http://www.gnu.org/licenses/>.
+# Authors:
+#       Marco Trevisan <marco.trevisan@canonical.com>
+
+import argparse
+import importlib.util
+import inspect
+import os
+import unittest
+
+def list_tests(module):
+    tests = []
+    for name, obj in inspect.getmembers(module):
+        if inspect.isclass(obj) and issubclass(obj, unittest.TestCase):
+            cases = unittest.defaultTestLoader.getTestCaseNames(obj)
+            tests += [ (obj, '{}.{}'.format(name, t)) for t in cases ]
+    return tests
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('unittest_source', type=argparse.FileType('r'))
+
+    args = parser.parse_args()
+    source_path = args.unittest_source.name
+    spec = importlib.util.spec_from_file_location(
+        os.path.basename(source_path), source_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    for machine, human in list_tests(module):
+        print(human)

tests/virtual-image.py

@@ -1,20 +1,25 @@
 #!/usr/bin/env python3
 
-
-import gi
-gi.require_version('FPrint', '2.0')
-from gi.repository import FPrint, GLib, Gio
-
-import os
 import sys
-import unittest
-import socket
-import struct
-import subprocess
-import shutil
-import glob
-import cairo
-import tempfile
+try:
+    import gi
+    import os
+
+    from gi.repository import GLib, Gio
+
+    import unittest
+    import socket
+    import struct
+    import subprocess
+    import shutil
+    import glob
+    import cairo
+    import tempfile
+except Exception as e:
+    print("Missing dependencies: %s" % str(e))
+    sys.exit(77)
+
+FPrint = None
 
 # Re-run the test with the passed wrapper if set
 wrapper = os.getenv('LIBFPRINT_TEST_WRAPPER')
@@ -83,6 +88,8 @@ class VirtualImage(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
         shutil.rmtree(cls.tmpdir)
+        del cls.dev
+        del cls.ctx
 
     def setUp(self):
         self.dev.open_sync()
@@ -95,15 +102,15 @@ class VirtualImage(unittest.TestCase):
         del self.con
         self.dev.close_sync()
 
-    def send_retry(self, retry_error=1, iterate=True):
-        # The default (1) is too-short
-        self.sendall(struct.pack('ii', -1, retry_error))
+    def send_retry(self, retry_error=None, iterate=True):
+        retry_error = retry_error if retry_error else FPrint.DeviceRetry.TOO_SHORT
+        self.con.sendall(struct.pack('ii', -1, retry_error))
         while iterate and ctx.pending():
             ctx.iteration(False)
 
-    def send_error(self, device_error=0, iterate=True):
-        # The default (0) is a generic error
-        self.sendall(struct.pack('ii', -1, retry_error))
+    def send_error(self, device_error=None, iterate=True):
+        device_error = device_error if device_error else FPrint.DeviceError.GENERAL
+        self.con.sendall(struct.pack('ii', -2, device_error))
         while iterate and ctx.pending():
             ctx.iteration(False)
 
@@ -210,15 +217,16 @@ class VirtualImage(unittest.TestCase):
         done = False
 
         def verify_cb(dev, res):
-            match, fp = dev.verify_finish(res)
-            self._verify_match = match
-            self._verify_fp = fp
+            try:
+                self._verify_match, self._verify_fp = dev.verify_finish(res)
+            except gi.repository.GLib.Error as e:
+                self._verify_error = e
 
         fp_whorl = self.enroll_print('whorl')
 
         self._verify_match = None
         self._verify_fp = None
-        self.dev.verify(fp_whorl, None, verify_cb)
+        self.dev.verify(fp_whorl, callback=verify_cb)
         self.send_image('whorl')
         while self._verify_match is None:
             ctx.iteration(True)
@@ -226,41 +234,79 @@ class VirtualImage(unittest.TestCase):
 
         self._verify_match = None
         self._verify_fp = None
-        self.dev.verify(fp_whorl, None, verify_cb)
+        self.dev.verify(fp_whorl, callback=verify_cb)
         self.send_image('tented_arch')
         while self._verify_match is None:
             ctx.iteration(True)
         assert(not self._verify_match)
 
+        # Test verify error cases
+        self._verify_fp = None
+        self._verify_error = None
+        self.dev.verify(fp_whorl, callback=verify_cb)
+        self.send_retry()
+        while self._verify_fp is None and self._verify_error is None:
+            ctx.iteration(True)
+        assert(self._verify_error is not None)
+        assert(self._verify_error.matches(FPrint.device_retry_quark(), FPrint.DeviceRetry.TOO_SHORT))
+
+        self._verify_fp = None
+        self._verify_error = None
+        self.dev.verify(fp_whorl, callback=verify_cb)
+        self.send_error()
+        while self._verify_fp is None and self._verify_error is None:
+            ctx.iteration(True)
+        assert(self._verify_error is not None)
+        print(self._verify_error)
+        assert(self._verify_error.matches(FPrint.device_error_quark(), FPrint.DeviceError.GENERAL))
+
     def test_identify(self):
         done = False
 
-        def verify_cb(dev, res):
-            r, fp = dev.verify_finish(res)
-            self._verify_match = r
-            self._verify_fp = fp
-
         fp_whorl = self.enroll_print('whorl')
         fp_tented_arch = self.enroll_print('tented_arch')
 
         def identify_cb(dev, res):
             print('Identify finished')
-            self._identify_match, self._identify_fp = self.dev.identify_finish(res)
+            try:
+                self._identify_match, self._identify_fp = self.dev.identify_finish(res)
+            except gi.repository.GLib.Error as e:
+                print(e)
+                self._identify_error = e
 
         self._identify_fp = None
-        self.dev.identify([fp_whorl, fp_tented_arch], None, identify_cb)
+        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
         self.send_image('tented_arch')
         while self._identify_fp is None:
             ctx.iteration(True)
         assert(self._identify_match is fp_tented_arch)
 
         self._identify_fp = None
-        self.dev.identify([fp_whorl, fp_tented_arch], None, identify_cb)
+        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
         self.send_image('whorl')
         while self._identify_fp is None:
             ctx.iteration(True)
         assert(self._identify_match is fp_whorl)
 
+        # Test error cases
+        self._identify_fp = None
+        self._identify_error = None
+        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
+        self.send_retry()
+        while self._identify_fp is None and self._identify_error is None:
+            ctx.iteration(True)
+        assert(self._identify_error is not None)
+        assert(self._identify_error.matches(FPrint.device_retry_quark(), FPrint.DeviceRetry.TOO_SHORT))
+
+        self._identify_fp = None
+        self._identify_error = None
+        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
+        self.send_error()
+        while self._identify_fp is None and self._identify_error is None:
+            ctx.iteration(True)
+        assert(self._identify_error is not None)
+        assert(self._identify_error.matches(FPrint.device_error_quark(), FPrint.DeviceError.GENERAL))
+
     def test_verify_serialized(self):
         done = False
 
@@ -288,7 +334,7 @@ class VirtualImage(unittest.TestCase):
 
         self._verify_match = None
         self._verify_fp = None
-        self.dev.verify(fp_whorl_new, None, verify_cb)
+        self.dev.verify(fp_whorl_new, callback=verify_cb)
         self.send_image('whorl')
         while self._verify_match is None:
             ctx.iteration(True)
@@ -296,12 +342,19 @@ class VirtualImage(unittest.TestCase):
 
         self._verify_match = None
         self._verify_fp = None
-        self.dev.verify(fp_whorl_new, None, verify_cb)
+        self.dev.verify(fp_whorl_new, callback=verify_cb)
         self.send_image('tented_arch')
         while self._verify_match is None:
             ctx.iteration(True)
         assert(not self._verify_match)
 
-# avoid writing to stderr
-unittest.main(testRunner=unittest.TextTestRunner(stream=sys.stdout, verbosity=2))
+if __name__ == '__main__':
+    try:
+        gi.require_version('FPrint', '2.0')
+        from gi.repository import FPrint
+    except Exception as e:
+        print("Missing dependencies: %s" % str(e))
+        sys.exit(77)
 
+    # avoid writing to stderr
+    unittest.main(testRunner=unittest.TextTestRunner(stream=sys.stdout, verbosity=2))