Release 1.90.7

It's not smart as g_strdup, so need to ensure we don't use it for NULL
strings.

This is a regression caused by commit bf223662

.git-blame-ignore-revs

@@ -0,0 +1,7 @@
+# The commits that did automated reformatting. You can ignore them
+# during git-blame with `--ignore-rev` or `--ignore-revs-file`.
+#
+#   $ git config --add 'blame.ignoreRevsFile' '.git-blame-ignore-revs'
+#
+
+f73429f06226f5423c92b1c504313657c9b6f9b5

.gitlab-ci.yml

@@ -29,6 +29,11 @@ variables:
 
 image: "$FEDORA_IMAGE"
 
+stages:
+  - check-source
+  - build
+  - test
+
 .fprintd_build_preconditions:
   except:
     variables:
@@ -47,8 +52,17 @@ image: "$FEDORA_IMAGE"
     # So we don't get error about this libfprint file
     - echo "libfprint/demo/gtk-libfprint-test.ui" >> po/POTFILES.skip
 
+test_indent:
+  stage: check-source
+  extends: .fprintd_build_preconditions
+  script:
+    - scripts/uncrustify.sh
+    - git diff
+    - "! git status -s | grep -q ."
+
 build_stable:
   extends: .fprintd_build_preconditions
+  stage: build
   script:
     - meson _build
     - ninja -C _build -v
@@ -58,6 +72,7 @@ build_dev:
   extends:
     - .fprintd_build_preconditions
     - .install_libfprint_dev
+  stage: build
   script:
     - meson _build --werror -Dgtk_doc=true
     - ninja -C _build -v

NEWS

@@ -1,6 +1,34 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
+Version 1.90.7:
+
+While 1.90.6 fixed a number of issues, we did have a bad regression due
+causing pam_fprintd to crash when there are no fingerprint devices
+installed.
+
+Highlights:
+ - pam: Guard strdup calls against NULL pointers
+
+
+Version 1.90.6:
+
+The 1.90.5 release was unusable due to a number of inter-related issues
+with the DBus interface and authorization. We also found a number of
+problems with possible security implications.
+
+Currently fprintd will do interactive authorization even if this was not
+requested using the correct DBus method call flag. All API users MUST be
+updated to set the flag as it will be enabled in the future!
+
+Highlights:
+ - Fix fprintd DBus configuration
+ - Change details of what requires authorization
+ - Fix various race conditions in pam_fprintd
+ - Permit interactive authorization from fprintd utilities
+ - Do not allow deletion while another operation is ongoing
+
+
 Version 1.90.5:
 
 The 1.90.4 release contained some bad errors, this release addresses those.

data/net.reactivated.Fprint.conf

@@ -13,7 +13,9 @@
   <!-- Anyone can talk to the service -->
   <policy context="default">
     <allow send_destination="net.reactivated.Fprint"
-           send_interface="net.reactivated.Fprint"/>
+           send_interface="net.reactivated.Fprint.Manager"/>
+    <allow send_destination="net.reactivated.Fprint"
+           send_interface="net.reactivated.Fprint.Device"/>
 
     <!-- Basic D-Bus API stuff -->
     <allow send_destination="net.reactivated.Fprint"

meson.build

@@ -1,5 +1,5 @@
 project('fprintd', 'c',
-    version: '1.90.5',
+    version: '1.90.7',
     license: 'GPLv2+',
     default_options: [
         'buildtype=debugoptimized',
@@ -62,6 +62,7 @@ common_cflags = cc.get_supported_arguments([
 add_project_arguments(common_cflags, language: 'c')
 
 host_system = host_machine.system()
+# NOTE: Bump gdbus-codegen min version once we can depend on 2.64!
 glib_min_version = '2.56'
 libfprint_min_version = '1.90.1'
 

pam/fingerprint-strings.h

@@ -28,115 +28,128 @@
 
 #define GNUC_UNUSED __attribute__((__unused__))
 
-static bool str_equal (const char *a, const char *b)
+static bool
+str_equal (const char *a, const char *b)
 {
-	if (a == NULL && b == NULL)
-		return true;
-	if (a == NULL || b == NULL)
-		return false;
-	return (strcmp (a, b) == 0);
+  if (a == NULL && b == NULL)
+    return true;
+  if (a == NULL || b == NULL)
+    return false;
+  return strcmp (a, b) == 0;
 }
 
-struct {
-	const char *dbus_name;
-	const char *place_str_generic;
-	const char *place_str_specific;
-	const char *swipe_str_generic;
-	const char *swipe_str_specific;
+struct
+{
+  const char *dbus_name;
+  const char *place_str_generic;
+  const char *place_str_specific;
+  const char *swipe_str_generic;
+  const char *swipe_str_specific;
 } fingers[] = {
-	{ "any",
-	  N_("Place your finger on the fingerprint reader"),
-	  N_("Place your finger on %s"),
-	  N_("Swipe your finger across the fingerprint reader"),
-	  N_("Swipe your finger across %s") },
-	{ "left-thumb",
-	  N_("Place your left thumb on the fingerprint reader"),
-	  N_("Place your left thumb on %s"),
-	  N_("Swipe your left thumb across the fingerprint reader"),
-	  N_("Swipe your left thumb across %s") },
-	{ "left-index-finger",
-	  N_("Place your left index finger on the fingerprint reader"),
-	  N_("Place your left index finger on %s"),
-	  N_("Swipe your left index finger across the fingerprint reader"),
-	  N_("Swipe your left index finger across %s") },
-	{ "left-middle-finger",
-	  N_("Place your left middle finger on the fingerprint reader"),
-	  N_("Place your left middle finger on %s"),
-	  N_("Swipe your left middle finger across the fingerprint reader"),
-	  N_("Swipe your left middle finger across %s") },
-	{ "left-ring-finger",
-	  N_("Place your left ring finger on the fingerprint reader"),
-	  N_("Place your left ring finger on %s"),
-	  N_("Swipe your left ring finger across the fingerprint reader"),
-	  N_("Swipe your left ring finger across %s") },
-	{ "left-little-finger",
-	  N_("Place your left little finger on the fingerprint reader"),
-	  N_("Place your left little finger on %s"),
-	  N_("Swipe your left little finger across the fingerprint reader"),
-	  N_("Swipe your left little finger across %s") },
-	{ "right-thumb",
-	  N_("Place your right thumb on the fingerprint reader"),
-	  N_("Place your right thumb on %s"),
-	  N_("Swipe your right thumb across the fingerprint reader"),
-	  N_("Swipe your right thumb across %s") },
-	{ "right-index-finger",
-	  N_("Place your right index finger on the fingerprint reader"),
-	  N_("Place your right index finger on %s"),
-	  N_("Swipe your right index finger across the fingerprint reader"),
-	  N_("Swipe your right index finger across %s") },
-	{ "right-middle-finger",
-	  N_("Place your right middle finger on the fingerprint reader"),
-	  N_("Place your right middle finger on %s"),
-	  N_("Swipe your right middle finger across the fingerprint reader"),
-	  N_("Swipe your right middle finger across %s") },
-	{ "right-ring-finger",
-	  N_("Place your right ring finger on the fingerprint reader"),
-	  N_("Place your right ring finger on %s"),
-	  N_("Swipe your right ring finger across the fingerprint reader"),
-	  N_("Swipe your right ring finger across %s") },
-	{ "right-little-finger",
-	  N_("Place your right little finger on the fingerprint reader"),
-	  N_("Place your right little finger on %s"),
-	  N_("Swipe your right little finger across the fingerprint reader"),
-	  N_("Swipe your right little finger across %s") },
-	{ NULL, NULL, NULL, NULL, NULL }
+  { "any",
+    N_("Place your finger on the fingerprint reader"),
+    N_("Place your finger on %s"),
+    N_("Swipe your finger across the fingerprint reader"),
+    N_("Swipe your finger across %s") },
+  { "left-thumb",
+    N_("Place your left thumb on the fingerprint reader"),
+    N_("Place your left thumb on %s"),
+    N_("Swipe your left thumb across the fingerprint reader"),
+    N_("Swipe your left thumb across %s") },
+  { "left-index-finger",
+    N_("Place your left index finger on the fingerprint reader"),
+    N_("Place your left index finger on %s"),
+    N_("Swipe your left index finger across the fingerprint reader"),
+    N_("Swipe your left index finger across %s") },
+  { "left-middle-finger",
+    N_("Place your left middle finger on the fingerprint reader"),
+    N_("Place your left middle finger on %s"),
+    N_("Swipe your left middle finger across the fingerprint reader"),
+    N_("Swipe your left middle finger across %s") },
+  { "left-ring-finger",
+    N_("Place your left ring finger on the fingerprint reader"),
+    N_("Place your left ring finger on %s"),
+    N_("Swipe your left ring finger across the fingerprint reader"),
+    N_("Swipe your left ring finger across %s") },
+  { "left-little-finger",
+    N_("Place your left little finger on the fingerprint reader"),
+    N_("Place your left little finger on %s"),
+    N_("Swipe your left little finger across the fingerprint reader"),
+    N_("Swipe your left little finger across %s") },
+  { "right-thumb",
+    N_("Place your right thumb on the fingerprint reader"),
+    N_("Place your right thumb on %s"),
+    N_("Swipe your right thumb across the fingerprint reader"),
+    N_("Swipe your right thumb across %s") },
+  { "right-index-finger",
+    N_("Place your right index finger on the fingerprint reader"),
+    N_("Place your right index finger on %s"),
+    N_("Swipe your right index finger across the fingerprint reader"),
+    N_("Swipe your right index finger across %s") },
+  { "right-middle-finger",
+    N_("Place your right middle finger on the fingerprint reader"),
+    N_("Place your right middle finger on %s"),
+    N_("Swipe your right middle finger across the fingerprint reader"),
+    N_("Swipe your right middle finger across %s") },
+  { "right-ring-finger",
+    N_("Place your right ring finger on the fingerprint reader"),
+    N_("Place your right ring finger on %s"),
+    N_("Swipe your right ring finger across the fingerprint reader"),
+    N_("Swipe your right ring finger across %s") },
+  { "right-little-finger",
+    N_("Place your right little finger on the fingerprint reader"),
+    N_("Place your right little finger on %s"),
+    N_("Swipe your right little finger across the fingerprint reader"),
+    N_("Swipe your right little finger across %s") },
+  { NULL, NULL, NULL, NULL, NULL }
 };
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 
-GNUC_UNUSED static char *finger_str_to_msg(const char *finger_name, const char *driver_name, bool is_swipe)
+GNUC_UNUSED static char *
+finger_str_to_msg (const char *finger_name, const char *driver_name, bool is_swipe)
 {
-	int i;
+  int i;
 
-	if (finger_name == NULL)
-		return NULL;
+  if (finger_name == NULL)
+    return NULL;
 
-	for (i = 0; fingers[i].dbus_name != NULL; i++) {
-		if (str_equal (fingers[i].dbus_name, finger_name)) {
-			if (is_swipe == false) {
-				if (driver_name) {
-					char *s;
-					int ret;
-					ret = asprintf (&s, TR (fingers[i].place_str_specific), driver_name);
-					return ret >= 0 ? s : NULL;
-				} else {
-					return strdup (TR (fingers[i].place_str_generic));
-				}
-			} else {
-				if (driver_name) {
-					char *s;
-					int ret;
-					ret = asprintf (&s, TR (fingers[i].swipe_str_specific), driver_name);
-					return ret >= 0 ? s : NULL;
-				} else {
-					return strdup (TR (fingers[i].swipe_str_generic));
-				}
-			}
-		}
-	}
+  for (i = 0; fingers[i].dbus_name != NULL; i++)
+    {
+      if (!str_equal (fingers[i].dbus_name, finger_name))
+        continue;
+      if (is_swipe == false)
+        {
+          if (driver_name)
+            {
+              char *s;
+              int ret;
+              ret = asprintf (&s, TR (fingers[i].place_str_specific), driver_name);
+              return ret >= 0 ? s : NULL;
+            }
+          else
+            {
+              return strdup (TR (fingers[i].place_str_generic));
+            }
+        }
+      else
+        {
+          if (driver_name)
+            {
+              char *s;
+              int ret;
+              ret = asprintf (&s, TR (fingers[i].swipe_str_specific), driver_name);
+              return ret >= 0 ? s : NULL;
+            }
+          else
+            {
+              return strdup (TR (fingers[i].swipe_str_generic));
+            }
+        }
+    }
 
-	return NULL;
+  return NULL;
 }
 
 #pragma GCC diagnostic pop
@@ -146,25 +159,27 @@ GNUC_UNUSED static char *finger_str_to_msg(const char *finger_name, const char *
  * verify-match
  * verify-unknown-error
  */
-GNUC_UNUSED static const char *verify_result_str_to_msg(const char *result, bool is_swipe)
+GNUC_UNUSED static const char *
+verify_result_str_to_msg (const char *result, bool is_swipe)
 {
-	if (result == NULL)
-		return NULL;
+  if (result == NULL)
+    return NULL;
 
-	if (strcmp (result, "verify-retry-scan") == 0) {
-		if (is_swipe == false)
-			return TR (N_("Place your finger on the reader again"));
-		else
-			return TR (N_("Swipe your finger again"));
-	}
-	if (strcmp (result, "verify-swipe-too-short") == 0)
-		return TR (N_("Swipe was too short, try again"));
-	if (strcmp (result, "verify-finger-not-centered") == 0)
-		return TR (N_("Your finger was not centered, try swiping your finger again"));
-	if (strcmp (result, "verify-remove-and-retry") == 0)
-		return TR (N_("Remove your finger, and try swiping your finger again"));
+  if (strcmp (result, "verify-retry-scan") == 0)
+    {
+      if (is_swipe == false)
+        return TR (N_("Place your finger on the reader again"));
+      else
+        return TR (N_("Swipe your finger again"));
+    }
+  if (strcmp (result, "verify-swipe-too-short") == 0)
+    return TR (N_("Swipe was too short, try again"));
+  if (strcmp (result, "verify-finger-not-centered") == 0)
+    return TR (N_("Your finger was not centered, try swiping your finger again"));
+  if (strcmp (result, "verify-remove-and-retry") == 0)
+    return TR (N_("Remove your finger, and try swiping your finger again"));
 
-	return NULL;
+  return NULL;
 }
 
 /* Cases not handled:
@@ -172,24 +187,25 @@ GNUC_UNUSED static const char *verify_result_str_to_msg(const char *result, bool
  * enroll-failed
  * enroll-unknown-error
  */
-GNUC_UNUSED static const char *enroll_result_str_to_msg(const char *result, bool is_swipe)
+GNUC_UNUSED static const char *
+enroll_result_str_to_msg (const char *result, bool is_swipe)
 {
-	if (result == NULL)
-		return NULL;
+  if (result == NULL)
+    return NULL;
 
-	if (strcmp (result, "enroll-retry-scan") == 0 || strcmp (result, "enroll-stage-passed") == 0) {
-		if (is_swipe == false)
-			return TR (N_("Place your finger on the reader again"));
-		else
-			return TR (N_("Swipe your finger again"));
-	}
-	if (strcmp (result, "enroll-swipe-too-short") == 0)
-		return TR (N_("Swipe was too short, try again"));
-	if (strcmp (result, "enroll-finger-not-centered") == 0)
-		return TR (N_("Your finger was not centered, try swiping your finger again"));
-	if (strcmp (result, "enroll-remove-and-retry") == 0)
-		return TR (N_("Remove your finger, and try swiping your finger again"));
+  if (strcmp (result, "enroll-retry-scan") == 0 || strcmp (result, "enroll-stage-passed") == 0)
+    {
+      if (is_swipe == false)
+        return TR (N_("Place your finger on the reader again"));
+      else
+        return TR (N_("Swipe your finger again"));
+    }
+  if (strcmp (result, "enroll-swipe-too-short") == 0)
+    return TR (N_("Swipe was too short, try again"));
+  if (strcmp (result, "enroll-finger-not-centered") == 0)
+    return TR (N_("Your finger was not centered, try swiping your finger again"));
+  if (strcmp (result, "enroll-remove-and-retry") == 0)
+    return TR (N_("Remove your finger, and try swiping your finger again"));
 
-	return NULL;
+  return NULL;
 }
-

pam/pam_fprintd_autoptrs.h

@@ -0,0 +1,61 @@
+/*
+ * pam_fprint: PAM module for fingerprint authentication through fprintd
+ * Copyright (C) 2020 Marco Trevisan <marco.trevisan@canonical.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#pragma once
+
+#include <stdlib.h>
+
+/* Define auto-pointers functions, based on GLib Macros */
+
+#define _CLEANUP_FUNC(func) __attribute__((cleanup (func)))
+
+#define _PF_AUTOPTR_FUNC_NAME(TypeName) pf_autoptr_cleanup_ ## TypeName
+#define _PF_AUTOPTR_TYPENAME(TypeName)  TypeName ## _pf_autoptr
+
+#define PF_DEFINE_AUTOPTR_CLEANUP_FUNC(TypeName, cleanup) \
+  typedef TypeName *_PF_AUTOPTR_TYPENAME (TypeName);    \
+  static __attribute__((__unused__)) inline void        \
+  _PF_AUTOPTR_FUNC_NAME (TypeName) (TypeName **_ptr)    \
+  { if (_ptr) (cleanup) (*_ptr); }
+
+#define PF_DEFINE_AUTO_CLEAN_FUNC(TypeName, cleanup)  \
+  static __attribute__((__unused__)) inline void    \
+  _PF_AUTOPTR_FUNC_NAME (TypeName) (TypeName *_ptr) \
+  { cleanup (_ptr); }
+
+static inline void
+autoptr_cleanup_generic_free (void *p)
+{
+  void **pp = (void **) p;
+
+  free (*pp);
+}
+
+#define pf_autofree _CLEANUP_FUNC (autoptr_cleanup_generic_free)
+#define pf_autoptr(TypeName) \
+  _CLEANUP_FUNC (_PF_AUTOPTR_FUNC_NAME (TypeName)) \
+  _PF_AUTOPTR_TYPENAME (TypeName)
+#define pf_auto(TypeName) \
+  _CLEANUP_FUNC (_PF_AUTOPTR_FUNC_NAME (TypeName)) TypeName
+
+PF_DEFINE_AUTOPTR_CLEANUP_FUNC (sd_bus, sd_bus_unref)
+PF_DEFINE_AUTOPTR_CLEANUP_FUNC (sd_bus_message, sd_bus_message_unref)
+PF_DEFINE_AUTOPTR_CLEANUP_FUNC (sd_bus_slot, sd_bus_slot_unref)
+
+PF_DEFINE_AUTO_CLEAN_FUNC (sd_bus_error, sd_bus_error_free)

scripts/uncrustify.cfg

@@ -0,0 +1,137 @@
+newlines                lf
+
+input_tab_size          8
+output_tab_size         8
+
+string_escape_char      92
+string_escape_char2     0
+
+# indenting
+indent_columns          2
+indent_with_tabs        0
+indent_align_string     True
+indent_brace            2
+indent_braces           false
+indent_braces_no_func   True
+indent_func_call_param  false
+indent_func_def_param   false
+indent_func_proto_param false
+indent_switch_case      0
+indent_case_brace       2
+indent_paren_close      1
+
+# spacing
+sp_arith                        Add
+sp_assign                       Add
+sp_enum_assign                  Add
+sp_bool                         Add
+sp_compare                      Add
+sp_inside_paren                 Remove
+sp_inside_fparens               Remove
+sp_func_def_paren               Force
+sp_func_proto_paren             Force
+sp_paren_paren                  Remove
+sp_balance_nested_parens        False
+sp_paren_brace                  Remove
+sp_before_square                Remove
+sp_before_squares               Remove
+sp_inside_square                Remove
+sp_before_ptr_star              Add
+sp_between_ptr_star             Remove
+sp_after_comma                  Add
+sp_before_comma                 Remove
+sp_after_cast                   Add
+sp_sizeof_paren                 Add
+sp_not                          Remove
+sp_inv                          Remove
+sp_addr                         Remove
+sp_member                       Remove
+sp_deref                        Remove
+sp_sign                         Remove
+sp_incdec                       Remove
+sp_attribute_paren              remove
+sp_macro                        Force
+sp_func_call_paren              Force
+sp_func_call_user_paren         Remove
+set func_call_user _ N_ C_ g_autoptr g_auto
+sp_brace_typedef                add
+sp_cond_colon                   add
+sp_cond_question                add
+sp_defined_paren                remove
+
+# alignment
+align_keep_tabs                 False
+align_with_tabs                 False
+align_on_tabstop                False
+align_number_right              False
+align_func_params               True
+align_var_def_span              0
+align_var_def_amp_style         1
+align_var_def_colon             true
+align_enum_equ_span             0
+align_var_struct_span           2
+align_var_def_star_style        2
+align_var_def_amp_style         2
+align_typedef_span              2
+align_typedef_func              0
+align_typedef_star_style        2
+align_typedef_amp_style         2
+
+# newlines
+nl_assign_leave_one_liners      True
+nl_enum_leave_one_liners        False
+nl_func_leave_one_liners        False
+nl_if_leave_one_liners          False
+nl_end_of_file                  Add
+nl_assign_brace                 Remove
+nl_func_var_def_blk             1
+nl_fcall_brace                  Add
+nl_enum_brace                   Remove
+nl_struct_brace                 Force
+nl_union_brace                  Force
+nl_if_brace                     Force
+nl_brace_else                   Force
+nl_elseif_brace                 Force
+nl_else_brace                   Add
+nl_for_brace                    Force
+nl_while_brace                  Force
+nl_do_brace                     Force
+nl_brace_while                  Force
+nl_switch_brace                 Force
+nl_before_case                  True
+nl_after_case                   False
+nl_func_type_name               Force
+nl_func_proto_type_name         Remove
+nl_func_paren                   Remove
+nl_func_decl_start              Remove
+nl_func_decl_args               Force
+nl_func_decl_end                Remove
+nl_fdef_brace                   Force
+nl_after_return                 False
+nl_define_macro                 False
+nl_create_if_one_liner          False
+nl_create_for_one_liner         False
+nl_create_while_one_liner       False
+nl_after_semicolon              True
+nl_multi_line_cond              true
+
+# mod
+# I'd like these to be remove, but that removes brackets in if { if { foo } }, which i dislike
+# Not clear what to do about that...
+mod_full_brace_for              Remove
+mod_full_brace_if               Remove
+mod_full_brace_if_chain         True
+mod_full_brace_while            Remove
+mod_full_brace_do               Remove
+mod_full_brace_nl               3
+mod_paren_on_return             Remove
+
+# line splitting
+#code_width                     = 78
+ls_for_split_full               True
+ls_func_split_full              True
+
+# positioning
+pos_bool                        Trail
+pos_conditional                 Trail
+

scripts/uncrustify.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+SRCROOT=`git rev-parse --show-toplevel`
+CFG="$SRCROOT/scripts/uncrustify.cfg"
+echo "srcroot: $SRCROOT"
+
+case "$1" in
+    -c|--check)
+	OPTS="--check"
+        ;;
+    *)
+	OPTS="--replace --no-backup"
+        ;;
+esac
+
+pushd "$SRCROOT"
+uncrustify -c "$CFG" $OPTS `git ls-tree --name-only -r HEAD | grep -E '.*\.[ch]$' | grep -v build/`
+RES=$?
+popd
+exit $RES

src/dbus-interactive-auth.patch

@@ -0,0 +1,110 @@
+--- a/src/fprintd-dbus.c	2020-12-04 16:38:28.527712626 +0100
++++ b/src/fprintd-dbus.c	2020-12-04 16:40:03.561692619 +0100
+@@ -1149,7 +1149,7 @@
+     "ListEnrolledFingers",
+     g_variant_new ("(s)",
+                    arg_username),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     callback,
+@@ -1213,7 +1213,7 @@
+     "ListEnrolledFingers",
+     g_variant_new ("(s)",
+                    arg_username),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     error);
+@@ -1253,7 +1253,7 @@
+     "DeleteEnrolledFingers",
+     g_variant_new ("(s)",
+                    arg_username),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     callback,
+@@ -1312,7 +1312,7 @@
+     "DeleteEnrolledFingers",
+     g_variant_new ("(s)",
+                    arg_username),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     error);
+@@ -1348,7 +1348,7 @@
+   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+     "DeleteEnrolledFingers2",
+     g_variant_new ("()"),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     callback,
+@@ -1404,7 +1404,7 @@
+   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+     "DeleteEnrolledFingers2",
+     g_variant_new ("()"),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     error);
+@@ -1443,7 +1443,7 @@
+     "Claim",
+     g_variant_new ("(s)",
+                    arg_username),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     callback,
+@@ -1502,7 +1502,7 @@
+     "Claim",
+     g_variant_new ("(s)",
+                    arg_username),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     error);
+@@ -1633,7 +1633,7 @@
+     "VerifyStart",
+     g_variant_new ("(s)",
+                    arg_finger_name),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     callback,
+@@ -1692,7 +1692,7 @@
+     "VerifyStart",
+     g_variant_new ("(s)",
+                    arg_finger_name),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     error);
+@@ -1823,7 +1823,7 @@
+     "EnrollStart",
+     g_variant_new ("(s)",
+                    arg_finger_name),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     callback,
+@@ -1882,7 +1882,7 @@
+     "EnrollStart",
+     g_variant_new ("(s)",
+                    arg_finger_name),
+-    G_DBUS_CALL_FLAGS_NONE,
++    G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION,
+     -1,
+     cancellable,
+     error);

src/file_storage.c

@@ -44,271 +44,297 @@
 
 static char *storage_path = NULL;
 
-static const char *get_storage_path(void)
+static const char *
+get_storage_path (void)
 {
-	const char *path = NULL;
+  const char *path = NULL;
 
-	if (storage_path != NULL)
-		return storage_path;
+  if (storage_path != NULL)
+    return storage_path;
 
-	/* set by systemd >= 240 to an absolute path
-	 * taking into account the StateDirectory
-	 * unit file setting */
-	path = g_getenv ("STATE_DIRECTORY");
-	if (path != NULL) {
-		/* If multiple directories are set, then in the environment variable
-		 * the paths are concatenated with colon (":"). */
-		if (strchr (path, ':')) {
-			g_auto(GStrv) elems = NULL;
-			elems = g_strsplit (path, ":", -1);
-			storage_path = g_strdup (elems[0]);
-		}
-	}
+  /* set by systemd >= 240 to an absolute path
+   * taking into account the StateDirectory
+   * unit file setting */
+  path = g_getenv ("STATE_DIRECTORY");
+  if (path != NULL)
+    {
+      /* If multiple directories are set, then in the environment variable
+       * the paths are concatenated with colon (":"). */
+      if (strchr (path, ':'))
+        {
+          g_auto(GStrv) elems = NULL;
+          elems = g_strsplit (path, ":", -1);
+          storage_path = g_strdup (elems[0]);
+        }
+    }
 
-	if (storage_path == NULL)
-		storage_path = g_strdup (FILE_STORAGE_PATH);
+  if (storage_path == NULL)
+    storage_path = g_strdup (FILE_STORAGE_PATH);
 
-	return storage_path;
+  return storage_path;
 }
 
-static char *get_path_to_storedir(const char *driver, const char * device_id, char *base_store)
+static char *
+get_path_to_storedir (const char *driver, const char * device_id, char *base_store)
 {
-	return g_build_filename(base_store, driver, device_id, NULL);
+  return g_build_filename (base_store, driver, device_id, NULL);
 }
 
-static char *__get_path_to_print(const char *driver, const char * device_id,
-	FpFinger finger, char *base_store)
+static char *
+__get_path_to_print (const char *driver, const char * device_id,
+                     FpFinger finger, char *base_store)
 {
-	g_autofree char *dirpath = NULL;
-	char *path;
-	char fingername[2];
+  g_autofree char *dirpath = NULL;
+  char *path;
+  char fingername[2];
 
-	g_snprintf(fingername, 2, "%x", finger);
+  g_snprintf (fingername, 2, "%x", finger);
 
-	dirpath = get_path_to_storedir(driver, device_id, base_store);
-	path = g_build_filename(dirpath, fingername, NULL);
-	return path;
+  dirpath = get_path_to_storedir (driver, device_id, base_store);
+  path = g_build_filename (dirpath, fingername, NULL);
+  return path;
 }
 
-static char *get_path_to_print(FpDevice *dev, FpFinger finger, char *base_store)
+static char *
+get_path_to_print (FpDevice *dev, FpFinger finger, char *base_store)
 {
-	return __get_path_to_print(fp_device_get_driver (dev),
-				   fp_device_get_device_id(dev),
-				   finger,
-				   base_store);
+  return __get_path_to_print (fp_device_get_driver (dev),
+                              fp_device_get_device_id (dev),
+                              finger,
+                              base_store);
 }
 
-static char *get_path_to_print_dscv(FpDevice *dev, FpFinger finger, char *base_store)
+static char *
+get_path_to_print_dscv (FpDevice *dev, FpFinger finger, char *base_store)
 {
-	return __get_path_to_print(fp_device_get_driver (dev),
-				   fp_device_get_device_id(dev),
-				   finger,
-				   base_store);
+  return __get_path_to_print (fp_device_get_driver (dev),
+                              fp_device_get_device_id (dev),
+                              finger,
+                              base_store);
 }
 
-static char *file_storage_get_basestore_for_username(const char *username)
+static char *
+file_storage_get_basestore_for_username (const char *username)
 {
-	return g_build_filename(get_storage_path(), username, NULL);
+  return g_build_filename (get_storage_path (), username, NULL);
 }
 
-int file_storage_print_data_save(FpPrint *print)
+int
+file_storage_print_data_save (FpPrint *print)
 {
-	g_autoptr(GError) err = NULL;
-	g_autofree char *path = NULL;
-	g_autofree char *dirpath = NULL;
-	g_autofree char *base_store = NULL;
-	g_autofree char *buf = NULL;
-	gsize len;
-	int r;
+  g_autoptr(GError) err = NULL;
+  g_autofree char *path = NULL;
+  g_autofree char *dirpath = NULL;
+  g_autofree char *base_store = NULL;
+  g_autofree char *buf = NULL;
+  gsize len;
+  int r;
 
-	base_store = file_storage_get_basestore_for_username(fp_print_get_username (print));
+  base_store = file_storage_get_basestore_for_username (fp_print_get_username (print));
 
-	if (!fp_print_serialize (print, (guchar **) &buf, &len, &err)) {
-		g_warning ("Error serializing data: %s", err->message);
-		return -ENOMEM;
-	}
+  if (!fp_print_serialize (print, (guchar **) &buf, &len, &err))
+    {
+      g_warning ("Error serializing data: %s", err->message);
+      return -ENOMEM;
+    }
 
-	path = __get_path_to_print(fp_print_get_driver (print),
-	                           fp_print_get_device_id (print),
-	                           fp_print_get_finger (print),
-	                           base_store);
-	dirpath = g_path_get_dirname(path);
-	r = g_mkdir_with_parents(dirpath, DIR_PERMS);
-	if (r < 0) {
-		g_debug("file_storage_print_data_save(): could not mkdir(\"%s\"): %s",
-			dirpath, g_strerror(r));
-		return r;
-	}
+  path = __get_path_to_print (fp_print_get_driver (print),
+                              fp_print_get_device_id (print),
+                              fp_print_get_finger (print),
+                              base_store);
+  dirpath = g_path_get_dirname (path);
+  r = g_mkdir_with_parents (dirpath, DIR_PERMS);
+  if (r < 0)
+    {
+      g_debug ("file_storage_print_data_save(): could not mkdir(\"%s\"): %s",
+               dirpath, g_strerror (r));
+      return r;
+    }
 
-	//fp_dbg("saving to %s", path);
-	g_file_set_contents(path, buf, len, &err);
-	if (err) {
-		g_debug("file_storage_print_data_save(): could not save '%s': %s",
-			path, err->message);
-		/* FIXME interpret error codes */
-		return err->code;
-	}
+  //fp_dbg("saving to %s", path);
+  g_file_set_contents (path, buf, len, &err);
+  if (err)
+    {
+      g_debug ("file_storage_print_data_save(): could not save '%s': %s",
+               path, err->message);
+      /* FIXME interpret error codes */
+      return err->code;
+    }
 
-	return 0;
+  return 0;
 }
 
-static int load_from_file(char *path, FpPrint **print)
+static int
+load_from_file (char *path, FpPrint **print)
 {
-	g_autoptr(GError) err = NULL;
-	gsize length;
-	g_autofree char *contents = NULL;
-	FpPrint *new;
+  g_autoptr(GError) err = NULL;
+  gsize length;
+  g_autofree char *contents = NULL;
+  FpPrint *new;
 
-	//fp_dbg("from %s", path);
-	g_file_get_contents(path, &contents, &length, &err);
-	if (err) {
-		int r = err->code;
-		/* FIXME interpret more error codes */
-		if (r == G_FILE_ERROR_NOENT)
-			return -ENOENT;
-		else
-			return r;
-	}
+  //fp_dbg("from %s", path);
+  g_file_get_contents (path, &contents, &length, &err);
+  if (err)
+    {
+      int r = err->code;
+      /* FIXME interpret more error codes */
+      if (r == G_FILE_ERROR_NOENT)
+        return -ENOENT;
+      else
+        return r;
+    }
 
-	new = fp_print_deserialize ((guchar *) contents, length, &err);
-	if (!new) {
-		g_print ("Error deserializing data: %s", err->message);
-		return -EIO;
-	}
+  new = fp_print_deserialize ((guchar *) contents, length, &err);
+  if (!new)
+    {
+      g_print ("Error deserializing data: %s", err->message);
+      return -EIO;
+    }
 
-	*print = new;
-	return 0;
+  *print = new;
+  return 0;
 }
 
-int file_storage_print_data_load(FpDevice *dev,
-				 FpFinger  finger,
-				 const char *username,
-				 FpPrint **print)
+int
+file_storage_print_data_load (FpDevice   *dev,
+                              FpFinger    finger,
+                              const char *username,
+                              FpPrint   **print)
 {
-	g_autofree gchar *path = NULL;
-	g_autofree gchar *base_store = NULL;
-	g_autoptr(FpPrint) new = NULL;
-	int r;
+  g_autofree gchar *path = NULL;
+  g_autofree gchar *base_store = NULL;
 
-	base_store = file_storage_get_basestore_for_username(username);
+  g_autoptr(FpPrint) new = NULL;
+  int r;
 
-	path = get_path_to_print(dev, finger, base_store);
-	r = load_from_file(path, &new);
-	g_debug ("file_storage_print_data_load(): loaded '%s' %s",
-		 path, g_strerror(r));
-	if (r)
-		return r;
+  base_store = file_storage_get_basestore_for_username (username);
 
-	if (!fp_print_compatible (new, dev)) {
-		return -EINVAL;
-	}
+  path = get_path_to_print (dev, finger, base_store);
+  r = load_from_file (path, &new);
+  g_debug ("file_storage_print_data_load(): loaded '%s' %s",
+           path, g_strerror (r));
+  if (r)
+    return r;
 
-	*print = g_steal_pointer (&new);
-	return 0;
+  if (!fp_print_compatible (new, dev))
+    return -EINVAL;
+
+  *print = g_steal_pointer (&new);
+  return 0;
 }
 
-int file_storage_print_data_delete(FpDevice *dev, FpFinger finger, const char *username)
+int
+file_storage_print_data_delete (FpDevice *dev, FpFinger finger, const char *username)
 {
-	g_autofree gchar *base_store = NULL;
-	g_autofree gchar *path = NULL;
-	int r;
+  g_autofree gchar *base_store = NULL;
+  g_autofree gchar *path = NULL;
+  int r;
 
-	base_store = file_storage_get_basestore_for_username(username);
+  base_store = file_storage_get_basestore_for_username (username);
 
-	path = get_path_to_print_dscv(dev, finger, base_store);
+  path = get_path_to_print_dscv (dev, finger, base_store);
 
-	r = g_unlink(path);
-	g_debug("file_storage_print_data_delete(): unlink(\"%s\") %s",
-		path, g_strerror(r));
+  r = g_unlink (path);
+  g_debug ("file_storage_print_data_delete(): unlink(\"%s\") %s",
+           path, g_strerror (r));
 
-	/* FIXME: cleanup empty directory */
-	return g_unlink(path);
+  /* FIXME: cleanup empty directory */
+  return g_unlink (path);
 }
 
-static GSList *scan_dev_storedir(char *devpath,
-                                 GSList *list)
+static GSList *
+scan_dev_storedir (char   *devpath,
+                   GSList *list)
 {
-	g_autoptr(GError) err = NULL;
-	const gchar *ent;
+  g_autoptr(GError) err = NULL;
+  const gchar *ent;
 
-	GDir *dir = g_dir_open(devpath, 0, &err);
-	if (!dir) {
-		g_debug("scan_dev_storedir(): opendir(\"%s\") failed: %s", devpath, err->message);
-		return list;
-	}
+  GDir *dir = g_dir_open (devpath, 0, &err);
 
-	while ((ent = g_dir_read_name(dir))) {
-		/* ent is an 1 hex character fp_finger code */
-		guint64 val;
-		gchar *endptr;
+  if (!dir)
+    {
+      g_debug ("scan_dev_storedir(): opendir(\"%s\") failed: %s", devpath, err->message);
+      return list;
+    }
 
-		if (*ent == 0 || strlen(ent) != 1)
-			continue;
+  while ((ent = g_dir_read_name (dir)))
+    {
+      /* ent is an 1 hex character fp_finger code */
+      guint64 val;
+      gchar *endptr;
 
-		val = g_ascii_strtoull(ent, &endptr, 16);
-		if (endptr == ent || !FP_FINGER_IS_VALID(val)) {
-			g_debug("scan_dev_storedir(): skipping print file '%s'", ent);
-			continue;
-		}
+      if (*ent == 0 || strlen (ent) != 1)
+        continue;
 
-		list = g_slist_prepend(list, GINT_TO_POINTER(val));
-	}
+      val = g_ascii_strtoull (ent, &endptr, 16);
+      if (endptr == ent || !FP_FINGER_IS_VALID (val))
+        {
+          g_debug ("scan_dev_storedir(): skipping print file '%s'", ent);
+          continue;
+        }
 
-	g_dir_close(dir);
-	return list;
+      list = g_slist_prepend (list, GUINT_TO_POINTER (val));
+    }
+
+  g_dir_close (dir);
+  return list;
 }
 
-GSList *file_storage_discover_prints(FpDevice *dev, const char *username)
+GSList *
+file_storage_discover_prints (FpDevice *dev, const char *username)
 {
-	GSList *list = NULL;
-	g_autofree gchar *base_store = NULL;
-	g_autofree gchar *storedir = NULL;
+  GSList *list = NULL;
+  g_autofree gchar *base_store = NULL;
+  g_autofree gchar *storedir = NULL;
 
-	base_store = file_storage_get_basestore_for_username(username);
+  base_store = file_storage_get_basestore_for_username (username);
 
-	storedir = get_path_to_storedir(fp_device_get_driver (dev),
-					fp_device_get_device_id (dev),
-					base_store);
+  storedir = get_path_to_storedir (fp_device_get_driver (dev),
+                                   fp_device_get_device_id (dev),
+                                   base_store);
 
-	g_debug ("file_storage_discover_prints() for user '%s' in '%s'",
-		 username, storedir);
+  g_debug ("file_storage_discover_prints() for user '%s' in '%s'",
+           username, storedir);
 
-	list = scan_dev_storedir(storedir, list);
+  list = scan_dev_storedir (storedir, list);
 
-	return list;
+  return list;
 }
 
-GSList *file_storage_discover_users(void)
+GSList *
+file_storage_discover_users (void)
 {
-	g_autoptr(GError) err = NULL;
-	GSList *list = NULL;
-	const gchar *ent;
-	GDir *dir = g_dir_open(get_storage_path(), 0, &err);
+  g_autoptr(GError) err = NULL;
+  GSList *list = NULL;
+  const gchar *ent;
+  GDir *dir = g_dir_open (get_storage_path (), 0, &err);
 
-	if (!dir) {
-		return list;
-	}
+  if (!dir)
+    return list;
 
-	while ((ent = g_dir_read_name(dir))) {
-		/* ent is a username */
-		if (*ent == 0)
-			continue;
+  while ((ent = g_dir_read_name (dir)))
+    {
+      /* ent is a username */
+      if (*ent == 0)
+        continue;
 
-		list = g_slist_prepend(list, g_strdup (ent));
-	}
+      list = g_slist_prepend (list, g_strdup (ent));
+    }
 
-	g_dir_close(dir);
-	return list;
+  g_dir_close (dir);
+  return list;
 }
 
-int file_storage_init(void)
+int
+file_storage_init (void)
 {
-	/* Nothing to do */
-	return 0;
+  /* Nothing to do */
+  return 0;
 }
 
-int file_storage_deinit(void)
+int
+file_storage_deinit (void)
 {
-	g_clear_pointer (&storage_path, g_free);
-	return 0;
+  g_clear_pointer (&storage_path, g_free);
+  return 0;
 }

src/file_storage.h

@@ -20,20 +20,21 @@
 
 #pragma once
 
-int file_storage_print_data_save(FpPrint *print);
+int file_storage_print_data_save (FpPrint *print);
 
-int file_storage_print_data_load(FpDevice *dev,
-                                 FpFinger  finger,
-                                 const char *username,
-                                 FpPrint **print);
+int file_storage_print_data_load (FpDevice   *dev,
+                                  FpFinger    finger,
+                                  const char *username,
+                                  FpPrint   **print);
 
-int file_storage_print_data_delete(FpDevice *dev,
-                                   FpFinger finger,
-                                   const char *username);
+int file_storage_print_data_delete (FpDevice   *dev,
+                                    FpFinger    finger,
+                                    const char *username);
 
-int file_storage_init(void);
+int file_storage_init (void);
 
-int file_storage_deinit(void);
+int file_storage_deinit (void);
 
-GSList *file_storage_discover_prints(FpDevice *dev, const char *username);
-GSList *file_storage_discover_users(void);
+GSList *file_storage_discover_prints (FpDevice   *dev,
+                                      const char *username);
+GSList *file_storage_discover_users (void);

src/fprintd.h

@@ -31,55 +31,63 @@
 #define FPRINT_SERVICE_PATH "/net/reactivated/Fprint"
 
 /* Errors */
-GQuark fprint_error_quark(void);
+GQuark fprint_error_quark (void);
 
-#define FPRINT_ERROR fprint_error_quark()
+#define FPRINT_ERROR fprint_error_quark ()
 typedef enum {
-	/* developer didn't claim the device */
-	FPRINT_ERROR_CLAIM_DEVICE, /*< nick=net.reactivated.Fprint.Error.ClaimDevice >*/
-	/* device is already claimed by somebody else */
-	FPRINT_ERROR_ALREADY_IN_USE, /*< nick=net.reactivated.Fprint.Error.AlreadyInUse >*/
-	/* internal error occurred */
-	FPRINT_ERROR_INTERNAL, /*< nick=net.reactivated.Fprint.Error.Internal >*/
-	/* PolicyKit refused the action */
-	FPRINT_ERROR_PERMISSION_DENIED, /*< nick=net.reactivated.Fprint.Error.PermissionDenied >*/
-	/* No prints are enrolled */
-	FPRINT_ERROR_NO_ENROLLED_PRINTS, /*< nick=net.reactivated.Fprint.Error.NoEnrolledPrints >*/
-	/* No actions currently in progress */
-	FPRINT_ERROR_NO_ACTION_IN_PROGRESS, /*< nick=net.reactivated.Fprint.Error.NoActionInProgress >*/
-	/* the finger name passed was invalid */
-	FPRINT_ERROR_INVALID_FINGERNAME, /*< nick=net.reactivated.Fprint.Error.InvalidFingername >*/
-	/* device does not exist */
-	FPRINT_ERROR_NO_SUCH_DEVICE, /*< nick=net.reactivated.Fprint.Error.NoSuchDevice >*/
+  /* developer didn't claim the device */
+  FPRINT_ERROR_CLAIM_DEVICE,       /*< nick=net.reactivated.Fprint.Error.ClaimDevice >*/
+  /* device is already claimed by somebody else */
+  FPRINT_ERROR_ALREADY_IN_USE,       /*< nick=net.reactivated.Fprint.Error.AlreadyInUse >*/
+  /* internal error occurred */
+  FPRINT_ERROR_INTERNAL,       /*< nick=net.reactivated.Fprint.Error.Internal >*/
+  /* PolicyKit refused the action */
+  FPRINT_ERROR_PERMISSION_DENIED,       /*< nick=net.reactivated.Fprint.Error.PermissionDenied >*/
+  /* No prints are enrolled */
+  FPRINT_ERROR_NO_ENROLLED_PRINTS,       /*< nick=net.reactivated.Fprint.Error.NoEnrolledPrints >*/
+  /* No actions currently in progress */
+  FPRINT_ERROR_NO_ACTION_IN_PROGRESS,       /*< nick=net.reactivated.Fprint.Error.NoActionInProgress >*/
+  /* the finger name passed was invalid */
+  FPRINT_ERROR_INVALID_FINGERNAME,       /*< nick=net.reactivated.Fprint.Error.InvalidFingername >*/
+  /* device does not exist */
+  FPRINT_ERROR_NO_SUCH_DEVICE,       /*< nick=net.reactivated.Fprint.Error.NoSuchDevice >*/
 } FprintError;
 
+/* Enum of possible permissions, orders and nick matter here:
+   - The order controls the priority of a required permission when various are
+     accepted: the lowest the value, the more priorty it has.
+   - Nick must match the relative polkit rule.
+ */
 typedef enum {
-	FPRINT_DEVICE_PERMISSION_NONE = 0,
-	FPRINT_DEVICE_PERMISSION_ENROLL = (1 << 0), /*< nick=net.reactivated.fprint.device.enroll >*/
-	FPRINT_DEVICE_PERMISSION_SETUSERNAME = (1 << 1), /*< nick=net.reactivated.fprint.device.setusername >*/
-	FPRINT_DEVICE_PERMISSION_VERIFY = (1 << 2), /*< nick=net.reactivated.fprint.device.verify >*/
+  FPRINT_DEVICE_PERMISSION_NONE = 0,
+  FPRINT_DEVICE_PERMISSION_VERIFY = (1 << 0),       /*< nick=net.reactivated.fprint.device.verify >*/
+  FPRINT_DEVICE_PERMISSION_ENROLL = (1 << 1),       /*< nick=net.reactivated.fprint.device.enroll >*/
+  FPRINT_DEVICE_PERMISSION_SETUSERNAME = (1 << 2),       /*< nick=net.reactivated.fprint.device.setusername >*/
 } FprintDevicePermission;
 
 /* Manager */
-#define FPRINT_TYPE_MANAGER            (fprint_manager_get_type())
+#define FPRINT_TYPE_MANAGER (fprint_manager_get_type ())
 G_DECLARE_FINAL_TYPE (FprintManager, fprint_manager, FPRINT, MANAGER, GObject)
 
-struct _FprintManager {
-	GObject parent;
+struct _FprintManager
+{
+  GObject parent;
 };
 
-FprintManager *fprint_manager_new (GDBusConnection *connection, gboolean no_timeout);
+FprintManager *fprint_manager_new (GDBusConnection *connection,
+                                   gboolean         no_timeout);
 
 /* Device */
-#define FPRINT_TYPE_DEVICE            (fprint_device_get_type())
+#define FPRINT_TYPE_DEVICE (fprint_device_get_type ())
 G_DECLARE_FINAL_TYPE (FprintDevice, fprint_device, FPRINT, DEVICE,
-		      FprintDBusDeviceSkeleton)
+                      FprintDBusDeviceSkeleton)
 
-struct _FprintDevice {
-	FprintDBusDeviceSkeleton parent;
+struct _FprintDevice
+{
+  FprintDBusDeviceSkeleton parent;
 };
 
-FprintDevice *fprint_device_new(FpDevice *dev);
-guint32 _fprint_device_get_id(FprintDevice *rdev);
+FprintDevice *fprint_device_new (FpDevice *dev);
+guint32 _fprint_device_get_id (FprintDevice *rdev);
 /* Print */
 /* TODO */

src/main.c

@@ -44,171 +44,179 @@ static gboolean g_fatal_warnings = FALSE;
 static void
 set_storage_file (void)
 {
-	store.init = &file_storage_init;
-	store.deinit = &file_storage_deinit;
-	store.print_data_save = &file_storage_print_data_save;
-	store.print_data_load = &file_storage_print_data_load;
-	store.print_data_delete = &file_storage_print_data_delete;
-	store.discover_prints = &file_storage_discover_prints;
-	store.discover_users = &file_storage_discover_users;
+  store.init = &file_storage_init;
+  store.deinit = &file_storage_deinit;
+  store.print_data_save = &file_storage_print_data_save;
+  store.print_data_load = &file_storage_print_data_load;
+  store.print_data_delete = &file_storage_print_data_delete;
+  store.discover_prints = &file_storage_discover_prints;
+  store.discover_users = &file_storage_discover_users;
 }
 
 static gboolean
 load_storage_module (const char *module_name)
 {
-	GModule *module;
-	g_autofree char *filename = NULL;
+  GModule *module;
+  g_autofree char *filename = NULL;
 
-	filename = g_module_build_path (PLUGINDIR, module_name);
-	module = g_module_open (filename, 0);
-	if (module == NULL)
-		return FALSE;
+  filename = g_module_build_path (PLUGINDIR, module_name);
+  module = g_module_open (filename, 0);
+  if (module == NULL)
+    return FALSE;
 
-	if (!g_module_symbol (module, "init", (gpointer *) &store.init) ||
-	    !g_module_symbol (module, "deinit", (gpointer *) &store.deinit) ||
-	    !g_module_symbol (module, "print_data_save", (gpointer *) &store.print_data_save) ||
-	    !g_module_symbol (module, "print_data_load", (gpointer *) &store.print_data_load) ||
-	    !g_module_symbol (module, "print_data_delete", (gpointer *) &store.print_data_delete) ||
-	    !g_module_symbol (module, "discover_prints", (gpointer *) &store.discover_prints)) {
-	    	g_module_close (module);
-	    	return FALSE;
-	}
+  if (!g_module_symbol (module, "init", (gpointer *) &store.init) ||
+      !g_module_symbol (module, "deinit", (gpointer *) &store.deinit) ||
+      !g_module_symbol (module, "print_data_save", (gpointer *) &store.print_data_save) ||
+      !g_module_symbol (module, "print_data_load", (gpointer *) &store.print_data_load) ||
+      !g_module_symbol (module, "print_data_delete", (gpointer *) &store.print_data_delete) ||
+      !g_module_symbol (module, "discover_prints", (gpointer *) &store.discover_prints))
+    {
+      g_module_close (module);
+      return FALSE;
+    }
 
-	g_module_make_resident (module);
+  g_module_make_resident (module);
 
-	return TRUE;
+  return TRUE;
 }
 
 static gboolean
 load_conf (void)
 {
-	g_autofree char *filename = NULL;
-	g_autofree char *module_name = NULL;
-	g_autoptr(GKeyFile) file = NULL;
-	g_autoptr(GError) error = NULL;
+  g_autofree char *filename = NULL;
+  g_autofree char *module_name = NULL;
 
-	filename = g_build_filename (SYSCONFDIR, "fprintd.conf", NULL);
-	file = g_key_file_new ();
-	g_debug("About to load configuration file '%s'", filename);
-	if (!g_key_file_load_from_file (file, filename, G_KEY_FILE_NONE, &error)) {
-		g_warning ("Could not open \"%s\": %s\n", filename, error->message);
-		return FALSE;
-	}
+  g_autoptr(GKeyFile) file = NULL;
+  g_autoptr(GError) error = NULL;
 
-	module_name = g_key_file_get_string (file, "storage", "type", &error);
-	if (module_name == NULL)
-		return FALSE;
+  filename = g_build_filename (SYSCONFDIR, "fprintd.conf", NULL);
+  file = g_key_file_new ();
+  g_debug ("About to load configuration file '%s'", filename);
+  if (!g_key_file_load_from_file (file, filename, G_KEY_FILE_NONE, &error))
+    {
+      g_warning ("Could not open \"%s\": %s\n", filename, error->message);
+      return FALSE;
+    }
 
-	if (g_str_equal (module_name, "file")) {
-		set_storage_file ();
-		return TRUE;
-	}
+  module_name = g_key_file_get_string (file, "storage", "type", &error);
+  if (module_name == NULL)
+    return FALSE;
 
-	return load_storage_module (module_name);
+  if (g_str_equal (module_name, "file"))
+    {
+      set_storage_file ();
+      return TRUE;
+    }
+
+  return load_storage_module (module_name);
 }
 
 static const GOptionEntry entries[] = {
-	{"g-fatal-warnings", 0, 0, G_OPTION_ARG_NONE, &g_fatal_warnings, "Make all warnings fatal", NULL},
-	{"no-timeout", 't', 0, G_OPTION_ARG_NONE, &no_timeout, "Do not exit after unused for a while", NULL},
-	{ NULL }
+  {"g-fatal-warnings", 0, 0, G_OPTION_ARG_NONE, &g_fatal_warnings, "Make all warnings fatal", NULL},
+  {"no-timeout", 't', 0, G_OPTION_ARG_NONE, &no_timeout, "Do not exit after unused for a while", NULL},
+  { NULL }
 };
 
-static gboolean sigterm_callback(gpointer data)
+static gboolean
+sigterm_callback (gpointer data)
 {
-	GMainLoop *loop = data;
+  GMainLoop *loop = data;
 
-	g_main_loop_quit (loop);
-	return FALSE;
+  g_main_loop_quit (loop);
+  return FALSE;
 }
 
 static void
 on_name_acquired (GDBusConnection *connection,
-		  const char      *name,
-		  gpointer         user_data)
+                  const char      *name,
+                  gpointer         user_data)
 {
-	g_debug ("D-Bus service launched with name: %s", name);
+  g_debug ("D-Bus service launched with name: %s", name);
 }
 
 static void
 on_name_lost (GDBusConnection *connection,
-	      const char      *name,
-	      gpointer         user_data)
+              const char      *name,
+              gpointer         user_data)
 {
-	GMainLoop *loop = user_data;
+  GMainLoop *loop = user_data;
 
-	g_warning ("Failed to get name: %s", name);
+  g_warning ("Failed to get name: %s", name);
 
-	g_main_loop_quit (loop);
+  g_main_loop_quit (loop);
 }
 
-int main(int argc, char **argv)
+int
+main (int argc, char **argv)
 {
-	g_autoptr(GOptionContext) context = NULL;
-	g_autoptr(GMainLoop) loop = NULL;
-	g_autoptr(GError) error = NULL;
-	g_autoptr(FprintManager) manager = NULL;
-	g_autoptr(GDBusConnection) connection = NULL;
-	guint32 request_name_ret;
+  g_autoptr(GOptionContext) context = NULL;
+  g_autoptr(GMainLoop) loop = NULL;
+  g_autoptr(GError) error = NULL;
+  g_autoptr(FprintManager) manager = NULL;
+  g_autoptr(GDBusConnection) connection = NULL;
+  guint32 request_name_ret;
 
-	setlocale (LC_ALL, "");
+  setlocale (LC_ALL, "");
 
-	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
-	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
-	textdomain (GETTEXT_PACKAGE);
+  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+  textdomain (GETTEXT_PACKAGE);
 
-	context = g_option_context_new ("Fingerprint handler daemon");
-	g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
+  context = g_option_context_new ("Fingerprint handler daemon");
+  g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
 
-	if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
-		g_warning ("couldn't parse command-line options: %s\n", error->message);
-		return 1;
-	}
+  if (g_option_context_parse (context, &argc, &argv, &error) == FALSE)
+    {
+      g_warning ("couldn't parse command-line options: %s\n", error->message);
+      return 1;
+    }
 
-	if (g_fatal_warnings) {
-		GLogLevelFlags fatal_mask;
+  if (g_fatal_warnings)
+    {
+      GLogLevelFlags fatal_mask;
 
-		fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
-		fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
-		g_log_set_always_fatal (fatal_mask);
-	}
+      fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
+      fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
+      g_log_set_always_fatal (fatal_mask);
+    }
 
-	/* Obtain a connection to the system bus */
-	connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
-	if (!G_IS_DBUS_CONNECTION (connection)) {
-		g_warning("Failed to open connection to bus: %s", error->message);
-		return 1;
-	}
+  /* Obtain a connection to the system bus */
+  connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (!G_IS_DBUS_CONNECTION (connection))
+    {
+      g_warning ("Failed to open connection to bus: %s", error->message);
+      return 1;
+    }
 
-	/* Load the configuration file,
-	 * and the default storage plugin */
-	if (!load_conf())
-		set_storage_file ();
-	store.init ();
+  /* Load the configuration file,
+   * and the default storage plugin */
+  if (!load_conf ())
+    set_storage_file ();
+  store.init ();
 
-	loop = g_main_loop_new(NULL, FALSE);
-	g_unix_signal_add (SIGTERM, sigterm_callback, loop);
+  loop = g_main_loop_new (NULL, FALSE);
+  g_unix_signal_add (SIGTERM, sigterm_callback, loop);
 
-	g_debug("Launching FprintObject");
+  g_debug ("Launching FprintObject");
 
-	/* create the one instance of the Manager object to be shared between
-	 * all fprintd users. This blocks until all the devices are enumerated */
-	manager = fprint_manager_new (connection, no_timeout);
+  /* create the one instance of the Manager object to be shared between
+   * all fprintd users. This blocks until all the devices are enumerated */
+  manager = fprint_manager_new (connection, no_timeout);
 
-	/* Obtain the well-known name after the manager has been initialized.
-	 * Otherwise a client immediately enumerating the devices will not see
-	 * any. */
-	request_name_ret = g_bus_own_name_on_connection (connection,
-							 FPRINT_SERVICE_NAME,
-							 G_BUS_NAME_OWNER_FLAGS_NONE,
-							 on_name_acquired,
-							 on_name_lost,
-							 loop, NULL);
+  /* Obtain the well-known name after the manager has been initialized.
+   * Otherwise a client immediately enumerating the devices will not see
+   * any. */
+  request_name_ret = g_bus_own_name_on_connection (connection,
+                                                   FPRINT_SERVICE_NAME,
+                                                   G_BUS_NAME_OWNER_FLAGS_NONE,
+                                                   on_name_acquired,
+                                                   on_name_lost,
+                                                   loop, NULL);
 
-	g_debug("entering main loop");
-	g_main_loop_run(loop);
-	g_bus_unown_name (request_name_ret);
-	g_debug("main loop completed");
+  g_debug ("entering main loop");
+  g_main_loop_run (loop);
+  g_bus_unown_name (request_name_ret);
+  g_debug ("main loop completed");
 
-	return 0;
+  return 0;
 }
-

src/manager.c

@@ -28,294 +28,316 @@
 #include "fprintd.h"
 
 static void fprint_manager_constructed (GObject *object);
-static gboolean fprint_manager_get_devices(FprintManager *manager,
-	GPtrArray **devices, GError **error);
-static gboolean fprint_manager_get_default_device(FprintManager *manager,
-	const char **device, GError **error);
+static gboolean fprint_manager_get_devices (FprintManager *manager,
+                                            GPtrArray    **devices,
+                                            GError       **error);
+static gboolean fprint_manager_get_default_device (FprintManager *manager,
+                                                   const char   **device,
+                                                   GError       **error);
 
 typedef struct
 {
-	GDBusConnection *connection;
-	GDBusObjectManager *object_manager;
-	FprintDBusManager *dbus_manager;
-	FpContext *context;
-	gboolean no_timeout;
-	guint timeout_id;
+  GDBusConnection    *connection;
+  GDBusObjectManager *object_manager;
+  FprintDBusManager  *dbus_manager;
+  FpContext          *context;
+  gboolean            no_timeout;
+  guint               timeout_id;
 } FprintManagerPrivate;
 
-G_DEFINE_TYPE_WITH_CODE(FprintManager, fprint_manager, G_TYPE_OBJECT, G_ADD_PRIVATE (FprintManager))
+G_DEFINE_TYPE_WITH_CODE (FprintManager, fprint_manager, G_TYPE_OBJECT, G_ADD_PRIVATE (FprintManager))
 
 enum {
-	PROP_0,
-	FPRINT_MANAGER_CONNECTION,
-	N_PROPS
+  PROP_0,
+  FPRINT_MANAGER_CONNECTION,
+  N_PROPS
 };
 
 static GParamSpec *properties[N_PROPS];
 
-static void fprint_manager_finalize(GObject *object)
+static void
+fprint_manager_finalize (GObject *object)
 {
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (FPRINT_MANAGER (object));
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (FPRINT_MANAGER (object));
 
-	g_clear_object (&priv->object_manager);
-	g_clear_object (&priv->dbus_manager);
-	g_clear_object (&priv->connection);
-	g_clear_object (&priv->context);
+  g_clear_object (&priv->object_manager);
+  g_clear_object (&priv->dbus_manager);
+  g_clear_object (&priv->connection);
+  g_clear_object (&priv->context);
 
-	G_OBJECT_CLASS(fprint_manager_parent_class)->finalize(object);
+  G_OBJECT_CLASS (fprint_manager_parent_class)->finalize (object);
 }
 
 static FprintDevice *
-fprint_dbus_object_skeleton_get_device (FprintDBusObjectSkeleton *object) {
-	FprintDevice *rdev;
+fprint_dbus_object_skeleton_get_device (FprintDBusObjectSkeleton *object)
+{
+  FprintDevice *rdev;
 
-	g_object_get (object, "device", &rdev, NULL);
-	return rdev;
+  g_object_get (object, "device", &rdev, NULL);
+  return rdev;
 }
 
-static void fprint_manager_set_property (GObject *object, guint property_id,
-					 const GValue *value, GParamSpec *pspec)
+static void
+fprint_manager_set_property (GObject *object, guint property_id,
+                             const GValue *value, GParamSpec *pspec)
 {
-	FprintManager *self = FPRINT_MANAGER (object);
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (self);
+  FprintManager *self = FPRINT_MANAGER (object);
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (self);
 
-	switch (property_id) {
-	case FPRINT_MANAGER_CONNECTION:
-		priv->connection = g_value_dup_object (value);
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
-		break;
-	}
+  switch (property_id)
+    {
+    case FPRINT_MANAGER_CONNECTION:
+      priv->connection = g_value_dup_object (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
 }
 
-static void fprint_manager_get_property (GObject *object, guint property_id,
-					 GValue *value, GParamSpec *pspec)
+static void
+fprint_manager_get_property (GObject *object, guint property_id,
+                             GValue *value, GParamSpec *pspec)
 {
-	FprintManager *self = FPRINT_MANAGER (object);
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (self);
+  FprintManager *self = FPRINT_MANAGER (object);
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (self);
 
-	switch (property_id) {
-	case FPRINT_MANAGER_CONNECTION:
-		g_value_set_object (value, priv->connection);
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
-		break;
-	}
+  switch (property_id)
+    {
+    case FPRINT_MANAGER_CONNECTION:
+      g_value_set_object (value, priv->connection);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
 }
 
-static void fprint_manager_class_init(FprintManagerClass *klass)
+static void
+fprint_manager_class_init (FprintManagerClass *klass)
 {
-	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-	object_class->constructed = fprint_manager_constructed;
-	object_class->set_property = fprint_manager_set_property;
-	object_class->get_property = fprint_manager_get_property;
-	object_class->finalize = fprint_manager_finalize;
+  object_class->constructed = fprint_manager_constructed;
+  object_class->set_property = fprint_manager_set_property;
+  object_class->get_property = fprint_manager_get_property;
+  object_class->finalize = fprint_manager_finalize;
 
-	properties[FPRINT_MANAGER_CONNECTION] =
-		g_param_spec_object ("connection",
-				     "Connection",
-				     "Set GDBus connection property",
-				     G_TYPE_DBUS_CONNECTION,
-				     G_PARAM_CONSTRUCT_ONLY |
-				     G_PARAM_READWRITE);
+  properties[FPRINT_MANAGER_CONNECTION] =
+    g_param_spec_object ("connection",
+                         "Connection",
+                         "Set GDBus connection property",
+                         G_TYPE_DBUS_CONNECTION,
+                         G_PARAM_CONSTRUCT_ONLY |
+                         G_PARAM_READWRITE);
 
-	g_object_class_install_properties (object_class, N_PROPS, properties);
+  g_object_class_install_properties (object_class, N_PROPS, properties);
 }
 
-static gchar *get_device_path(FprintDevice *rdev)
+static gchar *
+get_device_path (FprintDevice *rdev)
 {
-	return g_strdup_printf (FPRINT_SERVICE_PATH "/Device/%d",
-		_fprint_device_get_id(rdev));
+  return g_strdup_printf (FPRINT_SERVICE_PATH "/Device/%d",
+                          _fprint_device_get_id (rdev));
 }
 
 static gboolean
 fprint_manager_timeout_cb (FprintManager *manager)
 {
-	//FIXME kill all the devices
-	exit(0);
-	return FALSE;
+  //FIXME kill all the devices
+  exit (0);
+  return FALSE;
 }
 
 static void
 fprint_manager_in_use_notified (FprintDevice *rdev, GParamSpec *spec, FprintManager *manager)
 {
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
-	guint num_devices_used = 0;
-	g_autolist(GDBusObject) devices = NULL;
-	GList *l;
-	gboolean in_use;
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
+  guint num_devices_used = 0;
 
-	if (priv->timeout_id > 0) {
-		g_source_remove (priv->timeout_id);
-		priv->timeout_id = 0;
-	}
-	if (priv->no_timeout)
-		return;
+  g_autolist (GDBusObject) devices = NULL;
+  GList *l;
+  gboolean in_use;
 
-	devices = g_dbus_object_manager_get_objects (priv->object_manager);
+  if (priv->timeout_id > 0)
+    {
+      g_source_remove (priv->timeout_id);
+      priv->timeout_id = 0;
+    }
+  if (priv->no_timeout)
+    return;
 
-	for (l = devices; l != NULL; l = l->next) {
-		g_autoptr(FprintDevice) dev = NULL;
-		FprintDBusObjectSkeleton *object = l->data;
+  devices = g_dbus_object_manager_get_objects (priv->object_manager);
 
-		dev = fprint_dbus_object_skeleton_get_device (object);
-		g_object_get (G_OBJECT(dev), "in-use", &in_use, NULL);
-		if (in_use != FALSE)
-			num_devices_used++;
-	}
+  for (l = devices; l != NULL; l = l->next)
+    {
+      g_autoptr(FprintDevice) dev = NULL;
+      FprintDBusObjectSkeleton *object = l->data;
 
-	if (num_devices_used == 0)
-		priv->timeout_id = g_timeout_add_seconds (TIMEOUT, (GSourceFunc) fprint_manager_timeout_cb, manager);
+      dev = fprint_dbus_object_skeleton_get_device (object);
+      g_object_get (G_OBJECT (dev), "in-use", &in_use, NULL);
+      if (in_use != FALSE)
+        num_devices_used++;
+    }
+
+  if (num_devices_used == 0)
+    priv->timeout_id = g_timeout_add_seconds (TIMEOUT, (GSourceFunc) fprint_manager_timeout_cb, manager);
 }
 
 static gboolean
 handle_get_devices (FprintManager *manager, GDBusMethodInvocation *invocation,
-		    FprintDBusManager *skeleton)
+                    FprintDBusManager *skeleton)
 {
-	g_autoptr(GPtrArray) devices = NULL;
-	g_autoptr(GError) error = NULL;
+  g_autoptr(GPtrArray) devices = NULL;
+  g_autoptr(GError) error = NULL;
 
-	if (!fprint_manager_get_devices (manager, &devices, &error)) {
-		g_dbus_method_invocation_return_gerror (invocation, error);
-		return TRUE;
-	}
+  if (!fprint_manager_get_devices (manager, &devices, &error))
+    {
+      g_dbus_method_invocation_return_gerror (invocation, error);
+      return TRUE;
+    }
 
-	fprint_dbus_manager_complete_get_devices (skeleton, invocation,
-						  (const gchar *const *)
-						  devices->pdata);
+  fprint_dbus_manager_complete_get_devices (skeleton, invocation,
+                                            (const gchar *const *)
+                                            devices->pdata);
 
-	return TRUE;
+  return TRUE;
 }
 
 static gboolean
-handle_get_default_device (FprintManager *manager,
-			   GDBusMethodInvocation *invocation,
-			   FprintDBusManager *skeleton)
+handle_get_default_device (FprintManager         *manager,
+                           GDBusMethodInvocation *invocation,
+                           FprintDBusManager     *skeleton)
 {
-	const gchar *device;
-	g_autoptr(GError) error = NULL;
+  const gchar *device;
 
-	if (!fprint_manager_get_default_device (manager, &device, &error)) {
-		g_dbus_method_invocation_return_gerror (invocation, error);
-		return TRUE;
-	}
+  g_autoptr(GError) error = NULL;
 
-	fprint_dbus_manager_complete_get_default_device (skeleton, invocation,
-							 device);
+  if (!fprint_manager_get_default_device (manager, &device, &error))
+    {
+      g_dbus_method_invocation_return_gerror (invocation, error);
+      return TRUE;
+    }
 
-	return TRUE;
+  fprint_dbus_manager_complete_get_default_device (skeleton, invocation,
+                                                   device);
+
+  return TRUE;
 }
 
 static void
 device_added_cb (FprintManager *manager, FpDevice *device, FpContext *context)
 {
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
-	g_autoptr(FprintDBusObjectSkeleton) object = NULL;
-	g_autoptr(FprintDevice) rdev = NULL;
-	g_autofree gchar *path = NULL;
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
 
-	rdev = fprint_device_new(device);
+  g_autoptr(FprintDBusObjectSkeleton) object = NULL;
+  g_autoptr(FprintDevice) rdev = NULL;
+  g_autofree gchar *path = NULL;
 
-	g_signal_connect (G_OBJECT(rdev), "notify::in-use",
-			  G_CALLBACK (fprint_manager_in_use_notified), manager);
+  rdev = fprint_device_new (device);
 
-	path = get_device_path (rdev);
+  g_signal_connect (G_OBJECT (rdev), "notify::in-use",
+                    G_CALLBACK (fprint_manager_in_use_notified), manager);
 
-	object = fprint_dbus_object_skeleton_new (path);
-	fprint_dbus_object_skeleton_set_device (object,
-						FPRINT_DBUS_DEVICE (rdev));
-	g_dbus_object_manager_server_export (
-		G_DBUS_OBJECT_MANAGER_SERVER (priv->object_manager),
-		G_DBUS_OBJECT_SKELETON (object));
+  path = get_device_path (rdev);
+
+  object = fprint_dbus_object_skeleton_new (path);
+  fprint_dbus_object_skeleton_set_device (object,
+                                          FPRINT_DBUS_DEVICE (rdev));
+  g_dbus_object_manager_server_export (
+    G_DBUS_OBJECT_MANAGER_SERVER (priv->object_manager),
+    G_DBUS_OBJECT_SKELETON (object));
 }
 
 static void
 device_removed_cb (FprintManager *manager, FpDevice *device, FpContext *context)
 {
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
-	g_autolist (FprintDBusObjectSkeleton) objects = NULL;
-	GList *item;
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
 
-	objects = g_dbus_object_manager_get_objects (priv->object_manager);
+  g_autolist (FprintDBusObjectSkeleton) objects = NULL;
+  GList *item;
 
-	for (item = objects; item; item = item->next) {
-		g_autoptr(FprintDevice) rdev = NULL;
-		g_autoptr(FpDevice) dev = NULL;
-		FprintDBusObjectSkeleton *object = item->data;
+  objects = g_dbus_object_manager_get_objects (priv->object_manager);
 
-		rdev = fprint_dbus_object_skeleton_get_device (object);
-		g_object_get (rdev, "dev", &dev, NULL);
-		if (dev != device)
-			continue;
+  for (item = objects; item; item = item->next)
+    {
+      g_autoptr(FprintDevice) rdev = NULL;
+      g_autoptr(FpDevice) dev = NULL;
+      FprintDBusObjectSkeleton *object = item->data;
 
-		g_dbus_object_manager_server_unexport (
-			G_DBUS_OBJECT_MANAGER_SERVER (priv->object_manager),
-			g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (rdev)));
+      rdev = fprint_dbus_object_skeleton_get_device (object);
+      g_object_get (rdev, "dev", &dev, NULL);
+      if (dev != device)
+        continue;
 
-		g_signal_handlers_disconnect_by_data (rdev, manager);
+      g_dbus_object_manager_server_unexport (
+        G_DBUS_OBJECT_MANAGER_SERVER (priv->object_manager),
+        g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (rdev)));
 
-		/* We cannot continue to iterate at this point, but we don't need to either */
-		break;
-	}
+      g_signal_handlers_disconnect_by_data (rdev, manager);
 
-	/* The device that disappeared might have been in-use.
-	 * Do we need to do anything else in this case to clean up more gracefully? */
-	fprint_manager_in_use_notified (NULL, NULL, manager);
+      /* We cannot continue to iterate at this point, but we don't need to either */
+      break;
+    }
+
+  /* The device that disappeared might have been in-use.
+   * Do we need to do anything else in this case to clean up more gracefully? */
+  fprint_manager_in_use_notified (NULL, NULL, manager);
 }
 
-static void fprint_manager_constructed (GObject *object)
+static void
+fprint_manager_constructed (GObject *object)
 {
-	FprintManager *manager = FPRINT_MANAGER (object);
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
-	GDBusObjectManagerServer *object_manager_server;
+  FprintManager *manager = FPRINT_MANAGER (object);
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
+  GDBusObjectManagerServer *object_manager_server;
 
-	object_manager_server =
-		g_dbus_object_manager_server_new (FPRINT_SERVICE_PATH "/Device");
+  object_manager_server =
+    g_dbus_object_manager_server_new (FPRINT_SERVICE_PATH "/Device");
 
-	priv->object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);
-	priv->dbus_manager = fprint_dbus_manager_skeleton_new ();
-	priv->context = fp_context_new ();
+  priv->object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);
+  priv->dbus_manager = fprint_dbus_manager_skeleton_new ();
+  priv->context = fp_context_new ();
 
-	g_signal_connect_object (priv->dbus_manager,
-				 "handle-get-devices",
-				 G_CALLBACK (handle_get_devices),
-				 manager,
-				 G_CONNECT_SWAPPED);
-	g_signal_connect_object (priv->dbus_manager,
-				 "handle-get-default-device",
-				 G_CALLBACK (handle_get_default_device),
-				 manager,
-				 G_CONNECT_SWAPPED);
+  g_signal_connect_object (priv->dbus_manager,
+                           "handle-get-devices",
+                           G_CALLBACK (handle_get_devices),
+                           manager,
+                           G_CONNECT_SWAPPED);
+  g_signal_connect_object (priv->dbus_manager,
+                           "handle-get-default-device",
+                           G_CALLBACK (handle_get_default_device),
+                           manager,
+                           G_CONNECT_SWAPPED);
 
-	g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->dbus_manager),
-					  priv->connection,
-					  FPRINT_SERVICE_PATH "/Manager", NULL);
+  g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->dbus_manager),
+                                    priv->connection,
+                                    FPRINT_SERVICE_PATH "/Manager", NULL);
 
-	g_dbus_object_manager_server_set_connection (object_manager_server,
-						     priv->connection);
+  g_dbus_object_manager_server_set_connection (object_manager_server,
+                                               priv->connection);
 
-	/* And register the signals for initial enumeration and hotplug. */
-	g_signal_connect_object (priv->context,
-				 "device-added",
-				 (GCallback) device_added_cb,
-				 manager,
-				 G_CONNECT_SWAPPED);
+  /* And register the signals for initial enumeration and hotplug. */
+  g_signal_connect_object (priv->context,
+                           "device-added",
+                           (GCallback) device_added_cb,
+                           manager,
+                           G_CONNECT_SWAPPED);
 
-	g_signal_connect_object (priv->context,
-				 "device-removed",
-				 (GCallback) device_removed_cb,
-				 manager,
-				 G_CONNECT_SWAPPED);
+  g_signal_connect_object (priv->context,
+                           "device-removed",
+                           (GCallback) device_removed_cb,
+                           manager,
+                           G_CONNECT_SWAPPED);
 
-	/* Prepare everything by enumerating all devices.
-	 * This blocks the main loop until the existing devices are enumerated
-	 */
-	fp_context_enumerate (priv->context);
+  /* Prepare everything by enumerating all devices.
+   * This blocks the main loop until the existing devices are enumerated
+   */
+  fp_context_enumerate (priv->context);
 
-	G_OBJECT_CLASS (fprint_manager_parent_class)->constructed (object);
+  G_OBJECT_CLASS (fprint_manager_parent_class)->constructed (object);
 }
 
 static void
@@ -323,99 +345,113 @@ fprint_manager_init (FprintManager *manager)
 {
 }
 
-FprintManager *fprint_manager_new (GDBusConnection *connection, gboolean no_timeout)
+FprintManager *
+fprint_manager_new (GDBusConnection *connection, gboolean no_timeout)
 {
-	FprintManagerPrivate *priv;
-	GObject *object;
+  FprintManagerPrivate *priv;
+  GObject *object;
 
-	object = g_object_new (FPRINT_TYPE_MANAGER, "connection", connection, NULL);
-	priv = fprint_manager_get_instance_private (FPRINT_MANAGER (object));
-	priv->no_timeout = no_timeout;
+  object = g_object_new (FPRINT_TYPE_MANAGER, "connection", connection, NULL);
+  priv = fprint_manager_get_instance_private (FPRINT_MANAGER (object));
+  priv->no_timeout = no_timeout;
 
-	if (!priv->no_timeout)
-		priv->timeout_id = g_timeout_add_seconds (TIMEOUT, (GSourceFunc) fprint_manager_timeout_cb, object);
+  if (!priv->no_timeout)
+    priv->timeout_id = g_timeout_add_seconds (TIMEOUT, (GSourceFunc) fprint_manager_timeout_cb, object);
 
-	return FPRINT_MANAGER (object);
+  return FPRINT_MANAGER (object);
 }
 
-static gboolean fprint_manager_get_devices(FprintManager *manager,
-	GPtrArray **devices, GError **error)
+static gboolean
+fprint_manager_get_devices (FprintManager *manager,
+                            GPtrArray **devices, GError **error)
 {
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
-	g_autolist (FprintDBusObjectSkeleton) objects = NULL;
-	GList *l;
-	int num_open;
-	GPtrArray *devs;
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
 
-	objects = g_dbus_object_manager_get_objects (priv->object_manager);
-	objects = g_list_reverse (objects);
+  g_autolist (FprintDBusObjectSkeleton) objects = NULL;
+  GList *l;
+  int num_open;
+  GPtrArray *devs;
 
-	num_open = g_list_length (objects);
-	devs = g_ptr_array_sized_new(num_open);
+  objects = g_dbus_object_manager_get_objects (priv->object_manager);
+  objects = g_list_reverse (objects);
 
-	if (num_open > 0) {
-		for (l = objects; l != NULL; l = l->next) {
-			g_autoptr(FprintDevice) rdev = NULL;
-			FprintDBusObjectSkeleton *object = l->data;
-			const char *path;
+  num_open = g_list_length (objects);
+  devs = g_ptr_array_sized_new (num_open);
 
-			rdev = fprint_dbus_object_skeleton_get_device (object);
-			path = g_dbus_interface_skeleton_get_object_path (
-				G_DBUS_INTERFACE_SKELETON (rdev));
-			g_ptr_array_add (devs, (char *) path);
-		}
-	}
-	g_ptr_array_add (devs, NULL);
+  if (num_open > 0)
+    {
+      for (l = objects; l != NULL; l = l->next)
+        {
+          g_autoptr(FprintDevice) rdev = NULL;
+          FprintDBusObjectSkeleton *object = l->data;
+          const char *path;
 
-	*devices = devs;
-	return TRUE;
+          rdev = fprint_dbus_object_skeleton_get_device (object);
+          path = g_dbus_interface_skeleton_get_object_path (
+            G_DBUS_INTERFACE_SKELETON (rdev));
+          g_ptr_array_add (devs, (char *) path);
+        }
+    }
+  g_ptr_array_add (devs, NULL);
+
+  *devices = devs;
+  return TRUE;
 }
 
-static gboolean fprint_manager_get_default_device(FprintManager *manager,
-	const char **device, GError **error)
+static gboolean
+fprint_manager_get_default_device (FprintManager *manager,
+                                   const char **device, GError **error)
 {
-	FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
-	g_autolist (FprintDBusObjectSkeleton) objects = NULL;
-	int num_open;
+  FprintManagerPrivate *priv = fprint_manager_get_instance_private (manager);
 
-	objects = g_dbus_object_manager_get_objects (priv->object_manager);
-	num_open = g_list_length (objects);
+  g_autolist (FprintDBusObjectSkeleton) objects = NULL;
+  int num_open;
 
-	if (num_open > 0) {
-		g_autoptr(FprintDevice) rdev = NULL;
-		FprintDBusObjectSkeleton *object = g_list_last (objects)->data;
+  objects = g_dbus_object_manager_get_objects (priv->object_manager);
+  num_open = g_list_length (objects);
 
-		rdev = fprint_dbus_object_skeleton_get_device (object);
-		*device = g_dbus_interface_skeleton_get_object_path (
-			G_DBUS_INTERFACE_SKELETON (rdev));
-		return TRUE;
-	} else {
-		g_set_error (error, FPRINT_ERROR, FPRINT_ERROR_NO_SUCH_DEVICE,
-			     "No devices available");
-		*device = NULL;
-		return FALSE;
-	}
+  if (num_open > 0)
+    {
+      g_autoptr(FprintDevice) rdev = NULL;
+      FprintDBusObjectSkeleton *object = g_list_last (objects)->data;
+
+      rdev = fprint_dbus_object_skeleton_get_device (object);
+      *device = g_dbus_interface_skeleton_get_object_path (
+        G_DBUS_INTERFACE_SKELETON (rdev));
+      return TRUE;
+    }
+  else
+    {
+      g_set_error (error, FPRINT_ERROR, FPRINT_ERROR_NO_SUCH_DEVICE,
+                   "No devices available");
+      *device = NULL;
+      return FALSE;
+    }
 }
 
-GQuark fprint_error_quark (void)
+GQuark
+fprint_error_quark (void)
 {
-	static volatile gsize quark = 0;
-	if (g_once_init_enter (&quark)) {
-		g_autoptr(GEnumClass) errors_enum = NULL;
-		GQuark domain;
-		unsigned i;
+  static volatile gsize quark = 0;
 
-		domain = g_quark_from_static_string ("fprintd-error-quark");
-		errors_enum = g_type_class_ref (FPRINT_TYPE_ERROR);
+  if (g_once_init_enter (&quark))
+    {
+      g_autoptr(GEnumClass) errors_enum = NULL;
+      GQuark domain;
+      unsigned i;
 
-		for (i = 0; i < errors_enum->n_values; ++i) {
-			GEnumValue *value = &errors_enum->values[i];
+      domain = g_quark_from_static_string ("fprintd-error-quark");
+      errors_enum = g_type_class_ref (FPRINT_TYPE_ERROR);
 
-			g_dbus_error_register_error (domain, value->value,
-						     value->value_nick);
-		}
+      for (i = 0; i < errors_enum->n_values; ++i)
+        {
+          GEnumValue *value = &errors_enum->values[i];
 
-		g_once_init_leave (&quark, domain);
-	}
-	return (GQuark) quark;
+          g_dbus_error_register_error (domain, value->value,
+                                       value->value_nick);
+        }
+
+      g_once_init_leave (&quark, domain);
+    }
+  return (GQuark) quark;
 }

src/meson.build

@@ -14,7 +14,8 @@ foreach interface_name: dbus_interfaces
     )
 endforeach
 
-fprintd_dbus_sources = gnome.gdbus_codegen('fprintd-dbus',
+# NOTE: We should pass "--glib-min-required 2.64" but cannot
+fprintd_dbus_sources_base = gnome.gdbus_codegen('fprintd-dbus',
     sources: dbus_interfaces_files,
     autocleanup: 'all',
     interface_prefix: 'net.reactivated.Fprint.',
@@ -22,6 +23,23 @@ fprintd_dbus_sources = gnome.gdbus_codegen('fprintd-dbus',
     object_manager: true,
 )
 
+# FIXME: remove this and just use fprintd_dbus_sources when we're on glib 2.64
+fprintd_dbus_sources = [
+    fprintd_dbus_sources_base[1] # header file
+]
+
+fprintd_dbus_sources += custom_target('fprintd-dbus-interactive',
+    input: fprintd_dbus_sources_base[0], # c file,
+    output: 'fprintd-dbus-interactive.c',
+    command: [
+        find_program('patch'),
+        '-p1',
+        '--merge',
+        '@INPUT@',
+        files('dbus-interactive-auth.patch'),
+        '-o', '@OUTPUT@',
+    ])
+
 fprintd_enum_files = gnome.mkenums_simple('fprintd-enums',
   sources: 'fprintd.h',
 )

src/storage.h

@@ -28,19 +28,21 @@ typedef int (*storage_print_data_load)(FpDevice   *dev,
 typedef int (*storage_print_data_delete)(FpDevice   *dev,
                                          FpFinger    finger,
                                          const char *username);
-typedef GSList *(*storage_discover_prints)(FpDevice *dev, const char *username);
+typedef GSList *(*storage_discover_prints)(FpDevice   *dev,
+                                           const char *username);
 typedef GSList *(*storage_discover_users)(void);
 typedef int (*storage_init)(void);
 typedef int (*storage_deinit)(void);
 
-struct storage {
-	storage_init init;
-	storage_deinit deinit;
-	storage_print_data_save print_data_save;
-	storage_print_data_load print_data_load;
-	storage_print_data_delete print_data_delete;
-	storage_discover_prints discover_prints;
-	storage_discover_users discover_users;
+struct storage
+{
+  storage_init              init;
+  storage_deinit            deinit;
+  storage_print_data_save   print_data_save;
+  storage_print_data_load   print_data_load;
+  storage_print_data_delete print_data_delete;
+  storage_discover_prints   discover_prints;
+  storage_discover_users    discover_users;
 };
 
 typedef struct storage fp_storage;

tests/dbusmock/fprintd.py

@@ -18,6 +18,8 @@ __email__ = 'hadess@hadess.net'
 __copyright__ = '(c) 2020 Red Hat Inc.'
 __license__ = 'LGPL 3+'
 
+import sys
+from gi.repository import GLib
 import dbus
 import asyncio
 
@@ -213,13 +215,26 @@ def can_verify_finger(device, finger_name):
         return True
     return False
 
-async def send_verify_script(device, script):
-    for [result, done, timeout] in device.verify_script:
-        await asyncio.sleep(timeout)
-        device.EmitSignal(DEVICE_IFACE, 'VerifyStatus', 'sb', [
-                            result,
-                            done
-                          ])
+def glib_sleep(timeout):
+    waiting = True
+
+    def done_waiting():
+        nonlocal waiting
+        waiting = False
+
+    GLib.timeout_add(timeout, done_waiting)
+    while (waiting):
+        GLib.main_context_default().iteration(True)
+
+def device_run_script(device, result, done):
+    if result == 'MOCK: quit':
+        sys.exit(0)
+
+    # Emit signal
+    device.EmitSignal(DEVICE_IFACE, 'VerifyStatus', 'sb', [
+                        result,
+                        done
+                      ])
 
 @dbus.service.method(DEVICE_IFACE,
                      in_signature='s', out_signature='')
@@ -249,13 +264,44 @@ def VerifyStart(device, finger_name):
     if finger_name == 'any' and not device.has_identification:
         finger_name = device.fingers[device.claimed_user][0]
     device.selected_finger = finger_name
-    device.EmitSignal(DEVICE_IFACE, 'VerifyFingerSelected', 's', [
-                          finger_name
-                      ])
+    # Needs to happen after method return
+    GLib.idle_add(device.EmitSignal,
+                  DEVICE_IFACE, 'VerifyFingerSelected', 's', [
+                    device.selected_finger
+                  ])
 
-    if device.verify_script is not None and len(device.verify_script) > 0:
-        asyncio.run(send_verify_script(device, device.verify_script))
+    error = None
+    base_delay = 0
+    while device.verify_script is not None and len(device.verify_script) > 0:
+        result, done, timeout = device.verify_script.pop(0)
 
+        # We stop when "timeout >= 0 and done"
+        if result == 'MOCK: no-prints':
+            # Special case to change return value of DBus call, ignores timeout
+            error = dbus.exceptions.DBusException(
+                'No enrolled prints for user \'%s\'' % device.claimed_user,
+                name='net.reactivated.Fprint.Error.NoEnrolledPrints')
+
+        elif timeout < 0:
+            # Negative timeouts mean emitting before the DBus call returns
+            device_run_script(device, result, done)
+            glib_sleep(-timeout)
+
+        else:
+            # Positive or zero means emitting afterwards the given timeout
+            base_delay += timeout
+            GLib.timeout_add(base_delay,
+                             device_run_script,
+                             device,
+                             result,
+                             done)
+
+            # Stop processing commands when the done flag is set
+            if done:
+                break
+
+    if error:
+        raise error
 
 @dbus.service.method(DEVICE_MOCK_IFACE,
                      in_signature='sb', out_signature='')
@@ -383,3 +429,11 @@ def SetVerifyScript(device, script):
     '''
 
     device.verify_script = script
+
+@dbus.service.method(DEVICE_MOCK_IFACE,
+                     in_signature='s', out_signature='')
+def SetClaimed(device, user):
+    if user == '':
+        device.claimed_user = None
+    else:
+        device.claimed_user = user

tests/fprintd.py

@@ -493,32 +493,55 @@ class FPrintdManagerPreStartTests(FPrintdTest):
             self.manager.GetDefaultDevice()
 
     def test_manager_get_devices_on_name_appeared(self):
-        self._appeared_res = []
+        self._appeared_name = None
 
         def on_name_appeared(connection, name, name_owner):
-            self._appeared_res.append(connection.call_sync('net.reactivated.Fprint',
-                '/net/reactivated/Fprint/Manager',
-                'net.reactivated.Fprint.Manager',
-                'GetDefaultDevice', None, None,
-                Gio.DBusCallFlags.NO_AUTO_START, 500, None))
+            self._appeared_name = name
+
+        def on_name_vanished(connection, name):
+            self._appeared_name = 'NAME_VANISHED'
 
         id = Gio.bus_watch_name_on_connection(self.dbus,
             'net.reactivated.Fprint', Gio.BusNameWatcherFlags.NONE,
-            on_name_appeared, None)
+            on_name_appeared, on_name_vanished)
+        self.addCleanup(Gio.bus_unwatch_name, id)
 
         self.daemon_start()
-        while not self._appeared_res:
+        while not self._appeared_name:
             ctx.iteration(True)
 
-        self.assertIsNotNone(self._appeared_res[0])
-        dev_path = self._appeared_res[0][0]
-        self.assertTrue(dev_path.startswith('/net/reactivated/Fprint/Device/'))
+        self.assertEqual(self._appeared_name, 'net.reactivated.Fprint')
 
-        Gio.bus_unwatch_name(id)
+        try:
+            appeared_device = self.dbus.call_sync(
+                'net.reactivated.Fprint',
+                '/net/reactivated/Fprint/Manager',
+                'net.reactivated.Fprint.Manager',
+                'GetDefaultDevice', None, None,
+                Gio.DBusCallFlags.NO_AUTO_START, 500, None)
+        except GLib.GError as e:
+            if 'net.reactivated.Fprint.Error.NoSuchDevice' in e.message:
+                self.skipTest("Need virtual_image device to run the test")
+            raise(e)
+
+        self.assertIsNotNone(appeared_device)
+        [dev_path] = appeared_device
+        self.assertTrue(dev_path.startswith('/net/reactivated/Fprint/Device/'))
 
 
 class FPrintdVirtualDeviceTest(FPrintdVirtualDeviceBaseTest):
 
+    def test_name_property(self):
+        self.assertEqual(self.device.get_cached_property('name').unpack(),
+            'Virtual image device for debugging')
+
+    def test_enroll_stages_property(self):
+        self.assertEqual(self.device.get_cached_property('num-enroll-stages').unpack(), 5)
+
+    def test_scan_type(self):
+        self.assertEqual(self.device.get_cached_property('scan-type').unpack(),
+            'swipe')
+
     def test_allowed_claim_release_enroll(self):
         self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.setusername',
                                       'net.reactivated.fprint.device.enroll'])
@@ -580,6 +603,34 @@ class FPrintdVirtualDeviceTest(FPrintdVirtualDeviceBaseTest):
         with self.assertFprintError('PermissionDenied'):
             self.device.Claim('(s)', 'testuser')
 
+    def test_unallowed_enroll_with_verify_claim(self):
+        self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.verify'])
+        self.device.Claim('(s)', '')
+
+        with self.assertFprintError('PermissionDenied'):
+            self.enroll_image('whorl', finger='right-thumb')
+
+    def test_unallowed_delete_with_verify_claim(self):
+        self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.verify'])
+        self.device.Claim('(s)', '')
+
+        with self.assertFprintError('PermissionDenied'):
+            self.device.DeleteEnrolledFingers('(s)', 'testuser')
+
+    def test_unallowed_delete2_with_verify_claim(self):
+        self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.verify'])
+        self.device.Claim('(s)', '')
+
+        with self.assertFprintError('PermissionDenied'):
+            self.device.DeleteEnrolledFingers2()
+
+    def test_unallowed_verify_with_enroll_claim(self):
+        self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.enroll'])
+        self.device.Claim('(s)', '')
+
+        with self.assertFprintError('PermissionDenied'):
+            self.device.VerifyStart('(s)', 'any')
+
     def test_unallowed_claim_current_user(self):
         self._polkitd_obj.SetAllowed([''])
 
@@ -597,20 +648,11 @@ class FPrintdVirtualDeviceTest(FPrintdVirtualDeviceBaseTest):
 
         self.device.Release()
 
-    def test_unallowed_release(self):
+    def test_always_allowed_release(self):
         self.device.Claim('(s)', 'testuser')
 
         self._polkitd_obj.SetAllowed([''])
 
-        with self.assertFprintError('PermissionDenied'):
-            self.device.Release()
-
-        self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.setusername'])
-
-        with self.assertFprintError('PermissionDenied'):
-            self.device.Release()
-
-        self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.enroll'])
         self.device.Release()
 
     def test_unclaimed_release(self):
@@ -780,6 +822,7 @@ class FPrintdVirtualDeviceClaimedTest(FPrintdVirtualDeviceBaseTest):
         self.wait_for_result()
         self.assertTrue(self._verify_stopped)
         self.assertEqual(self._last_result, 'verify-match')
+        self.device.VerifyStop()
 
         self.assertEqual(self.device.ListEnrolledFingers('(s)', 'testuser'), ['right-index-finger'])
 
@@ -959,15 +1002,11 @@ class FPrintdVirtualDeviceClaimedTest(FPrintdVirtualDeviceBaseTest):
         self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.enroll'])
         self.enroll_image('whorl')
 
-    def test_unallowed_enroll_stop(self):
+    def test_always_allowed_enroll_stop(self):
         self.device.EnrollStart('(s)', 'right-index-finger')
 
         self._polkitd_obj.SetAllowed([''])
 
-        with self.assertFprintError('PermissionDenied'):
-            self.device.EnrollStop()
-
-        self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.enroll'])
         self.device.EnrollStop()
 
     def test_unallowed_verify_start(self):
@@ -976,15 +1015,11 @@ class FPrintdVirtualDeviceClaimedTest(FPrintdVirtualDeviceBaseTest):
         with self.assertFprintError('PermissionDenied'):
             self.device.VerifyStart('(s)', 'any')
 
-    def test_unallowed_verify_stop(self):
+    def test_always_allowed_verify_stop(self):
         self.enroll_image('whorl')
         self.device.VerifyStart('(s)', 'any')
 
         self._polkitd_obj.SetAllowed([''])
-        with self.assertFprintError('PermissionDenied'):
-            self.device.VerifyStop()
-
-        self._polkitd_obj.SetAllowed(['net.reactivated.fprint.device.verify'])
         self.device.VerifyStop()
 
     def test_list_enrolled_fingers_current_user(self):

tests/output_checker.py

@@ -0,0 +1,148 @@
+#! /usr/bin/env python3
+# Copyright © 2020, RedHat Inc.
+#
+# 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:
+#       Benjamin Berg <bberg@redhat.com>
+
+import os
+import sys
+import fcntl
+import io
+import re
+import time
+import threading
+
+class OutputChecker(object):
+
+    def __init__(self, out=sys.stdout):
+        self._output = out
+        self._pipe_fd_r, self._pipe_fd_w = os.pipe()
+        self._partial_buf = b''
+        self._lines_sem = threading.Semaphore()
+        self._lines = []
+        self._reader_io = io.StringIO()
+
+        # Just to be sure, shouldn't be a problem even if we didn't set it
+        fcntl.fcntl(self._pipe_fd_r, fcntl.F_SETFL,
+                    fcntl.fcntl(self._pipe_fd_r, fcntl.F_GETFL) | os.O_CLOEXEC)
+        fcntl.fcntl(self._pipe_fd_w, fcntl.F_SETFL,
+                    fcntl.fcntl(self._pipe_fd_w, fcntl.F_GETFL) | os.O_CLOEXEC)
+
+        # Start copier thread
+        self._thread = threading.Thread(target=self._copy)
+        self._thread.start()
+
+    def _copy(self):
+        while True:
+            r = os.read(self._pipe_fd_r, 1024)
+            if not r:
+                return
+
+            l = r.split(b'\n')
+            l[0] = self._partial_buf + l[0]
+            self._lines.extend(l[:-1])
+            self._partial_buf = l[-1]
+
+            self._lines_sem.release()
+
+            os.write(self._output.fileno(), r)
+
+    def check_line_re(self, needle_re, timeout=0, failmsg=None):
+        deadline = time.time() + timeout
+
+        if isinstance(needle_re, str):
+            needle_re = needle_re.encode('ascii')
+
+        r = re.compile(needle_re)
+        ret = []
+
+        while True:
+            try:
+                l = self._lines.pop(0)
+            except IndexError:
+                # Check if should wake up
+                if not self._lines_sem.acquire(timeout = deadline - time.time()):
+                    if failmsg:
+                        raise AssertionError(failmsg)
+                    else:
+                        raise AssertionError('Timed out waiting for needle %s (timeout: %0.2f)' % (str(needle_re), timeout))
+                continue
+
+            ret.append(l)
+            if r.search(l):
+                return ret
+
+    def check_line(self, needle, timeout=0, failmsg=None):
+        if isinstance(needle, str):
+            needle = needle.encode('ascii')
+
+        needle_re = re.escape(needle)
+
+        return self.check_line_re(needle_re, timeout=timeout, failmsg=failmsg)
+
+    def check_no_line_re(self, needle_re, wait=0, failmsg=None):
+        deadline = time.time() + wait
+
+        if isinstance(needle_re, str):
+            needle_re = needle_re.encode('ascii')
+
+        r = re.compile(needle_re)
+        ret = []
+
+        while True:
+            try:
+                l = self._lines.pop(0)
+            except IndexError:
+                # Check if should wake up
+                if not self._lines_sem.acquire(timeout = deadline - time.time()):
+                    # Timed out, so everything is good
+                    break
+                continue
+
+            ret.append(l)
+            if r.search(l):
+                if failmsg:
+                    raise AssertionError(failmsg)
+                else:
+                    raise AssertionError('Found needle %s but shouldn\'t have been there (timeout: %0.2f)' % (str(needle_re), timeout))
+
+        return ret
+
+    def check_no_line(self, needle, wait=0, failmsg=None):
+        if isinstance(needle, str):
+            needle = needle.encode('ascii')
+
+        needle_re = re.escape(needle)
+
+        return self.check_no_line_re(needle_re, wait=wait, failmsg=failmsg)
+
+    def clear(self):
+        ret = self._lines
+        self._lines = []
+        return ret
+
+    def assert_closed(self, timeout=1):
+        self._thread.join(timeout)
+        if self._thread.is_alive() != False:
+            raise AssertionError("OutputCheck: Write side has not been closed yet!")
+
+    @property
+    def fd(self):
+        return self._pipe_fd_w
+
+    def writer_attached(self):
+        os.close(self._pipe_fd_w)
+        self._pipe_fd_w = -1
+

tests/pam/test_pam_fprintd.py

@@ -17,7 +17,6 @@ import sys
 import subprocess
 import dbus
 import dbusmock
-import fcntl
 import glob
 import os
 import shutil
@@ -75,10 +74,7 @@ class TestPamFprintd(dbusmock.DBusTestCase):
 
     def setUp(self):
         (self.p_mock, self.obj_fprintd_manager) = self.spawn_server_template(
-            self.template_name, {}, stdout=subprocess.PIPE)
-        # set log to nonblocking
-        flags = fcntl.fcntl(self.p_mock.stdout, fcntl.F_GETFL)
-        fcntl.fcntl(self.p_mock.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+            self.template_name, {})
         self.obj_fprintd_mock = dbus.Interface(self.obj_fprintd_manager, 'net.reactivated.Fprint.Manager.Mock')
 
     def tearDown(self):
@@ -90,6 +86,10 @@ class TestPamFprintd(dbusmock.DBusTestCase):
         self.device_mock = self.dbus_con.get_object('net.reactivated.Fprint', device_path)
         self.device_mock.SetEnrolledFingers('toto', ['left-little-finger', 'right-little-finger'])
 
+    def test_pam_no_device(self):
+        tc = pypamtest.TestCase(pypamtest.PAMTEST_AUTHENTICATE, expected_rv=PAM_AUTHINFO_UNAVAIL)
+        res = pypamtest.run_pamtest("toto", "fprintd-pam-test", [tc], [ 'unused' ])
+
     def test_pam_fprintd_identify_error(self):
         self.setup_device()
         script = [
@@ -143,6 +143,66 @@ class TestPamFprintd(dbusmock.DBusTestCase):
         self.assertRegex(res.info[0], r'Swipe your left little finger across the fingerprint reader')
         self.assertEqual(len(res.errors), 0)
 
+    def test_pam_fprintd_no_fingers(self):
+        self.setup_device()
+        self.device_mock.SetEnrolledFingers('toto', dbus.Array(set([]), signature='s'))
+        script = [
+            ( 'verify-match', True, 1 )
+        ]
+        self.device_mock.SetVerifyScript(script)
+
+        tc = pypamtest.TestCase(pypamtest.PAMTEST_AUTHENTICATE, expected_rv=PAM_AUTHINFO_UNAVAIL)
+        res = pypamtest.run_pamtest("toto", "fprintd-pam-test", [tc], [ 'unused' ])
+
+    def test_pam_fprintd_no_fingers_while_verifying(self):
+        self.setup_device()
+        script = [
+            ( 'MOCK: no-prints', True, 1),
+            ( 'verify-match', True, 1 )
+        ]
+        self.device_mock.SetVerifyScript(script)
+
+        tc = pypamtest.TestCase(pypamtest.PAMTEST_AUTHENTICATE, expected_rv=PAM_USER_UNKNOWN)
+        res = pypamtest.run_pamtest("toto", "fprintd-pam-test", [tc], [ 'unused' ])
+
+    def test_pam_fprintd_blocks_unexpected_auth(self):
+        self.setup_device()
+        script = [
+            ( 'verify-match', True, -500 ), # This one is sent before VerifyStart has completed
+            ( 'verify-no-match', True, 1 ),
+            ( 'verify-no-match', True, 1 ),
+            ( 'verify-no-match', True, 1 ),
+        ]
+        self.device_mock.SetVerifyScript(script)
+
+        tc = pypamtest.TestCase(pypamtest.PAMTEST_AUTHENTICATE, expected_rv=PAM_MAXTRIES)
+        res = pypamtest.run_pamtest("toto", "fprintd-pam-test", [tc], [ 'unused' ])
+
+        self.assertRegex(res.info[0], r'Swipe your left little finger across the fingerprint reader')
+        self.assertEqual(len(res.errors), 3)
+        self.assertRegex(res.errors[0], r'Failed to match fingerprint')
+        self.assertRegex(res.errors[0], r'Failed to match fingerprint')
+        self.assertRegex(res.errors[0], r'Failed to match fingerprint')
+
+    def test_pam_fprintd_blocks_unexpected_auth2(self):
+        self.setup_device()
+        script = [
+            ( 'verify-no-match', True, 1 ),
+            ( 'verify-match', True, -500 ), # This one is sent before VerifyStart has completed
+            ( 'verify-no-match', True, 1 ),
+            ( 'verify-no-match', True, 1 ),
+        ]
+        self.device_mock.SetVerifyScript(script)
+
+        tc = pypamtest.TestCase(pypamtest.PAMTEST_AUTHENTICATE, expected_rv=PAM_MAXTRIES)
+        res = pypamtest.run_pamtest("toto", "fprintd-pam-test", [tc], [ 'unused' ])
+
+        self.assertRegex(res.info[0], r'Swipe your left little finger across the fingerprint reader')
+        self.assertEqual(len(res.errors), 3)
+        self.assertRegex(res.errors[0], r'Failed to match fingerprint')
+        self.assertRegex(res.errors[0], r'Failed to match fingerprint')
+        self.assertRegex(res.errors[0], r'Failed to match fingerprint')
+
     def test_pam_fprintd_dual_reader_auth(self):
         device_path = self.obj_fprintd_mock.AddDevice('FDO Sandpaper Reader', 3, 'press')
         sandpaper_device_mock = self.dbus_con.get_object('net.reactivated.Fprint', device_path)
@@ -196,6 +256,20 @@ class TestPamFprintd(dbusmock.DBusTestCase):
         self.assertRegex(res.errors[1], r'Failed to match fingerprint')
         self.assertRegex(res.errors[2], r'Failed to match fingerprint')
 
+    def test_pam_already_claimed(self):
+        self.setup_device()
+        script = [
+            ( 'verify-match', True, 2 )
+        ]
+        self.device_mock.SetVerifyScript(script)
+        self.device_mock.SetClaimed('toto')
+
+        tc = pypamtest.TestCase(pypamtest.PAMTEST_AUTHENTICATE, expected_rv=PAM_AUTHINFO_UNAVAIL)
+        res = pypamtest.run_pamtest("toto", "fprintd-pam-test", [tc], [ 'unused' ])
+
+        self.assertEqual(len(res.info), 0)
+        self.assertEqual(len(res.errors), 0)
+
     def test_pam_timeout(self):
         self.setup_device()
 
@@ -203,6 +277,19 @@ class TestPamFprintd(dbusmock.DBusTestCase):
         res = pypamtest.run_pamtest("toto", "fprintd-pam-test", [tc], [ 'unused' ])
         self.assertRegex(res.info[1], r'Verification timed out')
 
+    def test_pam_notices_fprintd_disappearing(self):
+        self.setup_device()
+
+        script = [
+            ( 'MOCK: quit', True, 0 ),
+        ]
+        self.device_mock.SetVerifyScript(script)
+
+        tc = pypamtest.TestCase(pypamtest.PAMTEST_AUTHENTICATE, expected_rv=PAM_AUTHINFO_UNAVAIL)
+        res = pypamtest.run_pamtest("toto", "fprintd-pam-test", [tc], [ 'unused' ])
+        self.assertEqual(len(res.errors), 0)
+        self.assertEqual(len(res.info), 0)
+
 if __name__ == '__main__':
     if 'PAM_WRAPPER_SERVICE_DIR' not in os.environ:
         print('Cannot run test without environment set correctly, run "meson test" instead')

tests/test_fprintd_utils.py

@@ -18,9 +18,9 @@ import subprocess
 import dbus
 import dbus.mainloop.glib
 import dbusmock
-import fcntl
 import os
 import time
+from output_checker import OutputChecker
 
 
 VALID_FINGER_NAMES = [
@@ -77,10 +77,8 @@ class TestFprintdUtilsBase(dbusmock.DBusTestCase):
     def setUp(self):
         super().setUp()
         (self.p_mock, self.obj_fprintd_manager) = self.spawn_server_template(
-            self.template_name, {}, stdout=subprocess.PIPE)
+            self.template_name, {})
         # set log to nonblocking
-        flags = fcntl.fcntl(self.p_mock.stdout, fcntl.F_GETFL)
-        fcntl.fcntl(self.p_mock.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
         self.obj_fprintd_mock = dbus.Interface(self.obj_fprintd_manager, 'net.reactivated.Fprint.Manager.Mock')
 
     def tearDown(self):
@@ -102,22 +100,21 @@ class TestFprintdUtilsBase(dbusmock.DBusTestCase):
 
     def start_utility_process(self, utility_name, args=[], sleep=True):
         utility = [ os.path.join(self.tools_prefix, 'fprintd-{}'.format(utility_name)) ]
+        output = OutputChecker()
         process = subprocess.Popen(self.wrapper_args + utility + args,
-                                   stdout=subprocess.PIPE,
-                                   stderr=subprocess.STDOUT,
-                                   universal_newlines=True)
-        flags = fcntl.fcntl(process.stdout, fcntl.F_GETFL)
-        fcntl.fcntl(process.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+                                   stdout=output.fd,
+                                   stderr=subprocess.STDOUT)
+        output.writer_attached()
 
+        self.addCleanup(output.assert_closed)
         self.addCleanup(self.try_stop_utility_process, process)
 
         if sleep:
             time.sleep(self.sleep_time)
 
-        return process
+        return process, output
 
     def stop_utility_process(self, process):
-        print(process.stdout.read())
         process.terminate()
         process.wait()
 
@@ -127,17 +124,12 @@ class TestFprintdUtilsBase(dbusmock.DBusTestCase):
         except:
             pass
 
-    def get_process_output(self, process):
-        out = process.stdout.read()
-        self.addCleanup(print, out)
-        return out
-
     def run_utility_process(self, utility_name, args=[], sleep=True, timeout=None):
-        proc = self.start_utility_process(utility_name, args=args, sleep=sleep)
+        proc, output = self.start_utility_process(utility_name, args=args, sleep=sleep)
         ret = proc.wait(timeout=timeout if timeout is not None else self.sleep_time * 4)
         self.assertLessEqual(ret, 128)
 
-        return self.get_process_output(proc), ret
+        return b''.join(output.clear()), ret
 
 
 class TestFprintdUtils(TestFprintdUtilsBase):
@@ -146,65 +138,62 @@ class TestFprintdUtils(TestFprintdUtilsBase):
         self.setup_device()
 
     def test_fprintd_enroll(self):
-        process = self.start_utility_process('enroll', ['-f', 'right-index-finger', 'toto'])
+        process, out = self.start_utility_process('enroll', ['-f', 'right-index-finger', 'toto'])
 
-        out = self.get_process_output(process)
-        self.assertRegex(out, r'right-index-finger')
+        out.check_line(rb'right-index-finger', 0)
 
         self.device_mock.EmitEnrollStatus('enroll-completed', True)
-        time.sleep(self.sleep_time)
 
-        out = self.get_process_output(process)
-        self.assertRegex(out, 'Enroll result: enroll-completed')
+        out.check_line(rb'Enroll result: enroll-completed', self.sleep_time)
 
     def test_fprintd_list(self):
         # Rick has no fingerprints enrolled
         out, ret = self.run_utility_process('list', ['rick'])
-        self.assertRegex(out, r'has no fingers enrolled for')
+        self.assertRegex(out, rb'has no fingers enrolled for')
         self.assertEqual(ret, 0)
 
         # Toto does
         out, ret = self.run_utility_process('list', ['toto'])
-        self.assertRegex(out, r'right-little-finger')
+        self.assertRegex(out, rb'right-little-finger')
         self.assertEqual(ret, 0)
 
     def test_fprintd_delete(self):
         # Has fingerprints enrolled
         out, ret = self.run_utility_process('list', ['toto'])
-        self.assertRegex(out, r'left-little-finger')
+        self.assertRegex(out, rb'left-little-finger')
         self.assertEqual(ret, 0)
-        self.assertRegex(out, r'right-little-finger')
+        self.assertRegex(out, rb'right-little-finger')
 
         # Delete fingerprints
         out, ret = self.run_utility_process('delete', ['toto'])
-        self.assertRegex(out, r'Fingerprints deleted')
+        self.assertRegex(out, rb'Fingerprints deleted')
         self.assertEqual(ret, 0)
 
         # Doesn't have fingerprints
         out, ret = self.run_utility_process('list', ['toto'])
-        self.assertRegex(out, r'has no fingers enrolled for')
+        self.assertRegex(out, rb'has no fingers enrolled for')
         self.assertEqual(ret, 0)
 
 
 class TestFprintdUtilsNoDeviceTests(TestFprintdUtilsBase):
     def test_fprintd_enroll(self):
         out, ret = self.run_utility_process('enroll', ['toto'])
-        self.assertIn('No devices available', out)
+        self.assertIn(b'No devices available', out)
         self.assertEqual(ret, 1)
 
     def test_fprintd_list(self):
         out, ret = self.run_utility_process('list', ['toto'])
-        self.assertIn('No devices available', out)
+        self.assertIn(b'No devices available', out)
         self.assertEqual(ret, 1)
 
     def test_fprintd_delete(self):
         out, ret = self.run_utility_process('delete', ['toto'])
-        self.assertIn('No devices available', out)
+        self.assertIn(b'No devices available', out)
         self.assertEqual(ret, 1)
 
     def test_fprintd_verify(self):
         out, ret = self.run_utility_process('verify', ['toto'])
-        self.assertIn('No devices available', out)
+        self.assertIn(b'No devices available', out)
         self.assertEqual(ret, 1)
 
 
@@ -213,24 +202,20 @@ class TestFprintdUtilsVerify(TestFprintdUtilsBase):
         super().setUp()
         self.setup_device()
 
-    def start_verify_process(self, user='toto', finger=None, checkEnrolled=True):
+    def start_verify_process(self, user='toto', finger=None, nowait=False):
         args = [user]
         if finger:
             args += ['-f', finger]
 
-        self.process = self.start_utility_process('verify', args)
-        out = self.get_process_output(self.process)
+        self.process, self.output = self.start_utility_process('verify', args)
+        if nowait:
+            return
 
-        self.assertNotRegex(out, r'Device already in use by [A-z]+')
-        self.assertNotIn('Verify result:', out)
+        preamble = self.output.check_line(b'Verify started!')
 
-        if checkEnrolled and finger:
-            self.assertNotIn('''Finger '{}' not enrolled for user {}'''.format(
-                finger, user), out)
+        out = b''.join(preamble)
 
-        if checkEnrolled:
-            for f in self.enrolled_fingers:
-                self.assertIn(f, out)
+        self.assertNotIn(b'Verify result:', out)
 
         if finger:
             expected_finger = finger
@@ -239,9 +224,8 @@ class TestFprintdUtilsVerify(TestFprintdUtilsBase):
             self.assertEqual(self.device_mock.GetSelectedFinger(), expected_finger)
 
     def assertVerifyMatch(self, match):
-        self.assertIn('Verify result: {} (done)'.format(
-            'verify-match' if match else 'verify-no-match'),
-            self.get_process_output(self.process))
+        self.output.check_line(r'Verify result: {} (done)'.format(
+            'verify-match' if match else 'verify-no-match'))
 
     def test_fprintd_verify(self):
         self.start_verify_process()
@@ -280,14 +264,16 @@ class TestFprintdUtilsVerify(TestFprintdUtilsBase):
 
     def test_fprintd_verify_not_enrolled_fingers(self):
         for finger in [f for f in VALID_FINGER_NAMES if f not in self.enrolled_fingers]:
+            self.start_verify_process(finger=finger, nowait=True)
             regex = r'Finger \'{}\' not enrolled'.format(finger)
-            with self.assertRaisesRegex(AssertionError, regex):
-                self.start_verify_process(finger=finger)
+            self.output.check_line_re(regex, timeout=self.sleep_time)
+
             self.device_mock.Release()
 
     def test_fprintd_verify_no_enrolled_fingers(self):
         self.set_enrolled_fingers([])
-        self.start_verify_process()
+        self.start_verify_process(nowait=True)
+        self.output.check_line(b'No fingers enrolled for this device.', timeout=self.sleep_time)
         self.assertEqual(self.process.poll(), 1)
 
     def test_fprintd_list_all_fingers(self):
@@ -299,16 +285,17 @@ class TestFprintdUtilsVerify(TestFprintdUtilsBase):
             ( 'verify-match', True, 2 )
         ]
         self.device_mock.SetVerifyScript(script)
+        time.sleep(2)
 
         self.start_verify_process()
-        time.sleep(self.sleep_time * 4)
+        time.sleep(2 + self.sleep_time)
         self.assertVerifyMatch(True)
 
     def test_fprintd_multiple_verify_fails(self):
         self.start_verify_process()
 
-        with self.assertRaisesRegex(AssertionError, r'Device already in use'):
-            self.start_verify_process()
+        self.start_verify_process(nowait=True)
+        self.output.check_line_re(rb'Device already in use by [A-z]+', timeout=self.sleep_time)
 
 if __name__ == '__main__':
     # avoid writing to stderr

utils/delete.c

@@ -26,126 +26,146 @@
 static FprintDBusManager *manager = NULL;
 static GDBusConnection *connection = NULL;
 
-static void create_manager(void)
+static void
+create_manager (void)
 {
-	g_autoptr(GError) error = NULL;
+  g_autoptr(GError) error = NULL;
 
-	connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
-	if (connection == NULL) {
-		g_print("Failed to connect to session bus: %s\n", error->message);
-		exit (1);
-	}
+  connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (connection == NULL)
+    {
+      g_print ("Failed to connect to session bus: %s\n", error->message);
+      exit (1);
+    }
 
-	manager = fprint_dbus_manager_proxy_new_sync (connection,
-						      G_DBUS_PROXY_FLAGS_NONE,
-						      "net.reactivated.Fprint",
-						      "/net/reactivated/Fprint/Manager",
-						      NULL, &error);
-	if (manager == NULL) {
-		g_print ("Failed to get Fprintd manager: %s\n", error->message);
-		exit (1);
-	}
+  manager = fprint_dbus_manager_proxy_new_sync (connection,
+                                                G_DBUS_PROXY_FLAGS_NONE,
+                                                "net.reactivated.Fprint",
+                                                "/net/reactivated/Fprint/Manager",
+                                                NULL, &error);
+  if (manager == NULL)
+    {
+      g_print ("Failed to get Fprintd manager: %s\n", error->message);
+      exit (1);
+    }
 }
 
-static void delete_fingerprints (FprintDBusDevice *dev, const char *username)
+static void
+delete_fingerprints (FprintDBusDevice *dev, const char *username)
 {
-	g_autoptr(GError) error = NULL;
+  g_autoptr(GError) error = NULL;
 
-	if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error)) {
-		g_print("failed to claim device: %s\n", error->message);
-		exit (1);
-	}
+  if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error))
+    {
+      g_print ("failed to claim device: %s\n", error->message);
+      exit (1);
+    }
 
-	if (!fprint_dbus_device_call_delete_enrolled_fingers2_sync (dev, NULL,
-								    &error)) {
-		gboolean ignore_error = FALSE;
-		if (g_dbus_error_is_remote_error (error)) {
-			g_autofree char *dbus_error =
-				g_dbus_error_get_remote_error (error);
-			if (g_str_equal (dbus_error,
-					 "net.reactivated.Fprint.Error.NoEnrolledPrints")) {
-				g_print ("No fingerprints to delete on %s\n",
-					 fprint_dbus_device_get_name (dev));
-				ignore_error = TRUE;
-			}
-		}
-		if (!ignore_error) {
-			g_print("ListEnrolledFingers failed: %s\n",
-				error->message);
-			exit (1);
-		} else {
-			g_print ("No fingerprints to delete on %s\n",
-				 fprint_dbus_device_get_name (dev));
-		}
-	} else {
-			g_print ("Fingerprints deleted on %s\n",
-				 fprint_dbus_device_get_name (dev));
-	}
-	g_clear_error (&error);
+  if (!fprint_dbus_device_call_delete_enrolled_fingers2_sync (dev, NULL,
+                                                              &error))
+    {
+      gboolean ignore_error = FALSE;
+      if (g_dbus_error_is_remote_error (error))
+        {
+          g_autofree char *dbus_error =
+            g_dbus_error_get_remote_error (error);
+          if (g_str_equal (dbus_error,
+                           "net.reactivated.Fprint.Error.NoEnrolledPrints"))
+            {
+              g_print ("No fingerprints to delete on %s\n",
+                       fprint_dbus_device_get_name (dev));
+              ignore_error = TRUE;
+            }
+        }
+      if (!ignore_error)
+        {
+          g_print ("ListEnrolledFingers failed: %s\n",
+                   error->message);
+          exit (1);
+        }
+      else
+        {
+          g_print ("No fingerprints to delete on %s\n",
+                   fprint_dbus_device_get_name (dev));
+        }
+    }
+  else
+    {
+      g_print ("Fingerprints deleted on %s\n",
+               fprint_dbus_device_get_name (dev));
+    }
+  g_clear_error (&error);
 
-	if (!fprint_dbus_device_call_release_sync (dev, NULL, &error)) {
-		g_print("ReleaseDevice failed: %s\n", error->message);
-		exit (1);
-	}
+  if (!fprint_dbus_device_call_release_sync (dev, NULL, &error))
+    {
+      g_print ("ReleaseDevice failed: %s\n", error->message);
+      exit (1);
+    }
 }
 
-static void process_devices(char **argv)
+static void
+process_devices (char **argv)
 {
-	g_autoptr(GError) error = NULL;
-	g_auto(GStrv) devices = NULL;
-	char *path;
-	guint num_devices;
-	guint i;
+  g_autoptr(GError) error = NULL;
+  g_auto(GStrv) devices = NULL;
+  char *path;
+  guint num_devices;
+  guint i;
 
-	if (!fprint_dbus_manager_call_get_devices_sync (manager, &devices,
-							NULL, &error)) {
-		g_print("Impossible to get devices: %s\n", error->message);
-		exit (1);
-	}
+  if (!fprint_dbus_manager_call_get_devices_sync (manager, &devices,
+                                                  NULL, &error))
+    {
+      g_print ("Impossible to get devices: %s\n", error->message);
+      exit (1);
+    }
 
-	num_devices = g_strv_length (devices);
-	if (num_devices == 0) {
-		g_print("No devices available\n");
-		exit(1);
-	}
+  num_devices = g_strv_length (devices);
+  if (num_devices == 0)
+    {
+      g_print ("No devices available\n");
+      exit (1);
+    }
 
-	g_print ("found %u devices\n", num_devices);
-	for (i = 0; devices[i] != NULL; i++) {
-		path = devices[i];
-		g_print("Device at %s\n", path);
-	}
+  g_print ("found %u devices\n", num_devices);
+  for (i = 0; devices[i] != NULL; i++)
+    {
+      path = devices[i];
+      g_print ("Device at %s\n", path);
+    }
 
-	for (i = 0; devices[i] != NULL; i++) {
-		g_autoptr(FprintDBusDevice) dev = NULL;
-		guint j;
+  for (i = 0; devices[i] != NULL; i++)
+    {
+      g_autoptr(FprintDBusDevice) dev = NULL;
+      guint j;
 
-		path = devices[i];
-		g_print("Using device %s\n", path);
+      path = devices[i];
+      g_print ("Using device %s\n", path);
 
-		/* NOTE: We should handle error cases! */
-		dev = fprint_dbus_device_proxy_new_sync (connection,
-							 G_DBUS_PROXY_FLAGS_NONE,
-							 "net.reactivated.Fprint",
-							 path, NULL, NULL);
+      /* NOTE: We should handle error cases! */
+      dev = fprint_dbus_device_proxy_new_sync (connection,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               "net.reactivated.Fprint",
+                                               path, NULL, NULL);
 
-		for (j = 1; argv[j] != NULL; j++)
-			delete_fingerprints (dev, argv[j]);
-	}
+      for (j = 1; argv[j] != NULL; j++)
+        delete_fingerprints (dev, argv[j]);
+    }
 }
 
-int main(int argc, char **argv)
+int
+main (int argc, char **argv)
 {
-	setlocale (LC_ALL, "");
+  setlocale (LC_ALL, "");
 
-	create_manager();
+  create_manager ();
 
-	if (argc < 2) {
-		g_print ("Usage: %s <username> [usernames...]\n", argv[0]);
-		return 1;
-	}
+  if (argc < 2)
+    {
+      g_print ("Usage: %s <username> [usernames...]\n", argv[0]);
+      return 1;
+    }
 
-	process_devices (argv);
+  process_devices (argv);
 
-	return 0;
+  return 0;
 }
-

utils/enroll.c

@@ -33,171 +33,193 @@ static GDBusConnection *connection = NULL;
 static char *finger_name = NULL;
 static char **usernames = NULL;
 
-static void create_manager(void)
+static void
+create_manager (void)
 {
-	g_autoptr(GError) error = NULL;
+  g_autoptr(GError) error = NULL;
 
-	connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
-	if (connection == NULL) {
-		g_print("Failed to connect to session bus: %s\n", error->message);
-		exit (1);
-	}
+  connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (connection == NULL)
+    {
+      g_print ("Failed to connect to session bus: %s\n", error->message);
+      exit (1);
+    }
 
-	manager = fprint_dbus_manager_proxy_new_sync (connection,
-						      G_DBUS_PROXY_FLAGS_NONE,
-						      "net.reactivated.Fprint",
-						      "/net/reactivated/Fprint/Manager",
-						      NULL, &error);
-	if (manager == NULL) {
-		g_print ("Failed to get Fprintd manager: %s\n", error->message);
-		exit (1);
-	}
+  manager = fprint_dbus_manager_proxy_new_sync (connection,
+                                                G_DBUS_PROXY_FLAGS_NONE,
+                                                "net.reactivated.Fprint",
+                                                "/net/reactivated/Fprint/Manager",
+                                                NULL, &error);
+  if (manager == NULL)
+    {
+      g_print ("Failed to get Fprintd manager: %s\n", error->message);
+      exit (1);
+    }
 }
 
-static FprintDBusDevice *open_device (const char *username)
+static FprintDBusDevice *
+open_device (const char *username)
 {
-	g_autoptr(FprintDBusDevice) dev = NULL;
-	g_autoptr(GError) error = NULL;
-	g_autofree char *path = NULL;
+  g_autoptr(FprintDBusDevice) dev = NULL;
+  g_autoptr(GError) error = NULL;
+  g_autofree char *path = NULL;
 
-	if (!fprint_dbus_manager_call_get_default_device_sync (manager, &path,
-							       NULL, &error)) {
-		g_print("Impossible to enroll: %s\n", error->message);
-		exit (1);
-	}
+  if (!fprint_dbus_manager_call_get_default_device_sync (manager, &path,
+                                                         NULL, &error))
+    {
+      g_print ("Impossible to enroll: %s\n", error->message);
+      exit (1);
+    }
 
-	g_print("Using device %s\n", path);
+  g_print ("Using device %s\n", path);
 
-	dev = fprint_dbus_device_proxy_new_sync (connection,
-						 G_DBUS_PROXY_FLAGS_NONE,
-						 "net.reactivated.Fprint",
-						 path, NULL, &error);
+  dev = fprint_dbus_device_proxy_new_sync (connection,
+                                           G_DBUS_PROXY_FLAGS_NONE,
+                                           "net.reactivated.Fprint",
+                                           path, NULL, &error);
 
-	if (error) {
-		g_print ("failed to connect to device: %s\n", error->message);
-		exit (1);
-	}
+  if (error)
+    {
+      g_print ("failed to connect to device: %s\n", error->message);
+      exit (1);
+    }
 
-	if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error)) {
-		g_print("failed to claim device: %s\n", error->message);
-		exit (1);
-	}
-	return g_steal_pointer (&dev);
+  if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error))
+    {
+      g_print ("failed to claim device: %s\n", error->message);
+      exit (1);
+    }
+  return g_steal_pointer (&dev);
 }
 
-static void enroll_result(GObject *object, const char *result, gboolean done, void *user_data)
+static void
+enroll_result (GObject *object, const char *result, gboolean done, void *user_data)
 {
-	gboolean *enroll_completed = user_data;
-	g_print("Enroll result: %s\n", result);
-	if (done != FALSE)
-		*enroll_completed = TRUE;
+  gboolean *enroll_completed = user_data;
+
+  g_print ("Enroll result: %s\n", result);
+  if (done != FALSE)
+    *enroll_completed = TRUE;
 }
 
-static void proxy_signal_cb (GDBusProxy *proxy,
-			     const gchar *sender_name,
-			     const gchar *signal_name,
-			     GVariant *parameters,
-			     gpointer user_data)
+static void
+proxy_signal_cb (GDBusProxy  *proxy,
+                 const gchar *sender_name,
+                 const gchar *signal_name,
+                 GVariant    *parameters,
+                 gpointer     user_data)
 {
-	if (g_str_equal (signal_name, "EnrollStatus")) {
-		const gchar *result;
-		gboolean done;
+  if (g_str_equal (signal_name, "EnrollStatus"))
+    {
+      const gchar *result;
+      gboolean done;
 
-		g_variant_get (parameters, "(&sb)", &result, &done);
-		enroll_result (G_OBJECT (proxy), result, done, user_data);
-	}
+      g_variant_get (parameters, "(&sb)", &result, &done);
+      enroll_result (G_OBJECT (proxy), result, done, user_data);
+    }
 }
 
-static void do_enroll (FprintDBusDevice *dev)
+static void
+do_enroll (FprintDBusDevice *dev)
 {
-	g_autoptr(GError) error = NULL;
-	gboolean enroll_completed = FALSE;
-	gboolean found;
-	guint i;
+  g_autoptr(GError) error = NULL;
+  gboolean enroll_completed = FALSE;
+  gboolean found;
+  guint i;
 
-	g_signal_connect (dev, "g-signal", G_CALLBACK (proxy_signal_cb),
-			  &enroll_completed);
+  g_signal_connect (dev, "g-signal", G_CALLBACK (proxy_signal_cb),
+                    &enroll_completed);
 
-	found = FALSE;
-	for (i = 0; fingers[i].dbus_name != NULL; i++) {
-		if (g_strcmp0 (fingers[i].dbus_name, finger_name) == 0) {
-			found = TRUE;
-			break;
-		}
-	}
-	if (!found) {
-		g_autoptr(GString) s = NULL;
+  found = FALSE;
+  for (i = 0; fingers[i].dbus_name != NULL; i++)
+    {
+      if (g_strcmp0 (fingers[i].dbus_name, finger_name) == 0)
+        {
+          found = TRUE;
+          break;
+        }
+    }
+  if (!found)
+    {
+      g_autoptr(GString) s = NULL;
 
-		s = g_string_new (NULL);
-		g_string_append_printf (s, "Invalid finger name '%s'. Name must be one of ", finger_name);
-		for (i = 0; fingers[i].dbus_name != NULL; i++) {
-			g_string_append_printf (s, "%s", fingers[i].dbus_name);
-			if (fingers[i + 1].dbus_name != NULL)
-				g_string_append (s, ", ");
-		}
-		g_warning ("%s", s->str);
-		exit (1);
-	}
+      s = g_string_new (NULL);
+      g_string_append_printf (s, "Invalid finger name '%s'. Name must be one of ", finger_name);
+      for (i = 0; fingers[i].dbus_name != NULL; i++)
+        {
+          g_string_append_printf (s, "%s", fingers[i].dbus_name);
+          if (fingers[i + 1].dbus_name != NULL)
+            g_string_append (s, ", ");
+        }
+      g_warning ("%s", s->str);
+      exit (1);
+    }
 
-	g_print("Enrolling %s finger.\n", finger_name);
-	if (!fprint_dbus_device_call_enroll_start_sync (dev, finger_name, NULL,
-							&error)) {
-		g_print("EnrollStart failed: %s\n", error->message);
-		exit (1);
-	}
+  g_print ("Enrolling %s finger.\n", finger_name);
+  if (!fprint_dbus_device_call_enroll_start_sync (dev, finger_name, NULL,
+                                                  &error))
+    {
+      g_print ("EnrollStart failed: %s\n", error->message);
+      exit (1);
+    }
 
-	while (!enroll_completed)
-		g_main_context_iteration(NULL, TRUE);
+  while (!enroll_completed)
+    g_main_context_iteration (NULL, TRUE);
 
-	g_signal_handlers_disconnect_by_func (dev, proxy_signal_cb, &enroll_result);
+  g_signal_handlers_disconnect_by_func (dev, proxy_signal_cb, &enroll_result);
 
-	if (!fprint_dbus_device_call_enroll_stop_sync (dev, NULL, &error)) {
-		g_print("VerifyStop failed: %s\n", error->message);
-		exit(1);
-	}
+  if (!fprint_dbus_device_call_enroll_stop_sync (dev, NULL, &error))
+    {
+      g_print ("VerifyStop failed: %s\n", error->message);
+      exit (1);
+    }
 }
 
-static void release_device (FprintDBusDevice *dev)
+static void
+release_device (FprintDBusDevice *dev)
 {
-	g_autoptr(GError) error = NULL;
-	if (!fprint_dbus_device_call_release_sync (dev, NULL, &error)) {
-		g_print("ReleaseDevice failed: %s\n", error->message);
-		exit (1);
-	}
+  g_autoptr(GError) error = NULL;
+  if (!fprint_dbus_device_call_release_sync (dev, NULL, &error))
+    {
+      g_print ("ReleaseDevice failed: %s\n", error->message);
+      exit (1);
+    }
 }
 
 static const GOptionEntry entries[] = {
-    { "finger", 'f',  0, G_OPTION_ARG_STRING, &finger_name, "Finger selected to verify (default is automatic)", NULL },
-    { G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_STRING_ARRAY, &usernames, NULL, "[username]" },
-    { NULL }
+  { "finger", 'f',  0, G_OPTION_ARG_STRING, &finger_name, "Finger selected to verify (default is automatic)", NULL },
+  { G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_STRING_ARRAY, &usernames, NULL, "[username]" },
+  { NULL }
 };
 
-int main(int argc, char **argv)
+int
+main (int argc, char **argv)
 {
-	g_autoptr(FprintDBusDevice) dev = NULL;
-	GOptionContext *context;
-	g_autoptr(GError) err = NULL;
+  g_autoptr(FprintDBusDevice) dev = NULL;
+  GOptionContext *context;
 
-	setlocale (LC_ALL, "");
+  g_autoptr(GError) err = NULL;
 
-	context = g_option_context_new ("Enroll a fingerprint");
-	g_option_context_add_main_entries (context, entries, NULL);
+  setlocale (LC_ALL, "");
 
-	if (g_option_context_parse (context, &argc, &argv, &err) == FALSE) {
-		g_print ("couldn't parse command-line options: %s\n", err->message);
-		return 1;
-	}
+  context = g_option_context_new ("Enroll a fingerprint");
+  g_option_context_add_main_entries (context, entries, NULL);
 
-	if (finger_name == NULL)
-		finger_name = g_strdup("right-index-finger");
+  if (g_option_context_parse (context, &argc, &argv, &err) == FALSE)
+    {
+      g_print ("couldn't parse command-line options: %s\n", err->message);
+      return 1;
+    }
 
-	create_manager();
+  if (finger_name == NULL)
+    finger_name = g_strdup ("right-index-finger");
 
-	dev = open_device (usernames ? usernames[0] : "");
-	do_enroll(dev);
-	release_device(dev);
-	g_free(finger_name);
-	g_strfreev(usernames);
-	return 0;
+  create_manager ();
+
+  dev = open_device (usernames ? usernames[0] : "");
+  do_enroll (dev);
+  release_device (dev);
+  g_free (finger_name);
+  g_strfreev (usernames);
+  return 0;
 }
-

utils/list.c

@@ -26,125 +26,137 @@
 static FprintDBusManager *manager = NULL;
 static GDBusConnection *connection = NULL;
 
-static void create_manager(void)
+static void
+create_manager (void)
 {
-	g_autoptr(GError) error = NULL;
+  g_autoptr(GError) error = NULL;
 
-	connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
-	if (connection == NULL) {
-		g_print("Failed to connect to session bus: %s\n", error->message);
-		exit (1);
-	}
+  connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (connection == NULL)
+    {
+      g_print ("Failed to connect to session bus: %s\n", error->message);
+      exit (1);
+    }
 
-	manager = fprint_dbus_manager_proxy_new_sync (connection,
-						      G_DBUS_PROXY_FLAGS_NONE,
-						      "net.reactivated.Fprint",
-						      "/net/reactivated/Fprint/Manager",
-						      NULL, &error);
-	if (manager == NULL) {
-		g_print ("Failed to get Fprintd manager: %s\n", error->message);
-		exit (1);
-	}
+  manager = fprint_dbus_manager_proxy_new_sync (connection,
+                                                G_DBUS_PROXY_FLAGS_NONE,
+                                                "net.reactivated.Fprint",
+                                                "/net/reactivated/Fprint/Manager",
+                                                NULL, &error);
+  if (manager == NULL)
+    {
+      g_print ("Failed to get Fprintd manager: %s\n", error->message);
+      exit (1);
+    }
 }
 
-static void list_fingerprints (FprintDBusDevice *dev, const char *username)
+static void
+list_fingerprints (FprintDBusDevice *dev, const char *username)
 {
-	g_autoptr(GError) error = NULL;
-	g_auto(GStrv) fingers = NULL;
-	guint i;
+  g_autoptr(GError) error = NULL;
+  g_auto(GStrv) fingers = NULL;
+  guint i;
 
-	if (!fprint_dbus_device_call_list_enrolled_fingers_sync (dev, username,
-								 &fingers, NULL,
-								 &error)) {
-		gboolean ignore_error = FALSE;
-		if (g_dbus_error_is_remote_error (error)) {
-			g_autofree char *dbus_error =
-				g_dbus_error_get_remote_error (error);
-			if (g_str_equal (dbus_error,
-					 "net.reactivated.Fprint.Error.NoEnrolledPrints")) {
-				ignore_error = TRUE;
-			}
-		}
+  if (!fprint_dbus_device_call_list_enrolled_fingers_sync (dev, username,
+                                                           &fingers, NULL,
+                                                           &error))
+    {
+      gboolean ignore_error = FALSE;
+      if (g_dbus_error_is_remote_error (error))
+        {
+          g_autofree char *dbus_error =
+            g_dbus_error_get_remote_error (error);
+          if (g_str_equal (dbus_error,
+                           "net.reactivated.Fprint.Error.NoEnrolledPrints"))
+            ignore_error = TRUE;
+        }
 
-		if (!ignore_error) {
-			g_print("ListEnrolledFingers failed: %s\n", error->message);
-			exit (1);
-		}
-	}
+      if (!ignore_error)
+        {
+          g_print ("ListEnrolledFingers failed: %s\n", error->message);
+          exit (1);
+        }
+    }
 
-	if (fingers == NULL || g_strv_length (fingers) == 0) {
-		g_print ("User %s has no fingers enrolled for %s.\n", username,
-			 fprint_dbus_device_get_name (dev));
-		return;
-	}
+  if (fingers == NULL || g_strv_length (fingers) == 0)
+    {
+      g_print ("User %s has no fingers enrolled for %s.\n", username,
+               fprint_dbus_device_get_name (dev));
+      return;
+    }
 
-	g_print("Fingerprints for user %s on %s (%s):\n",
-		username,
-		fprint_dbus_device_get_name (dev),
-		fprint_dbus_device_get_scan_type (dev));
+  g_print ("Fingerprints for user %s on %s (%s):\n",
+           username,
+           fprint_dbus_device_get_name (dev),
+           fprint_dbus_device_get_scan_type (dev));
 
-	for (i = 0; fingers[i] != NULL; i++) {
-		g_print(" - #%d: %s\n", i, fingers[i]);
-	}
+  for (i = 0; fingers[i] != NULL; i++)
+    g_print (" - #%d: %s\n", i, fingers[i]);
 }
 
-static void process_devices(char **argv)
+static void
+process_devices (char **argv)
 {
-	g_auto(GStrv) devices = NULL;
-	g_autoptr(GError) error = NULL;
-	char *path;
-	guint num_devices;
-	guint i;
+  g_auto(GStrv) devices = NULL;
+  g_autoptr(GError) error = NULL;
+  char *path;
+  guint num_devices;
+  guint i;
 
-	if (!fprint_dbus_manager_call_get_devices_sync (manager, &devices, NULL,
-							&error)) {
-		g_print("Impossible to get devices: %s\n", error->message);
-		exit (1);
-	}
+  if (!fprint_dbus_manager_call_get_devices_sync (manager, &devices, NULL,
+                                                  &error))
+    {
+      g_print ("Impossible to get devices: %s\n", error->message);
+      exit (1);
+    }
 
-	num_devices = g_strv_length (devices);
-	if (num_devices == 0) {
-		g_print("No devices available\n");
-		exit(1);
-	}
+  num_devices = g_strv_length (devices);
+  if (num_devices == 0)
+    {
+      g_print ("No devices available\n");
+      exit (1);
+    }
 
-	g_print ("found %u devices\n", num_devices);
-	for (i = 0; devices[i] != NULL; i++) {
-		path = devices[i];
-		g_print("Device at %s\n", path);
-	}
+  g_print ("found %u devices\n", num_devices);
+  for (i = 0; devices[i] != NULL; i++)
+    {
+      path = devices[i];
+      g_print ("Device at %s\n", path);
+    }
 
-	for (i = 0; devices[i] != NULL; i++) {
-		g_autoptr(FprintDBusDevice) dev = NULL;
-		guint j;
+  for (i = 0; devices[i] != NULL; i++)
+    {
+      g_autoptr(FprintDBusDevice) dev = NULL;
+      guint j;
 
-		path = devices[i];
-		g_print("Using device %s\n", path);
+      path = devices[i];
+      g_print ("Using device %s\n", path);
 
-		/* NOTE: We should handle error cases! */
-		dev = fprint_dbus_device_proxy_new_sync (connection,
-							 G_DBUS_PROXY_FLAGS_NONE,
-							 "net.reactivated.Fprint",
-							 path, NULL, NULL);
+      /* NOTE: We should handle error cases! */
+      dev = fprint_dbus_device_proxy_new_sync (connection,
+                                               G_DBUS_PROXY_FLAGS_NONE,
+                                               "net.reactivated.Fprint",
+                                               path, NULL, NULL);
 
-		for (j = 1; argv[j] != NULL; j++)
-			list_fingerprints (dev, argv[j]);
-	}
+      for (j = 1; argv[j] != NULL; j++)
+        list_fingerprints (dev, argv[j]);
+    }
 }
 
-int main(int argc, char **argv)
+int
+main (int argc, char **argv)
 {
-	setlocale (LC_ALL, "");
+  setlocale (LC_ALL, "");
 
-	create_manager();
+  create_manager ();
 
-	if (argc < 2) {
-		g_print ("Usage: %s <username> [usernames...]\n", argv[0]);
-		return 1;
-	}
+  if (argc < 2)
+    {
+      g_print ("Usage: %s <username> [usernames...]\n", argv[0]);
+      return 1;
+    }
 
-	process_devices (argv);
+  process_devices (argv);
 
-	return 0;
+  return 0;
 }
-

utils/verify.c

@@ -31,208 +31,274 @@ static char *finger_name = NULL;
 static gboolean g_fatal_warnings = FALSE;
 static char **usernames = NULL;
 
-static void create_manager(void)
+static void
+create_manager (void)
 {
-	g_autoptr(GError) error = NULL;
+  g_autoptr(GError) error = NULL;
 
-	connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
-	if (connection == NULL) {
-		g_print("Failed to connect to session bus: %s\n", error->message);
-		exit (1);
-	}
+  connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
+  if (connection == NULL)
+    {
+      g_print ("Failed to connect to session bus: %s\n", error->message);
+      exit (1);
+    }
 
-	manager = fprint_dbus_manager_proxy_new_sync (connection,
-						      G_DBUS_PROXY_FLAGS_NONE,
-						      "net.reactivated.Fprint",
-						      "/net/reactivated/Fprint/Manager",
-						      NULL, &error);
-	if (manager == NULL) {
-		g_print ("Failed to get Fprintd manager: %s\n", error->message);
-		exit (1);
-	}
+  manager = fprint_dbus_manager_proxy_new_sync (connection,
+                                                G_DBUS_PROXY_FLAGS_NONE,
+                                                "net.reactivated.Fprint",
+                                                "/net/reactivated/Fprint/Manager",
+                                                NULL, &error);
+  if (manager == NULL)
+    {
+      g_print ("Failed to get Fprintd manager: %s\n", error->message);
+      exit (1);
+    }
 }
 
-static FprintDBusDevice *open_device (const char *username)
+static FprintDBusDevice *
+open_device (const char *username)
 {
-	g_autoptr(FprintDBusDevice) dev = NULL;
-	g_autoptr(GError) error = NULL;
-	g_autofree char *path = NULL;
+  g_autoptr(FprintDBusDevice) dev = NULL;
+  g_autoptr(GError) error = NULL;
+  g_autofree char *path = NULL;
 
-	if (!fprint_dbus_manager_call_get_default_device_sync (manager, &path,
-							       NULL, &error)) {
-		g_print("Impossible to verify: %s\n", error->message);
-		exit (1);
-	}
+  if (!fprint_dbus_manager_call_get_default_device_sync (manager, &path,
+                                                         NULL, &error))
+    {
+      g_print ("Impossible to verify: %s\n", error->message);
+      exit (1);
+    }
 
-	g_print("Using device %s\n", path);
+  g_print ("Using device %s\n", path);
 
-	dev = fprint_dbus_device_proxy_new_sync (connection,
-						 G_DBUS_PROXY_FLAGS_NONE,
-						 "net.reactivated.Fprint",
-						 path, NULL, &error);
+  dev = fprint_dbus_device_proxy_new_sync (connection,
+                                           G_DBUS_PROXY_FLAGS_NONE,
+                                           "net.reactivated.Fprint",
+                                           path, NULL, &error);
 
-	if (error) {
-		g_print ("failed to connect to device: %s\n", error->message);
-		exit (1);
-	}
+  if (error)
+    {
+      g_print ("failed to connect to device: %s\n", error->message);
+      exit (1);
+    }
 
-	if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error)) {
-		g_print("failed to claim device: %s\n", error->message);
-		exit (1);
-	}
+  if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error))
+    {
+      g_print ("failed to claim device: %s\n", error->message);
+      exit (1);
+    }
 
-	return g_steal_pointer (&dev);
+  return g_steal_pointer (&dev);
 }
 
-static void find_finger (FprintDBusDevice *dev, const char *username)
+static void
+find_finger (FprintDBusDevice *dev, const char *username)
 {
-	g_autoptr(GError) error = NULL;
-	g_auto(GStrv) fingers = NULL;
-	guint i;
+  g_autoptr(GError) error = NULL;
+  g_auto(GStrv) fingers = NULL;
+  guint i;
 
-	if (!fprint_dbus_device_call_list_enrolled_fingers_sync (dev, username,
-								 &fingers,
-								 NULL, &error)) {
-		g_print("ListEnrolledFingers failed: %s\n", error->message);
-		exit (1);
-	}
+  if (!fprint_dbus_device_call_list_enrolled_fingers_sync (dev, username,
+                                                           &fingers,
+                                                           NULL, &error))
+    {
+      g_print ("ListEnrolledFingers failed: %s\n", error->message);
+      exit (1);
+    }
 
-	if (fingers == NULL || g_strv_length (fingers) == 0) {
-		g_print("No fingers enrolled for this device.\n");
-		exit(1);
-	}
+  if (fingers == NULL || g_strv_length (fingers) == 0)
+    {
+      g_print ("No fingers enrolled for this device.\n");
+      exit (1);
+    }
 
-	g_print("Listing enrolled fingers:\n");
-	for (i = 0; fingers[i] != NULL; i++) {
-		g_print(" - #%d: %s\n", i, fingers[i]);
-	}
+  g_print ("Listing enrolled fingers:\n");
+  for (i = 0; fingers[i] != NULL; i++)
+    g_print (" - #%d: %s\n", i, fingers[i]);
 
-	if (finger_name && !g_str_equal (finger_name, "any") &&
-	    !g_strv_contains ((const char **) fingers, finger_name)) {
-		g_print("Finger '%s' not enrolled for user %s.\n", finger_name,
-		        username);
-		g_free (finger_name);
-		exit(1);
-	}
+  if (finger_name && !g_str_equal (finger_name, "any") &&
+      !g_strv_contains ((const char **) fingers, finger_name))
+    {
+      g_print ("Finger '%s' not enrolled for user %s.\n", finger_name,
+               username);
+      g_free (finger_name);
+      exit (1);
+    }
 
-	if (finger_name == NULL) {
-		finger_name = g_strdup (fingers[0]);
-	}
+  if (finger_name == NULL)
+    finger_name = g_strdup (fingers[0]);
 }
 
-static void verify_result(GObject *object, const char *result, gboolean done, void *user_data)
+struct VerifyState
 {
-	gboolean *verify_completed = user_data;
-	g_print("Verify result: %s (%s)\n", result, done ? "done" : "not done");
-	if (done != FALSE)
-		*verify_completed = TRUE;
+  GError  *error;
+  gboolean started;
+  gboolean completed;
+};
+
+static void
+verify_result (GObject *object, const char *result, gboolean done, void *user_data)
+{
+  struct VerifyState *verify_state = user_data;
+
+  g_print ("Verify result: %s (%s)\n", result, done ? "done" : "not done");
+  if (done != FALSE)
+    verify_state->completed = TRUE;
 }
 
-static void verify_finger_selected(GObject *object, const char *name, void *user_data)
+static void
+verify_finger_selected (GObject *object, const char *name, void *user_data)
 {
-	g_print("Verifying: %s\n", name);
+  g_print ("Verifying: %s\n", name);
 }
 
-static void proxy_signal_cb (GDBusProxy *proxy,
-			     const gchar *sender_name,
-			     const gchar *signal_name,
-			     GVariant *parameters,
-			     gpointer user_data)
+static void
+verify_started_cb (GObject      *obj,
+                   GAsyncResult *res,
+                   gpointer      user_data)
 {
-	if (g_str_equal (signal_name, "VerifyStatus")) {
-		const gchar *result;
-		gboolean done;
+  struct VerifyState *verify_state = user_data;
 
-		g_variant_get (parameters, "(&sb)", &result, &done);
-		verify_result (G_OBJECT (proxy), result, done, user_data);
-	} else if (g_str_equal (signal_name, "VerifyFingerSelected")) {
-		const gchar *name;
-
-		g_variant_get (parameters, "(&s)", &name);
-		verify_finger_selected (G_OBJECT (proxy), name, user_data);
-	}
+  if (fprint_dbus_device_call_verify_start_finish (FPRINT_DBUS_DEVICE (obj), res, &verify_state->error))
+    verify_state->started = TRUE;
 }
 
-static void do_verify (FprintDBusDevice *dev)
+static void
+proxy_signal_cb (GDBusProxy  *proxy,
+                 const gchar *sender_name,
+                 const gchar *signal_name,
+                 GVariant    *parameters,
+                 gpointer     user_data)
 {
-	g_autoptr(GError) error = NULL;
-	gboolean verify_completed = FALSE;
+  struct VerifyState *verify_state = user_data;
 
-	g_signal_connect (dev, "g-signal", G_CALLBACK (proxy_signal_cb),
-			  &verify_completed);
+  if (!verify_state->started)
+    return;
 
-	if (!fprint_dbus_device_call_verify_start_sync (dev, finger_name, NULL,
-							&error)) {
-		g_print("VerifyStart failed: %s\n", error->message);
-		exit (1);
-	}
+  if (g_str_equal (signal_name, "VerifyStatus"))
+    {
+      const gchar *result;
+      gboolean done;
 
-	while (!verify_completed)
-		g_main_context_iteration(NULL, TRUE);
+      g_variant_get (parameters, "(&sb)", &result, &done);
+      verify_result (G_OBJECT (proxy), result, done, user_data);
+    }
+  else if (g_str_equal (signal_name, "VerifyFingerSelected"))
+    {
+      const gchar *name;
 
-
-	g_signal_handlers_disconnect_by_func (dev, proxy_signal_cb,
-					      &verify_completed);
-
-	if (!fprint_dbus_device_call_verify_stop_sync (dev, NULL, &error)) {
-		g_print("VerifyStop failed: %s\n", error->message);
-		exit (1);
-	}
+      g_variant_get (parameters, "(&s)", &name);
+      verify_finger_selected (G_OBJECT (proxy), name, user_data);
+    }
 }
 
-static void release_device (FprintDBusDevice *dev)
+static void
+do_verify (FprintDBusDevice *dev)
 {
-	g_autoptr(GError) error = NULL;
-	if (!fprint_dbus_device_call_release_sync (dev, NULL, &error)) {
-		g_print("ReleaseDevice failed: %s\n", error->message);
-		exit (1);
-	}
+  g_autoptr(GError) error = NULL;
+  struct VerifyState verify_state = { 0 };
+
+  /* This one is funny. We connect to the signal immediately to avoid
+   * race conditions. However, we must ignore any authentication results
+   * that happen before our start call returns.
+   * This is because the verify call itself may internally try to verify
+   * against fprintd (possibly using a separate account).
+   *
+   * To do so, we *must* use the async version of the verify call, as the
+   * sync version would cause the signals to be queued and only processed
+   * after it returns.
+   */
+
+  g_signal_connect (dev, "g-signal", G_CALLBACK (proxy_signal_cb),
+                    &verify_state);
+
+  fprint_dbus_device_call_verify_start (dev, finger_name, NULL,
+                                        verify_started_cb,
+                                        &verify_state);
+
+  /* Wait for verify start while discarding any VerifyStatus signals */
+  while (!verify_state.started && !verify_state.error)
+    g_main_context_iteration (NULL, TRUE);
+
+  if (verify_state.error)
+    {
+      g_print ("VerifyStart failed: %s\n", verify_state.error->message);
+      g_clear_error (&verify_state.error);
+      exit (1);
+    }
+  g_print ("Verify started!\n");
+
+  /* VerifyStatus signals are processing, wait for completion. */
+  while (!verify_state.completed)
+    g_main_context_iteration (NULL, TRUE);
+
+
+  g_signal_handlers_disconnect_by_func (dev, proxy_signal_cb,
+                                        &verify_state);
+
+  if (!fprint_dbus_device_call_verify_stop_sync (dev, NULL, &error))
+    {
+      g_print ("VerifyStop failed: %s\n", error->message);
+      exit (1);
+    }
+}
+
+static void
+release_device (FprintDBusDevice *dev)
+{
+  g_autoptr(GError) error = NULL;
+  if (!fprint_dbus_device_call_release_sync (dev, NULL, &error))
+    {
+      g_print ("ReleaseDevice failed: %s\n", error->message);
+      exit (1);
+    }
 }
 
 static const GOptionEntry entries[] = {
-	{ "finger", 'f',  0, G_OPTION_ARG_STRING, &finger_name, "Finger selected to verify (default is automatic)", NULL },
-	{"g-fatal-warnings", 0, 0, G_OPTION_ARG_NONE, &g_fatal_warnings, "Make all warnings fatal", NULL},
- 	{ G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_STRING_ARRAY, &usernames, NULL, "[username]" },
-	{ NULL }
+  { "finger", 'f',  0, G_OPTION_ARG_STRING, &finger_name, "Finger selected to verify (default is automatic)", NULL },
+  {"g-fatal-warnings", 0, 0, G_OPTION_ARG_NONE, &g_fatal_warnings, "Make all warnings fatal", NULL},
+  { G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_STRING_ARRAY, &usernames, NULL, "[username]" },
+  { NULL }
 };
 
-int main(int argc, char **argv)
+int
+main (int argc, char **argv)
 {
-	g_autoptr(FprintDBusDevice) dev = NULL;
-	g_autoptr(GError) err = NULL;
-	GOptionContext *context;
-	const char *username = NULL;
+  g_autoptr(FprintDBusDevice) dev = NULL;
+  g_autoptr(GError) err = NULL;
+  GOptionContext *context;
+  const char *username = NULL;
 
-	setlocale (LC_ALL, "");
+  setlocale (LC_ALL, "");
 
-	context = g_option_context_new ("Verify a fingerprint");
-	g_option_context_add_main_entries (context, entries, NULL);
+  context = g_option_context_new ("Verify a fingerprint");
+  g_option_context_add_main_entries (context, entries, NULL);
 
-	if (g_option_context_parse (context, &argc, &argv, &err) == FALSE) {
-		g_print ("couldn't parse command-line options: %s\n", err->message);
-		return 1;
-	}
+  if (g_option_context_parse (context, &argc, &argv, &err) == FALSE)
+    {
+      g_print ("couldn't parse command-line options: %s\n", err->message);
+      return 1;
+    }
 
-	if (usernames == NULL) {
-		username = "";
-	} else {
-		username = usernames[0];
-	}
+  if (usernames == NULL)
+    username = "";
+  else
+    username = usernames[0];
 
-	if (g_fatal_warnings) {
-		GLogLevelFlags fatal_mask;
+  if (g_fatal_warnings)
+    {
+      GLogLevelFlags fatal_mask;
 
-		fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
-		fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
-		g_log_set_always_fatal (fatal_mask);
-	}
+      fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
+      fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
+      g_log_set_always_fatal (fatal_mask);
+    }
 
-	create_manager();
+  create_manager ();
 
-	dev = open_device(username);
-	find_finger(dev, username);
-	do_verify(dev);
-	release_device(dev);
-	return 0;
+  dev = open_device (username);
+  find_finger (dev, username);
+  do_verify (dev);
+  release_device (dev);
+  return 0;
 }
-