fdo-mirrors/fprintd
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libfprint/fprintd.git synced 2026-05-27 13:48:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions
fprintd/src/device.c

1733 lines
52 KiB
C
Raw Normal View History

Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
/*
* /net/reactivated/Fprint/Device/foo object implementation
* Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
* Copyright (C) 2020 Marco Trevisan <marco.trevisan@canonical.com>
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
*
* 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.
*/
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
#include "config.h"
#include <glib/gi18n.h>
daemon: Use GDBus to monitor clients Instead of the custom egg code.
2011-04-18 17:55:13 +01:00
#include <gio/gio.h>
Start of PolicyKit support Get a PolicyKit context per-device, set up its main loop, and steal more code from gnome-panel to check whether the actions are allowed for a particular caller.
2008-05-20 17:00:58 +01:00
#include <polkit/polkit.h>
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
#include <fprint.h>
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
The user that claims the device is the one we work on When the user claims the device, get its uid and username, and use this data to read/save from storage.
2008-05-20 14:18:40 +01:00
#include <sys/types.h>
#include <pwd.h>
Detect when a device is disconnected Pretty hacky way to detect whether the device we're handling has been disconnected during a verify or enrollment. This should allow us to avoid users having to wait when somebody pulls the plug.
2009-01-27 12:29:23 +00:00
#include <errno.h>
The user that claims the device is the one we work on When the user claims the device, get its uid and username, and use this data to read/save from storage.
2008-05-20 14:18:40 +01:00
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
#include "fprintd.h"
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
#include "storage.h"
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Mark fingers names array as const and use unique name With the stronger warnings enabled when building with meson, we get a warning for all the fingers definitions: ../src/device.c:38:24: warning: initialization discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers] 38 | [FP_FINGER_UNKNOWN] = "unknown", As the `fingers` array name was shadowed in another file: ../src/device.c:1000:11: warning: declaration of ‘fingers’ shadows a global declaration [-Wshadow] 1000 | GSList *fingers, *finger;
2020-01-27 18:55:05 +01:00
static const char *FINGERS_NAMES[] = {
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
[FP_FINGER_UNKNOWN] = "unknown",
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
"left-thumb",
"left-index-finger",
"left-middle-finger",
"left-ring-finger",
"left-little-finger",
"right-thumb",
"right-index-finger",
"right-middle-finger",
"right-ring-finger",
"right-little-finger"
};
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static void fprint_device_dbus_skeleton_iface_init (FprintDBusDeviceIface *);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
static gboolean action_authorization_handler (GDBusInterfaceSkeleton *,
GDBusMethodInvocation *,
gpointer user_data);
static GQuark quark_auth_user = 0;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
Track current action Track the current action happening in the device, so we can see what each device is doing. Refuse to launch a verification if there's already one in progress.
2008-11-03 13:41:45 +00:00
typedef enum {
ACTION_NONE = 0,
ACTION_IDENTIFY,
Add an enrollment action Return an error if an enrollment is already in progress.
2008-11-03 13:59:48 +00:00
ACTION_VERIFY,
device: Fix race condition when clients vanish If a client vanishes while we are opening or closing then fprintd would uncoditionally try to close the device immediately. This should not be done, it instead needs to wait for the open/close to complete. Add open/close to the current action enum and keep track of the fact that they are ongoing. Also check, whether the device has been closed in the meantime (after the nested mainloop is done). Fixes: #65
2020-05-12 17:20:13 +02:00
ACTION_ENROLL,
ACTION_OPEN,
ACTION_CLOSE,
Track current action Track the current action happening in the device, so we can see what each device is doing. Refuse to launch a verification if there's already one in progress.
2008-11-03 13:41:45 +00:00
} FprintDeviceAction;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
typedef enum {
STATE_CLAIMED,
STATE_UNCLAIMED,
STATE_IGNORED,
} FprintDeviceClaimState;
device: Use malloc-allocated SessionData Allocate SessionData using g_malloc(). There are no benefits to using GSlice for a seldom used structure. This also allows use to use g_clear_pointer() to free the struct.
2020-01-29 19:12:28 +01:00
typedef struct {
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
volatile gint _refcount;
device: Use session data for context, sender and user Use the device session data to store all the informations we care about while a device is claimed, and make its cleanup easier. Keep just one instance of the current context, given we use it only during claim and release, and those are mutually exclusive operations.
2020-01-29 22:13:18 +01:00
/* current method invocation */
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
GDBusMethodInvocation *invocation;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Use session data for context, sender and user Use the device session data to store all the informations we care about while a device is claimed, and make its cleanup easier. Keep just one instance of the current context, given we use it only during claim and release, and those are mutually exclusive operations.
2020-01-29 22:13:18 +01:00
/* The current user of the device, if claimed */
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
const char * const sender;
device: Use session data for context, sender and user Use the device session data to store all the informations we care about while a device is claimed, and make its cleanup easier. Keep just one instance of the current context, given we use it only during claim and release, and those are mutually exclusive operations.
2020-01-29 22:13:18 +01:00
/* The current user of the device, or if allowed,
* what was passed as a username argument */
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
const char * const username;
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
gboolean verify_status_reported;
device: Use malloc-allocated SessionData Allocate SessionData using g_malloc(). There are no benefits to using GSlice for a seldom used structure. This also allows use to use g_clear_pointer() to free the struct.
2020-01-29 19:12:28 +01:00
} SessionData;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Simplify FprintDevicePrivate declaration
2020-01-13 11:04:47 +01:00
typedef struct {
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
guint32 id;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
FpDevice *dev;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
SessionData *_session;
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
Port to PolicyKit 1.0 See https://bugzilla.redhat.com/show_bug.cgi?id=498368 and https://fedoraproject.org/wiki/Features/PolicyKitOne
2009-08-10 15:37:00 +01:00
PolkitAuthority *auth;
Start of PolicyKit support Get a PolicyKit context per-device, set up its main loop, and steal more code from gnome-panel to check whether the actions are allowed for a particular caller.
2008-05-20 17:00:58 +01:00
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
/* Hashtable of connected clients */
GHashTable *clients;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
/* Required to restart the operation on a retry failure. */
FpPrint *verify_data;
GPtrArray *identify_data;
device: Handle full device storage including garbage collection The new libfprint version has support for devices that store data on the sensor. In that case, the on-sensor storage might fill up when the user tries to enroll a new print. The strategy introduced here to handle this is to try and delete prints from the device that we do not know about (assuming, it is e.g. from an old installation and unusable). It can also happen that we are not able to garbage collect old prints. If that happens, a new error code "enroll-data-full" will be returned signalling the situation to the enrolling application.
2019-07-31 16:00:39 +02:00
int enroll_data;
Fix memleak on VerifyStart Clean up the data pass to the async verification and identification functions ourselves.
2008-11-24 15:23:05 +00:00
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
/* whether we're running an identify, or a verify */
Track current action Track the current action happening in the device, so we can see what each device is doing. Refuse to launch a verification if there's already one in progress.
2008-11-03 13:41:45 +00:00
FprintDeviceAction current_action;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
GCancellable *current_cancellable;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
GDBusMethodInvocation *current_cancel_invocation;
device: Simplify FprintDevicePrivate declaration
2020-01-13 11:04:47 +01:00
} FprintDevicePrivate;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
G_DEFINE_TYPE_WITH_CODE (FprintDevice, fprint_device,
FPRINT_DBUS_TYPE_DEVICE_SKELETON,
G_ADD_PRIVATE (FprintDevice)
G_IMPLEMENT_INTERFACE (FPRINT_DBUS_TYPE_DEVICE,
fprint_device_dbus_skeleton_iface_init));
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
enum fprint_device_properties {
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
FPRINT_DEVICE_CONSTRUCT_DEV = 1,
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
FPRINT_DEVICE_IN_USE,
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
FPRINT_DEVICE_NAME,
FPRINT_DEVICE_NUM_ENROLL,
FPRINT_DEVICE_SCAN_TYPE
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
};
Present verify results with a signal
2008-03-06 13:12:34 +00:00
enum fprint_device_signals {
Add enrollment functionality
2008-03-06 16:37:19 +00:00
SIGNAL_VERIFY_STATUS,
More identification work - Add a finger selected signal, so that when an "automatic" finger is selected for verification, we know which one to scan - Fix the finger print numbers list to use GPOINTER_TO_INT / GINT_TO_POINTER - Make sure the gallery is NULL when there's no prints available - Don't use identification when a finger number is provided - Add support for selecting the finger number in verify - Add support for fatal warnings there as well
2008-10-30 22:35:34 +00:00
SIGNAL_VERIFY_FINGER_SELECTED,
Add enrollment functionality
2008-03-06 16:37:19 +00:00
SIGNAL_ENROLL_STATUS,
Present verify results with a signal
2008-03-06 13:12:34 +00:00
NUM_SIGNALS,
};
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
static guint32 last_id = ~0;
Present verify results with a signal
2008-03-06 13:12:34 +00:00
static guint signals[NUM_SIGNALS] = { 0, };
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
static void
session_data_unref(SessionData *session)
{
if (g_atomic_int_dec_and_test (&session->_refcount)) {
g_clear_pointer((char**) &session->sender, g_free);
g_clear_pointer((char**) &session->username, g_free);
g_clear_object (&session->invocation);
g_free(session);
}
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC(SessionData, session_data_unref);
static SessionData*
session_data_get (FprintDevicePrivate *priv)
{
SessionData *invalid = (SessionData*) &priv->_session;
SessionData *cur;
/* Get the current pointer and mark the pointer as "busy". */
do {
cur = priv->_session;
/* Swap if cur is valid, otherwise busy loop. */
} while (cur == invalid || !g_atomic_pointer_compare_and_exchange (&priv->_session, cur, invalid));
/* We can safely increase the reference count now. */
if (cur)
g_atomic_int_inc (&cur->_refcount);
/* Swap back, this must succeed. */
if (!g_atomic_pointer_compare_and_exchange (&priv->_session, invalid, cur))
g_assert_not_reached ();
return cur;
}
/* Pass NULL sender and username to unset session data. */
static SessionData*
session_data_set_new (FprintDevicePrivate *priv, gchar *sender, gchar *username)
device: Use session data for context, sender and user Use the device session data to store all the informations we care about while a device is claimed, and make its cleanup easier. Keep just one instance of the current context, given we use it only during claim and release, and those are mutually exclusive operations.
2020-01-29 22:13:18 +01:00
{
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
SessionData *invalid = (SessionData*) &priv->_session;
SessionData *new = NULL;
SessionData *old;
g_assert ((!sender && !username) || (sender && username));
if (sender) {
new = g_new0 (SessionData, 1);
/* Internal reference of the pointer and returned reference. */
new->_refcount = 2;
*(char**) &new->sender = sender;
*(char**) &new->username = username;
}
/* Get the current (but not if it is busy) and put the new one in place. */
do {
old = priv->_session;
/* Swap if old is valid, otherwise busy loop as someone is ref'ing it currently. */
} while (old == invalid || !g_atomic_pointer_compare_and_exchange (&priv->_session, old, new));
/* We can safely drop the our internal reference now. */
if (old)
session_data_unref (old);
return new;
device: Use session data for context, sender and user Use the device session data to store all the informations we care about while a device is claimed, and make its cleanup easier. Keep just one instance of the current context, given we use it only during claim and release, and those are mutually exclusive operations.
2020-01-29 22:13:18 +01:00
}
device: Disconnect authorization callback and remove clients Add a dispose function to disconnect the authorization callback and remove all clients (i.e. unwatch their bus names) before destroying the hash table.
2020-11-13 14:10:26 +01:00
static void fprint_device_dispose(GObject *object)
{
FprintDevice *self = (FprintDevice *) object;
FprintDevicePrivate *priv = fprint_device_get_instance_private(self);
g_hash_table_remove_all (priv->clients);
g_object_disconnect (object,
"g-authorize-method",
G_CALLBACK (action_authorization_handler),
NULL,
NULL);
G_OBJECT_CLASS(fprint_device_parent_class)->dispose(object);
}
Use GObject-provided boilerplate Clean up the device object by using G_DEFINE_TYPE
2008-05-14 13:37:31 +01:00
static void fprint_device_finalize(GObject *object)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
FprintDevice *self = (FprintDevice *) object;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(self);
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
g_hash_table_destroy (priv->clients);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session_data_set_new(priv, NULL, NULL);
device: Destroy auth object in finalize
2020-11-13 14:10:10 +01:00
g_clear_object (&priv->auth);
device: Fix leaks on device finalization
2020-11-17 20:58:09 +01:00
g_clear_object (&priv->dev);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
/* FIXME close and stuff */
device: Fix memory leak on object destruction Add the missing chain-up on finalize().
2020-01-29 16:05:31 +01:00
G_OBJECT_CLASS(fprint_device_parent_class)->finalize(object);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
Use GObject-provided boilerplate Clean up the device object by using G_DEFINE_TYPE
2008-05-14 13:37:31 +01:00
static void fprint_device_set_property(GObject *object, guint property_id,
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
const GValue *value, GParamSpec *pspec)
{
FprintDevice *self = (FprintDevice *) object;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(self);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
switch (property_id) {
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
case FPRINT_DEVICE_CONSTRUCT_DEV:
priv->dev = g_value_dup_object(value);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
Add an action property Add an action property and notify listeners when the action changes.
2008-11-03 14:16:42 +00:00
static void fprint_device_get_property(GObject *object, guint property_id,
GValue *value, GParamSpec *pspec)
{
FprintDevice *self = (FprintDevice *) object;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(self);
Add an action property Add an action property and notify listeners when the action changes.
2008-11-03 14:16:42 +00:00
switch (property_id) {
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
case FPRINT_DEVICE_CONSTRUCT_DEV:
g_value_set_object(value, priv->dev);
break;
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
case FPRINT_DEVICE_IN_USE:
g_value_set_boolean(value, g_hash_table_size (priv->clients) != 0);
Add an action property Add an action property and notify listeners when the action changes.
2008-11-03 14:16:42 +00:00
break;
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
case FPRINT_DEVICE_NAME:
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_value_set_static_string (value, fp_device_get_name (priv->dev));
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
break;
case FPRINT_DEVICE_NUM_ENROLL:
if (priv->dev)
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_value_set_int (value, fp_device_get_nr_enroll_stages (priv->dev));
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
else
g_value_set_int (value, -1);
break;
case FPRINT_DEVICE_SCAN_TYPE: {
const char *type;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (fp_device_get_scan_type (priv->dev) == FP_SCAN_TYPE_PRESS)
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
type = "press";
else
type = "swipe";
g_value_set_static_string (value, type);
break;
}
Add an action property Add an action property and notify listeners when the action changes.
2008-11-03 14:16:42 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
Use GObject-provided boilerplate Clean up the device object by using G_DEFINE_TYPE
2008-05-14 13:37:31 +01:00
static void fprint_device_class_init(FprintDeviceClass *klass)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
GParamSpec *pspec;
device: Disconnect authorization callback and remove clients Add a dispose function to disconnect the authorization callback and remove all clients (i.e. unwatch their bus names) before destroying the hash table.
2020-11-13 14:10:26 +01:00
gobject_class->dispose = fprint_device_dispose;
Use GObject-provided boilerplate Clean up the device object by using G_DEFINE_TYPE
2008-05-14 13:37:31 +01:00
gobject_class->finalize = fprint_device_finalize;
gobject_class->set_property = fprint_device_set_property;
Add an action property Add an action property and notify listeners when the action changes.
2008-11-03 14:16:42 +00:00
gobject_class->get_property = fprint_device_get_property;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
pspec = g_param_spec_object("dev", "Device",
"Set device construction property",
FP_TYPE_DEVICE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_READABLE);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
g_object_class_install_property(gobject_class,
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
FPRINT_DEVICE_CONSTRUCT_DEV, pspec);
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
pspec = g_param_spec_boolean("in-use", "In use",
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
"Whether the device is currently in use", FALSE,
G_PARAM_READABLE);
Add an action property Add an action property and notify listeners when the action changes.
2008-11-03 14:16:42 +00:00
g_object_class_install_property(gobject_class,
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
FPRINT_DEVICE_IN_USE, pspec);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_object_class_override_property (gobject_class,
FPRINT_DEVICE_NAME,
"name");
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_object_class_override_property (gobject_class,
FPRINT_DEVICE_SCAN_TYPE,
"scan-type");
Use D-Bus properties instead of GetProperties - Use D-Bus native properties instead of a GetProperties call. - Fix a number of front-ends by registering the right signals and marshallers following the "done" signal argument addition - Fix VerifyStart call in the pam module
2008-11-22 00:00:06 +00:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_object_class_override_property (gobject_class,
FPRINT_DEVICE_NUM_ENROLL,
"num-enroll-stages");
signals[SIGNAL_VERIFY_STATUS] =
g_signal_lookup ("verify-status", FPRINT_TYPE_DEVICE);
signals[SIGNAL_ENROLL_STATUS] =
g_signal_lookup ("enroll-status", FPRINT_TYPE_DEVICE);
signals[SIGNAL_VERIFY_FINGER_SELECTED] =
g_signal_lookup ("verify-finger-selected", FPRINT_TYPE_DEVICE);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
quark_auth_user = g_quark_from_static_string ("authorized-user");
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
device: Unwatch names when removing them If a device is unplugged/destroyed while a client is using it, then we would still end up watching the name. The vanish notification will then access the destroyed FprintDevice object. Fix this by unwatching the bus name when removing the client entry from the dictionary.
2020-11-13 14:00:48 +01:00
static void _unwatch_name (gpointer id)
{
g_bus_unwatch_name (GPOINTER_TO_INT (id));
}
Use GObject-provided boilerplate Clean up the device object by using G_DEFINE_TYPE
2008-05-14 13:37:31 +01:00
static void fprint_device_init(FprintDevice *device)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(device);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
priv->id = ++last_id;
Start of PolicyKit support Get a PolicyKit context per-device, set up its main loop, and steal more code from gnome-panel to check whether the actions are allowed for a particular caller.
2008-05-20 17:00:58 +01:00
/* Setup PolicyKit */
device: Use non-deprecated PolKit call
2012-11-17 09:10:35 +01:00
priv->auth = polkit_authority_get_sync (NULL, NULL);
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
priv->clients = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
device: Unwatch names when removing them If a device is unplugged/destroyed while a client is using it, then we would still end up watching the name. The vanish notification will then access the destroyed FprintDevice object. Fix this by unwatching the bus name when removing the client entry from the dictionary.
2020-11-13 14:00:48 +01:00
_unwatch_name);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
g_signal_connect (device, "g-authorize-method",
G_CALLBACK (action_authorization_handler),
NULL);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
FprintDevice *fprint_device_new(FpDevice *dev)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
return g_object_new(FPRINT_TYPE_DEVICE, "dev", dev, NULL);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
guint32 _fprint_device_get_id(FprintDevice *rdev)
{
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
return priv->id;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
static const char *
finger_num_to_name (int finger_num)
{
if (finger_num == -1)
return "any";
device: Use FP_FINGER_IS_VALID to check finger number
2019-12-19 14:29:04 +01:00
if (!FP_FINGER_IS_VALID (finger_num))
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
return NULL;
device: Mark fingers names array as const and use unique name With the stronger warnings enabled when building with meson, we get a warning for all the fingers definitions: ../src/device.c:38:24: warning: initialization discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers] 38 | [FP_FINGER_UNKNOWN] = "unknown", As the `fingers` array name was shadowed in another file: ../src/device.c:1000:11: warning: declaration of ‘fingers’ shadows a global declaration [-Wshadow] 1000 | GSList *fingers, *finger;
2020-01-27 18:55:05 +01:00
return FINGERS_NAMES[finger_num];
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
}
static int
finger_name_to_num (const char *finger_name)
{
guint i;
if (finger_name == NULL || *finger_name == '\0' || g_str_equal (finger_name, "any"))
return -1;
file-storage: Use first/last fingers references instead of named ones Don't depend in the hardcoded libfprint fingers order, but use instead the aliases for first/last fingers in libfprint order
2019-12-18 17:32:52 +01:00
for (i = FP_FINGER_FIRST; i <= FP_FINGER_LAST; i++) {
device: Mark fingers names array as const and use unique name With the stronger warnings enabled when building with meson, we get a warning for all the fingers definitions: ../src/device.c:38:24: warning: initialization discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers] 38 | [FP_FINGER_UNKNOWN] = "unknown", As the `fingers` array name was shadowed in another file: ../src/device.c:1000:11: warning: declaration of ‘fingers’ shadows a global declaration [-Wshadow] 1000 | GSList *fingers, *finger;
2020-01-27 18:55:05 +01:00
if (g_str_equal (finger_name, FINGERS_NAMES[i]))
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
return i;
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
}
/* Invalid, let's try that */
return -1;
}
Remove all uses of enums in the API The clients aren't supposed to know the magic numbers for enums, so use strings instead.
2008-11-20 16:51:46 +00:00
static const char *
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
verify_result_to_name (gboolean match, GError *error)
Remove all uses of enums in the API The clients aren't supposed to know the magic numbers for enums, so use strings instead.
2008-11-20 16:51:46 +00:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (!error) {
if (match)
return "verify-match";
else
return "verify-no-match";
}
if (error->domain == FP_DEVICE_RETRY) {
switch (error->code) {
case FP_DEVICE_RETRY_TOO_SHORT:
return "verify-swipe-too-short";
case FP_DEVICE_RETRY_CENTER_FINGER:
return "verify-finger-not-centered";
case FP_DEVICE_RETRY_REMOVE_FINGER:
return "verify-remove-and-retry";
default:
return "verify-retry-scan";
}
} else {
/* Which errors should be mapped to disconnection?
* Are drivers/libfprint/fprintd really in agreement here?
*/
if (g_error_matches (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_PROTO))
device: Fix verify-disconnected state name Respect protocol, and use proper name
2020-02-11 23:00:25 +01:00
return "verify-disconnected";
device: Return 'verify-no-match' on cancelled verification We were returning a 'verify-unknown-error' while we actually know what happened, so better to return a soft operation failure.
2020-02-10 17:23:19 +01:00
else if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return "verify-no-match";
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
Remove all uses of enums in the API The clients aren't supposed to know the magic numbers for enums, so use strings instead.
2008-11-20 16:51:46 +00:00
return "verify-unknown-error";
}
}
static const char *
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
enroll_result_to_name (gboolean completed, gboolean enrolled, GError *error)
Remove all uses of enums in the API The clients aren't supposed to know the magic numbers for enums, so use strings instead.
2008-11-20 16:51:46 +00:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (!error) {
if (!completed)
return "enroll-stage-passed";
else if (enrolled)
return "enroll-completed";
else
return "enroll-failed";
}
if (error->domain == FP_DEVICE_RETRY) {
switch (error->code) {
case FP_DEVICE_RETRY_TOO_SHORT:
return "enroll-swipe-too-short";
case FP_DEVICE_RETRY_CENTER_FINGER:
return "enroll-finger-not-centered";
case FP_DEVICE_RETRY_REMOVE_FINGER:
return "enroll-remove-and-retry";
device: Fix retry enroll error names Use proper names for enroll retry errors, fixing a copy/paste error from the verify code.
2020-02-07 21:28:58 +01:00
default:
return "enroll-retry-scan";
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
}
} else {
/* Which errors should be mapped to disconnection?
* Are drivers/libfprint/fprintd really in agreement here?
*/
if (g_error_matches (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_PROTO))
return "enroll-disconnected";
device: Handle full device storage including garbage collection The new libfprint version has support for devices that store data on the sensor. In that case, the on-sensor storage might fill up when the user tries to enroll a new print. The strategy introduced here to handle this is to try and delete prints from the device that we do not know about (assuming, it is e.g. from an old installation and unusable). It can also happen that we are not able to garbage collect old prints. If that happens, a new error code "enroll-data-full" will be returned signalling the situation to the enrolling application.
2019-07-31 16:00:39 +02:00
else if (g_error_matches (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_FULL))
return "enroll-data-full";
device: Return 'enroll-failed' on cancelled enrollment We were returning an 'enroll-unknown-error' while we actually know what happened, so better to return a soft operation failure.
2020-02-10 17:22:50 +01:00
else if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return "enroll-failed";
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
Remove all uses of enums in the API The clients aren't supposed to know the magic numbers for enums, so use strings instead.
2008-11-20 16:51:46 +00:00
return "enroll-unknown-error";
}
}
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
static gboolean
_fprint_device_check_claimed (FprintDevice *rdev,
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
GDBusMethodInvocation *invocation,
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
FprintDeviceClaimState requested_state,
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
GError **error)
{
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
const char *sender;
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
gboolean retval;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
if (requested_state == STATE_IGNORED)
return TRUE;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
if (requested_state == STATE_UNCLAIMED) {
/* Is it already claimed? */
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
if (!session) {
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
return TRUE;
}
g_set_error(error, FPRINT_ERROR, FPRINT_ERROR_ALREADY_IN_USE,
"Device was already claimed");
return FALSE;
}
g_assert (requested_state == STATE_CLAIMED);
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
/* The device wasn't claimed, exit */
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
if (session == NULL) {
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
g_set_error (error, FPRINT_ERROR, FPRINT_ERROR_CLAIM_DEVICE,
_("Device was not claimed before use"));
return FALSE;
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
sender = g_dbus_method_invocation_get_sender (invocation);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
retval = g_str_equal (sender, session->sender);
g_print("sender: %s, session owner: %s", sender, session->sender);
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
if (retval == FALSE || session->invocation != NULL) {
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
g_set_error (error, FPRINT_ERROR, FPRINT_ERROR_ALREADY_IN_USE,
_("Device already in use by another user"));
}
return retval;
}
Start of PolicyKit support Get a PolicyKit context per-device, set up its main loop, and steal more code from gnome-panel to check whether the actions are allowed for a particular caller.
2008-05-20 17:00:58 +01:00
static gboolean
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
_fprint_device_check_polkit_for_action (FprintDevice *rdev,
GDBusMethodInvocation *invocation,
const char *action,
GError **error)
Start of PolicyKit support Get a PolicyKit context per-device, set up its main loop, and steal more code from gnome-panel to check whether the actions are allowed for a particular caller.
2008-05-20 17:00:58 +01:00
{
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
const char *sender;
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_autoptr(GError) _error = NULL;
g_autoptr(PolkitAuthorizationResult) result = NULL;
g_autoptr(PolkitSubject) subject = NULL;
Start of PolicyKit support Get a PolicyKit context per-device, set up its main loop, and steal more code from gnome-panel to check whether the actions are allowed for a particular caller.
2008-05-20 17:00:58 +01:00
/* Check that caller is privileged */
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
sender = g_dbus_method_invocation_get_sender (invocation);
Port to PolicyKit 1.0 See https://bugzilla.redhat.com/show_bug.cgi?id=498368 and https://fedoraproject.org/wiki/Features/PolicyKitOne
2009-08-10 15:37:00 +01:00
subject = polkit_system_bus_name_new (sender);
result = polkit_authority_check_authorization_sync (priv->auth,
subject,
action,
NULL,
POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
NULL, &_error);
if (result == NULL) {
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
g_set_error (error, FPRINT_ERROR,
Port to PolicyKit 1.0 See https://bugzilla.redhat.com/show_bug.cgi?id=498368 and https://fedoraproject.org/wiki/Features/PolicyKitOne
2009-08-10 15:37:00 +01:00
FPRINT_ERROR_PERMISSION_DENIED,
"Not Authorized: %s", _error->message);
Start of PolicyKit support Get a PolicyKit context per-device, set up its main loop, and steal more code from gnome-panel to check whether the actions are allowed for a particular caller.
2008-05-20 17:00:58 +01:00
return FALSE;
}
Port to PolicyKit 1.0 See https://bugzilla.redhat.com/show_bug.cgi?id=498368 and https://fedoraproject.org/wiki/Features/PolicyKitOne
2009-08-10 15:37:00 +01:00
if (!polkit_authorization_result_get_is_authorized (result)) {
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
g_set_error (error, FPRINT_ERROR,
Review possible errors and document them Review all the possible errors and document them for each function.
2008-11-24 14:16:41 +00:00
FPRINT_ERROR_PERMISSION_DENIED,
Port to PolicyKit 1.0 See https://bugzilla.redhat.com/show_bug.cgi?id=498368 and https://fedoraproject.org/wiki/Features/PolicyKitOne
2009-08-10 15:37:00 +01:00
"Not Authorized: %s", action);
Start of PolicyKit support Get a PolicyKit context per-device, set up its main loop, and steal more code from gnome-panel to check whether the actions are allowed for a particular caller.
2008-05-20 17:00:58 +01:00
return FALSE;
}
return TRUE;
}
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
static gboolean
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
fprint_device_check_polkit_for_permissions (FprintDevice *rdev,
GDBusMethodInvocation *invocation,
FprintDevicePermission permissions,
GError **error)
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
{
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
g_autoptr(GFlagsClass) permission_flags = NULL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
unsigned i;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
if (permissions == FPRINT_DEVICE_PERMISSION_NONE)
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
return TRUE;
device: Use meson to generate fprint device permission flags
2020-11-06 18:42:21 +01:00
permission_flags = g_type_class_ref (FPRINT_TYPE_DEVICE_PERMISSION);
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
for (i = 0; i < permission_flags->n_values; ++i) {
GFlagsValue *value = &permission_flags->values[i];
const char *action;
if (!(value->value & permissions)) {
continue;
}
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
action = value->value_nick;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
g_debug ("Getting authorization to perform Polkit action %s",
action);
g_clear_error (error);
if (_fprint_device_check_polkit_for_action (rdev, invocation,
action, error)) {
return TRUE;
}
}
g_assert (!error || *error);
return FALSE;
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
}
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
static char *
_fprint_device_check_for_username (FprintDevice *rdev,
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
GDBusMethodInvocation *invocation,
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
const char *username,
GError **error)
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
{
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_autoptr(GVariant) ret = NULL;
g_autoptr(GError) err = NULL;
GDBusConnection *connection;
const char *sender;
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
struct passwd *user;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
guint32 uid;
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
/* Get details about the current sender, and username/uid */
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
connection = g_dbus_method_invocation_get_connection (invocation);
sender = g_dbus_method_invocation_get_sender (invocation);
ret = g_dbus_connection_call_sync (connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"GetConnectionUnixUser",
g_variant_new ("(s)", sender),
NULL, G_DBUS_CALL_FLAGS_NONE, -1,
NULL, &err);
if (!ret) {
g_autoptr(GError) e = NULL;
g_set_error (error, FPRINT_ERROR, FPRINT_ERROR_INTERNAL,
"Could not get conection unix user ID: %s",
err->message);
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
return NULL;
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_variant_get (ret, "(u)", &uid);
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
user = getpwuid (uid);
if (user == NULL) {
Review possible errors and document them Review all the possible errors and document them for each function.
2008-11-24 14:16:41 +00:00
g_set_error(error, FPRINT_ERROR, FPRINT_ERROR_INTERNAL,
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
"Failed to get information about user UID %u", uid);
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
return NULL;
}
/* The current user is usually allowed to access their
* own data, this should be followed by PolicyKit checks
* anyway */
device: Fix client_username memory leak No need to duplicate that string until we pass it out. From https://bugs.launchpad.net/ubuntu/+source/fprintd/+bug/1745455/comments/7
2018-08-23 13:44:14 +02:00
if (username == NULL || *username == '\0' || g_str_equal (username, user->pw_name)) {
return g_strdup (user->pw_name);
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
}
/* If we're not allowed to set a different username,
* then fail */
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
if (!fprint_device_check_polkit_for_permissions (rdev, invocation,
FPRINT_DEVICE_PERMISSION_SETUSERNAME,
error)) {
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
return NULL;
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
}
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
return g_strdup (username);
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
}
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
static void
daemon: Use GDBus to monitor clients Instead of the custom egg code.
2011-04-18 17:55:13 +01:00
_fprint_device_client_vanished (GDBusConnection *connection,
const char *name,
FprintDevice *rdev)
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GError) error = NULL;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
daemon: Use GDBus to monitor clients Instead of the custom egg code.
2011-04-18 17:55:13 +01:00
/* Was that the client that claimed the device? */
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
if (session != NULL &&
g_strcmp0 (session->sender, name) == 0) {
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
while (priv->current_action != ACTION_NONE) {
device: Fix race condition when clients vanish If a client vanishes while we are opening or closing then fprintd would uncoditionally try to close the device immediately. This should not be done, it instead needs to wait for the open/close to complete. Add open/close to the current action enum and keep track of the fact that they are ongoing. Also check, whether the device has been closed in the meantime (after the nested mainloop is done). Fixes: #65
2020-05-12 17:20:13 +02:00
/* OPEN/CLOSE are not cancellable, we just need to wait */
if (priv->current_cancellable)
g_cancellable_cancel (priv->current_cancellable);
device: Fix crash on exit Fix a possible crash when an fprintd client disappears. If the client requested for the device to be released, then, without waiting for the reply of that release, disappeared from the bus, we would try to close it a second time, accessing a function pointer that didn't exist anymore. See https://bugzilla.redhat.com/show_bug.cgi?id=1515720
2018-05-30 20:00:26 +02:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_main_context_iteration (NULL, TRUE);
device: Don't call fp_async_dev_close() with NULL device In some cases, the priv->dev is already freed and NULL, so ensure that we don't try to close NULL devices and crash.
2015-10-14 12:12:39 +02:00
}
daemon: Use GDBus to monitor clients Instead of the custom egg code.
2011-04-18 17:55:13 +01:00
device: Fix race condition when clients vanish If a client vanishes while we are opening or closing then fprintd would uncoditionally try to close the device immediately. This should not be done, it instead needs to wait for the open/close to complete. Add open/close to the current action enum and keep track of the fact that they are ongoing. Also check, whether the device has been closed in the meantime (after the nested mainloop is done). Fixes: #65
2020-05-12 17:20:13 +02:00
/* The session may have disappeared at this point if the device
* was already closing. */
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
if (session && !fp_device_close_sync (priv->dev, NULL, &error))
device: Make possible client vanished race testable using critical The tests cannot currently parse the logs of fprintd. This means we need to rely on fprintd aborting when a condition is hit that needs to be tested. This makes certain possible races when clients vanish testable.
2020-05-12 19:09:30 +02:00
g_critical ("Error closing device after disconnect: %s", error->message);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session_data_set_new (priv, NULL, NULL);
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
}
daemon: Use GDBus to monitor clients Instead of the custom egg code.
2011-04-18 17:55:13 +01:00
g_hash_table_remove (priv->clients, name);
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
if (g_hash_table_size (priv->clients) == 0) {
g_object_notify (G_OBJECT (rdev), "in-use");
}
}
static void
_fprint_device_add_client (FprintDevice *rdev, const char *sender)
{
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
daemon: Use GDBus to monitor clients Instead of the custom egg code.
2011-04-18 17:55:13 +01:00
guint id;
id = GPOINTER_TO_UINT (g_hash_table_lookup (priv->clients, sender));
if (id == 0) {
id = g_bus_watch_name (G_BUS_TYPE_SYSTEM,
sender,
G_BUS_NAME_WATCHER_FLAGS_NONE,
NULL,
(GBusNameVanishedCallback) _fprint_device_client_vanished,
rdev,
NULL);
g_hash_table_insert (priv->clients, g_strdup (sender), GUINT_TO_POINTER(id));
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
g_object_notify (G_OBJECT (rdev), "in-use");
}
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
static void dev_open_cb(FpDevice *dev, GAsyncResult *res, void *user_data)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GError) error = NULL;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
FprintDevice *rdev = user_data;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
g_autoptr(GDBusMethodInvocation) invocation = NULL;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
invocation = g_steal_pointer (&session->invocation);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Fix race condition when clients vanish If a client vanishes while we are opening or closing then fprintd would uncoditionally try to close the device immediately. This should not be done, it instead needs to wait for the open/close to complete. Add open/close to the current action enum and keep track of the fact that they are ongoing. Also check, whether the device has been closed in the meantime (after the nested mainloop is done). Fixes: #65
2020-05-12 17:20:13 +02:00
priv->current_action = ACTION_NONE;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (!fp_device_open_finish (dev, res, &error)) {
g_autoptr(GError) dbus_error = NULL;
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
dbus_error = g_error_new (FPRINT_ERROR,
FPRINT_ERROR_INTERNAL,
"Open failed with error: %s", error->message);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation, dbus_error);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session_data_set_new (priv, NULL, NULL);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
return;
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_debug("claimed device %d", priv->id);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
fprint_dbus_device_complete_claim (FPRINT_DBUS_DEVICE (rdev),
invocation);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
static gboolean
fprintd_device_authorize_user (FprintDevice *rdev,
GDBusMethodInvocation *invocation,
GError **error)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
GVariant *params = NULL;
const char *username = NULL;
g_autofree char *user = NULL;
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
params = g_dbus_method_invocation_get_parameters (invocation);
g_assert (g_variant_n_children (params) == 1);
g_variant_get (params, "(&s)", &username);
g_assert (username);
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
user = _fprint_device_check_for_username (rdev,
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
invocation,
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
username,
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
error);
Rework the "SetUsername" functionality - Remove SetUsername itself, and add a username parameter to DeviceClaim, ListEnrolledFingers and DeleteEnrolledFingers. - For each of those calls, check that the incoming connection is allowed to operate on that particular username - Don't require a claimed device to list or remove fingerprints - Clean up username and sender when releasing the device - Modify the storage backend to not require an opened device to list or delete fingerprints - Add a simple test program to list registered fingerprints for the usernames passed as argument
2008-10-30 16:53:05 +00:00
if (user == NULL) {
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
return FALSE;
Add user tracking when claiming a device Mark all the methods on the device as async, so we can get access to the associated DBusGMethodInvocation. When claiming the device, remember the sender, and for every API entry point, check that the sender is the same as the one that made the original claim. Trying to enroll a user whilst the device is already claimed from another program will fail with: ** ERROR **: failed to claim device: Device was already claimed This is the first step towards PolicyKit and multi-user support
2008-05-16 17:24:45 +01:00
}
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
/* We keep the user attached to the invocation as it may not be the same
* of the requested one, in case an empty one was passed.
* Given that now we may have multiple cuncurrent requests, it wouldn't
* be safe to add another member to the priv, as it would need even more
* multi-thread checks around, and over-complicate things.
*/
g_object_set_qdata_full (G_OBJECT (invocation), quark_auth_user,
g_steal_pointer (&user), g_free);
return TRUE;
}
static gboolean fprint_device_claim (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation,
const char *username)
{
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
g_autoptr(GError) error = NULL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
char *sender, *user;
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
if (!_fprint_device_check_claimed (rdev, invocation, STATE_UNCLAIMED, &error)) {
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
user = g_object_steal_qdata (G_OBJECT (invocation), quark_auth_user);
g_assert (user);
The user that claims the device is the one we work on When the user claims the device, get its uid and username, and use this data to read/save from storage.
2008-05-20 14:18:40 +01:00
device: Get sender from invocation instead that during username check We now can get an invocation-owned sender at any moment with GDBus, so there's no point of getting it as optional return-out value from the username check function.
2020-11-05 19:41:12 +01:00
sender = g_strdup (g_dbus_method_invocation_get_sender (invocation));
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
_fprint_device_add_client (rdev, sender);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_set_new (priv, g_steal_pointer (&sender), g_steal_pointer(&user));
session->invocation = g_object_ref (invocation);
username = g_steal_pointer (&user);
sender = g_steal_pointer (&sender);
device: Use session data for context, sender and user Use the device session data to store all the informations we care about while a device is claimed, and make its cleanup easier. Keep just one instance of the current context, given we use it only during claim and release, and those are mutually exclusive operations.
2020-01-29 22:13:18 +01:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_debug ("user '%s' claiming the device: %d", session->username, priv->id);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Fix race condition when clients vanish If a client vanishes while we are opening or closing then fprintd would uncoditionally try to close the device immediately. This should not be done, it instead needs to wait for the open/close to complete. Add open/close to the current action enum and keep track of the fact that they are ongoing. Also check, whether the device has been closed in the meantime (after the nested mainloop is done). Fixes: #65
2020-05-12 17:20:13 +02:00
priv->current_action = ACTION_OPEN;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
fp_device_open (priv->dev, NULL, (GAsyncReadyCallback) dev_open_cb, rdev);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
return TRUE;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
static void dev_close_cb(FpDevice *dev, GAsyncResult *res, void *user_data)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GError) error = NULL;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
FprintDevice *rdev = user_data;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
g_autoptr(SessionData) session = NULL;
g_autoptr(GDBusMethodInvocation) invocation = NULL;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
session_data_set_new (priv, NULL, NULL);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
invocation = g_steal_pointer (&session->invocation);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Fix race condition when clients vanish If a client vanishes while we are opening or closing then fprintd would uncoditionally try to close the device immediately. This should not be done, it instead needs to wait for the open/close to complete. Add open/close to the current action enum and keep track of the fact that they are ongoing. Also check, whether the device has been closed in the meantime (after the nested mainloop is done). Fixes: #65
2020-05-12 17:20:13 +02:00
priv->current_action = ACTION_NONE;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (!fp_device_close_finish (dev, res, &error)) {
g_autoptr(GError) dbus_error = NULL;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
dbus_error = g_error_new (FPRINT_ERROR,
FPRINT_ERROR_INTERNAL,
"Release failed with error: %s", error->message);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation, dbus_error);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
return;
}
The user that claims the device is the one we work on When the user claims the device, get its uid and username, and use this data to read/save from storage.
2008-05-20 14:18:40 +01:00
main: Turn messages in debug messages Rather than filling the logs with mostly useless messages, print those as debug.
2018-05-30 19:59:07 +02:00
g_debug("released device %d", priv->id);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
fprint_dbus_device_complete_release (FPRINT_DBUS_DEVICE (rdev),
invocation);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static gboolean fprint_device_release (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
g_autoptr(GError) error = NULL;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
if (!_fprint_device_check_claimed (rdev, invocation, STATE_CLAIMED, &error)) {
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
device: Cancel the ongoing operation when releasing the device If a device is currently verifying, identifying or enrolling we may want the user to stop the operation before we actually release the device. Otherwise we may end-up in trying to close (failing) the internal device, while fprintd is still considering the device active, causing a dead-lock (the device can't be released, but neither claimed again or stop the current action). In fact calling Claim() -> EnrollStart() -> Release(), we would fail with the error net.reactivated.Fprint.Error.Internal: Release failed with error: The device is still busy with another operation, please try again later. (36)" However, if we try to call VerifyStop, after this error, we'd fail because for the fprintd logic, the device is not claimed anymore, but actually closed, and we'd need to claim it again, but... That would still cause an internal error. To avoid this, in case Relase() is called cancel the ongoing operation, and wait until it's done before completing the release call.
2020-02-06 21:34:39 +01:00
if (priv->current_cancellable) {
if (priv->current_action == ACTION_ENROLL) {
g_warning("Enrollment was in progress, stopping it");
} else if (priv->current_action == ACTION_IDENTIFY ||
priv->current_action == ACTION_VERIFY) {
g_warning("Verification was in progress, stopping it");
}
g_cancellable_cancel (priv->current_cancellable);
while (priv->current_action != ACTION_NONE)
g_main_context_iteration (NULL, TRUE);
}
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
session->invocation = g_object_ref (invocation);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
device: Fix race condition when clients vanish If a client vanishes while we are opening or closing then fprintd would uncoditionally try to close the device immediately. This should not be done, it instead needs to wait for the open/close to complete. Add open/close to the current action enum and keep track of the fact that they are ongoing. Also check, whether the device has been closed in the meantime (after the nested mainloop is done). Fixes: #65
2020-05-12 17:20:13 +02:00
priv->current_action = ACTION_CLOSE;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
fp_device_close (priv->dev, NULL, (GAsyncReadyCallback) dev_close_cb, rdev);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
return TRUE;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
static void report_verify_status (FprintDevice *rdev,
gboolean match,
GError *error)
{
FprintDevicePrivate *priv = fprint_device_get_instance_private (rdev);
const char *result = verify_result_to_name (match, error);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
gboolean done;
done = (error == NULL || error->domain != FP_DEVICE_RETRY);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
if (done && session->verify_status_reported) {
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
/* It is completely fine for cancellation to occur after a
* result has been reported. */
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Verify status already reported. Ignoring %s", result);
return;
}
g_debug ("report_verify_status: result %s", result);
g_signal_emit (rdev, signals[SIGNAL_VERIFY_STATUS], 0, result, done);
if (done)
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session->verify_status_reported = TRUE;
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
}
static void match_cb (FpDevice *device,
FpPrint *match,
FpPrint *print,
gpointer user_data,
GError *error)
{
FprintDevice *rdev = user_data;
FprintDevicePrivate *priv = fprint_device_get_instance_private (rdev);
gboolean matched;
gboolean cancelled;
g_assert_true (error == NULL || error->domain == FP_DEVICE_RETRY);
cancelled = g_cancellable_is_cancelled (priv->current_cancellable);
matched = match != NULL && cancelled == FALSE;
/* No-match is reported only after the operation completes.
* This avoids problems when the operation is immediately restarted. */
report_verify_status (rdev, matched, error);
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
static void verify_cb(FpDevice *dev, GAsyncResult *res, void *user_data)
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GError) error = NULL;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
main: Use G_DECLARE_FINAL_TYPE to define objet
2020-01-28 18:30:32 +01:00
FprintDevice *rdev = user_data;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDBusDevice *dbus_dev = FPRINT_DBUS_DEVICE (rdev);
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
gboolean success;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
const char *name;
gboolean match;
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
success = fp_device_verify_finish (dev, res, &match, NULL, &error);
g_assert (!!success == !error);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
name = verify_result_to_name (match, error);
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_debug("verify_cb: result %s", name);
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
/* Automatically restart the operation for retry failures */
if (error && error->domain == FP_DEVICE_RETRY) {
fp_device_verify (priv->dev,
priv->verify_data,
priv->current_cancellable,
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
match_cb, rdev, NULL,
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
(GAsyncReadyCallback) verify_cb,
rdev);
} else {
g_clear_object (&priv->verify_data);
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
if (error) {
report_verify_status (rdev, FALSE, error);
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_warning ("Device reported an error during verify: %s",
error->message);
}
}
device: Print warnings for fatal errors
2019-12-04 17:00:01 +01:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
/* Return the cancellation or reset action right away if vanished. */
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
if (priv->current_cancel_invocation) {
fprint_dbus_device_complete_verify_stop (dbus_dev,
g_steal_pointer (&priv->current_cancel_invocation));
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_action = ACTION_NONE;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session->verify_status_reported = FALSE;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
} else if (g_cancellable_is_cancelled (priv->current_cancellable)) {
priv->current_action = ACTION_NONE;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session->verify_status_reported = FALSE;
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
}
Fix memleak on VerifyStart Clean up the data pass to the async verification and identification functions ourselves.
2008-11-24 15:23:05 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_clear_object (&priv->current_cancellable);
Fix memleak on VerifyStart Clean up the data pass to the async verification and identification functions ourselves.
2008-11-24 15:23:05 +00:00
}
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
static void identify_cb(FpDevice *dev, GAsyncResult *res, void *user_data)
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GError) error = NULL;
device: Fix leaked matched print on identify When starting an identify operation we allocate a gallery of prints from the gallery, although if we match one of them we get that back in the finish callback but with a further reference added. So, in order to clean it up, use an auto-pointer or we'd end up in leaking it, and the address sanitizer was catching this in our tests already: Indirect leak of 12020 byte(s) in 5 object(s) allocated from: #0 0x7fe8bc638ce6 in calloc (/usr/lib/x86_64-linux-gnu/libasan.so.5+0x10dce6) #1 0x7fe8bc37ffd0 in g_malloc0 ../../glib/glib/gmem.c:132 #2 0x55d100635c01 in load_from_file ../src/file_storage.c:159 #3 0x55d100635c01 in file_storage_print_data_load ../src/file_storage.c:182 #4 0x55d10063e950 in fprint_device_verify_start ../src/device.c:882 #5 0x55d10064036b in dbus_glib_marshal_fprint_device_VOID__STRING_POINTER src/device-dbus-glue.h:96 #6 0x7fe8bc50f6f5 (/usr/lib/x86_64-linux-gnu/libdbus-glib-1.so.2+0xd6f5)
2020-02-12 05:53:36 +01:00
g_autoptr(FpPrint) match = NULL;
main: Use G_DECLARE_FINAL_TYPE to define objet
2020-01-28 18:30:32 +01:00
FprintDevice *rdev = user_data;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDBusDevice *dbus_dev = FPRINT_DBUS_DEVICE (rdev);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
const char *name;
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
gboolean success;
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
success = fp_device_identify_finish (dev, res, &match, NULL, &error);
g_assert (!!success == !error);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
name = verify_result_to_name (match != NULL, error);
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
device: Use proper function name in debug
2020-02-11 01:19:26 +01:00
g_debug("identify_cb: result %s", name);
Stop extra signals from being emitted Some devices keep sending us signals when an enrollment or verification finished. Ignore all those signals, we hate them.
2008-11-26 18:05:22 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
/* Automatically restart the operation for retry failures */
if (error && error->domain == FP_DEVICE_RETRY) {
fp_device_identify (priv->dev,
priv->identify_data,
priv->current_cancellable,
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
match_cb, rdev, NULL,
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
(GAsyncReadyCallback) identify_cb,
rdev);
} else {
g_clear_pointer (&priv->identify_data, g_ptr_array_unref);
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
if (error) {
report_verify_status (rdev, FALSE, error);
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_warning ("Device reported an error during identify: %s",
error->message);
}
}
device: Print warnings for fatal errors
2019-12-04 17:00:01 +01:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
/* Return the cancellation or reset action right away if vanished. */
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
if (priv->current_cancel_invocation) {
fprint_dbus_device_complete_verify_stop (dbus_dev,
g_steal_pointer (&priv->current_cancel_invocation));
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_action = ACTION_NONE;
} else if (g_cancellable_is_cancelled (priv->current_cancellable)) {
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
session = session_data_get (priv);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_action = ACTION_NONE;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session->verify_status_reported = FALSE;
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_clear_object (&priv->current_cancellable);
Fix memleak on VerifyStart Clean up the data pass to the async verification and identification functions ourselves.
2008-11-24 15:23:05 +00:00
}
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static gboolean fprint_device_verify_start (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation,
const char *finger_name)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GPtrArray) gallery = NULL;
g_autoptr(FpPrint) print = NULL;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GError) error = NULL;
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
guint finger_num = finger_name_to_num (finger_name);
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
if (!_fprint_device_check_claimed (rdev, invocation, STATE_CLAIMED, &error)) {
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
Track current action Track the current action happening in the device, so we can see what each device is doing. Refuse to launch a verification if there's already one in progress.
2008-11-03 13:41:45 +00:00
if (priv->current_action != ACTION_NONE) {
Add an enrollment action Return an error if an enrollment is already in progress.
2008-11-03 13:59:48 +00:00
if (priv->current_action == ACTION_ENROLL) {
g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_ALREADY_IN_USE,
"Enrollment in progress");
} else {
g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_ALREADY_IN_USE,
"Verification already in progress");
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
}
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
if (finger_num == -1) {
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_autoptr(GSList) prints = NULL;
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
prints = store.discover_prints(priv->dev, session->username);
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
if (prints == NULL) {
Review possible errors and document them Review all the possible errors and document them for each function.
2008-11-24 14:16:41 +00:00
g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_NO_ENROLLED_PRINTS,
Fix another error path More to do though...
2008-10-31 00:33:33 +00:00
"No fingerprints enrolled");
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (fp_device_supports_identify (priv->dev)) {
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
GSList *l;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
gallery = g_ptr_array_new_with_free_func (g_object_unref);
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
for (l = prints; l != NULL; l = l->next) {
main: Turn messages in debug messages Rather than filling the logs with mostly useless messages, print those as debug.
2018-05-30 19:59:07 +02:00
g_debug ("adding finger %d to the gallery", GPOINTER_TO_INT (l->data));
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
store.print_data_load(priv->dev, GPOINTER_TO_INT (l->data),
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session->username, &print);
More identification work - Add a finger selected signal, so that when an "automatic" finger is selected for verification, we know which one to scan - Fix the finger print numbers list to use GPOINTER_TO_INT / GINT_TO_POINTER - Make sure the gallery is NULL when there's no prints available - Don't use identification when a finger number is provided - Add support for selecting the finger number in verify - Add support for fatal warnings there as well
2008-10-30 22:35:34 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (print)
g_ptr_array_add (gallery, g_steal_pointer (&print));
More identification work - Add a finger selected signal, so that when an "automatic" finger is selected for verification, we know which one to scan - Fix the finger print numbers list to use GPOINTER_TO_INT / GINT_TO_POINTER - Make sure the gallery is NULL when there's no prints available - Don't use identification when a finger number is provided - Add support for selecting the finger number in verify - Add support for fatal warnings there as well
2008-10-30 22:35:34 +00:00
}
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
} else {
More identification work - Add a finger selected signal, so that when an "automatic" finger is selected for verification, we know which one to scan - Fix the finger print numbers list to use GPOINTER_TO_INT / GINT_TO_POINTER - Make sure the gallery is NULL when there's no prints available - Don't use identification when a finger number is provided - Add support for selecting the finger number in verify - Add support for fatal warnings there as well
2008-10-30 22:35:34 +00:00
finger_num = GPOINTER_TO_INT (prints->data);
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
}
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (fp_device_supports_identify (priv->dev) && finger_num == -1) {
if (gallery->len == 0) {
Review possible errors and document them Review all the possible errors and document them for each function.
2008-11-24 14:16:41 +00:00
g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_NO_ENROLLED_PRINTS,
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
"No fingerprints on that device");
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
}
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
priv->current_action = ACTION_IDENTIFY;
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
main: Turn messages in debug messages Rather than filling the logs with mostly useless messages, print those as debug.
2018-05-30 19:59:07 +02:00
g_debug ("start identification device %d", priv->id);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_cancellable = g_cancellable_new ();
priv->identify_data = g_ptr_array_ref (gallery);
device: Adjust to new libfprint API for early match reporting This API was added to libfprint to allow drivers to report the match result early before the operation has been completed. No driver makes use of this facility yet and instead drivers try to finish the operation early for quick result reporting. This primarily means not waiting for finger removal. Once drivers are updated, fprintd reactivity will regress unless the early match callback is implemented as they would only get an operation finished callback when the whole of the operation was finished, including finger removal and finishing up USB communications. See: https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-01-13 16:08:34 +01:00
fp_device_identify (priv->dev, gallery, priv->current_cancellable,
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
match_cb, rdev, NULL,
device: Adjust to new libfprint API for early match reporting This API was added to libfprint to allow drivers to report the match result early before the operation has been completed. No driver makes use of this facility yet and instead drivers try to finish the operation early for quick result reporting. This primarily means not waiting for finger removal. Once drivers are updated, fprintd reactivity will regress unless the early match callback is implemented as they would only get an operation finished callback when the whole of the operation was finished, including finger removal and finishing up USB communications. See: https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-01-13 16:08:34 +01:00
(GAsyncReadyCallback) identify_cb, rdev);
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
} else {
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
priv->current_action = ACTION_VERIFY;
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
main: Turn messages in debug messages Rather than filling the logs with mostly useless messages, print those as debug.
2018-05-30 19:59:07 +02:00
g_debug("start verification device %d finger %d", priv->id, finger_num);
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
store.print_data_load(priv->dev, finger_num,
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session->username, &print);
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (!print) {
device: Throw NoEnrolledPrints on missing finger in gallery Throw a NoEnrolledPrints error if the requested finger isn't present in the gallery.
2020-02-11 02:29:13 +01:00
g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_NO_ENROLLED_PRINTS,
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
"No such print %d", finger_num);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation,
error);
return TRUE;
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
}
More identification work - Add a finger selected signal, so that when an "automatic" finger is selected for verification, we know which one to scan - Fix the finger print numbers list to use GPOINTER_TO_INT / GINT_TO_POINTER - Make sure the gallery is NULL when there's no prints available - Don't use identification when a finger number is provided - Add support for selecting the finger number in verify - Add support for fatal warnings there as well
2008-10-30 22:35:34 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_cancellable = g_cancellable_new ();
priv->verify_data = g_object_ref (print);
device: Adjust to new libfprint API for early match reporting This API was added to libfprint to allow drivers to report the match result early before the operation has been completed. No driver makes use of this facility yet and instead drivers try to finish the operation early for quick result reporting. This primarily means not waiting for finger removal. Once drivers are updated, fprintd reactivity will regress unless the early match callback is implemented as they would only get an operation finished callback when the whole of the operation was finished, including finger removal and finishing up USB communications. See: https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-01-13 16:08:34 +01:00
fp_device_verify (priv->dev, print, priv->current_cancellable,
device: Use early match for reporting verify status libfprint 1.90.1 supports early match result report which allows to inform the clients as soon as the driver detected a match/no-match without having to wait the whole device driver deactivation. Use this feature in fprintd, by emitting the "VerifyStatus" signal as soon as we've an usable result we can inform the client about. As per this, ignore any possible error we may get afterwards, due to device issues or late user cancellation, as the point of the verification action (i.e. getting a match/no-match) can be considered accomplished. Fixes https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-02-12 00:55:21 +01:00
match_cb, rdev, NULL,
device: Adjust to new libfprint API for early match reporting This API was added to libfprint to allow drivers to report the match result early before the operation has been completed. No driver makes use of this facility yet and instead drivers try to finish the operation early for quick result reporting. This primarily means not waiting for finger removal. Once drivers are updated, fprintd reactivity will regress unless the early match callback is implemented as they would only get an operation finished callback when the whole of the operation was finished, including finger removal and finishing up USB communications. See: https://gitlab.freedesktop.org/libfprint/fprintd/issues/35
2020-01-13 16:08:34 +01:00
(GAsyncReadyCallback) verify_cb, rdev);
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
}
Always emit VerifyFingerSelected If the finger passed for verification is -1, always emit the VerifyFingerSelected signal, as the front-end isn't to know whether we're using identification or verification.
2008-10-31 11:53:05 +00:00
/* Emit VerifyFingerSelected telling the front-end which finger
* we selected for auth */
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
g_signal_emit(rdev, signals[SIGNAL_VERIFY_FINGER_SELECTED],
0, finger_num_to_name (finger_num));
Always emit VerifyFingerSelected If the finger passed for verification is -1, always emit the VerifyFingerSelected signal, as the front-end isn't to know whether we're using identification or verification.
2008-10-31 11:53:05 +00:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
fprint_dbus_device_complete_verify_start (dbus_dev, invocation);
return TRUE;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static gboolean fprint_device_verify_stop (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation)
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
{
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_autoptr(GError) error = NULL;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
if (!_fprint_device_check_claimed (rdev, invocation, STATE_CLAIMED, &error)) {
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (priv->current_action == ACTION_NONE) {
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_dbus_method_invocation_return_error_literal (invocation,
FPRINT_ERROR,
FPRINT_ERROR_NO_ACTION_IN_PROGRESS,
"No verification in progress");
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
return TRUE;
device: Throw AlreadyInUse error if stopping an enroll during verification When starting an enroll when verification is in progress (and vice-versa) we emit an AlreadyInUse error, however when calling VerifyStop() during an enrollment (and vice-versa) we just return a NoActionInProgress error, which is not the case. So let's be consistent and change the error type.
2020-02-11 02:09:47 +01:00
} else if (priv->current_action == ACTION_ENROLL) {
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_dbus_method_invocation_return_error_literal (invocation,
FPRINT_ERROR,
FPRINT_ERROR_ALREADY_IN_USE,
"Enrollment in progress");
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
return TRUE;
Add identify support Passing -1 to the VerifyStart function will either accept any fingers scanned, if the driver supports identification, or select the first enrolled fingerprint for scanning if it doesn't.
2008-10-30 19:27:17 +00:00
}
Track current action Track the current action happening in the device, so we can see what each device is doing. Refuse to launch a verification if there's already one in progress.
2008-11-03 13:41:45 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (priv->current_cancellable) {
/* We return only when the action was cancelled */
g_cancellable_cancel (priv->current_cancellable);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
priv->current_cancel_invocation = invocation;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
} else {
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
fprint_dbus_device_complete_verify_stop (dbus_dev, invocation);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_action = ACTION_NONE;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
session->verify_status_reported = FALSE;
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
return TRUE;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
}
device: Restart verification if error is "retry" fprintd's API docs say that "retry" errors for verification "the verification is still ongoing" and that "[the] user should retry scanning their finger. Unfortunately, retry errors are fatal in libfprint. Make fprintd restart operations when "retry" is the error for either identification or verification purposes. We need to also make sure that a "*Stop" D-Bus call will return as normal if called while we're stopping a verification or identification in order to restart it. Closes: #22
2019-08-07 15:27:37 +02:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
static void enroll_progress_cb(FpDevice *dev,
gint completed_stages,
FpPrint *print,
gpointer user_data,
GError *error)
{
main: Use G_DECLARE_FINAL_TYPE to define objet
2020-01-28 18:30:32 +01:00
FprintDevice *rdev = user_data;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
const char *name = enroll_result_to_name (FALSE, FALSE, error);
Track current action Track the current action happening in the device, so we can see what each device is doing. Refuse to launch a verification if there's already one in progress.
2008-11-03 13:41:45 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_debug("enroll_stage_cb: result %s", name);
if (completed_stages < fp_device_get_nr_enroll_stages (dev))
g_signal_emit(rdev, signals[SIGNAL_ENROLL_STATUS], 0, name, FALSE);
}
device: Handle full device storage including garbage collection The new libfprint version has support for devices that store data on the sensor. In that case, the on-sensor storage might fill up when the user tries to enroll a new print. The strategy introduced here to handle this is to try and delete prints from the device that we do not know about (assuming, it is e.g. from an old installation and unusable). It can also happen that we are not able to garbage collect old prints. If that happens, a new error code "enroll-data-full" will be returned signalling the situation to the enrolling application.
2019-07-31 16:00:39 +02:00
static gboolean try_delete_print(FprintDevice *rdev)
{
g_autoptr(GError) error = NULL;
g_autoptr(GPtrArray) device_prints = NULL;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Handle full device storage including garbage collection The new libfprint version has support for devices that store data on the sensor. In that case, the on-sensor storage might fill up when the user tries to enroll a new print. The strategy introduced here to handle this is to try and delete prints from the device that we do not know about (assuming, it is e.g. from an old installation and unusable). It can also happen that we are not able to garbage collect old prints. If that happens, a new error code "enroll-data-full" will be returned signalling the situation to the enrolling application.
2019-07-31 16:00:39 +02:00
GSList *users, *user;
device_prints = fp_device_list_prints_sync (priv->dev, NULL, &error);
if (!device_prints) {
g_warning ("Failed to query prints: %s", error->message);
return FALSE;
}
g_debug ("Device has %d prints stored", device_prints->len);
users = store.discover_users();
for (user = users; user; user = user->next) {
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
const char *username = user->data;
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_autoptr(GSList) fingers = NULL;
GSList *finger;
device: Handle full device storage including garbage collection The new libfprint version has support for devices that store data on the sensor. In that case, the on-sensor storage might fill up when the user tries to enroll a new print. The strategy introduced here to handle this is to try and delete prints from the device that we do not know about (assuming, it is e.g. from an old installation and unusable). It can also happen that we are not able to garbage collect old prints. If that happens, a new error code "enroll-data-full" will be returned signalling the situation to the enrolling application.
2019-07-31 16:00:39 +02:00
fingers = store.discover_prints (priv->dev, username);
for (finger = fingers; finger; finger = finger->next) {
g_autoptr(FpPrint) print = NULL;
guint index;
store.print_data_load (priv->dev,
GPOINTER_TO_INT (fingers->data),
username,
&print);
if (!print)
continue;
if (!g_ptr_array_find_with_equal_func (device_prints,
print,
(GEqualFunc) fp_print_equal,
&index))
continue;
/* Found an equal print, remove it */
g_ptr_array_remove_index (device_prints, index);
}
}
g_slist_free_full (users, g_free);
g_debug ("Device has %d prints stored that we do not need", device_prints->len);
if (device_prints->len == 0)
return FALSE;
/* Just delete the first print in the list at this point.
* We could be smarter and fetch some more metadata. */
fp_device_delete_print_sync (priv->dev,
g_ptr_array_index (device_prints, 0),
NULL,
&error);
if (error) {
g_warning ("Failed to garbage collect a print: %s", error->message);
return FALSE;
}
return TRUE;
}
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
#if !GLIB_CHECK_VERSION (2, 63, 3)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GDate, g_date_free);
#endif
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
static FpPrint*
fprint_device_create_enroll_template(FprintDevice *rdev, gint finger_num)
{
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_autoptr(GDateTime) datetime = NULL;
g_autoptr(GDate) date = NULL;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
FpPrint *template = NULL;
gint year, month, day;
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
template = fp_print_new (priv->dev);
fp_print_set_finger (template, finger_num);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
fp_print_set_username (template, session->username);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
datetime = g_date_time_new_now_local ();
g_date_time_get_ymd (datetime, &year, &month, &day);
date = g_date_new_dmy (day, month, year);
fp_print_set_enroll_date (template, date);
return template;
Move to object oriented model There is now a single Manager class shared between all apps. Apps then share a collection of Device objects.
2008-03-05 20:00:28 +00:00
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
static void enroll_cb(FpDevice *dev, GAsyncResult *res, void *user_data)
Add enrollment functionality
2008-03-06 16:37:19 +00:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GError) error = NULL;
main: Use G_DECLARE_FINAL_TYPE to define objet
2020-01-28 18:30:32 +01:00
FprintDevice *rdev = user_data;
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDBusDevice *dbus_dev = FPRINT_DBUS_DEVICE (rdev);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(FpPrint) print = NULL;
const char *name;
Add enrollment functionality
2008-03-06 16:37:19 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
print = fp_device_enroll_finish (dev, res, &error);
device: Handle full device storage including garbage collection The new libfprint version has support for devices that store data on the sensor. In that case, the on-sensor storage might fill up when the user tries to enroll a new print. The strategy introduced here to handle this is to try and delete prints from the device that we do not know about (assuming, it is e.g. from an old installation and unusable). It can also happen that we are not able to garbage collect old prints. If that happens, a new error code "enroll-data-full" will be returned signalling the situation to the enrolling application.
2019-07-31 16:00:39 +02:00
/* We need to special case the issue where the on device storage
* is completely full. In that case, we check whether we can delete
* a print that is not coming from us; assuming it is from an old
* installation.
* We do this synchronously, which is not great but should be good
* enough. */
if (g_error_matches (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_FULL)) {
g_debug ("Device storage is full, trying to garbage collect old prints");
if (try_delete_print (rdev)) {
/* Success? Then restart the operation */
fp_device_enroll (priv->dev,
fprint_device_create_enroll_template (rdev, priv->enroll_data),
priv->current_cancellable,
enroll_progress_cb,
rdev,
NULL,
(GAsyncReadyCallback) enroll_cb,
rdev);
return;
}
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
name = enroll_result_to_name (TRUE, print != NULL, error);
g_debug ("enroll_cb: result %s", name);
Stop extra signals from being emitted Some devices keep sending us signals when an enrollment or verification finished. Ignore all those signals, we hate them.
2008-11-26 18:05:22 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (print) {
int r;
r = store.print_data_save(print);
Save using storage Save the fingerprint using the storage functions so we can verify the data we enroll.
2008-05-20 11:20:11 +01:00
if (r < 0)
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
name = "enroll-failed";
Save using storage Save the fingerprint using the storage functions so we can verify the data we enroll.
2008-05-20 11:20:11 +01:00
}
Add enrollment functionality
2008-03-06 16:37:19 +00:00
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_signal_emit(rdev, signals[SIGNAL_ENROLL_STATUS], 0, name, TRUE);
Stop extra signals from being emitted Some devices keep sending us signals when an enrollment or verification finished. Ignore all those signals, we hate them.
2008-11-26 18:05:22 +00:00
device: Print warnings for fatal errors
2019-12-04 17:00:01 +01:00
if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Device reported an error during enroll: %s", error->message);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
/* Return the cancellation or reset action right away if vanished. */
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
if (priv->current_cancel_invocation) {
fprint_dbus_device_complete_enroll_stop (dbus_dev,
g_steal_pointer (&priv->current_cancel_invocation));
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_action = ACTION_NONE;
} else if (g_cancellable_is_cancelled (priv->current_cancellable)) {
priv->current_action = ACTION_NONE;
}
g_clear_object (&priv->current_cancellable);
Add enrollment functionality
2008-03-06 16:37:19 +00:00
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static gboolean fprint_device_enroll_start (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation,
const char *finger_name)
Add enrollment functionality
2008-03-06 16:37:19 +00:00
{
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
g_autoptr(GError) error = NULL;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
int finger_num = finger_name_to_num (finger_name);
Add enrollment functionality
2008-03-06 16:37:19 +00:00
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
if (!_fprint_device_check_claimed (rdev, invocation, STATE_CLAIMED, &error)) {
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
if (finger_num == -1) {
Review possible errors and document them Review all the possible errors and document them for each function.
2008-11-24 14:16:41 +00:00
g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_INVALID_FINGERNAME,
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
"Invalid finger name");
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
}
Add an enrollment action Return an error if an enrollment is already in progress.
2008-11-03 13:59:48 +00:00
if (priv->current_action != ACTION_NONE) {
if (priv->current_action == ACTION_ENROLL) {
g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_ALREADY_IN_USE,
"Enrollment already in progress");
} else {
g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_ALREADY_IN_USE,
"Verification in progress");
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
Add an enrollment action Return an error if an enrollment is already in progress.
2008-11-03 13:59:48 +00:00
}
main: Turn messages in debug messages Rather than filling the logs with mostly useless messages, print those as debug.
2018-05-30 19:59:07 +02:00
g_debug("start enrollment device %d finger %d", priv->id, finger_num);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_cancellable = g_cancellable_new ();
device: Handle full device storage including garbage collection The new libfprint version has support for devices that store data on the sensor. In that case, the on-sensor storage might fill up when the user tries to enroll a new print. The strategy introduced here to handle this is to try and delete prints from the device that we do not know about (assuming, it is e.g. from an old installation and unusable). It can also happen that we are not able to garbage collect old prints. If that happens, a new error code "enroll-data-full" will be returned signalling the situation to the enrolling application.
2019-07-31 16:00:39 +02:00
priv->enroll_data = finger_num;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
fp_device_enroll (priv->dev,
fprint_device_create_enroll_template (rdev, priv->enroll_data),
priv->current_cancellable,
enroll_progress_cb,
rdev,
NULL,
(GAsyncReadyCallback) enroll_cb,
rdev);
Add enrollment functionality
2008-03-06 16:37:19 +00:00
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
priv->current_action = ACTION_ENROLL;
Add an enrollment action Return an error if an enrollment is already in progress.
2008-11-03 13:59:48 +00:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
fprint_dbus_device_complete_enroll_start (dbus_dev, invocation);
return TRUE;
Add enrollment functionality
2008-03-06 16:37:19 +00:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static gboolean fprint_device_enroll_stop (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation)
Add enrollment functionality
2008-03-06 16:37:19 +00:00
{
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
g_autoptr(GError) error = NULL;
if (!_fprint_device_check_claimed (rdev, invocation, STATE_CLAIMED, &error)) {
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
Add enrollment functionality
2008-03-06 16:37:19 +00:00
Add an enrollment action Return an error if an enrollment is already in progress.
2008-11-03 13:59:48 +00:00
if (priv->current_action != ACTION_ENROLL) {
device: Throw AlreadyInUse error if stopping an enroll during verification When starting an enroll when verification is in progress (and vice-versa) we emit an AlreadyInUse error, however when calling VerifyStop() during an enrollment (and vice-versa) we just return a NoActionInProgress error, which is not the case. So let's be consistent and change the error type.
2020-02-11 02:09:47 +01:00
if (priv->current_action == ACTION_NONE) {
g_set_error (&error, FPRINT_ERROR, FPRINT_ERROR_NO_ACTION_IN_PROGRESS,
"No enrollment in progress");
} else if (priv->current_action == ACTION_VERIFY) {
g_set_error (&error, FPRINT_ERROR, FPRINT_ERROR_ALREADY_IN_USE,
"Verification in progress");
} else if (priv->current_action == ACTION_IDENTIFY) {
g_set_error (&error, FPRINT_ERROR, FPRINT_ERROR_ALREADY_IN_USE,
"Identification in progress");
} else
g_assert_not_reached ();
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
Add an enrollment action Return an error if an enrollment is already in progress.
2008-11-03 13:59:48 +00:00
}
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
if (priv->current_cancellable) {
/* We return only when the action was cancelled */
g_cancellable_cancel (priv->current_cancellable);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
priv->current_cancel_invocation = invocation;
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
} else {
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
fprint_dbus_device_complete_enroll_stop (dbus_dev, invocation);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
priv->current_action = ACTION_NONE;
Add enrollment functionality
2008-03-06 16:37:19 +00:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
return TRUE;
Add enrollment functionality
2008-03-06 16:37:19 +00:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static gboolean fprint_device_list_enrolled_fingers (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation,
const char *username)
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
{
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_autoptr (GPtrArray) ret = NULL;
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_autoptr(GSList) prints = NULL;
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
GSList *item;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
const char *sender;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
const char *user;
Add PolicyKit checking Add PolicyKit checks to all the public functions, grouped in 2 main groups: Verify and Enroll By default, only the user is able to enroll new fingers, or verify themselves. You need to be allowed at least one of those 2 actions to be allowed to claim or release the device. We also add a new SetUsername function, for administration functions. Users will need to be authenticate as admins to be allowed to change the username on which the actions will be taken. Any prints loaded before the change of username will be unloaded.
2008-05-21 14:36:36 +01:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
sender = g_dbus_method_invocation_get_sender (invocation);
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
_fprint_device_add_client (rdev, sender);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
user = g_object_get_qdata (G_OBJECT (invocation), quark_auth_user);
g_assert (user);
Initial port to libfprint2
2019-07-30 19:45:50 +02:00
prints = store.discover_prints(priv->dev, user);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
if (!prints) {
device: Always use auto-pointers Remove manual memory management when possible, using new GLib facilities In a few cases, avoid creating a temporary GError instead.
2020-01-29 22:14:36 +01:00
g_dbus_method_invocation_return_error_literal (invocation,
FPRINT_ERROR,
FPRINT_ERROR_NO_ENROLLED_PRINTS,
"Failed to discover prints");
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
return TRUE;
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
}
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
ret = g_ptr_array_new ();
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
for (item = prints; item; item = item->next) {
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
int finger_num = GPOINTER_TO_INT (item->data);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_ptr_array_add (ret, (char *) finger_num_to_name (finger_num));
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
}
Remove use of finger number in the API Use well-defined strings instead of numbers to pass around specific fingers in the public API.
2008-11-19 20:05:54 +00:00
g_ptr_array_add (ret, NULL);
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
fprint_dbus_device_complete_list_enrolled_fingers (dbus_dev,
invocation, (const gchar *const *) ret->pdata);
return TRUE;
Initial storage implementation [dsd: changed from /etc/fprint to /var/lib/fprint] Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>
2008-04-07 01:12:44 +03:00
}
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
static void delete_enrolled_fingers(FprintDevice *rdev, const char *user)
{
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
guint i;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
g_debug ("Deleting enrolled fingers for user %s", user);
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
/* First try deleting the print from the device, we don't consider it
* fatal if this does not work. */
if (fp_device_has_storage (priv->dev)) {
g_autoptr(GSList) prints = NULL;
GSList *l;
prints = store.discover_prints(priv->dev, user);
for (l = prints; l != NULL; l = l->next) {
g_autoptr(FpPrint) print = NULL;
store.print_data_load(priv->dev,
GPOINTER_TO_INT (l->data),
user,
&print);
if (print) {
g_autoptr(GError) error = NULL;
if (!fp_device_delete_print_sync (priv->dev, print, NULL, &error)) {
g_warning ("Error deleting print from device: %s", error->message);
g_warning ("This might indicate an issue in the libfprint driver or in the fingerprint device.");
}
}
}
}
file-storage: Use first/last fingers references instead of named ones Don't depend in the hardcoded libfprint fingers order, but use instead the aliases for first/last fingers in libfprint order
2019-12-18 17:32:52 +01:00
for (i = FP_FINGER_FIRST; i <= FP_FINGER_LAST; i++) {
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
store.print_data_delete(priv->dev, i, user);
}
}
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
#ifdef __linux__
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static void log_offending_client_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
{
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
GDBusConnection *connection = G_DBUS_CONNECTION (object);
g_autoptr(GVariant) ret = NULL;
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
g_autofree char *path = NULL;
g_autofree char *content = NULL;
guint pid = 0;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
ret = g_dbus_connection_call_finish (connection, res, NULL);
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
if (!ret)
return;
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_variant_get (ret, "(u)", &pid);
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
path = g_strdup_printf ("/proc/%u/comm", pid);
if (g_file_get_contents (path, &content, NULL, NULL)) {
g_strchomp (content);
g_warning ("Offending API user is %s", content);
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
}
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static void log_offending_client (GDBusMethodInvocation *invocation)
{
const char *sender;
GDBusConnection *connection;
connection = g_dbus_method_invocation_get_connection (invocation);
sender = g_dbus_method_invocation_get_sender (invocation);
g_dbus_connection_call (connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"GetConnectionUnixProcessID",
g_variant_new ("(s)", sender),
NULL, G_DBUS_CALL_FLAGS_NONE,
-1, NULL, log_offending_client_cb, NULL);
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
}
#endif
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static gboolean fprint_device_delete_enrolled_fingers (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation,
const char *username)
Add DeleteEnrolledFingers To delete all the enrolled finger prints for a particular user. We can already overwrite existing enrolled fingerprints, and there's not really any point in dismissing just one fingerprint.
2008-10-29 15:47:36 +00:00
{
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Always free error in delete enrolled fingers During delete enrolled fingers call, if the check-claimed control fails, and we get an error different from FPRINT_ERROR_CLAIM_DEVICE, we would return the error without freeing it. While this could be fixed by just a further g_error_free call, let's just remove all the manual free calls, and use an auto-pointer instead for this function.
2020-01-29 22:14:36 +01:00
g_autoptr(GError) error = NULL;
device: Don't leak the user on claim error while deleting prints When using the delete method we check if the device was claimed, if this fails because the device is already in use we return an error, but we don't free the user. While this could be fixed by just a further g_free call, let's just remove remove the other manual free calls, and use an auto-pointer instead for this function.
2020-02-06 14:18:16 +01:00
g_autofree char *user = NULL;
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
const char *sender;
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
gboolean opened;
g_warning ("The API user should be updated to use DeleteEnrolledFingers2 method!");
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
#ifdef __linux__
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
log_offending_client (invocation);
device: Log offending API user if DeleteEnrolledFinger is used When the DeleteEnrolledFinger API is used, log an additional warning with the command that made the call.
2019-12-02 15:38:10 +01:00
#endif
Add DeleteEnrolledFingers To delete all the enrolled finger prints for a particular user. We can already overwrite existing enrolled fingerprints, and there's not really any point in dismissing just one fingerprint.
2008-10-29 15:47:36 +00:00
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
user = g_object_steal_qdata (G_OBJECT (invocation), quark_auth_user);
g_assert (user);
Add DeleteEnrolledFingers To delete all the enrolled finger prints for a particular user. We can already overwrite existing enrolled fingerprints, and there's not really any point in dismissing just one fingerprint.
2008-10-29 15:47:36 +00:00
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
if (!_fprint_device_check_claimed (rdev, invocation, STATE_CLAIMED,
&error)) {
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
/* Return error for anything but FPRINT_ERROR_CLAIM_DEVICE */
if (!g_error_matches (error, FPRINT_ERROR, FPRINT_ERROR_CLAIM_DEVICE)) {
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
g_dbus_method_invocation_return_gerror (invocation,
error);
return TRUE;
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
}
opened = FALSE;
} else {
opened = TRUE;
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
sender = g_dbus_method_invocation_get_sender (invocation);
Clean up device when the client disconnects Track clients connected to each device using EggDbusMonitor. When there are no more clients connected to the device, release it. When no devices are used anymore, set up a timeout to exit within 30 seconds.
2008-11-03 17:20:59 +00:00
_fprint_device_add_client (rdev, sender);
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
if (!opened && fp_device_has_storage (priv->dev))
fp_device_open_sync (priv->dev, NULL, NULL);
delete_enrolled_fingers (rdev, user);
if (!opened && fp_device_has_storage (priv->dev))
fp_device_close_sync (priv->dev, NULL, NULL);
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
fprint_dbus_device_complete_delete_enrolled_fingers (dbus_dev,
invocation);
return TRUE;
Add DeleteEnrolledFingers To delete all the enrolled finger prints for a particular user. We can already overwrite existing enrolled fingerprints, and there's not really any point in dismissing just one fingerprint.
2008-10-29 15:47:36 +00:00
}
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static gboolean fprint_device_delete_enrolled_fingers2 (FprintDBusDevice *dbus_dev,
GDBusMethodInvocation *invocation)
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
{
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
device: Replace deprecated g_type_class_add_private()
2020-01-13 11:05:37 +01:00
FprintDevicePrivate *priv = fprint_device_get_instance_private(rdev);
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
g_autoptr(SessionData) session = NULL;
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
g_autoptr(GError) error = NULL;
if (!_fprint_device_check_claimed (rdev, invocation, STATE_CLAIMED, &error)) {
g_dbus_method_invocation_return_gerror (invocation, error);
return TRUE;
}
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
session = session_data_get (priv);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
device: Implement lock-free session getting scheme Add a scheme that allows getting and referencing the current session data while also adding a reference at the same time. This allows getting the session and using the constant attributes from outside the main thread without worrying about it being destroyed. Implement the getter/setter in a safe way by marking the pointer as invalid while we get the reference.
2020-11-09 17:27:27 +01:00
delete_enrolled_fingers (rdev, session->username);
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
fprint_dbus_device_complete_delete_enrolled_fingers2 (dbus_dev,
invocation);
return TRUE;
}
static gboolean
handle_unauthorized_access (FprintDevice *rdev,
GDBusMethodInvocation *invocation,
GError *error)
{
FprintDevicePrivate *priv = fprint_device_get_instance_private (rdev);
g_assert (error);
g_warning ("Client %s not authorized for device %s: %s",
g_dbus_method_invocation_get_sender (invocation),
fp_device_get_name (priv->dev),
error->message);
g_dbus_method_invocation_return_gerror (invocation, error);
return FALSE;
}
static gboolean
action_authorization_handler (GDBusInterfaceSkeleton *interface,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
FprintDBusDevice *dbus_dev = FPRINT_DBUS_DEVICE (interface);
FprintDevice *rdev = FPRINT_DEVICE (dbus_dev);
FprintDevicePrivate *priv = fprint_device_get_instance_private (rdev);
FprintDeviceClaimState required_state = STATE_IGNORED;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
FprintDevicePermission required_perms = FPRINT_DEVICE_PERMISSION_NONE;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
gboolean needs_user_auth = FALSE;
device: Always free error in delete enrolled fingers2 During delete enrolled fingers2 call, if the check-claimed control fails, we would return the error without freeing it. While this could be fixed by just a further g_error_free call, let's just remove the other manual free call, and use an auto-pointer instead for this function.
2020-02-04 19:47:56 +01:00
g_autoptr(GError) error = NULL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
const gchar *method_name;
method_name = g_dbus_method_invocation_get_method_name (invocation);
g_debug ("Requesting device '%s' authorization for method %s from %s",
fp_device_get_name (priv->dev), method_name,
g_dbus_method_invocation_get_sender (invocation));
if (g_str_equal (method_name, "Claim")) {
needs_user_auth = TRUE;
required_state = STATE_UNCLAIMED;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_VERIFY;
required_perms |= FPRINT_DEVICE_PERMISSION_ENROLL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else if (g_str_equal (method_name, "DeleteEnrolledFingers")) {
needs_user_auth = TRUE;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_ENROLL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else if (g_str_equal (method_name, "DeleteEnrolledFingers2")) {
required_state = STATE_CLAIMED;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_ENROLL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else if (g_str_equal (method_name, "EnrollStart")) {
required_state = STATE_CLAIMED;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_ENROLL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else if (g_str_equal (method_name, "EnrollStop")) {
required_state = STATE_CLAIMED;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_ENROLL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else if (g_str_equal (method_name, "ListEnrolledFingers")) {
needs_user_auth = TRUE;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_VERIFY;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else if (g_str_equal (method_name, "Release")) {
required_state = STATE_CLAIMED;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_VERIFY;
required_perms |= FPRINT_DEVICE_PERMISSION_ENROLL;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else if (g_str_equal (method_name, "VerifyStart")) {
required_state = STATE_CLAIMED;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_VERIFY;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else if (g_str_equal (method_name, "VerifyStop")) {
required_state = STATE_CLAIMED;
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
required_perms |= FPRINT_DEVICE_PERMISSION_VERIFY;
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
} else {
g_assert_not_reached ();
}
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
device: Fix possible race condition when checking claimed state We already check the claimed state in advance during authorization. This makes sense, as we can avoid authorization if the API has been used incorrectly. However, as the mainloop is running and handling other request the claimed state might change at any point until the method handler is actually running. As such, check the claimed state again in each method. Doing so fixes the possible race condition.
2020-11-09 14:59:33 +01:00
/* This is just a quick check in order to avoid authentication if
* the user cannot make the call at this time anyway.
* The method handler itself is required to check again! */
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
if (!_fprint_device_check_claimed (rdev, invocation, required_state,
&error)) {
return handle_unauthorized_access (rdev, invocation, error);
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
}
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
if (needs_user_auth &&
!fprintd_device_authorize_user (rdev, invocation, &error)) {
return handle_unauthorized_access (rdev, invocation, error);
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
}
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
/* This may possibly block the invocation till the user has not
* provided an authentication method, so other calls could arrive */
device: Use GFlags to handle permission types easily as flags And thanks to the GEnumValues we can easily get their nick string from them that we can pass to Polkit
2020-11-06 18:22:15 +01:00
if (!fprint_device_check_polkit_for_permissions (rdev, invocation,
required_perms,
&error)) {
device: Check Polkit actions asynchronously using skeleton authorize method GDBus generated interface skeletons support natively an authorization method that allows to filter calls before we get into the method callback and that gets called into the call thread, before we go back to main thread. As per this, we can move all the polkit and other authorization checks into this callback so that method handlers are now just assuming they're the right to perform the requested operation. As per the fact we'll share some data between another thread and the callbacks, we will need to introduce some locking mechanism to ensure safe data access. This might be reduced by moving the claiming checks back to the method, but would lead errors to be handled in different ordering, and so the user to be requested for a password, and then - in case fail. This can still happen now, but only if there are concurrent requests.
2020-11-05 21:01:25 +01:00
return handle_unauthorized_access (rdev, invocation, error);
}
g_debug ("Authorization granted to %s for device %s!",
fp_device_get_name (priv->dev),
g_dbus_method_invocation_get_sender (invocation));
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
return TRUE;
}
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
fprintd: Use GDBus codegen based implementation Fprintd is dependent on the deprecated dbus-glib, also this doesn't provide various features we can take advantage of, like the ones for async authentication mechanism. So, remove all the dbus-glib dependencies and simplify the code, but without any further refactor, and keeping everything as it used to work, while this will give room for further improvements in subsequent commits. Internally, we just use dbus-codegen to generate the skeletons, and we use the generated FprintdDBusManager with composition, while we implement the device skeleton interface in FprintDevice, so that we don't have to use it as a proxy, and keep being closer to what it used to be with dbus-glib. Fixes: #61
2020-02-03 20:29:56 +01:00
static void fprint_device_dbus_skeleton_iface_init (FprintDBusDeviceIface *iface)
{
iface->handle_claim = fprint_device_claim;
iface->handle_delete_enrolled_fingers = fprint_device_delete_enrolled_fingers;
iface->handle_delete_enrolled_fingers2 = fprint_device_delete_enrolled_fingers2;
iface->handle_enroll_start = fprint_device_enroll_start;
iface->handle_enroll_stop = fprint_device_enroll_stop;
iface->handle_list_enrolled_fingers = fprint_device_list_enrolled_fingers;
iface->handle_release = fprint_device_release;
iface->handle_verify_start = fprint_device_verify_start;
iface->handle_verify_stop = fprint_device_verify_stop;
device: Add new API and fallback to delete prints from device Some devices require storing the print on the device, to support this, try deleting prints from the device before deleting them from local storage. To handle these devices, add a new API that requires the device to be claimed rather than allowing deletion without claiming the device first. Also add appropriate fallbacks so that the old API will continue to work, but warn about its use.
2019-08-13 13:03:13 +02:00
}
Reference in a new issue Copy permalink