cookiez/pam-fprint-grosshack
1
0
Fork 0
mirror of https://gitlab.com/mishakmak/pam-fprint-grosshack.git synced 2026-04-08 20:03:34 +02:00
Code Issues Packages Projects Releases Wiki Activity

fprintd: Use GDBus codegen based implementation

Browse Source 
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
This commit is contained in:
Marco Trevisan (Treviño)
2020-02-03 20:29:56 +01:00
committed by Benjamin Berg
parent e224913b80
commit 93bad82540
15 changed files with 750 additions and 588 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
utils/delete.c
View File

@ -1,6 +1,7 @@
/*
* fprintd example to delete fingerprints
* Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>
* Copyright (C) 2020 Marco Trevisan <marco.trevisan@canonical.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -20,109 +21,115 @@
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <dbus/dbus-glib-bindings.h>
#include "manager-dbus-glue.h"
#include "device-dbus-glue.h"
#include "fprintd-dbus.h"
static DBusGProxy *manager = NULL;
static DBusGConnection *connection = NULL;
static FprintDBusManager *manager = NULL;
static GDBusConnection *connection = NULL;
static void create_manager(void)
{
GError *error = NULL;
connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (connection == NULL) {
g_print("Failed to connect to session bus: %s\n", error->message);
exit (1);
}
manager = dbus_g_proxy_new_for_name(connection,
"net.reactivated.Fprint", "/net/reactivated/Fprint/Manager",
"net.reactivated.Fprint.Manager");
}
static void delete_fingerprints(DBusGProxy *dev, const char *username)
{
GError *error = NULL;
GHashTable *props;
DBusGProxy *p;
p = dbus_g_proxy_new_from_proxy(dev, "org.freedesktop.DBus.Properties", NULL);
if (!dbus_g_proxy_call (p, "GetAll", &error, G_TYPE_STRING, "net.reactivated.Fprint.Device", G_TYPE_INVALID,
dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &props, G_TYPE_INVALID)) {
g_print("GetAll on the Properties interface failed: %s\n", error->message);
manager = fprint_dbus_manager_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
"net.reactivated.Fprint",
"/net/reactivated/Fprint/Manager",
NULL, &error);
if (manager == NULL) {
g_print ("Failed to get Fprintd manager: %s\n", error->message);
exit (1);
}
}
if (!net_reactivated_Fprint_Device_claim(dev, username, &error)) {
static void delete_fingerprints (FprintDBusDevice *dev, const char *username)
{
GError *error = NULL;
if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error)) {
g_print("failed to claim device: %s\n", error->message);
exit (1);
}
if (!net_reactivated_Fprint_Device_delete_enrolled_fingers2(dev, &error)) {
if (dbus_g_error_has_name (error, "net.reactivated.Fprint.Error.NoEnrolledPrints") == FALSE) {
g_print("ListEnrolledFingers failed: %s\n", error->message);
if (!fprint_dbus_device_call_delete_enrolled_fingers2_sync (dev, NULL,
&error)) {
gboolean ignore_error = FALSE;
if (g_dbus_error_is_remote_error (error)) {
g_autofree char *dbus_error =
g_dbus_error_get_remote_error (error);
if (g_str_equal (dbus_error,
"net.reactivated.Fprint.Error.NoEnrolledPrints")) {
g_print ("No fingerprints to delete on %s\n",
fprint_dbus_device_get_name (dev));
ignore_error = TRUE;
}
}
if (!ignore_error) {
g_print("ListEnrolledFingers failed: %s\n",
error->message);
exit (1);
} else {
g_print ("No fingerprints to delete on %s\n", g_value_get_string (g_hash_table_lookup (props, "name")));
g_print ("No fingerprints to delete on %s\n",
fprint_dbus_device_get_name (dev));
g_clear_error (&error);
}
} else {
g_print ("Fingerprints deleted on %s\n", g_value_get_string (g_hash_table_lookup (props, "name")));
g_print ("Fingerprints deleted on %s\n",
fprint_dbus_device_get_name (dev));
}
if (!net_reactivated_Fprint_Device_release(dev, &error)) {
if (!fprint_dbus_device_call_release_sync (dev, NULL, &error)) {
g_print("ReleaseDevice failed: %s\n", error->message);
exit (1);
}
g_hash_table_destroy (props);
g_object_unref (p);
}
static void process_devices(char **argv)
{
GError *error = NULL;
GPtrArray *devices;
g_auto(GStrv) devices = NULL;
char *path;
guint num_devices;
guint i;
if (!net_reactivated_Fprint_Manager_get_devices(manager, &devices, &error)) {
if (!fprint_dbus_manager_call_get_devices_sync (manager, &devices,
NULL, &error)) {
g_print("Impossible to get devices: %s\n", error->message);
exit (1);
}
if (devices->len == 0) {
num_devices = g_strv_length (devices);
if (num_devices == 0) {
g_print("No devices available\n");
exit(1);
}
g_print("found %d devices\n", devices->len);
for (i = 0; i < devices->len; i++) {
path = g_ptr_array_index(devices, i);
g_print ("found %u devices\n", num_devices);
for (i = 0; devices[i] != NULL; i++) {
path = devices[i];
g_print("Device at %s\n", path);
}
for (i = 0; i < devices->len; i++) {
for (i = 0; devices[i] != NULL; i++) {
g_autoptr(FprintDBusDevice) dev = NULL;
guint j;
DBusGProxy *dev;
path = g_ptr_array_index(devices, i);
path = devices[i];
g_print("Using device %s\n", path);
/* FIXME use for_name_owner?? */
dev = dbus_g_proxy_new_for_name(connection, "net.reactivated.Fprint",
path, "net.reactivated.Fprint.Device");
dev = fprint_dbus_device_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
"net.reactivated.Fprint",
path, NULL, &error);
for (j = 1; argv[j] != NULL; j++)
delete_fingerprints (dev, argv[j]);
g_object_unref (dev);
}
g_ptr_array_foreach(devices, (GFunc) g_free, NULL);
g_ptr_array_free(devices, TRUE);
}
int main(int argc, char **argv)

88
utils/enroll.c
View File

@ -1,6 +1,7 @@
/*
* fprintd example to enroll right index finger
* Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>
* Copyright (C) 2020 Marco Trevisan <marco.trevisan@canonical.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -21,17 +22,14 @@
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <dbus/dbus-glib-bindings.h>
#include "manager-dbus-glue.h"
#include "device-dbus-glue.h"
#include "fprintd-marshal.h"
#include "fprintd-dbus.h"
#define N_(x) x
#define TR(x) x
#include "fingerprint-strings.h"
static DBusGProxy *manager = NULL;
static DBusGConnection *connection = NULL;
static FprintDBusManager *manager = NULL;
static GDBusConnection *connection = NULL;
static char *finger_name = NULL;
static char **usernames = NULL;
@ -39,41 +37,54 @@ static void create_manager(void)
{
GError *error = NULL;
connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (connection == NULL) {
g_print("Failed to connect to session bus: %s\n", error->message);
exit (1);
}
manager = dbus_g_proxy_new_for_name(connection,
"net.reactivated.Fprint", "/net/reactivated/Fprint/Manager",
"net.reactivated.Fprint.Manager");
manager = fprint_dbus_manager_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
"net.reactivated.Fprint",
"/net/reactivated/Fprint/Manager",
NULL, &error);
if (manager == NULL) {
g_print ("Failed to get Fprintd manager: %s\n", error->message);
exit (1);
}
}
static DBusGProxy *open_device(const char *username)
static FprintDBusDevice *open_device (const char *username)
{
g_autoptr(FprintDBusDevice) dev = NULL;
GError *error = NULL;
gchar *path;
DBusGProxy *dev;
if (!net_reactivated_Fprint_Manager_get_default_device(manager, &path, &error)) {
if (!fprint_dbus_manager_call_get_default_device_sync (manager, &path,
NULL, &error)) {
g_print("Impossible to enroll: %s\n", error->message);
exit (1);
}
g_print("Using device %s\n", path);
/* FIXME use for_name_owner?? */
dev = dbus_g_proxy_new_for_name(connection, "net.reactivated.Fprint",
path, "net.reactivated.Fprint.Device");
dev = fprint_dbus_device_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
"net.reactivated.Fprint",
path, NULL, &error);
g_free (path);
if (!net_reactivated_Fprint_Device_claim(dev, username, &error)) {
if (error) {
g_print ("failed to connect to device: %s\n", error->message);
exit (1);
}
if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error)) {
g_print("failed to claim device: %s\n", error->message);
exit (1);
}
return dev;
return g_steal_pointer (&dev);
}
static void enroll_result(GObject *object, const char *result, gboolean done, void *user_data)
@ -84,16 +95,30 @@ static void enroll_result(GObject *object, const char *result, gboolean done, vo
*enroll_completed = TRUE;
}
static void do_enroll(DBusGProxy *dev)
static void proxy_signal_cb (GDBusProxy *proxy,
const gchar *sender_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
if (g_str_equal (signal_name, "EnrollStatus")) {
const gchar *result;
gboolean done;
g_variant_get (parameters, "(&sb)", &result, &done);
enroll_result (G_OBJECT (proxy), result, done, user_data);
}
}
static void do_enroll (FprintDBusDevice *dev)
{
GError *error = NULL;
gboolean enroll_completed = FALSE;
gboolean found;
guint i;
dbus_g_proxy_add_signal(dev, "EnrollStatus", G_TYPE_STRING, G_TYPE_BOOLEAN, NULL);
dbus_g_proxy_connect_signal(dev, "EnrollStatus", G_CALLBACK(enroll_result),
&enroll_completed, NULL);
g_signal_connect (dev, "g-signal", G_CALLBACK (proxy_signal_cb),
&enroll_completed);
found = FALSE;
for (i = 0; fingers[i].dbus_name != NULL; i++) {
@ -118,7 +143,8 @@ static void do_enroll(DBusGProxy *dev)
}
g_print("Enrolling %s finger.\n", finger_name);
if (!net_reactivated_Fprint_Device_enroll_start(dev, finger_name, &error)) {
if (!fprint_dbus_device_call_enroll_start_sync (dev, finger_name, NULL,
&error)) {
g_print("EnrollStart failed: %s\n", error->message);
exit (1);
}
@ -126,19 +152,18 @@ static void do_enroll(DBusGProxy *dev)
while (!enroll_completed)
g_main_context_iteration(NULL, TRUE);
dbus_g_proxy_disconnect_signal(dev, "EnrollStatus",
G_CALLBACK(enroll_result), &enroll_completed);
g_signal_handlers_disconnect_by_func (dev, proxy_signal_cb, &enroll_result);
if (!net_reactivated_Fprint_Device_enroll_stop(dev, &error)) {
if (!fprint_dbus_device_call_enroll_stop_sync (dev, NULL, &error)) {
g_print("VerifyStop failed: %s\n", error->message);
exit(1);
}
}
static void release_device(DBusGProxy *dev)
static void release_device (FprintDBusDevice *dev)
{
GError *error = NULL;
if (!net_reactivated_Fprint_Device_release(dev, &error)) {
if (!fprint_dbus_device_call_release_sync (dev, NULL, &error)) {
g_print("ReleaseDevice failed: %s\n", error->message);
exit (1);
}
@ -152,15 +177,12 @@ static const GOptionEntry entries[] = {
int main(int argc, char **argv)
{
g_autoptr(FprintDBusDevice) dev = NULL;
GOptionContext *context;
GError *err = NULL;
DBusGProxy *dev;
setlocale (LC_ALL, "");
dbus_g_object_register_marshaller (fprintd_marshal_VOID__STRING_BOOLEAN,
G_TYPE_NONE, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INVALID);
context = g_option_context_new ("Enroll a fingerprint");
g_option_context_add_main_entries (context, entries, NULL);
@ -175,7 +197,7 @@ int main(int argc, char **argv)
create_manager();
dev = open_device(usernames ? usernames[0] : NULL);
dev = open_device (usernames ? usernames[0] : "");
do_enroll(dev);
release_device(dev);
g_free(finger_name);

94
utils/list.c
View File

@ -1,6 +1,7 @@
/*
* fprintd example to list enrolled fingerprints
* Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>
* Copyright (C) 2020 Marco Trevisan <marco.trevisan@canonical.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -20,38 +21,52 @@
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <dbus/dbus-glib-bindings.h>
#include "manager-dbus-glue.h"
#include "device-dbus-glue.h"
#include "fprintd-dbus.h"
static DBusGProxy *manager = NULL;
static DBusGConnection *connection = NULL;
static FprintDBusManager *manager = NULL;
static GDBusConnection *connection = NULL;
static void create_manager(void)
{
GError *error = NULL;
connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (connection == NULL) {
g_print("Failed to connect to session bus: %s\n", error->message);
exit (1);
}
manager = dbus_g_proxy_new_for_name(connection,
"net.reactivated.Fprint", "/net/reactivated/Fprint/Manager",
"net.reactivated.Fprint.Manager");
manager = fprint_dbus_manager_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
"net.reactivated.Fprint",
"/net/reactivated/Fprint/Manager",
NULL, &error);
if (manager == NULL) {
g_print ("Failed to get Fprintd manager: %s\n", error->message);
exit (1);
}
}
static void list_fingerprints(DBusGProxy *dev, const char *username)
static void list_fingerprints (FprintDBusDevice *dev, const char *username)
{
GError *error = NULL;
char **fingers;
GHashTable *props;
DBusGProxy *p;
guint i;
if (!net_reactivated_Fprint_Device_list_enrolled_fingers(dev, username, &fingers, &error)) {
if (dbus_g_error_has_name (error, "net.reactivated.Fprint.Error.NoEnrolledPrints") == FALSE) {
if (!fprint_dbus_device_call_list_enrolled_fingers_sync (dev, username,
&fingers, NULL,
&error)) {
gboolean ignore_error = FALSE;
if (g_dbus_error_is_remote_error (error)) {
g_autofree char *dbus_error =
g_dbus_error_get_remote_error (error);
if (g_str_equal (dbus_error,
"net.reactivated.Fprint.Error.NoEnrolledPrints")) {
ignore_error = TRUE;
}
}
if (!ignore_error) {
g_print("ListEnrolledFingers failed: %s\n", error->message);
exit (1);
} else {
@ -60,24 +75,16 @@ static void list_fingerprints(DBusGProxy *dev, const char *username)
}
}
p = dbus_g_proxy_new_from_proxy(dev, "org.freedesktop.DBus.Properties", NULL);
if (!dbus_g_proxy_call (p, "GetAll", &error, G_TYPE_STRING, "net.reactivated.Fprint.Device", G_TYPE_INVALID,
dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &props, G_TYPE_INVALID)) {
g_print("GetAll on the Properties interface failed: %s\n", error->message);
exit (1);
}
if (fingers == NULL || g_strv_length (fingers) == 0) {
g_print("User %s has no fingers enrolled for %s.\n", username, g_value_get_string (g_hash_table_lookup (props, "name")));
g_print ("User %s has no fingers enrolled for %s.\n", username,
fprint_dbus_device_get_name (dev));
return;
}
g_print("Fingerprints for user %s on %s (%s):\n",
username,
g_value_get_string (g_hash_table_lookup (props, "name")),
g_value_get_string (g_hash_table_lookup (props, "scan-type")));
g_hash_table_destroy (props);
g_object_unref (p);
fprint_dbus_device_get_name (dev),
fprint_dbus_device_get_scan_type (dev));
for (i = 0; fingers[i] != NULL; i++) {
g_print(" - #%d: %s\n", i, fingers[i]);
@ -88,46 +95,45 @@ static void list_fingerprints(DBusGProxy *dev, const char *username)
static void process_devices(char **argv)
{
g_auto(GStrv) devices = NULL;
GError *error = NULL;
GPtrArray *devices;
char *path;
guint num_devices;
guint i;
if (!net_reactivated_Fprint_Manager_get_devices(manager, &devices, &error)) {
if (!fprint_dbus_manager_call_get_devices_sync (manager, &devices, NULL,
&error)) {
g_print("Impossible to get devices: %s\n", error->message);
exit (1);
}
if (devices->len == 0) {
num_devices = g_strv_length (devices);
if (num_devices == 0) {
g_print("No devices available\n");
exit(1);
}
g_print("found %d devices\n", devices->len);
for (i = 0; i < devices->len; i++) {
path = g_ptr_array_index(devices, i);
g_print ("found %u devices\n", num_devices);
for (i = 0; devices[i] != NULL; i++) {
path = devices[i];
g_print("Device at %s\n", path);
}
for (i = 0; i < devices->len; i++) {
for (i = 0; devices[i] != NULL; i++) {
g_autoptr(FprintDBusDevice) dev = NULL;
guint j;
DBusGProxy *dev;
path = g_ptr_array_index(devices, i);
path = devices[i];
g_print("Using device %s\n", path);
/* FIXME use for_name_owner?? */
dev = dbus_g_proxy_new_for_name(connection, "net.reactivated.Fprint",
path, "net.reactivated.Fprint.Device");
dev = fprint_dbus_device_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
"net.reactivated.Fprint",
path, NULL, &error);
for (j = 1; argv[j] != NULL; j++)
list_fingerprints (dev, argv[j]);
g_object_unref (dev);
}
g_ptr_array_foreach(devices, (GFunc) g_free, NULL);
g_ptr_array_free(devices, TRUE);
}
int main(int argc, char **argv)

37
utils/meson.build
View File

@ -1,42 +1,19 @@
dbus_client_glue_sources = []
foreach interface_name: dbus_interfaces
interface = interface_name.to_lower()
interface_file = meson.source_root() / 'src' / interface + '.xml'
glue_name = interface + '-dbus-glue.h'
dbus_client_glue_sources += custom_target(glue_name,
input: interface_file,
output: glue_name,
command: [
dbus_binding_tool,
'--prefix=fprint_' + interface,
'--mode=glib-client',
'--output=@OUTPUT@',
'@INPUT@',
])
endforeach
libfprintd_utils_dep = declare_dependency(
include_directories: [
include_directories('../src'),
include_directories('../pam'),
],
dependencies: [
glib_dep,
dbus_glib_dep,
gio_dep,
gio_unix_dep,
],
sources: [
fprintd_marshal,
dbus_client_glue_sources,
fprintd_dbus_sources,
],
link_with: [
libfprintd_private
],
link_with: static_library('fprintd_utils',
sources: [
dbus_client_glue_sources,
fprintd_marshal,
],
dependencies: [
glib_dep,
]
),
)
utils = [

107
utils/verify.c
View File

@ -1,6 +1,7 @@
/*
* fprintd example to verify a fingerprint
* Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>
* Copyright (C) 2020 Marco Trevisan <marco.trevisan@canonical.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -21,66 +22,79 @@
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <dbus/dbus-glib-bindings.h>
#include "manager-dbus-glue.h"
#include "device-dbus-glue.h"
#include "fprintd-marshal.h"
#include <gio/gio.h>
#include "fprintd-dbus.h"
static DBusGProxy *manager = NULL;
static DBusGConnection *connection = NULL;
static FprintDBusManager *manager = NULL;
static GDBusConnection *connection = NULL;
static char *finger_name = NULL;
static gboolean g_fatal_warnings = FALSE;
static char **usernames = NULL;
static void create_manager(void)
{
GError *error = NULL;
g_autoptr(GError) error = NULL;
connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (connection == NULL) {
g_print("Failed to connect to session bus: %s\n", error->message);
exit (1);
}
manager = dbus_g_proxy_new_for_name(connection,
"net.reactivated.Fprint", "/net/reactivated/Fprint/Manager",
"net.reactivated.Fprint.Manager");
manager = fprint_dbus_manager_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
"net.reactivated.Fprint",
"/net/reactivated/Fprint/Manager",
NULL, &error);
if (manager == NULL) {
g_print ("Failed to get Fprintd manager: %s\n", error->message);
exit (1);
}
}
static DBusGProxy *open_device(const char *username)
static FprintDBusDevice *open_device (const char *username)
{
g_autoptr(FprintDBusDevice) dev = NULL;
GError *error = NULL;
gchar *path;
DBusGProxy *dev;
if (!net_reactivated_Fprint_Manager_get_default_device(manager, &path, &error)) {
if (!fprint_dbus_manager_call_get_default_device_sync (manager, &path,
NULL, &error)) {
g_print("Impossible to verify: %s\n", error->message);
exit (1);
}
g_print("Using device %s\n", path);
/* FIXME use for_name_owner?? */
dev = dbus_g_proxy_new_for_name(connection, "net.reactivated.Fprint",
path, "net.reactivated.Fprint.Device");
dev = fprint_dbus_device_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
"net.reactivated.Fprint",
path, NULL, &error);
g_free (path);
if (!net_reactivated_Fprint_Device_claim(dev, username, &error)) {
if (error) {
g_print ("failed to connect to device: %s\n", error->message);
exit (1);
}
if (!fprint_dbus_device_call_claim_sync (dev, username, NULL, &error)) {
g_print("failed to claim device: %s\n", error->message);
exit (1);
}
return dev;
return g_steal_pointer (&dev);
}
static void find_finger(DBusGProxy *dev, const char *username)
static void find_finger (FprintDBusDevice *dev, const char *username)
{
GError *error = NULL;
char **fingers;
guint i;
if (!net_reactivated_Fprint_Device_list_enrolled_fingers(dev, username, &fingers, &error)) {
if (!fprint_dbus_device_call_list_enrolled_fingers_sync (dev, username,
&fingers,
NULL, &error)) {
g_print("ListEnrolledFingers failed: %s\n", error->message);
exit (1);
}
@ -123,19 +137,36 @@ static void verify_finger_selected(GObject *object, const char *name, void *user
g_print("Verifying: %s\n", name);
}
static void do_verify(DBusGProxy *dev)
static void proxy_signal_cb (GDBusProxy *proxy,
const gchar *sender_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
if (g_str_equal (signal_name, "VerifyStatus")) {
const gchar *result;
gboolean done;
g_variant_get (parameters, "(&sb)", &result, &done);
verify_result (G_OBJECT (proxy), result, done, user_data);
} else if (g_str_equal (signal_name, "VerifyFingerSelected")) {
const gchar *name;
g_variant_get (parameters, "(&s)", &name);
verify_finger_selected (G_OBJECT (proxy), name, user_data);
}
}
static void do_verify (FprintDBusDevice *dev)
{
GError *error = NULL;
gboolean verify_completed = FALSE;
dbus_g_proxy_add_signal(dev, "VerifyStatus", G_TYPE_STRING, G_TYPE_BOOLEAN, NULL);
dbus_g_proxy_add_signal(dev, "VerifyFingerSelected", G_TYPE_INT, NULL);
dbus_g_proxy_connect_signal(dev, "VerifyStatus", G_CALLBACK(verify_result),
&verify_completed, NULL);
dbus_g_proxy_connect_signal(dev, "VerifyFingerSelected", G_CALLBACK(verify_finger_selected),
NULL, NULL);
g_signal_connect (dev, "g-signal", G_CALLBACK (proxy_signal_cb),
&verify_completed);
if (!net_reactivated_Fprint_Device_verify_start(dev, finger_name, &error)) {
if (!fprint_dbus_device_call_verify_start_sync (dev, finger_name, NULL,
&error)) {
g_print("VerifyStart failed: %s\n", error->message);
exit (1);
}
@ -143,19 +174,20 @@ static void do_verify(DBusGProxy *dev)
while (!verify_completed)
g_main_context_iteration(NULL, TRUE);
dbus_g_proxy_disconnect_signal(dev, "VerifyStatus", G_CALLBACK(verify_result), &verify_completed);
dbus_g_proxy_disconnect_signal(dev, "VerifyFingerSelected", G_CALLBACK(verify_finger_selected), NULL);
if (!net_reactivated_Fprint_Device_verify_stop(dev, &error)) {
g_signal_handlers_disconnect_by_func (dev, proxy_signal_cb,
&verify_completed);
if (!fprint_dbus_device_call_verify_stop_sync (dev, NULL, &error)) {
g_print("VerifyStop failed: %s\n", error->message);
exit (1);
}
}
static void release_device(DBusGProxy *dev)
static void release_device (FprintDBusDevice *dev)
{
GError *error = NULL;
if (!net_reactivated_Fprint_Device_release(dev, &error)) {
if (!fprint_dbus_device_call_release_sync (dev, NULL, &error)) {
g_print("ReleaseDevice failed: %s\n", error->message);
exit (1);
}
@ -170,16 +202,13 @@ static const GOptionEntry entries[] = {
int main(int argc, char **argv)
{
g_autoptr(FprintDBusDevice) dev = NULL;
GOptionContext *context;
GError *err = NULL;
DBusGProxy *dev;
const char *username = NULL;
setlocale (LC_ALL, "");
dbus_g_object_register_marshaller (fprintd_marshal_VOID__STRING_BOOLEAN,
G_TYPE_NONE, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INVALID);
context = g_option_context_new ("Verify a fingerprint");
g_option_context_add_main_entries (context, entries, NULL);