|
|
@@ -0,0 +1,1033 @@
|
|
|
+#!/usr/bin/env python3
|
|
|
+"""fprintd-compatible D-Bus service backed by the Wine-sandbox driver.
|
|
|
+
|
|
|
+Drop-in replacement for fprintd's daemon for the Synaptics 06cb:0081 sensor
|
|
|
+that libfprint cannot drive yet. It serves the `net.reactivated.Fprint` bus
|
|
|
+name with the same Manager/Device API, so GNOME Shell (lock-screen
|
|
|
+re-authentication), gnome-control-center and pam_fprintd work unchanged.
|
|
|
+
|
|
|
+Verification shells out to work/fp-verify.sh (vendor driver under Wine, run
|
|
|
+as the Wine-prefix owner). Enrollment and deletion drive the harness
|
|
|
+binaries built by work/artifacts/make-enroll-delete.sh:
|
|
|
+ enroll.exe - default flow trimmed to enrollment (touch ~10 times)
|
|
|
+ delete.exe - default flow with enroll() redirected to deleteRecord()
|
|
|
+ (real sensor-side delete, ioctl 0x442034)
|
|
|
+
|
|
|
+The sensor stores a single template (identity c5698517-.../subfactor 0xF6),
|
|
|
+so the per-user finger list in state.json is a mapping onto that one
|
|
|
+template: deleting the last reported finger deletes the sensor record,
|
|
|
+deleting one of several only updates the reported list.
|
|
|
+
|
|
|
+Run with --session for a session-bus smoke test (no root needed, see
|
|
|
+selftest.py / apitest.py).
|
|
|
+"""
|
|
|
+
|
|
|
+import argparse
|
|
|
+import glob
|
|
|
+import json
|
|
|
+import logging
|
|
|
+import os
|
|
|
+import select
|
|
|
+import signal
|
|
|
+import subprocess
|
|
|
+import sys
|
|
|
+import threading
|
|
|
+import time
|
|
|
+
|
|
|
+import gi
|
|
|
+
|
|
|
+gi.require_version('Gio', '2.0')
|
|
|
+gi.require_version('GLib', '2.0')
|
|
|
+from gi.repository import Gio, GLib # noqa: E402
|
|
|
+
|
|
|
+# ---------------------------------------------------------------- constants
|
|
|
+
|
|
|
+BUS_NAME = 'net.reactivated.Fprint'
|
|
|
+MANAGER_PATH = '/net/reactivated/Fprint/Manager'
|
|
|
+DEVICE_PATH = '/net/reactivated/Fprint/Device/0'
|
|
|
+IFACE_MANAGER = 'net.reactivated.Fprint.Manager'
|
|
|
+IFACE_DEVICE = 'net.reactivated.Fprint.Device'
|
|
|
+
|
|
|
+HERE = os.path.dirname(os.path.abspath(__file__))
|
|
|
+ROOT = os.path.dirname(os.path.dirname(HERE))
|
|
|
+VERIFY_SCRIPT = os.path.join(ROOT, 'work', 'fp-verify.sh')
|
|
|
+SANDBOX = os.path.join(ROOT, 'work', 'synaWudfBioUsb-sandbox')
|
|
|
+WINE64 = os.path.join(ROOT, 'work', 'wine-build', 'install', 'bin', 'wine64')
|
|
|
+ENROLL_EXE = 'enroll.exe'
|
|
|
+DELETE_EXE = 'delete.exe'
|
|
|
+
|
|
|
+# same lock file as work/fp-verify.sh: one sensor access at a time
|
|
|
+VERIFY_LOCK = '/tmp/opencode/fp-verify.lock'
|
|
|
+
|
|
|
+RUN_USER = 'nebulon'
|
|
|
+STATE_DIR = os.environ.get('FP_SHIM_STATE_DIR', '/var/lib/fprintd-shim')
|
|
|
+STATE_FILE = os.path.join(STATE_DIR, 'state.json')
|
|
|
+
|
|
|
+DEVICE_NAME = 'Synaptics 06cb:0081'
|
|
|
+SCAN_TYPE = 'press'
|
|
|
+NUM_ENROLL_STAGES = 10
|
|
|
+
|
|
|
+# pam_fprintd's default per-attempt timeout is 30 s; end our run slightly
|
|
|
+# earlier so a no-touch attempt is a clean pam timeout instead of a bogus
|
|
|
+# "failed to match".
|
|
|
+VERIFY_TIMEOUT = int(os.environ.get('FP_SHIM_VERIFY_TIMEOUT', '26'))
|
|
|
+ENROLL_TIMEOUT = int(os.environ.get('FP_SHIM_ENROLL_TIMEOUT', '900'))
|
|
|
+DELETE_TIMEOUT = int(os.environ.get('FP_SHIM_DELETE_TIMEOUT', '180'))
|
|
|
+
|
|
|
+FINGERS = [
|
|
|
+ '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',
|
|
|
+]
|
|
|
+
|
|
|
+# Bus errors
|
|
|
+E_ALREADY_IN_USE = 'net.reactivated.Fprint.Error.AlreadyInUse'
|
|
|
+E_CLAIM_DEVICE = 'net.reactivated.Fprint.Error.ClaimDevice'
|
|
|
+E_INTERNAL = 'net.reactivated.Fprint.Error.Internal'
|
|
|
+E_INVALID_FINGERNAME = 'net.reactivated.Fprint.Error.InvalidFingername'
|
|
|
+E_NO_ACTION = 'net.reactivated.Fprint.Error.NoActionInProgress'
|
|
|
+E_NO_ENROLLED_PRINTS = 'net.reactivated.Fprint.Error.NoEnrolledPrints'
|
|
|
+E_NO_SUCH_DEVICE = 'net.reactivated.Fprint.Error.NoSuchDevice'
|
|
|
+E_PERMISSION_DENIED = 'net.reactivated.Fprint.Error.PermissionDenied'
|
|
|
+E_PRINTS_NOT_DELETED = 'net.reactivated.Fprint.Error.PrintsNotDeleted'
|
|
|
+
|
|
|
+log = logging.getLogger('fprintd-shim')
|
|
|
+
|
|
|
+MANAGER_XML = """
|
|
|
+<node>
|
|
|
+ <interface name="net.reactivated.Fprint.Manager">
|
|
|
+ <method name="GetDevices">
|
|
|
+ <arg type="ao" name="devices" direction="out"/>
|
|
|
+ </method>
|
|
|
+ <method name="GetDefaultDevice">
|
|
|
+ <arg type="o" name="device" direction="out"/>
|
|
|
+ </method>
|
|
|
+ </interface>
|
|
|
+</node>
|
|
|
+"""
|
|
|
+
|
|
|
+DEVICE_XML = """
|
|
|
+<node>
|
|
|
+ <interface name="net.reactivated.Fprint.Device">
|
|
|
+ <method name="ListEnrolledFingers">
|
|
|
+ <arg type="s" name="username" direction="in"/>
|
|
|
+ <arg type="as" name="enrolled_fingers" direction="out"/>
|
|
|
+ </method>
|
|
|
+ <method name="DeleteEnrolledFingers">
|
|
|
+ <arg type="s" name="username" direction="in"/>
|
|
|
+ </method>
|
|
|
+ <method name="DeleteEnrolledFingers2"/>
|
|
|
+ <method name="DeleteEnrolledFinger">
|
|
|
+ <arg type="s" name="finger_name" direction="in"/>
|
|
|
+ </method>
|
|
|
+ <method name="Claim">
|
|
|
+ <arg type="s" name="username" direction="in"/>
|
|
|
+ </method>
|
|
|
+ <method name="Release"/>
|
|
|
+ <method name="VerifyStart">
|
|
|
+ <arg type="s" name="finger_name" direction="in"/>
|
|
|
+ </method>
|
|
|
+ <method name="VerifyStop"/>
|
|
|
+ <method name="EnrollStart">
|
|
|
+ <arg type="s" name="finger_name" direction="in"/>
|
|
|
+ </method>
|
|
|
+ <method name="EnrollStop"/>
|
|
|
+ <signal name="VerifyFingerSelected">
|
|
|
+ <arg type="s" name="finger_name"/>
|
|
|
+ </signal>
|
|
|
+ <signal name="VerifyStatus">
|
|
|
+ <arg type="s" name="result"/>
|
|
|
+ <arg type="b" name="done"/>
|
|
|
+ </signal>
|
|
|
+ <signal name="EnrollStatus">
|
|
|
+ <arg type="s" name="result"/>
|
|
|
+ <arg type="b" name="done"/>
|
|
|
+ </signal>
|
|
|
+ <property name="name" type="s" access="read"/>
|
|
|
+ <property name="num-enroll-stages" type="i" access="read"/>
|
|
|
+ <property name="scan-type" type="s" access="read"/>
|
|
|
+ <property name="finger-present" type="b" access="read"/>
|
|
|
+ <property name="finger-needed" type="b" access="read"/>
|
|
|
+ </interface>
|
|
|
+</node>
|
|
|
+"""
|
|
|
+
|
|
|
+
|
|
|
+def sensor_present():
|
|
|
+ """06cb:0081 attached? Mirrors fprintd's "no devices" behaviour."""
|
|
|
+ try:
|
|
|
+ for dev in glob.glob('/sys/bus/usb/devices/*'):
|
|
|
+ try:
|
|
|
+ with open(os.path.join(dev, 'idVendor')) as f:
|
|
|
+ vid = f.read().strip()
|
|
|
+ if vid != '06cb':
|
|
|
+ continue
|
|
|
+ with open(os.path.join(dev, 'idProduct')) as f:
|
|
|
+ pid = f.read().strip()
|
|
|
+ if pid == '0081':
|
|
|
+ return True
|
|
|
+ except OSError:
|
|
|
+ continue
|
|
|
+ except OSError:
|
|
|
+ pass
|
|
|
+ return False
|
|
|
+
|
|
|
+
|
|
|
+def default_fingers(user):
|
|
|
+ """Before any enroll/delete through the shim the sensor already holds the
|
|
|
+ template enrolled with run_aexe.sh; report it for the workstation user."""
|
|
|
+ return ['right-index-finger'] if user == RUN_USER else []
|
|
|
+
|
|
|
+
|
|
|
+def load_state():
|
|
|
+ try:
|
|
|
+ with open(STATE_FILE, encoding='utf-8') as f:
|
|
|
+ state = json.load(f)
|
|
|
+ if isinstance(state, dict) and isinstance(state.get('users'), dict):
|
|
|
+ return state
|
|
|
+ log.warning('%s: unexpected layout, ignoring', STATE_FILE)
|
|
|
+ except FileNotFoundError:
|
|
|
+ pass
|
|
|
+ except (OSError, ValueError) as e:
|
|
|
+ log.warning('cannot read %s: %s', STATE_FILE, e)
|
|
|
+ return {'users': {}}
|
|
|
+
|
|
|
+
|
|
|
+def save_state(state):
|
|
|
+ os.makedirs(STATE_DIR, mode=0o700, exist_ok=True)
|
|
|
+ tmp = f'{STATE_FILE}.tmp'
|
|
|
+ with open(tmp, 'w', encoding='utf-8') as f:
|
|
|
+ json.dump(state, f, indent=2, sort_keys=True)
|
|
|
+ f.write('\n')
|
|
|
+ os.replace(tmp, STATE_FILE)
|
|
|
+
|
|
|
+
|
|
|
+class ShimDevice:
|
|
|
+ def __init__(self):
|
|
|
+ self.conn = None
|
|
|
+ self.claimed_by = None # unique bus name of the claiming client
|
|
|
+ self.claimed_user = None
|
|
|
+ self.lock = threading.Lock()
|
|
|
+
|
|
|
+ self.verify_proc = None
|
|
|
+ self.verify_thread = None
|
|
|
+ self.verify_cancel = threading.Event()
|
|
|
+ self.verifying = False
|
|
|
+
|
|
|
+ self.enroll_proc = None
|
|
|
+ self.enroll_thread = None
|
|
|
+ self.enroll_cancel = threading.Event()
|
|
|
+ self.enrolling = False
|
|
|
+ self._enroll_commit_started = False
|
|
|
+
|
|
|
+ self.delete_proc = None
|
|
|
+ self.delete_cancel = threading.Event()
|
|
|
+ self.deleting = False
|
|
|
+
|
|
|
+ self.finger_present = False
|
|
|
+ self.finger_needed = False
|
|
|
+
|
|
|
+ # ------------------------------------------------------------ state
|
|
|
+
|
|
|
+ def enrolled_fingers(self, user):
|
|
|
+ if not user:
|
|
|
+ user = RUN_USER
|
|
|
+ users = load_state().get('users', {})
|
|
|
+ if user in users:
|
|
|
+ return list(users[user])
|
|
|
+ return default_fingers(user)
|
|
|
+
|
|
|
+ def _set_enrolled_fingers(self, user, fingers):
|
|
|
+ state = load_state()
|
|
|
+ state.setdefault('users', {})[user] = sorted(set(fingers))
|
|
|
+ save_state(state)
|
|
|
+
|
|
|
+ def _selected_finger(self, finger):
|
|
|
+ """fprintd reports the concrete finger chosen for 'any'."""
|
|
|
+ if finger != 'any':
|
|
|
+ return finger
|
|
|
+ fingers = self.enrolled_fingers(self.claimed_user)
|
|
|
+ return fingers[0] if fingers else 'right-index-finger'
|
|
|
+
|
|
|
+ def _busy(self):
|
|
|
+ return self.verifying or self.enrolling or self.deleting
|
|
|
+
|
|
|
+ # ------------------------------------------------------- emission
|
|
|
+
|
|
|
+ def _emit(self, name, variant):
|
|
|
+ GLib.idle_add(self._emit_now, name, variant)
|
|
|
+
|
|
|
+ def _emit_now(self, name, variant):
|
|
|
+ if self.conn is not None:
|
|
|
+ try:
|
|
|
+ self.conn.emit_signal(None, DEVICE_PATH, IFACE_DEVICE, name,
|
|
|
+ variant)
|
|
|
+ except GLib.Error as e:
|
|
|
+ log.warning('cannot emit %s: %s', name, e.message)
|
|
|
+ return GLib.SOURCE_REMOVE
|
|
|
+
|
|
|
+ def _notify_properties(self, changed):
|
|
|
+ if self.conn is None:
|
|
|
+ return
|
|
|
+ try:
|
|
|
+ self.conn.emit_signal(
|
|
|
+ None, DEVICE_PATH, 'org.freedesktop.DBus.Properties',
|
|
|
+ 'PropertiesChanged',
|
|
|
+ GLib.Variant('(sa{sv}as)', (IFACE_DEVICE, changed, [])))
|
|
|
+ except GLib.Error as e:
|
|
|
+ log.warning('cannot emit PropertiesChanged: %s', e.message)
|
|
|
+
|
|
|
+ def _set_finger_present(self, value):
|
|
|
+ if self.finger_present == value:
|
|
|
+ return
|
|
|
+ self.finger_present = value
|
|
|
+ self._notify_properties({'finger-present': GLib.Variant('b', value)})
|
|
|
+
|
|
|
+ def _set_finger_needed(self, value):
|
|
|
+ if self.finger_needed == value:
|
|
|
+ return
|
|
|
+ self.finger_needed = value
|
|
|
+ self._notify_properties({'finger-needed': GLib.Variant('b', value)})
|
|
|
+
|
|
|
+ # ------------------------------------------------------- claim ops
|
|
|
+
|
|
|
+ def _release_claim(self, shutdown=False):
|
|
|
+ self._stop_verify(quiet=True)
|
|
|
+ self._stop_enroll(quiet=True)
|
|
|
+ # A running delete is deliberately left to finish: it mutates the
|
|
|
+ # device and aborting it can leave a partially written record (the
|
|
|
+ # client may already be gone; the state is updated when it completes).
|
|
|
+ if shutdown:
|
|
|
+ self._stop_delete(quiet=True)
|
|
|
+ self.claimed_by = None
|
|
|
+ self.claimed_user = None
|
|
|
+ self._notify_properties({'num-enroll-stages': GLib.Variant('i', -1)})
|
|
|
+
|
|
|
+ def _check_claim(self, sender, invocation):
|
|
|
+ """fprintd's _fprint_device_check_claimed for STATE_CLAIMED calls."""
|
|
|
+ if self.claimed_by is None:
|
|
|
+ invocation.return_dbus_error(E_CLAIM_DEVICE,
|
|
|
+ 'Device was not claimed before use')
|
|
|
+ return False
|
|
|
+ if self.claimed_by != sender:
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Device already in use by another user')
|
|
|
+ return False
|
|
|
+ return True
|
|
|
+
|
|
|
+ # ------------------------------------------------------ process ops
|
|
|
+
|
|
|
+ def _kill_proc(self, proc):
|
|
|
+ if proc is None or proc.poll() is not None:
|
|
|
+ return
|
|
|
+ try:
|
|
|
+ os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
|
|
|
+ except (ProcessLookupError, PermissionError):
|
|
|
+ return
|
|
|
+ try:
|
|
|
+ proc.wait(timeout=5)
|
|
|
+ except subprocess.TimeoutExpired:
|
|
|
+ try:
|
|
|
+ os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
|
|
|
+ except (ProcessLookupError, PermissionError):
|
|
|
+ pass
|
|
|
+
|
|
|
+ def _harness_env(self, binary):
|
|
|
+ env = os.environ.copy()
|
|
|
+ usb_script = f'/tmp/opencode/usb-{binary}-{int(time.time())}.txt'
|
|
|
+ try:
|
|
|
+ os.makedirs('/tmp/opencode', exist_ok=True)
|
|
|
+ # The fake winusb opens USB_SCRIPT for write ("wt") *as the Wine
|
|
|
+ # user* and does not check for failure - a root-owned file makes
|
|
|
+ # the harness hang in init without a single message, so create it
|
|
|
+ # as RUN_USER (verified: winusb.c WinUsb_Initialize).
|
|
|
+ fd = os.open(usb_script, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o666)
|
|
|
+ os.close(fd)
|
|
|
+ if os.geteuid() == 0:
|
|
|
+ import pwd
|
|
|
+ pw = pwd.getpwnam(RUN_USER)
|
|
|
+ os.chown(usb_script, pw.pw_uid, pw.pw_gid)
|
|
|
+ except (OSError, KeyError) as e:
|
|
|
+ log.warning('cannot prepare %s: %s', usb_script, e)
|
|
|
+ env.update({
|
|
|
+ 'HOME': os.path.join('/home', RUN_USER),
|
|
|
+ 'WINEPREFIX': os.path.join(ROOT, 'work', 'wineprefix-48'),
|
|
|
+ # keep wine quiet, but surface winusb/libfprint errors: a failed
|
|
|
+ # libusb transfer makes the hacked winusb stub exit(0) silently
|
|
|
+ 'WINEDEBUG': os.environ.get('FP_SHIM_WINEDEBUG', '-all,err+all'),
|
|
|
+ 'USB_PLAYBACK': '',
|
|
|
+ 'USB_SCRIPT': usb_script,
|
|
|
+ })
|
|
|
+ return env
|
|
|
+
|
|
|
+ def _harness_cmd(self, binary):
|
|
|
+ cmd = [WINE64, binary]
|
|
|
+ if os.geteuid() == 0:
|
|
|
+ cmd = ['setpriv', f'--reuid={RUN_USER}', f'--regid={RUN_USER}',
|
|
|
+ '--init-groups'] + cmd
|
|
|
+ # one sensor access at a time (same lock as work/fp-verify.sh)
|
|
|
+ return ['flock', '-w', '60', VERIFY_LOCK] + cmd
|
|
|
+
|
|
|
+ def _run_harness(self, binary, timeout, cancel, on_line, proc_slot=None,
|
|
|
+ expect_markers=None, first_timeout=120):
|
|
|
+ """Run the Wine harness, feed its stdout lines to on_line().
|
|
|
+
|
|
|
+ Returns (status, returncode) with status in
|
|
|
+ {'eof', 'cancelled', 'timeout', 'stalled'}; the process group is
|
|
|
+ killed on cancel/timeout. 'stalled' means no line of
|
|
|
+ expect_markers was seen within first_timeout (the winusb stub hangs
|
|
|
+ silently when e.g. USB_SCRIPT is not writable by the Wine user).
|
|
|
+ """
|
|
|
+ env = self._harness_env(binary)
|
|
|
+ harness_log = open(
|
|
|
+ f'/tmp/opencode/harness-{binary}-{int(time.time())}.log',
|
|
|
+ 'w', encoding='utf-8', errors='replace')
|
|
|
+ log.info('%s: harness log %s', binary, harness_log.name)
|
|
|
+ r, w = os.pipe()
|
|
|
+ proc = subprocess.Popen(self._harness_cmd(binary), cwd=SANDBOX,
|
|
|
+ env=env, stdin=subprocess.DEVNULL,
|
|
|
+ stdout=w, stderr=w, start_new_session=True)
|
|
|
+ os.close(w)
|
|
|
+ if proc_slot is not None:
|
|
|
+ proc_slot(proc)
|
|
|
+ started = time.monotonic()
|
|
|
+ deadline = started + timeout
|
|
|
+ status = 'eof'
|
|
|
+ buf = ''
|
|
|
+ saw_first = not expect_markers
|
|
|
+
|
|
|
+ def feed(chunk):
|
|
|
+ nonlocal buf, saw_first
|
|
|
+ buf += chunk
|
|
|
+ while '\n' in buf:
|
|
|
+ line, buf = buf.split('\n', 1)
|
|
|
+ line = line.rstrip('\r')
|
|
|
+ harness_log.write(line + '\n')
|
|
|
+ harness_log.flush()
|
|
|
+ if not saw_first and any(m in line for m in expect_markers):
|
|
|
+ saw_first = True
|
|
|
+ if on_line is not None:
|
|
|
+ on_line(line)
|
|
|
+
|
|
|
+ while True:
|
|
|
+ if cancel.is_set():
|
|
|
+ self._kill_proc(proc)
|
|
|
+ status = 'cancelled'
|
|
|
+ break
|
|
|
+ if time.monotonic() > deadline:
|
|
|
+ log.warning('%s: timeout after %ss', binary, timeout)
|
|
|
+ self._kill_proc(proc)
|
|
|
+ status = 'timeout'
|
|
|
+ break
|
|
|
+ if not saw_first and time.monotonic() - started > first_timeout:
|
|
|
+ log.error('%s: no progress in %ss (winusb init hang?) - '
|
|
|
+ 'killing; see %s', binary, first_timeout,
|
|
|
+ harness_log.name)
|
|
|
+ self._kill_proc(proc)
|
|
|
+ status = 'stalled'
|
|
|
+ break
|
|
|
+ ready, _, _ = select.select([r], [], [], 0.2)
|
|
|
+ if ready:
|
|
|
+ try:
|
|
|
+ chunk = os.read(r, 65536)
|
|
|
+ except OSError:
|
|
|
+ chunk = b''
|
|
|
+ if not chunk:
|
|
|
+ break
|
|
|
+ feed(chunk.decode('utf-8', 'replace'))
|
|
|
+ elif proc.poll() is not None:
|
|
|
+ # child exited: drain whatever is left in the pipe
|
|
|
+ while True:
|
|
|
+ ready, _, _ = select.select([r], [], [], 0)
|
|
|
+ if not ready:
|
|
|
+ break
|
|
|
+ try:
|
|
|
+ chunk = os.read(r, 65536)
|
|
|
+ except OSError:
|
|
|
+ chunk = b''
|
|
|
+ if not chunk:
|
|
|
+ break
|
|
|
+ feed(chunk.decode('utf-8', 'replace'))
|
|
|
+ break
|
|
|
+
|
|
|
+ code = proc.wait()
|
|
|
+ os.close(r)
|
|
|
+ harness_log.close()
|
|
|
+ if proc_slot is not None:
|
|
|
+ proc_slot(None)
|
|
|
+ return status, code
|
|
|
+
|
|
|
+ # ------------------------------------------------------ verify ops
|
|
|
+
|
|
|
+ def _stop_verify(self, quiet=False):
|
|
|
+ with self.lock:
|
|
|
+ running = self.verifying
|
|
|
+ self.verifying = False
|
|
|
+ self.verify_cancel.set()
|
|
|
+ proc = self.verify_proc
|
|
|
+ self.verify_proc = None
|
|
|
+ self._kill_proc(proc)
|
|
|
+ if running and not quiet:
|
|
|
+ log.info('verify stopped by client')
|
|
|
+ return running
|
|
|
+
|
|
|
+ def _verify_cmd(self):
|
|
|
+ script = ['/bin/bash', VERIFY_SCRIPT]
|
|
|
+ if os.geteuid() == 0:
|
|
|
+ return ['setpriv', f'--reuid={RUN_USER}', f'--regid={RUN_USER}',
|
|
|
+ '--init-groups'] + script
|
|
|
+ # session-bus smoke test: we are already the prefix owner
|
|
|
+ return script
|
|
|
+
|
|
|
+ def _verify_worker(self, finger):
|
|
|
+ try:
|
|
|
+ self._emit('VerifyFingerSelected', GLib.Variant('(s)', (finger,)))
|
|
|
+
|
|
|
+ env = os.environ.copy()
|
|
|
+ env['FP_VERIFY_TIMEOUT'] = str(VERIFY_TIMEOUT)
|
|
|
+ env['FP_VERIFY_QUIET'] = '1'
|
|
|
+ env['FP_VERIFY_LOCK_WAIT'] = '20'
|
|
|
+
|
|
|
+ for attempt in (1, 2): # one internal retry for flaky Wine/USB
|
|
|
+ if self.verify_cancel.is_set():
|
|
|
+ return
|
|
|
+ started = time.monotonic()
|
|
|
+ proc = subprocess.Popen(
|
|
|
+ self._verify_cmd(), env=env, text=True,
|
|
|
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
|
|
|
+ start_new_session=True)
|
|
|
+ with self.lock:
|
|
|
+ self.verify_proc = proc
|
|
|
+ try:
|
|
|
+ out, _ = proc.communicate(timeout=VERIFY_TIMEOUT + 20)
|
|
|
+ except subprocess.TimeoutExpired:
|
|
|
+ self._kill_proc(proc)
|
|
|
+ out, _ = proc.communicate()
|
|
|
+ rc = 124
|
|
|
+ else:
|
|
|
+ rc = proc.returncode
|
|
|
+ elapsed = time.monotonic() - started
|
|
|
+ for line in (out or '').splitlines():
|
|
|
+ log.info('verify[%d]: %s', attempt, line)
|
|
|
+ with self.lock:
|
|
|
+ self.verify_proc = None
|
|
|
+
|
|
|
+ if self.verify_cancel.is_set():
|
|
|
+ return
|
|
|
+
|
|
|
+ if rc == 0:
|
|
|
+ self._emit('VerifyStatus',
|
|
|
+ GLib.Variant('(sb)', ('verify-match', True)))
|
|
|
+ return
|
|
|
+ if rc == 1:
|
|
|
+ self._emit('VerifyStatus',
|
|
|
+ GLib.Variant('(sb)', ('verify-no-match', True)))
|
|
|
+ return
|
|
|
+ # rc 2: timeout (no finger) or Wine/USB error. A quick exit
|
|
|
+ # means the sandbox failed before the touch window; retry once.
|
|
|
+ if attempt == 1 and elapsed < VERIFY_TIMEOUT - 5:
|
|
|
+ log.warning('verify run failed early (%.1fs, rc=%d), retrying',
|
|
|
+ elapsed, rc)
|
|
|
+ continue
|
|
|
+ log.info('no terminal status (rc=%d after %.1fs); '
|
|
|
+ 'pam_fprintd will time out', rc, elapsed)
|
|
|
+ return
|
|
|
+ finally:
|
|
|
+ with self.lock:
|
|
|
+ self.verify_proc = None
|
|
|
+ # NOTE: keep self.verifying set after a terminal status: fprintd's
|
|
|
+ # action stays ACTION_VERIFY until VerifyStop/Release (clients like
|
|
|
+ # fprintd-verify call VerifyStop after the result and expect it to
|
|
|
+ # succeed).
|
|
|
+
|
|
|
+ def _start_verify(self, finger):
|
|
|
+ with self.lock:
|
|
|
+ if self._busy():
|
|
|
+ return False
|
|
|
+ self.verifying = True
|
|
|
+ self.verify_cancel.clear()
|
|
|
+ self.verify_thread = threading.Thread(
|
|
|
+ target=self._verify_worker, args=(finger,), daemon=True)
|
|
|
+ self.verify_thread.start()
|
|
|
+ return True
|
|
|
+
|
|
|
+ # ------------------------------------------------------ enroll ops
|
|
|
+
|
|
|
+ def _stop_enroll(self, quiet=False):
|
|
|
+ with self.lock:
|
|
|
+ running = self.enrolling
|
|
|
+ commit_started = self._enroll_commit_started
|
|
|
+ proc = self.enroll_proc
|
|
|
+ if commit_started and proc is not None and proc.poll() is None:
|
|
|
+ # The template write is in flight: let it finish instead of
|
|
|
+ # risking a partially written record. The action stays "in
|
|
|
+ # progress" until the worker completes.
|
|
|
+ log.info('enroll: commit in progress, not aborting')
|
|
|
+ return running
|
|
|
+ with self.lock:
|
|
|
+ self.enrolling = False
|
|
|
+ self.enroll_cancel.set()
|
|
|
+ self.enroll_proc = None
|
|
|
+ self._kill_proc(proc)
|
|
|
+ self._set_finger_needed(False)
|
|
|
+ self._set_finger_present(False)
|
|
|
+ if running and not quiet:
|
|
|
+ log.info('enrollment stopped by client')
|
|
|
+ return running
|
|
|
+
|
|
|
+ def _enroll_worker(self, user, finger):
|
|
|
+ """Drive `wine enroll.exe`; map the harness output to EnrollStatus.
|
|
|
+
|
|
|
+ Markers (see hello.cc enroll()/commitEnrollment()):
|
|
|
+ "about to Create Enrollment"
|
|
|
+ "about to IOCTL_BIOMETRIC_CAPTURE_DATA" <- waiting for a touch
|
|
|
+ "about to Update Enrollment" <- capture accepted
|
|
|
+ "Got back 0x.. bytes: <hex>" <- response; hex[1:2] is
|
|
|
+ the stage state (00 = done)
|
|
|
+ "about to Check For Duplicate" / "about to Commit Enrollment"
|
|
|
+ A capture marker that follows another capture marker (without an
|
|
|
+ Update Enrollment in between) is a rejected scan (SensorStatus 2).
|
|
|
+ """
|
|
|
+ st = {'capture_open': False, 'expect': None, 'stages': 0,
|
|
|
+ 'complete': False, 'committed': False}
|
|
|
+
|
|
|
+ def on_line(line):
|
|
|
+ if line == 'about to IOCTL_BIOMETRIC_CAPTURE_DATA':
|
|
|
+ if st['capture_open']:
|
|
|
+ log.info('enroll: scan rejected, retry')
|
|
|
+ self._emit('EnrollStatus',
|
|
|
+ GLib.Variant('(sb)', ('enroll-retry-scan', False)))
|
|
|
+ self._set_finger_present(False)
|
|
|
+ st['capture_open'] = True
|
|
|
+ st['expect'] = None
|
|
|
+ self._set_finger_needed(True)
|
|
|
+ elif line == 'about to Update Enrollment':
|
|
|
+ st['capture_open'] = False
|
|
|
+ st['expect'] = 'update'
|
|
|
+ self._set_finger_needed(False)
|
|
|
+ self._set_finger_present(True)
|
|
|
+ elif line == 'about to Check For Duplicate':
|
|
|
+ st['expect'] = 'duplicate'
|
|
|
+ elif line == 'about to Commit Enrollment':
|
|
|
+ st['expect'] = 'commit'
|
|
|
+ self._enroll_commit_started = True
|
|
|
+ elif line.startswith('Got back 0x') and st['expect']:
|
|
|
+ kind, st['expect'] = st['expect'], None
|
|
|
+ hexpart = line.split(':', 1)[1].strip() if ':' in line else ''
|
|
|
+ first = hexpart[:2].lower()
|
|
|
+ if kind == 'update':
|
|
|
+ self._set_finger_present(False)
|
|
|
+ if first == '00':
|
|
|
+ st['complete'] = True
|
|
|
+ else:
|
|
|
+ st['stages'] += 1
|
|
|
+ log.info('enroll: stage %d passed', st['stages'])
|
|
|
+ self._emit('EnrollStatus',
|
|
|
+ GLib.Variant('(sb)', ('enroll-stage-passed', False)))
|
|
|
+ self._set_finger_needed(True)
|
|
|
+ elif kind == 'commit':
|
|
|
+ st['committed'] = True
|
|
|
+ log.info('enroll: committed')
|
|
|
+ self._set_finger_present(False)
|
|
|
+ self._set_finger_needed(False)
|
|
|
+
|
|
|
+ def slot(proc):
|
|
|
+ with self.lock:
|
|
|
+ self.enroll_proc = proc
|
|
|
+
|
|
|
+ try:
|
|
|
+ # A commit that replaces an existing record makes the device
|
|
|
+ # re-enumerate mid-write; the hacked winusb stub cannot detect
|
|
|
+ # reconnects and exits with LIBUSB_ERROR_NO_DEVICE (verified
|
|
|
+ # 2026-10-15 13:11-13:12, harness logs). The delete ioctl does
|
|
|
+ # not reset the device, and a fresh write commits reliably, so
|
|
|
+ # clear any existing record first.
|
|
|
+ if self.enrolled_fingers(user):
|
|
|
+ log.info('enroll: existing record for %s, deleting it first',
|
|
|
+ user)
|
|
|
+ dstatus, dcode = self._run_harness(
|
|
|
+ DELETE_EXE, DELETE_TIMEOUT, self.enroll_cancel, None, slot,
|
|
|
+ expect_markers=('about to 442034',))
|
|
|
+ d_ok = (dstatus == 'eof' and dcode == 0)
|
|
|
+ log.info('enroll: pre-delete %s (harness %s rc=%s)',
|
|
|
+ 'ok' if d_ok else 'FAILED', dstatus, dcode)
|
|
|
+ if d_ok:
|
|
|
+ # the device has no record now: report that honestly even if
|
|
|
+ # the enrollment is aborted later on
|
|
|
+ self._set_enrolled_fingers(user, [])
|
|
|
+ if self.enroll_cancel.is_set():
|
|
|
+ log.info('enroll: cancelled before start')
|
|
|
+ return
|
|
|
+
|
|
|
+ status, code = self._run_harness(
|
|
|
+ ENROLL_EXE, ENROLL_TIMEOUT, self.enroll_cancel, on_line, slot,
|
|
|
+ expect_markers=('about to setMode', 'about to Create Enrollment',
|
|
|
+ 'about to IOCTL_BIOMETRIC_CAPTURE_DATA'))
|
|
|
+ # A committed template is on the device even if the client went
|
|
|
+ # away meanwhile: always record it and report completion.
|
|
|
+ if st['committed']:
|
|
|
+ self._set_enrolled_fingers(user, [finger])
|
|
|
+ log.info('enroll: user %s -> %s (harness %s rc=%s)',
|
|
|
+ user, finger, status, code)
|
|
|
+ self._emit('EnrollStatus',
|
|
|
+ GLib.Variant('(sb)', ('enroll-completed', True)))
|
|
|
+ elif self.enroll_cancel.is_set():
|
|
|
+ log.info('enroll: cancelled')
|
|
|
+ else:
|
|
|
+ log.warning('enroll: not committed (harness %s rc=%s, '
|
|
|
+ '%d stages)', status, code, st['stages'])
|
|
|
+ self._emit('EnrollStatus',
|
|
|
+ GLib.Variant('(sb)', ('enroll-failed', True)))
|
|
|
+ finally:
|
|
|
+ with self.lock:
|
|
|
+ self.enroll_proc = None
|
|
|
+ if self.claimed_by is None or self.enroll_cancel.is_set():
|
|
|
+ # no client is waiting for a stop reply any more
|
|
|
+ self.enrolling = False
|
|
|
+ self._set_finger_needed(False)
|
|
|
+ self._set_finger_present(False)
|
|
|
+ # NOTE: like verify, keep self.enrolling set (pending EnrollStop)
|
|
|
+ # when the client is still connected after a terminal status.
|
|
|
+
|
|
|
+ def _start_enroll(self, user, finger):
|
|
|
+ with self.lock:
|
|
|
+ if self._busy():
|
|
|
+ return False
|
|
|
+ self.enrolling = True
|
|
|
+ self._enroll_commit_started = False
|
|
|
+ self.enroll_cancel.clear()
|
|
|
+ self.enroll_thread = threading.Thread(
|
|
|
+ target=self._enroll_worker, args=(user, finger), daemon=True)
|
|
|
+ self.enroll_thread.start()
|
|
|
+ return True
|
|
|
+
|
|
|
+ # ------------------------------------------------------ delete ops
|
|
|
+
|
|
|
+ def _stop_delete(self, quiet=True):
|
|
|
+ with self.lock:
|
|
|
+ running = self.deleting
|
|
|
+ self.deleting = False
|
|
|
+ proc = self.delete_proc
|
|
|
+ self.delete_proc = None
|
|
|
+ self.delete_cancel.set()
|
|
|
+ self._kill_proc(proc)
|
|
|
+ if running and not quiet:
|
|
|
+ log.info('delete cancelled')
|
|
|
+ return running
|
|
|
+
|
|
|
+ def _delete_worker(self, invocation, user, remove):
|
|
|
+ """Remove fingers from the reported list; when the list becomes empty
|
|
|
+ also delete the sensor-side template (delete.exe)."""
|
|
|
+ ok, message = True, None
|
|
|
+ try:
|
|
|
+ fingers = self.enrolled_fingers(user)
|
|
|
+ remaining = [f for f in fingers if f not in remove]
|
|
|
+ if fingers and not remaining:
|
|
|
+ # Optimistic state update: the client (gnome-control-center)
|
|
|
+ # re-reads the list right after the call and gives up after
|
|
|
+ # ~10 s - reflect the deletion immediately, restore below if
|
|
|
+ # the harness fails.
|
|
|
+ self._set_enrolled_fingers(user, remaining)
|
|
|
+
|
|
|
+ def slot(proc):
|
|
|
+ with self.lock:
|
|
|
+ self.delete_proc = proc
|
|
|
+ status, code = self._run_harness(
|
|
|
+ DELETE_EXE, DELETE_TIMEOUT, self.delete_cancel, None, slot,
|
|
|
+ expect_markers=('about to 442034',))
|
|
|
+ ok = (status == 'eof' and code == 0)
|
|
|
+ log.info('delete: sensor record removal %s (harness %s rc=%s)',
|
|
|
+ 'ok' if ok else 'FAILED', status, code)
|
|
|
+ if not ok:
|
|
|
+ message = 'Could not delete the print from the device'
|
|
|
+ self._set_enrolled_fingers(user, fingers) # restore
|
|
|
+ elif remaining:
|
|
|
+ self._set_enrolled_fingers(user, remaining)
|
|
|
+ # NOTE: the state update happens even if the client released the
|
|
|
+ # claim meanwhile - the device record is gone and must not be
|
|
|
+ # reported as enrolled.
|
|
|
+ except Exception:
|
|
|
+ log.exception('delete failed')
|
|
|
+ ok, message = False, 'Internal error while deleting'
|
|
|
+ finally:
|
|
|
+ with self.lock:
|
|
|
+ self.delete_proc = None
|
|
|
+ self.deleting = False
|
|
|
+ GLib.idle_add(self._finish_delete, invocation, ok, message)
|
|
|
+
|
|
|
+ def _finish_delete(self, invocation, ok, message):
|
|
|
+ try:
|
|
|
+ if ok:
|
|
|
+ invocation.return_value(None)
|
|
|
+ else:
|
|
|
+ invocation.return_dbus_error(
|
|
|
+ E_PRINTS_NOT_DELETED,
|
|
|
+ message or 'Fingerprint was not deleted')
|
|
|
+ except GLib.Error as e:
|
|
|
+ # client already gave up / connection closed
|
|
|
+ log.info('delete reply not delivered: %s', e.message)
|
|
|
+ return GLib.SOURCE_REMOVE
|
|
|
+
|
|
|
+ # ------------------------------------------------ D-Bus callbacks
|
|
|
+
|
|
|
+ def on_method_call(self, conn, sender, path, iface, method, params, invocation):
|
|
|
+ try:
|
|
|
+ self._dispatch(sender, path, iface, method, params, invocation)
|
|
|
+ except Exception: # never kill the service on a bug
|
|
|
+ log.exception('method %s.%s failed', iface, method)
|
|
|
+ invocation.return_dbus_error(E_INTERNAL, 'shim internal error')
|
|
|
+
|
|
|
+ def _dispatch(self, sender, path, iface, method, params, invocation):
|
|
|
+ if iface == IFACE_MANAGER:
|
|
|
+ return self._dispatch_manager(method, invocation)
|
|
|
+ if iface == IFACE_DEVICE:
|
|
|
+ return self._dispatch_device(sender, method, params, invocation)
|
|
|
+ invocation.return_dbus_error(E_INTERNAL, f'unknown interface {iface}')
|
|
|
+
|
|
|
+ def _dispatch_manager(self, method, invocation):
|
|
|
+ if method == 'GetDevices':
|
|
|
+ devices = [DEVICE_PATH] if sensor_present() else []
|
|
|
+ invocation.return_value(GLib.Variant('(ao)', (devices,)))
|
|
|
+ elif method == 'GetDefaultDevice':
|
|
|
+ if not sensor_present():
|
|
|
+ invocation.return_dbus_error(E_NO_SUCH_DEVICE,
|
|
|
+ 'No fingerprint device present')
|
|
|
+ else:
|
|
|
+ invocation.return_value(GLib.Variant('(o)', (DEVICE_PATH,)))
|
|
|
+ else:
|
|
|
+ invocation.return_dbus_error(E_INTERNAL, f'unknown method {method}')
|
|
|
+
|
|
|
+ def _dispatch_device(self, sender, method, params, invocation):
|
|
|
+ if method == 'ListEnrolledFingers':
|
|
|
+ (user,) = params.unpack()
|
|
|
+ fingers = self.enrolled_fingers(user)
|
|
|
+ if not fingers:
|
|
|
+ invocation.return_dbus_error(
|
|
|
+ E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
|
|
|
+ else:
|
|
|
+ invocation.return_value(GLib.Variant('(as)', (fingers,)))
|
|
|
+
|
|
|
+ elif method == 'Claim':
|
|
|
+ (user,) = params.unpack()
|
|
|
+ if self.claimed_by is not None:
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Device already in use')
|
|
|
+ return
|
|
|
+ self.claimed_by = sender
|
|
|
+ self.claimed_user = user or RUN_USER
|
|
|
+ log.info('claim by %s for user %s', sender, self.claimed_user)
|
|
|
+ self._notify_properties(
|
|
|
+ {'num-enroll-stages': GLib.Variant('i', NUM_ENROLL_STAGES)})
|
|
|
+ invocation.return_value(None)
|
|
|
+
|
|
|
+ elif method == 'Release':
|
|
|
+ if not self._check_claim(sender, invocation):
|
|
|
+ return
|
|
|
+ self._release_claim()
|
|
|
+ log.info('release by %s', sender)
|
|
|
+ invocation.return_value(None)
|
|
|
+
|
|
|
+ elif method == 'VerifyStart':
|
|
|
+ (finger,) = params.unpack()
|
|
|
+ if not self._check_claim(sender, invocation):
|
|
|
+ return
|
|
|
+ if finger not in FINGERS and finger != 'any':
|
|
|
+ invocation.return_dbus_error(E_INVALID_FINGERNAME,
|
|
|
+ f'Invalid finger name {finger}')
|
|
|
+ return
|
|
|
+ fingers = self.enrolled_fingers(self.claimed_user)
|
|
|
+ if not fingers or (finger != 'any' and finger not in fingers):
|
|
|
+ invocation.return_dbus_error(
|
|
|
+ E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
|
|
|
+ return
|
|
|
+ if not self._start_verify(self._selected_finger(finger)):
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Another operation is in progress')
|
|
|
+ return
|
|
|
+ log.info('verify start (%s) by %s', finger, sender)
|
|
|
+ invocation.return_value(None)
|
|
|
+
|
|
|
+ elif method == 'VerifyStop':
|
|
|
+ if not self._check_claim(sender, invocation):
|
|
|
+ return
|
|
|
+ if not self._stop_verify():
|
|
|
+ invocation.return_dbus_error(E_NO_ACTION,
|
|
|
+ 'No verification in progress')
|
|
|
+ return
|
|
|
+ invocation.return_value(None)
|
|
|
+
|
|
|
+ elif method == 'EnrollStart':
|
|
|
+ (finger,) = params.unpack()
|
|
|
+ if not self._check_claim(sender, invocation):
|
|
|
+ return
|
|
|
+ if finger not in FINGERS:
|
|
|
+ invocation.return_dbus_error(
|
|
|
+ E_INVALID_FINGERNAME,
|
|
|
+ f'Invalid finger name {finger} (not "any")')
|
|
|
+ return
|
|
|
+ if not self._start_enroll(self.claimed_user, finger):
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Another operation is in progress')
|
|
|
+ return
|
|
|
+ log.info('enroll start (%s) by %s', finger, sender)
|
|
|
+ invocation.return_value(None)
|
|
|
+
|
|
|
+ elif method == 'EnrollStop':
|
|
|
+ if not self._check_claim(sender, invocation):
|
|
|
+ return
|
|
|
+ if not self._stop_enroll():
|
|
|
+ invocation.return_dbus_error(E_NO_ACTION,
|
|
|
+ 'No enrollment in progress')
|
|
|
+ return
|
|
|
+ invocation.return_value(None)
|
|
|
+
|
|
|
+ elif method == 'DeleteEnrolledFinger':
|
|
|
+ (finger,) = params.unpack()
|
|
|
+ if not self._check_claim(sender, invocation):
|
|
|
+ return
|
|
|
+ if finger not in FINGERS:
|
|
|
+ invocation.return_dbus_error(E_INVALID_FINGERNAME,
|
|
|
+ f'Invalid finger name {finger}')
|
|
|
+ return
|
|
|
+ if self._busy():
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Another operation is in progress')
|
|
|
+ return
|
|
|
+ fingers = self.enrolled_fingers(self.claimed_user)
|
|
|
+ if finger not in fingers:
|
|
|
+ invocation.return_dbus_error(
|
|
|
+ E_NO_ENROLLED_PRINTS,
|
|
|
+ f'Finger {finger} is not enrolled for this user')
|
|
|
+ return
|
|
|
+ self._start_delete(invocation, self.claimed_user, [finger])
|
|
|
+
|
|
|
+ elif method == 'DeleteEnrolledFingers2':
|
|
|
+ if not self._check_claim(sender, invocation):
|
|
|
+ return
|
|
|
+ if self._busy():
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Another operation is in progress')
|
|
|
+ return
|
|
|
+ fingers = self.enrolled_fingers(self.claimed_user)
|
|
|
+ if not fingers:
|
|
|
+ invocation.return_dbus_error(
|
|
|
+ E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
|
|
|
+ return
|
|
|
+ self._start_delete(invocation, self.claimed_user, fingers)
|
|
|
+
|
|
|
+ elif method == 'DeleteEnrolledFingers':
|
|
|
+ (user,) = params.unpack()
|
|
|
+ user = user or self.claimed_user or RUN_USER
|
|
|
+ if user != RUN_USER:
|
|
|
+ invocation.return_dbus_error(
|
|
|
+ E_PERMISSION_DENIED,
|
|
|
+ 'Only the local user is supported by the shim')
|
|
|
+ return
|
|
|
+ if self.claimed_by is not None and self.claimed_by != sender:
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Device already in use by another user')
|
|
|
+ return
|
|
|
+ if self._busy():
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Another operation is in progress')
|
|
|
+ return
|
|
|
+ fingers = self.enrolled_fingers(user)
|
|
|
+ if not fingers:
|
|
|
+ invocation.return_dbus_error(
|
|
|
+ E_NO_ENROLLED_PRINTS, 'No enrolled prints for user')
|
|
|
+ return
|
|
|
+ self._start_delete(invocation, user, fingers)
|
|
|
+
|
|
|
+ else:
|
|
|
+ invocation.return_dbus_error(E_INTERNAL, f'unknown method {method}')
|
|
|
+
|
|
|
+ def _start_delete(self, invocation, user, remove):
|
|
|
+ with self.lock:
|
|
|
+ if self._busy():
|
|
|
+ invocation.return_dbus_error(E_ALREADY_IN_USE,
|
|
|
+ 'Another operation is in progress')
|
|
|
+ return
|
|
|
+ self.deleting = True
|
|
|
+ self.delete_cancel.clear()
|
|
|
+ log.info('delete start: user=%s fingers=%s', user, ','.join(remove))
|
|
|
+ thread = threading.Thread(target=self._delete_worker,
|
|
|
+ args=(invocation, user, remove), daemon=True)
|
|
|
+ thread.start()
|
|
|
+
|
|
|
+ def on_get_property(self, conn, sender, path, iface, prop):
|
|
|
+ if iface != IFACE_DEVICE:
|
|
|
+ return None
|
|
|
+ if prop == 'name':
|
|
|
+ return GLib.Variant('s', DEVICE_NAME)
|
|
|
+ if prop == 'scan-type':
|
|
|
+ return GLib.Variant('s', SCAN_TYPE)
|
|
|
+ if prop == 'num-enroll-stages':
|
|
|
+ stages = NUM_ENROLL_STAGES if self.claimed_by else -1
|
|
|
+ return GLib.Variant('i', stages)
|
|
|
+ if prop == 'finger-present':
|
|
|
+ return GLib.Variant('b', self.finger_present)
|
|
|
+ if prop == 'finger-needed':
|
|
|
+ return GLib.Variant('b', self.finger_needed)
|
|
|
+ return None
|
|
|
+
|
|
|
+ def on_name_owner_changed(self, conn, sender, path, iface, signal_name, params):
|
|
|
+ name, _old, new = params.unpack()
|
|
|
+ if new:
|
|
|
+ return
|
|
|
+ if name == self.claimed_by:
|
|
|
+ log.info('claiming client %s vanished, releasing device', name)
|
|
|
+ self._release_claim()
|
|
|
+
|
|
|
+
|
|
|
+def main():
|
|
|
+ parser = argparse.ArgumentParser(description=__doc__)
|
|
|
+ parser.add_argument('--session', action='store_true',
|
|
|
+ help='own the name on the session bus (smoke test)')
|
|
|
+ parser.add_argument('--debug', action='store_true')
|
|
|
+ args = parser.parse_args()
|
|
|
+
|
|
|
+ logging.basicConfig(
|
|
|
+ level=logging.DEBUG if args.debug else logging.INFO,
|
|
|
+ format='fprintd-shim: %(levelname)s: %(message)s',
|
|
|
+ stream=sys.stderr)
|
|
|
+
|
|
|
+ bus_type = Gio.BusType.SESSION if args.session else Gio.BusType.SYSTEM
|
|
|
+ device = ShimDevice()
|
|
|
+ loop = GLib.MainLoop()
|
|
|
+
|
|
|
+ manager_info = Gio.DBusNodeInfo.new_for_xml(MANAGER_XML).interfaces[0]
|
|
|
+ device_info = Gio.DBusNodeInfo.new_for_xml(DEVICE_XML).interfaces[0]
|
|
|
+
|
|
|
+ def on_bus_acquired(conn, _name):
|
|
|
+ device.conn = conn
|
|
|
+ conn.register_object(MANAGER_PATH, manager_info,
|
|
|
+ device.on_method_call, device.on_get_property, None)
|
|
|
+ conn.register_object(DEVICE_PATH, device_info,
|
|
|
+ device.on_method_call, device.on_get_property, None)
|
|
|
+ conn.signal_subscribe(
|
|
|
+ 'org.freedesktop.DBus', 'org.freedesktop.DBus', 'NameOwnerChanged',
|
|
|
+ '/org/freedesktop/DBus', None, Gio.DBusSignalFlags.NONE,
|
|
|
+ device.on_name_owner_changed)
|
|
|
+ log.info('serving %s (device %s, state %s, enroll/delete via %s)',
|
|
|
+ BUS_NAME, DEVICE_PATH, STATE_FILE, SANDBOX)
|
|
|
+
|
|
|
+ def on_name_lost(_conn, _name):
|
|
|
+ log.warning('lost bus name %s', BUS_NAME)
|
|
|
+ device._release_claim()
|
|
|
+ loop.quit()
|
|
|
+
|
|
|
+ def on_term(_signum, _frame):
|
|
|
+ log.info('shutting down')
|
|
|
+ device._release_claim()
|
|
|
+ loop.quit()
|
|
|
+
|
|
|
+ signal.signal(signal.SIGTERM, on_term)
|
|
|
+ signal.signal(signal.SIGINT, on_term)
|
|
|
+
|
|
|
+ Gio.bus_own_name(bus_type, BUS_NAME, Gio.BusNameOwnerFlags.NONE,
|
|
|
+ on_bus_acquired, None, on_name_lost)
|
|
|
+ loop.run()
|
|
|
+
|
|
|
+
|
|
|
+if __name__ == '__main__':
|
|
|
+ main()
|