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

daemon: Use GDBus to monitor clients

Browse Source 
Instead of the custom egg code.
This commit is contained in:
Bastien Nocera
2011-04-18 17:55:13 +01:00
parent c3de292486
commit 2d11e76cb7
5 changed files with 49 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
configure.ac
View File

@ -25,7 +25,7 @@ PKG_CHECK_MODULES(GLIB, glib-2.0 dbus-glib-1)
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
PKG_CHECK_MODULES(DAEMON, glib-2.0 dbus-glib-1 gmodule-2.0 polkit-gobject-1 >= 0.91)
PKG_CHECK_MODULES(DAEMON, glib-2.0 dbus-glib-1 gmodule-2.0 polkit-gobject-1 >= 0.91 gio-2.0 >= 2.26)
AC_SUBST(DAEMON_LIBS)
AC_SUBST(DAEMON_CFLAGS)

1
src/Makefile.am
View File

@ -11,7 +11,6 @@ AM_CFLAGS = $(WARN_CFLAGS) $(FPRINT_CFLAGS) $(DAEMON_CFLAGS) -DLOCALEDIR=\""$(da
libfprintd_la_SOURCES = \
manager.c device.c \
egg-dbus-monitor.c egg-dbus-monitor.h \
$(MARSHALFILES) \
fprintd.h
libfprintd_la_LIBADD = $(FPRINT_LIBS) $(DAEMON_LIBS)

37
src/device.c
View File

@ -22,6 +22,7 @@
#include <dbus/dbus-glib-bindings.h>
#include <dbus/dbus-glib-lowlevel.h>
#include <glib/gi18n.h>
#include <gio/gio.h>
#include <polkit/polkit.h>
#include <libfprint/fprint.h>
@ -32,7 +33,6 @@
#include "fprintd-marshal.h"
#include "fprintd.h"
#include "storage.h"
#include "egg-dbus-monitor.h"
static char *fingers[] = {
"left-thumb",
@ -272,7 +272,7 @@ static void fprint_device_init(FprintDevice *device)
priv->clients = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_object_unref);
NULL);
}
G_DEFINE_TYPE(FprintDevice, fprint_device, G_TYPE_OBJECT);
@ -524,16 +524,14 @@ static void action_stop_cb(struct fp_dev *dev, void *user_data)
}
static void
_fprint_device_client_disconnected (EggDbusMonitor *monitor, gboolean connected, FprintDevice *rdev)
_fprint_device_client_vanished (GDBusConnection *connection,
const char *name,
FprintDevice *rdev)
{
FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
if (connected == FALSE) {
const char *sender;
sender = egg_dbus_monitor_get_service (monitor);
/* Was that the client that claimed the device? */
if (priv->sender != NULL) {
if (g_strcmp0 (priv->sender, name) == 0) {
gboolean done = FALSE;
switch (priv->current_action) {
case ACTION_NONE:
@ -567,8 +565,7 @@ _fprint_device_client_disconnected (EggDbusMonitor *monitor, gboolean connected,
g_free (priv->username);
priv->username = NULL;
}
g_hash_table_remove (priv->clients, sender);
}
g_hash_table_remove (priv->clients, name);
if (g_hash_table_size (priv->clients) == 0) {
g_object_notify (G_OBJECT (rdev), "in-use");
@ -578,17 +575,19 @@ _fprint_device_client_disconnected (EggDbusMonitor *monitor, gboolean connected,
static void
_fprint_device_add_client (FprintDevice *rdev, const char *sender)
{
EggDbusMonitor *monitor;
FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
guint id;
monitor = g_hash_table_lookup (priv->clients, sender);
if (monitor == NULL) {
monitor = egg_dbus_monitor_new ();
egg_dbus_monitor_assign (monitor, fprintd_dbus_conn, sender);
//FIXME handle replaced
g_signal_connect (G_OBJECT (monitor), "connection-changed",
G_CALLBACK (_fprint_device_client_disconnected), rdev);
g_hash_table_insert (priv->clients, g_strdup (sender), monitor);
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));
g_object_notify (G_OBJECT (rdev), "in-use");
}
}

265
src/egg-dbus-monitor.c
View File

@ -1,265 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Copyright (C) 2006-2008 Richard Hughes <richard@hughsie.com>
*
* Licensed under the GNU General Public License Version 2
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <glib.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>
#include <dbus/dbus.h>
#include "egg-dbus-monitor.h"
static void egg_dbus_monitor_class_init (EggDbusMonitorClass *klass);
static void egg_dbus_monitor_init (EggDbusMonitor *dbus_monitor);
static void egg_dbus_monitor_finalize (GObject *object);
#define EGG_DBUS_MONITOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EGG_TYPE_DBUS_MONITOR, EggDbusMonitorPrivate))
struct EggDbusMonitorPrivate
{
gchar *service;
DBusGProxy *proxy;
DBusGConnection *connection;
const gchar *unique_name;
};
enum {
EGG_DBUS_MONITOR_CONNECTION_CHANGED,
EGG_DBUS_MONITOR_CONNECTION_REPLACED,
EGG_DBUS_MONITOR_LAST_SIGNAL
};
static guint signals [EGG_DBUS_MONITOR_LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (EggDbusMonitor, egg_dbus_monitor, G_TYPE_OBJECT)
/**
* egg_dbus_monitor_name_owner_changed_cb:
**/
static void
egg_dbus_monitor_name_owner_changed_cb (DBusGProxy *proxy, const gchar *name,
const gchar *prev, const gchar *new,
EggDbusMonitor *monitor)
{
guint new_len;
guint prev_len;
g_return_if_fail (EGG_IS_DBUS_MONITOR (monitor));
if (monitor->priv->proxy == NULL)
return;
/* not us */
if (strcmp (name, monitor->priv->service) != 0)
return;
/* ITS4: ignore, not used for allocation */
new_len = strlen (new);
/* ITS4: ignore, not used for allocation */
prev_len = strlen (prev);
/* something --> nothing */
if (prev_len != 0 && new_len == 0) {
g_signal_emit (monitor, signals [EGG_DBUS_MONITOR_CONNECTION_CHANGED], 0, FALSE);
return;
}
/* nothing --> something */
if (prev_len == 0 && new_len != 0) {
g_signal_emit (monitor, signals [EGG_DBUS_MONITOR_CONNECTION_CHANGED], 0, TRUE);
return;
}
/* something --> something (we've replaced the old process) */
if (prev_len != 0 && new_len != 0) {
/* only send this to the prev client */
if (strcmp (monitor->priv->unique_name, prev) == 0)
g_signal_emit (monitor, signals [EGG_DBUS_MONITOR_CONNECTION_REPLACED], 0);
return;
}
}
/**
* egg_dbus_monitor_assign:
* @monitor: This class instance
* @connection: The bus connection
* @service: The EGG_DBUS_MONITOR service name
* Return value: success
*
* Emits connection-changed(TRUE) if connection is alive - this means you
* have to connect up the callback before this function is called.
**/
gboolean
egg_dbus_monitor_assign (EggDbusMonitor *monitor, DBusGConnection *connection, const gchar *service)
{
GError *error = NULL;
gboolean connected;
DBusConnection *conn;
g_return_val_if_fail (EGG_IS_DBUS_MONITOR (monitor), FALSE);
g_return_val_if_fail (service != NULL, FALSE);
g_return_val_if_fail (connection != NULL, FALSE);
if (monitor->priv->proxy != NULL) {
g_warning ("already assigned!");
return FALSE;
}
monitor->priv->service = g_strdup (service);
monitor->priv->connection = connection;
monitor->priv->proxy = dbus_g_proxy_new_for_name_owner (monitor->priv->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
&error);
if (error != NULL) {
g_warning ("Cannot connect to DBUS: %s", error->message);
g_error_free (error);
return FALSE;
}
dbus_g_proxy_add_signal (monitor->priv->proxy, "NameOwnerChanged",
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (monitor->priv->proxy, "NameOwnerChanged",
G_CALLBACK (egg_dbus_monitor_name_owner_changed_cb),
monitor, NULL);
/* coldplug */
connected = egg_dbus_monitor_is_connected (monitor);
if (connected)
g_signal_emit (monitor, signals [EGG_DBUS_MONITOR_CONNECTION_CHANGED], 0, TRUE);
/* save this for the replaced check */
conn = dbus_g_connection_get_connection (monitor->priv->connection);
monitor->priv->unique_name = dbus_bus_get_unique_name (conn);
return TRUE;
}
/**
* egg_dbus_monitor_is_connected:
* @monitor: This class instance
* Return value: if we are connected to a valid watch
**/
gboolean
egg_dbus_monitor_is_connected (EggDbusMonitor *monitor)
{
DBusError error;
DBusConnection *conn;
gboolean ret;
g_return_val_if_fail (EGG_IS_DBUS_MONITOR (monitor), FALSE);
/* get raw connection */
conn = dbus_g_connection_get_connection (monitor->priv->connection);
dbus_error_init (&error);
ret = dbus_bus_name_has_owner (conn, monitor->priv->service, &error);
if (dbus_error_is_set (&error)) {
g_debug ("error: %s", error.message);
dbus_error_free (&error);
}
return ret;
}
/**
* egg_dbus_monitor_get_service:
* @monitor: This class instance
* Return value: the service name being monitored
**/
const gchar *
egg_dbus_monitor_get_service (EggDbusMonitor *monitor)
{
g_return_val_if_fail (EGG_IS_DBUS_MONITOR (monitor), FALSE);
return monitor->priv->service;
}
/**
* egg_dbus_monitor_class_init:
* @klass: The EggDbusMonitorClass
**/
static void
egg_dbus_monitor_class_init (EggDbusMonitorClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = egg_dbus_monitor_finalize;
g_type_class_add_private (klass, sizeof (EggDbusMonitorPrivate));
signals [EGG_DBUS_MONITOR_CONNECTION_CHANGED] =
g_signal_new ("connection-changed",
G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (EggDbusMonitorClass, connection_changed),
NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN,
G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
signals [EGG_DBUS_MONITOR_CONNECTION_REPLACED] =
g_signal_new ("connection-replaced",
G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (EggDbusMonitorClass, connection_replaced),
NULL, NULL, g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
/**
* egg_dbus_monitor_init:
* @monitor: This class instance
**/
static void
egg_dbus_monitor_init (EggDbusMonitor *monitor)
{
monitor->priv = EGG_DBUS_MONITOR_GET_PRIVATE (monitor);
monitor->priv->service = NULL;
monitor->priv->connection = NULL;
monitor->priv->proxy = NULL;
}
/**
* egg_dbus_monitor_finalize:
* @object: The object to finalize
**/
static void
egg_dbus_monitor_finalize (GObject *object)
{
EggDbusMonitor *monitor;
g_return_if_fail (EGG_IS_DBUS_MONITOR (object));
monitor = EGG_DBUS_MONITOR (object);
g_return_if_fail (monitor->priv != NULL);
if (monitor->priv->proxy != NULL)
g_object_unref (monitor->priv->proxy);
G_OBJECT_CLASS (egg_dbus_monitor_parent_class)->finalize (object);
}
/**
* egg_dbus_monitor_new:
*
* Return value: a new EggDbusMonitor object.
**/
EggDbusMonitor *
egg_dbus_monitor_new (void)
{
EggDbusMonitor *monitor;
monitor = g_object_new (EGG_TYPE_DBUS_MONITOR, NULL);
return EGG_DBUS_MONITOR (monitor);
}

66
src/egg-dbus-monitor.h
View File

@ -1,66 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Copyright (C) 2008 Richard Hughes <richard@hughsie.com>
*
* Licensed under the GNU General Public License Version 2
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __EGG_DBUS_MONITOR_H
#define __EGG_DBUS_MONITOR_H
#include <glib-object.h>
#include <dbus/dbus-glib.h>
G_BEGIN_DECLS
#define EGG_TYPE_DBUS_MONITOR (egg_dbus_monitor_get_type ())
#define EGG_DBUS_MONITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EGG_TYPE_DBUS_MONITOR, EggDbusMonitor))
#define EGG_DBUS_MONITOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EGG_TYPE_DBUS_MONITOR, EggDbusMonitorClass))
#define EGG_IS_DBUS_MONITOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EGG_TYPE_DBUS_MONITOR))
#define EGG_IS_DBUS_MONITOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EGG_TYPE_DBUS_MONITOR))
#define EGG_DBUS_MONITOR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EGG_TYPE_DBUS_MONITOR, EggDbusMonitorClass))
#define EGG_DBUS_MONITOR_ERROR (egg_dbus_monitor_error_quark ())
#define EGG_DBUS_MONITOR_TYPE_ERROR (egg_dbus_monitor_error_get_type ())
typedef struct EggDbusMonitorPrivate EggDbusMonitorPrivate;
typedef struct
{
GObject parent;
EggDbusMonitorPrivate *priv;
} EggDbusMonitor;
typedef struct
{
GObjectClass parent_class;
void (* connection_changed) (EggDbusMonitor *watch,
gboolean connected);
void (* connection_replaced) (EggDbusMonitor *watch);
} EggDbusMonitorClass;
GType egg_dbus_monitor_get_type (void) G_GNUC_CONST;
EggDbusMonitor *egg_dbus_monitor_new (void);
gboolean egg_dbus_monitor_assign (EggDbusMonitor *monitor,
DBusGConnection *connection,
const gchar *service);
const gchar *egg_dbus_monitor_get_service (EggDbusMonitor *monitor);
gboolean egg_dbus_monitor_is_connected (EggDbusMonitor *monitor);
G_END_DECLS
#endif /* __EGG_DBUS_MONITOR_H */