/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* This is a very basic implementation of fingerprint to allow testing on the emulator. It
* is *not* meant to be the final implementation on real devices. For example, it does *not*
* implement all of the required features, such as secure template storage and recognition
* inside a Trusted Execution Environment (TEE). However, this file is a reasonable starting
* point as developers add fingerprint support to their platform. See inline comments and
* recommendations for details.
*
* Please see the Android Compatibility Definition Document (CDD) for a full list of requirements
* and suggestions.
*/
#define LOG_TAG "FingerprintHal"
#include <errno.h>
#include <endian.h>
#include <inttypes.h>
#include <malloc.h>
#include <string.h>
#include <cutils/log.h>
#include <hardware/hardware.h>
#include <hardware/fingerprint.h>
#include <hardware/qemud.h>
#include <poll.h>
#define FINGERPRINT_LISTEN_SERVICE_NAME "fingerprintlisten"
#define FINGERPRINT_FILENAME "emufp.bin"
#define AUTHENTICATOR_ID_FILENAME "emuauthid.bin"
#define MAX_COMM_CHARS 128
#define MAX_COMM_ERRORS 8
// Typical devices will allow up to 5 fingerprints per user to maintain performance of
// t < 500ms for recognition. This is the total number of fingerprints we'll store.
#define MAX_NUM_FINGERS 20
#define MAX_FID_VALUE 0x7FFFFFFF // Arbitrary limit
/**
* Most devices will have an internal state machine resembling this. There are 3 basic states, as
* shown below. When device is not authenticating or enrolling, it is expected to be in
* the idle state.
*
* Note that this is completely independent of device wake state. If the hardware device was in
* the "scan" state when the device drops into power collapse, it should resume scanning when power
* is restored. This is to facilitate rapid touch-to-unlock from keyguard.
*/
typedef enum worker_state_t {
STATE_IDLE = 0,
STATE_ENROLL,
STATE_SCAN,
STATE_EXIT
} worker_state_t;
typedef struct worker_thread_t {
pthread_t thread;
worker_state_t state;
uint64_t secureid[MAX_NUM_FINGERS];
uint64_t fingerid[MAX_NUM_FINGERS];
char fp_filename[PATH_MAX];
char authid_filename[PATH_MAX];
} worker_thread_t;
typedef struct qemu_fingerprint_device_t {
fingerprint_device_t device; // "inheritance"
worker_thread_t listener;
uint64_t op_id;
uint64_t challenge;
uint64_t user_id;
uint64_t group_id;
uint64_t secure_user_id;
uint64_t authenticator_id;
int qchanfd;
pthread_mutex_t lock;
} qemu_fingerprint_device_t;
/******************************************************************************/
static FILE* openForWrite(const char* filename);
static void saveFingerprint(worker_thread_t* listener, int idx) {
ALOGD("----------------> %s -----------------> idx %d", __FUNCTION__, idx);
// Save fingerprints to file
FILE* fp = openForWrite(listener->fp_filename);
if (fp == NULL) {
ALOGE("Could not open fingerprints storage at %s; "
"fingerprints won't be saved",
listener->fp_filename);
perror("Failed to open file");
return;
}
ALOGD("Write fingerprint[%d] (0x%" PRIx64 ",0x%" PRIx64 ")", idx,
listener->secureid[idx], listener->fingerid[idx]);
if (fseek(fp, (idx) * sizeof(uint64_t), SEEK_SET) < 0) {
ALOGE("Failed while seeking for fingerprint[%d] in emulator storage",
idx);
fclose(fp);
return;
}
int ns = fwrite(&listener->secureid[idx], sizeof(uint64_t), 1, fp);
if (fseek(fp, (MAX_NUM_FINGERS + idx) * sizeof(uint64_t), SEEK_SET) < 0) {
ALOGE("Failed while seeking for fingerprint[%d] in emulator storage",
idx);
fclose(fp);
return;
}
int nf = fwrite(&listener->fingerid[idx], sizeof(uint64_t), 1, fp);
if (ns != 1 || ns !=1)
ALOGW("Corrupt emulator fingerprints storage; could not save "
"fingerprints");
fclose(fp);
return;
}
static FILE* openForWrite(const char* filename) {
if (!filename) return NULL;
FILE* fp = fopen(filename, "r+"); // write but don't truncate
if (fp == NULL) {
fp = fopen(filename, "w");
if (fp) {
uint64_t zero = 0;
int i = 0;
for (i = 0; i < 2*MAX_NUM_FINGERS; ++i) {
fwrite(&zero, sizeof(uint64_t), 1, fp);
}
//the last one is for authenticator id
fwrite(&zero, sizeof(uint64_t), 1, fp);
}
}
return fp;
}
static void saveAuthenticatorId(const char* filename, uint64_t authenid) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
FILE* fp = openForWrite(filename);
if (!fp) {
ALOGE("Failed to open emulator storage file to save authenticator id");
return;
}
rewind(fp);
int na = fwrite(&authenid, sizeof(authenid), 1, fp);
if (na != 1) {
ALOGE("Failed while writing authenticator id in emulator storage");
}
ALOGD("Save authenticator id (0x%" PRIx64 ")", authenid);
fclose(fp);
}
static void loadAuthenticatorId(const char* authid_filename, uint64_t* pauthenid) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
FILE* fp = fopen(authid_filename, "r");
if (fp == NULL) {
ALOGE("Could not load authenticator id from storage at %s; "
"it has not yet been created.",
authid_filename);
perror("Failed to open/create file");
return;
}
rewind(fp);
int na = fread(pauthenid, sizeof(*pauthenid), 1, fp);
if (na != 1)
ALOGW("Corrupt emulator authenticator id storage (read %d)", na);
ALOGD("Read authenticator id (0x%" PRIx64 ")", *pauthenid);
fclose(fp);
return;
}
static void loadFingerprints(worker_thread_t* listener) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
FILE* fp = fopen(listener->fp_filename, "r");
if (fp == NULL) {
ALOGE("Could not load fingerprints from storage at %s; "
"it has not yet been created.",
listener->fp_filename);
perror("Failed to open/create file");
return;
}
int ns = fread(listener->secureid, MAX_NUM_FINGERS * sizeof(uint64_t), 1,
fp);
int nf = fread(listener->fingerid, MAX_NUM_FINGERS * sizeof(uint64_t), 1,
fp);
if (ns != 1 || nf != 1)
ALOGW("Corrupt emulator fingerprints storage (read %d+%db)", ns, nf);
int i = 0;
for (i = 0; i < MAX_NUM_FINGERS; i++)
ALOGD("Read fingerprint %d (0x%" PRIx64 ",0x%" PRIx64 ")", i,
listener->secureid[i], listener->fingerid[i]);
fclose(fp);
return;
}
/******************************************************************************/
static uint64_t get_64bit_rand() {
// This should use a cryptographically-secure random number generator like arc4random().
// It should be generated inside of the TEE where possible. Here we just use something
// very simple.
ALOGD("----------------> %s ----------------->", __FUNCTION__);
uint64_t r = (((uint64_t)rand()) << 32) | ((uint64_t)rand());
return r != 0 ? r : 1;
}
static uint64_t fingerprint_get_auth_id(struct fingerprint_device* device) {
// This should return the authentication_id generated when the fingerprint template database
// was created. Though this isn't expected to be secret, it is reasonable to expect it to be
// cryptographically generated to avoid replay attacks.
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
ALOGD("----------------> %s ----------------->", __FUNCTION__);
uint64_t authenticator_id = 0;
pthread_mutex_lock(&qdev->lock);
authenticator_id = qdev->authenticator_id;
pthread_mutex_unlock(&qdev->lock);
ALOGD("----------------> %s auth id %" PRIx64 "----------------->", __FUNCTION__, authenticator_id);
return authenticator_id;
}
static int fingerprint_set_active_group(struct fingerprint_device *device, uint32_t gid,
const char *path) {
ALOGD("----------------> %s -----------------> path %s", __FUNCTION__, path);
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
pthread_mutex_lock(&qdev->lock);
qdev->group_id = gid;
snprintf(qdev->listener.fp_filename, sizeof(qdev->listener.fp_filename),
"%s/%s", path, FINGERPRINT_FILENAME);
snprintf(qdev->listener.authid_filename, sizeof(qdev->listener.authid_filename),
"%s/%s", path, AUTHENTICATOR_ID_FILENAME);
uint64_t authenticator_id = 0;
loadFingerprints(&qdev->listener);
loadAuthenticatorId(qdev->listener.authid_filename, &authenticator_id);
if (authenticator_id == 0) {
// firs time, create an authenticator id
authenticator_id = get_64bit_rand();
// save it to disk
saveAuthenticatorId(qdev->listener.authid_filename, authenticator_id);
}
qdev->authenticator_id = authenticator_id;
pthread_mutex_unlock(&qdev->lock);
return 0;
}
/**
* If fingerprints are enrolled, then this function is expected to put the sensor into a
* "scanning" state where it's actively scanning and recognizing fingerprint features.
* Actual authentication must happen in TEE and should be monitored in a separate thread
* since this function is expected to return immediately.
*/
static int fingerprint_authenticate(struct fingerprint_device *device,
uint64_t operation_id, __unused uint32_t gid)
{
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
pthread_mutex_lock(&qdev->lock);
qdev->op_id = operation_id;
qdev->listener.state = STATE_SCAN;
pthread_mutex_unlock(&qdev->lock);
return 0;
}
/**
* This is expected to put the sensor into an "enroll" state where it's actively scanning and
* working towards a finished fingerprint database entry. Authentication must happen in
* a separate thread since this function is expected to return immediately.
*
* Note: This method should always generate a new random authenticator_id.
*
* Note: As with fingerprint_authenticate(), this would run in TEE on a real device.
*/
static int fingerprint_enroll(struct fingerprint_device *device,
const hw_auth_token_t *hat,
uint32_t __unused gid,
uint32_t __unused timeout_sec) {
ALOGD("fingerprint_enroll");
qemu_fingerprint_device_t* dev = (qemu_fingerprint_device_t*)device;
if (!hat) {
ALOGW("%s: null auth token", __func__);
return -EPROTONOSUPPORT;
}
if (hat->challenge == dev->challenge) {
// The secure_user_id retrieved from the auth token should be stored
// with the enrolled fingerprint template and returned in the auth result
// for a successful authentication with that finger.
dev->secure_user_id = hat->user_id;
} else {
ALOGW("%s: invalid auth token", __func__);
}
if (hat->version != HW_AUTH_TOKEN_VERSION) {
return -EPROTONOSUPPORT;
}
if (hat->challenge != dev->challenge && !(hat->authenticator_type & HW_AUTH_FINGERPRINT)) {
return -EPERM;
}
dev->user_id = hat->user_id;
pthread_mutex_lock(&dev->lock);
dev->listener.state = STATE_ENROLL;
pthread_mutex_unlock(&dev->lock);
// fingerprint id, authenticator id, and secure_user_id
// will be stored by worked thread
return 0;
}
/**
* The pre-enrollment step is simply to get an authentication token that can be wrapped and
* verified at a later step. The primary purpose is to return a token that protects against
* spoofing and replay attacks. It is passed to password authentication where it is wrapped and
* propagated to the enroll step.
*/
static uint64_t fingerprint_pre_enroll(struct fingerprint_device *device) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
uint64_t challenge = 0;
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
// The challenge will typically be a cryptographically-secure key
// coming from the TEE so it can be verified at a later step. For now we just generate a
// random value.
challenge = get_64bit_rand();
pthread_mutex_lock(&qdev->lock);
qdev->challenge = challenge;
pthread_mutex_unlock(&qdev->lock);
return challenge;
}
static int fingerprint_post_enroll(struct fingerprint_device* device) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
pthread_mutex_lock(&qdev->lock);
qdev->challenge = 0;
pthread_mutex_unlock(&qdev->lock);
return 0;
}
/**
* Cancel is called by the framework to cancel an outstanding event. This should *not* be called
* by the driver since it will cause the framework to stop listening for fingerprints.
*/
static int fingerprint_cancel(struct fingerprint_device *device) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
pthread_mutex_lock(&qdev->lock);
qdev->listener.state = STATE_IDLE;
pthread_mutex_unlock(&qdev->lock);
fingerprint_msg_t msg = {0, {0}};
msg.type = FINGERPRINT_ERROR;
msg.data.error = FINGERPRINT_ERROR_CANCELED;
qdev->device.notify(&msg);
return 0;
}
static int fingerprint_enumerate(struct fingerprint_device *device) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
if (device == NULL) {
ALOGE("Cannot enumerate saved fingerprints with uninitialized params");
return -1;
}
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
int template_count = 0;
for (int i = 0; i < MAX_NUM_FINGERS; i++) {
if (qdev->listener.secureid[i] != 0 ||
qdev->listener.fingerid[i] != 0) {
ALOGD("ENUM: Fingerprint [%d] = 0x%" PRIx64 ",%" PRIx64, i,
qdev->listener.secureid[i], qdev->listener.fingerid[i]);
template_count++;
}
}
fingerprint_msg_t message = {0, {0}};
message.type = FINGERPRINT_TEMPLATE_ENUMERATING;
message.data.enumerated.finger.gid = qdev->group_id;
for (int i = 0; i < MAX_NUM_FINGERS; i++) {
if (qdev->listener.secureid[i] != 0 ||
qdev->listener.fingerid[i] != 0) {
template_count--;
message.data.enumerated.remaining_templates = template_count;
message.data.enumerated.finger.fid = qdev->listener.fingerid[i];
qdev->device.notify(&message);
}
}
return 0;
}
static int fingerprint_remove(struct fingerprint_device *device,
uint32_t __unused gid, uint32_t fid) {
int idx = 0;
fingerprint_msg_t msg = {0, {0}};
ALOGD("----------------> %s -----------------> fid %d", __FUNCTION__, fid);
if (device == NULL) {
ALOGE("Can't remove fingerprint (gid=%d, fid=%d); "
"device not initialized properly",
gid, fid);
return -1;
}
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
if (fid == 0) {
// Delete all fingerprints
// I'll do this one at a time, so I am not
// holding the mutext during the notification
bool listIsEmpty;
do {
pthread_mutex_lock(&qdev->lock);
listIsEmpty = true; // Haven't seen a valid entry yet
for (idx = 0; idx < MAX_NUM_FINGERS; idx++) {
uint32_t theFid = qdev->listener.fingerid[idx];
if (theFid != 0) {
// Delete this entry
qdev->listener.secureid[idx] = 0;
qdev->listener.fingerid[idx] = 0;
saveFingerprint(&qdev->listener, idx);
// Send a notification that we deleted this one
pthread_mutex_unlock(&qdev->lock);
msg.type = FINGERPRINT_TEMPLATE_REMOVED;
msg.data.removed.finger.fid = theFid;
device->notify(&msg);
// Because we released the mutex, the list
// may have changed. Restart the 'for' loop
// after reacquiring the mutex.
listIsEmpty = false;
break;
}
} // end for (idx < MAX_NUM_FINGERS)
} while (!listIsEmpty);
msg.type = FINGERPRINT_TEMPLATE_REMOVED;
msg.data.removed.finger.fid = 0;
device->notify(&msg);
qdev->listener.state = STATE_IDLE;
pthread_mutex_unlock(&qdev->lock);
} else {
// Delete one fingerprint
// Look for this finger ID in our table.
pthread_mutex_lock(&qdev->lock);
for (idx = 0; idx < MAX_NUM_FINGERS; idx++) {
if (qdev->listener.fingerid[idx] == fid &&
qdev->listener.secureid[idx] != 0) {
// Found it!
break;
}
}
if (idx >= MAX_NUM_FINGERS) {
qdev->listener.state = STATE_IDLE;
pthread_mutex_unlock(&qdev->lock);
ALOGE("Fingerprint ID %d not found", fid);
return FINGERPRINT_ERROR;
}
qdev->listener.secureid[idx] = 0;
qdev->listener.fingerid[idx] = 0;
saveFingerprint(&qdev->listener, idx);
qdev->listener.state = STATE_IDLE;
pthread_mutex_unlock(&qdev->lock);
msg.type = FINGERPRINT_TEMPLATE_REMOVED;
msg.data.removed.finger.fid = fid;
device->notify(&msg);
}
return 0;
}
static int set_notify_callback(struct fingerprint_device *device,
fingerprint_notify_t notify) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
if (device == NULL || notify == NULL) {
ALOGE("Failed to set notify callback @ %p for fingerprint device %p",
device, notify);
return -1;
}
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
pthread_mutex_lock(&qdev->lock);
qdev->listener.state = STATE_IDLE;
device->notify = notify;
pthread_mutex_unlock(&qdev->lock);
ALOGD("fingerprint callback notification set");
return 0;
}
static bool is_valid_fid(qemu_fingerprint_device_t* qdev, uint64_t fid) {
int idx = 0;
if (0 == fid) { return false; }
for (idx = 0; idx < MAX_NUM_FINGERS; idx++) {
if (qdev->listener.fingerid[idx] == fid) {
return true;
}
}
return false;
}
static void send_scan_notice(qemu_fingerprint_device_t* qdev, int fid) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
// acquired message
fingerprint_msg_t acqu_msg = {0, {0}};
acqu_msg.type = FINGERPRINT_ACQUIRED;
acqu_msg.data.acquired.acquired_info = FINGERPRINT_ACQUIRED_GOOD;
// authenticated message
fingerprint_msg_t auth_msg = {0, {0}};
auth_msg.type = FINGERPRINT_AUTHENTICATED;
auth_msg.data.authenticated.finger.fid = is_valid_fid(qdev, fid) ? fid : 0;
auth_msg.data.authenticated.finger.gid = 0; // unused
auth_msg.data.authenticated.hat.version = HW_AUTH_TOKEN_VERSION;
auth_msg.data.authenticated.hat.authenticator_type =
htobe32(HW_AUTH_FINGERPRINT);
auth_msg.data.authenticated.hat.challenge = qdev->op_id;
auth_msg.data.authenticated.hat.authenticator_id = qdev->authenticator_id;
auth_msg.data.authenticated.hat.user_id = qdev->secure_user_id;
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
auth_msg.data.authenticated.hat.timestamp =
htobe64((uint64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
// pthread_mutex_lock(&qdev->lock);
qdev->device.notify(&acqu_msg);
qdev->device.notify(&auth_msg);
// pthread_mutex_unlock(&qdev->lock);
return;
}
static void send_enroll_notice(qemu_fingerprint_device_t* qdev, int fid) {
ALOGD("----------------> %s -----------------> fid %d", __FUNCTION__, fid);
if (fid == 0) {
ALOGD("Fingerprint ID is zero (invalid)");
return;
}
if (qdev->secure_user_id == 0) {
ALOGD("Secure user ID is zero (invalid)");
return;
}
// Find an available entry in the table
pthread_mutex_lock(&qdev->lock);
int idx = 0;
for (idx = 0; idx < MAX_NUM_FINGERS; idx++) {
if (qdev->listener.secureid[idx] == 0 ||
qdev->listener.fingerid[idx] == 0) {
// This entry is available
break;
}
}
if (idx >= MAX_NUM_FINGERS) {
qdev->listener.state = STATE_SCAN;
pthread_mutex_unlock(&qdev->lock);
ALOGD("Fingerprint ID table is full");
return;
}
qdev->listener.secureid[idx] = qdev->secure_user_id;
qdev->listener.fingerid[idx] = fid;
saveFingerprint(&qdev->listener, idx);
qdev->listener.state = STATE_SCAN;
pthread_mutex_unlock(&qdev->lock);
// LOCKED notification?
fingerprint_msg_t msg = {0, {0}};
msg.type = FINGERPRINT_TEMPLATE_ENROLLING;
msg.data.enroll.finger.fid = fid;
msg.data.enroll.samples_remaining = 0;
qdev->device.notify(&msg);
return;
}
static worker_state_t getListenerState(qemu_fingerprint_device_t* dev) {
ALOGV("----------------> %s ----------------->", __FUNCTION__);
worker_state_t state = STATE_IDLE;
pthread_mutex_lock(&dev->lock);
state = dev->listener.state;
pthread_mutex_unlock(&dev->lock);
return state;
}
/**
* This a very simple event loop for the fingerprint sensor. For a given state (enroll, scan),
* this would receive events from the sensor and forward them to fingerprintd using the
* notify() method.
*
* In this simple example, we open a qemu channel (a pipe) where the developer can inject events to
* exercise the API and test application code.
*
* The scanner should remain in the scanning state until either an error occurs or the operation
* completes.
*
* Recoverable errors such as EINTR should be handled locally; they should not
* be propagated unless there's something the user can do about it (e.g. "clean sensor"). Such
* messages should go through the onAcquired() interface.
*
* If an unrecoverable error occurs, an acquired message (e.g. ACQUIRED_PARTIAL) should be sent,
* followed by an error message (e.g. FINGERPRINT_ERROR_UNABLE_TO_PROCESS).
*
* Note that this event loop would typically run in TEE since it must interact with the sensor
* hardware and handle raw fingerprint data and encrypted templates. It is expected that
* this code monitors the TEE for resulting events, such as enrollment and authentication status.
* Here we just have a very simple event loop that monitors a qemu channel for pseudo events.
*/
static void* listenerFunction(void* data) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)data;
pthread_mutex_lock(&qdev->lock);
qdev->qchanfd = qemud_channel_open(FINGERPRINT_LISTEN_SERVICE_NAME);
if (qdev->qchanfd < 0) {
ALOGE("listener cannot open fingerprint listener service exit");
pthread_mutex_unlock(&qdev->lock);
return NULL;
}
qdev->listener.state = STATE_IDLE;
pthread_mutex_unlock(&qdev->lock);
const char* cmd = "listen";
if (qemud_channel_send(qdev->qchanfd, cmd, strlen(cmd)) < 0) {
ALOGE("cannot write fingerprint 'listen' to host");
goto done_quiet;
}
int comm_errors = 0;
struct pollfd pfd = {
.fd = qdev->qchanfd,
.events = POLLIN,
};
while (1) {
int size = 0;
int fid = 0;
char buffer[MAX_COMM_CHARS] = {0};
bool disconnected = false;
while (1) {
if (getListenerState(qdev) == STATE_EXIT) {
ALOGD("Received request to exit listener thread");
goto done;
}
// Reset revents before poll() (just to be safe)
pfd.revents = 0;
// Poll qemud channel for 5 seconds
// TODO: Eliminate the timeout so that polling can be interrupted
// instantly. One possible solution is to follow the example of
// android::Looper ($AOSP/system/core/include/utils/Looper.h and
// $AOSP/system/core/libutils/Looper.cpp), which makes use of an
// additional file descriptor ("wake event fd").
int nfds = poll(&pfd, 1, 5000);
if (nfds < 0) {
ALOGE("Could not poll qemud channel: %s", strerror(errno));
goto done;
}
if (!nfds) {
// poll() timed out - try again
continue;
}
// assert(nfds == 1)
if (pfd.revents & POLLIN) {
// Input data being available doesn't rule out a disconnection
disconnected = pfd.revents & (POLLERR | POLLHUP);
break; // Exit inner while loop
} else {
// Some event(s) other than "input data available" occurred,
// i.e. POLLERR or POLLHUP, indicating a disconnection
ALOGW("Lost connection to qemud channel");
goto done;
}
}
// Shouldn't block since we were just notified of a POLLIN event
if ((size = qemud_channel_recv(qdev->qchanfd, buffer,
sizeof(buffer) - 1)) > 0) {
buffer[size] = '\0';
if (sscanf(buffer, "on:%d", &fid) == 1) {
if (fid > 0 && fid <= MAX_FID_VALUE) {
switch (qdev->listener.state) {
case STATE_ENROLL:
send_enroll_notice(qdev, fid);
break;
case STATE_SCAN:
send_scan_notice(qdev, fid);
break;
default:
ALOGE("fingerprint event listener at unexpected "
"state 0%x",
qdev->listener.state);
}
} else {
ALOGE("fingerprintid %d not in valid range [%d, %d] and "
"will be "
"ignored",
fid, 1, MAX_FID_VALUE);
continue;
}
} else if (strncmp("off", buffer, 3) == 0) {
// TODO: Nothing to do here ? Looks valid
ALOGD("fingerprint ID %d off", fid);
} else {
ALOGE("Invalid command '%s' to fingerprint listener", buffer);
}
if (disconnected) {
ALOGW("Connection to qemud channel has been lost");
break;
}
} else {
ALOGE("fingerprint listener receive failure");
if (comm_errors > MAX_COMM_ERRORS)
break;
}
}
done:
ALOGD("Listener exit with %d receive errors", comm_errors);
done_quiet:
close(qdev->qchanfd);
return NULL;
}
static int fingerprint_close(hw_device_t* device) {
ALOGD("----------------> %s ----------------->", __FUNCTION__);
if (device == NULL) {
ALOGE("fingerprint hw device is NULL");
return -1;
}
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)device;
pthread_mutex_lock(&qdev->lock);
// Ask listener thread to exit
qdev->listener.state = STATE_EXIT;
pthread_mutex_unlock(&qdev->lock);
pthread_join(qdev->listener.thread, NULL);
pthread_mutex_destroy(&qdev->lock);
free(qdev);
return 0;
}
static int fingerprint_open(const hw_module_t* module, const char __unused *id,
hw_device_t** device)
{
ALOGD("----------------> %s ----------------->", __FUNCTION__);
if (device == NULL) {
ALOGE("NULL device on open");
return -EINVAL;
}
qemu_fingerprint_device_t* qdev = (qemu_fingerprint_device_t*)calloc(
1, sizeof(qemu_fingerprint_device_t));
if (qdev == NULL) {
ALOGE("Insufficient memory for virtual fingerprint device");
return -ENOMEM;
}
qdev->device.common.tag = HARDWARE_DEVICE_TAG;
qdev->device.common.version = HARDWARE_MODULE_API_VERSION(2, 1);
qdev->device.common.module = (struct hw_module_t*)module;
qdev->device.common.close = fingerprint_close;
qdev->device.pre_enroll = fingerprint_pre_enroll;
qdev->device.enroll = fingerprint_enroll;
qdev->device.post_enroll = fingerprint_post_enroll;
qdev->device.get_authenticator_id = fingerprint_get_auth_id;
qdev->device.set_active_group = fingerprint_set_active_group;
qdev->device.authenticate = fingerprint_authenticate;
qdev->device.cancel = fingerprint_cancel;
qdev->device.enumerate = fingerprint_enumerate;
qdev->device.remove = fingerprint_remove;
qdev->device.set_notify = set_notify_callback;
qdev->device.notify = NULL;
// init and create listener thread
pthread_mutex_init(&qdev->lock, NULL);
if (pthread_create(&qdev->listener.thread, NULL, listenerFunction, qdev) !=
0)
return -1;
// "Inheritance" / casting
*device = &qdev->device.common;
return 0;
}
static struct hw_module_methods_t fingerprint_module_methods = {
.open = fingerprint_open,
};
fingerprint_module_t HAL_MODULE_INFO_SYM = {
.common = {
.tag = HARDWARE_MODULE_TAG,
.module_api_version = FINGERPRINT_MODULE_API_VERSION_2_1,
.hal_api_version = HARDWARE_HAL_API_VERSION,
.id = FINGERPRINT_HARDWARE_MODULE_ID,
.name = "Emulator Fingerprint HAL",
.author = "The Android Open Source Project",
.methods = &fingerprint_module_methods,
},
};