From 2f41fd2d2ff6ba2a74572309d9e6858967b140d6 Mon Sep 17 00:00:00 2001 From: ljzyal Date: Tue, 6 Sep 2016 18:49:54 +0800 Subject: [PATCH] klte: Use new Fingerprint Hal without ValidityService * Use a fully OSS FPS stack to remove dependency on a service to register fingerprints and hacked up touchwiz libs from Samsung Change-Id: I66ae7fc807a213befdf77d0f09d38f2fbe01df61 --- common-proprietary-files.txt | 8 - fingerprint/Android.mk | 17 +- fingerprint/QSEEComAPI.c | 164 ++++ fingerprint/QSEEComAPI.h | 299 +++++++ fingerprint/fingerprint.c | 583 ++++++++------ fingerprint/fingerprint_common.h | 77 ++ fingerprint/fingerprint_tz.c | 735 ++++++++++++++++++ fingerprint/fingerprint_tz.h | 136 ++++ fingerprint/fp_klte.h | 115 +-- fingerprint/hash.c | 206 +++++ fingerprint/hash.h | 47 ++ fingerprint/vfs61xx_ioctl.h | 115 +++ klte.mk | 3 +- rootdir/etc/init.qcom.rc | 6 - sepolicy/file_contexts | 1 - sepolicy/fingerprintd.te | 14 +- sepolicy/system_app.te | 7 - sepolicy/vcs.te | 22 - validityservice/Android.mk | 33 - validityservice/AndroidManifest.xml | 37 - validityservice/proguard.flags | 2 - validityservice/res/drawable/icon.png | Bin 10486 -> 0 bytes validityservice/res/values/strings.xml | 20 - .../validity/fingerprint/ConsumerInfo.java | 32 - .../fingerprint/EnrollCaptureStatus.java | 32 - .../com/validity/fingerprint/EnrollUser.java | 30 - .../com/validity/fingerprint/Fingerprint.java | 211 ----- .../fingerprint/FingerprintBitmap.java | 26 - .../validity/fingerprint/FingerprintCore.java | 230 ------ .../fingerprint/FingerprintEvent.java | 24 - .../validity/fingerprint/IdentifyResult.java | 33 - .../validity/fingerprint/RemoveEnroll.java | 24 - .../com/validity/fingerprint/SensorInfo.java | 25 - .../src/com/validity/fingerprint/VLog.java | 56 -- .../validity/fingerprint/ValidityService.java | 390 ---------- .../fingerprint/ValidityServiceStarter.java | 36 - .../com/validity/fingerprint/VcsAddInfo.java | 31 - .../validity/fingerprint/VcsByteArray.java | 23 - .../com/validity/fingerprint/VcsEvents.java | 179 ----- .../src/com/validity/fingerprint/VcsInt.java | 23 - .../validity/fingerprint/VcsStringArray.java | 23 - 41 files changed, 2191 insertions(+), 1884 deletions(-) create mode 100644 fingerprint/QSEEComAPI.c create mode 100644 fingerprint/QSEEComAPI.h create mode 100644 fingerprint/fingerprint_common.h create mode 100644 fingerprint/fingerprint_tz.c create mode 100644 fingerprint/fingerprint_tz.h create mode 100644 fingerprint/hash.c create mode 100644 fingerprint/hash.h create mode 100644 fingerprint/vfs61xx_ioctl.h delete mode 100644 sepolicy/system_app.te delete mode 100644 sepolicy/vcs.te delete mode 100644 validityservice/Android.mk delete mode 100644 validityservice/AndroidManifest.xml delete mode 100644 validityservice/proguard.flags delete mode 100644 validityservice/res/drawable/icon.png delete mode 100644 validityservice/res/values/strings.xml delete mode 100644 validityservice/src/com/validity/fingerprint/ConsumerInfo.java delete mode 100644 validityservice/src/com/validity/fingerprint/EnrollCaptureStatus.java delete mode 100644 validityservice/src/com/validity/fingerprint/EnrollUser.java delete mode 100644 validityservice/src/com/validity/fingerprint/Fingerprint.java delete mode 100644 validityservice/src/com/validity/fingerprint/FingerprintBitmap.java delete mode 100644 validityservice/src/com/validity/fingerprint/FingerprintCore.java delete mode 100644 validityservice/src/com/validity/fingerprint/FingerprintEvent.java delete mode 100644 validityservice/src/com/validity/fingerprint/IdentifyResult.java delete mode 100644 validityservice/src/com/validity/fingerprint/RemoveEnroll.java delete mode 100644 validityservice/src/com/validity/fingerprint/SensorInfo.java delete mode 100644 validityservice/src/com/validity/fingerprint/VLog.java delete mode 100644 validityservice/src/com/validity/fingerprint/ValidityService.java delete mode 100644 validityservice/src/com/validity/fingerprint/ValidityServiceStarter.java delete mode 100644 validityservice/src/com/validity/fingerprint/VcsAddInfo.java delete mode 100644 validityservice/src/com/validity/fingerprint/VcsByteArray.java delete mode 100644 validityservice/src/com/validity/fingerprint/VcsEvents.java delete mode 100644 validityservice/src/com/validity/fingerprint/VcsInt.java delete mode 100644 validityservice/src/com/validity/fingerprint/VcsStringArray.java diff --git a/common-proprietary-files.txt b/common-proprietary-files.txt index ada18b9..ce354fe 100644 --- a/common-proprietary-files.txt +++ b/common-proprietary-files.txt @@ -224,14 +224,6 @@ vendor/lib/libwvm.so vendor/lib/libWVStreamControlAPI_L1.so vendor/lib/mediadrm/libwvdrmengine.so -# Fingerprint -bin/vcsFPService -lib/libfpasmtztransport.so -lib/libvalAuth.so -lib/libvcsfp.so -lib/libvfmClient.so -lib/libvfmtztransport.so - # Graphics vendor/lib/egl/eglsubAndroid.so vendor/lib/egl/libEGL_adreno.so diff --git a/fingerprint/Android.mk b/fingerprint/Android.mk index 7ba5599..e6c96aa 100644 --- a/fingerprint/Android.mk +++ b/fingerprint/Android.mk @@ -1,6 +1,6 @@ # -# Copyright (C) 2016 The CyanogenMod Project # Copyright (C) 2016 The Mokee Project +# Copyright (C) 2016 The CyanogenMod Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -21,8 +21,19 @@ include $(CLEAR_VARS) LOCAL_MODULE := fingerprint.msm8974 LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw -LOCAL_SRC_FILES := fingerprint.c -LOCAL_SHARED_LIBRARIES := liblog +LOCAL_SRC_FILES := \ + fingerprint.c \ + fingerprint_tz.c \ + QSEEComAPI.c \ + hash.c + +LOCAL_C_INCLUDES += \ + external/sqlite/dist + +LOCAL_SHARED_LIBRARIES := \ + liblog \ + libsqlite + LOCAL_MODULE_TAGS := optional include $(BUILD_SHARED_LIBRARY) diff --git a/fingerprint/QSEEComAPI.c b/fingerprint/QSEEComAPI.c new file mode 100644 index 0000000..b5dd507 --- /dev/null +++ b/fingerprint/QSEEComAPI.c @@ -0,0 +1,164 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * Copyright (C) 2016 The CyanogenMod Project + * Copyright (C) 2016 The Mokee 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. + */ + +#define LOG_TAG "Custom_QSEE" +#define LOG_NDEBUG 0 + +#include + +#include +#include + +#include "QSEEComAPI.h" + +struct qcom_keymaster_handle { + void *libhandle; + int (*QSEECom_start_app)(struct QSEECom_handle ** handle, const char* path, + const char* appname, uint32_t size); + int (*QSEECom_shutdown_app)(struct QSEECom_handle **handle); + int (*QSEECom_send_cmd)(struct QSEECom_handle* handle, void *cbuf, + uint32_t clen, void *rbuf, uint32_t rlen); + int (*QSEECom_send_modified_cmd)(struct QSEECom_handle* handle, void *cbuf, + uint32_t clen, void *rbuf, uint32_t rlen, + struct QSEECom_ion_fd_info *ihandle); + int (*QSEECom_set_bandwidth)(struct QSEECom_handle* handle, bool high); +}; +typedef struct qcom_keymaster_handle qcom_keymaster_handle_t; + +bool init = false; +qcom_keymaster_handle_t* km_handle; +int file_num = 0; + +static int qcom_km_get_lib_sym(qcom_keymaster_handle_t* km_handle) +{ + km_handle->libhandle = dlopen("libQSEEComAPI.so", RTLD_NOW); + if ( km_handle->libhandle ) { + *(void **)(&km_handle->QSEECom_start_app) = + dlsym(km_handle->libhandle,"QSEECom_start_app"); + if (km_handle->QSEECom_start_app == NULL) { + ALOGE("dlsym: Error Loading QSEECom_start_app"); + dlclose(km_handle->libhandle ); + km_handle->libhandle = NULL; + return -1; + } + *(void **)(&km_handle->QSEECom_shutdown_app) = + dlsym(km_handle->libhandle,"QSEECom_shutdown_app"); + if (km_handle->QSEECom_shutdown_app == NULL) { + ALOGE("dlsym: Error Loading QSEECom_shutdown_app"); + dlclose(km_handle->libhandle ); + km_handle->libhandle = NULL; + return -1; + } + *(void **)(&km_handle->QSEECom_send_cmd) = + dlsym(km_handle->libhandle,"QSEECom_send_cmd"); + if (km_handle->QSEECom_send_cmd == NULL) { + ALOGE("dlsym: Error Loading QSEECom_send_cmd"); + dlclose(km_handle->libhandle ); + km_handle->libhandle = NULL; + return -1; + } + *(void **)(&km_handle->QSEECom_send_modified_cmd) = + dlsym(km_handle->libhandle,"QSEECom_send_modified_cmd"); + if (km_handle->QSEECom_send_modified_cmd == NULL) { + ALOGE("dlsym: Error Loading QSEECom_send_modified_cmd"); + dlclose(km_handle->libhandle ); + km_handle->libhandle = NULL; + return -1; + } + *(void **)(&km_handle->QSEECom_set_bandwidth) = + dlsym(km_handle->libhandle,"QSEECom_set_bandwidth"); + if (km_handle->QSEECom_set_bandwidth == NULL) { + ALOGE("dlsym: Error Loading QSEECom_set_bandwidth"); + dlclose(km_handle->libhandle ); + km_handle->libhandle = NULL; + return -1; + } + + } else { + ALOGE("failed to load qseecom library"); + return -1; + } + return 0; +} + +static int init_qsee() +{ + if (init) { + return 0; + } + int ret = 0; + km_handle = (qcom_keymaster_handle_t *)malloc(sizeof(qcom_keymaster_handle_t)); + if (km_handle == NULL) { + ALOGE("Memalloc for keymaster handle failed"); + return -1; + } + km_handle->libhandle = NULL; + ret = qcom_km_get_lib_sym(km_handle); + if (ret) { + free(km_handle); + return -1; + } + init = true; + return 0; +} + + +int QSEECom_start_app(struct QSEECom_handle **clnt_handle, const char *path, + const char *fname, uint32_t sb_size) +{ + init_qsee(); + int ret = 0; + ret = (*km_handle->QSEECom_start_app)(clnt_handle,path,fname,sb_size); + return ret; +} + +int QSEECom_shutdown_app(struct QSEECom_handle **handle) +{ + init_qsee(); + int ret = 0; + ret = (*km_handle->QSEECom_shutdown_app)(handle); + return ret; +} + +int QSEECom_send_cmd(struct QSEECom_handle *handle, void *send_buf, + uint32_t sbuf_len, void *rcv_buf, uint32_t rbuf_len) +{ + init_qsee(); + int ret = 0; + ret = (*km_handle->QSEECom_send_cmd)(handle,send_buf,sbuf_len,rcv_buf,rbuf_len); + return ret; +} + +int QSEECom_send_modified_cmd(struct QSEECom_handle *handle, void *send_buf, + uint32_t sbuf_len, void *resp_buf, uint32_t rbuf_len, + struct QSEECom_ion_fd_info *ifd_data) +{ + init_qsee(); + int ret = 0; + ret = (*km_handle->QSEECom_send_modified_cmd)(handle,send_buf,sbuf_len,resp_buf,rbuf_len,ifd_data); + return ret; +} + +int QSEECom_set_bandwidth(struct QSEECom_handle *handle, bool high) +{ + init_qsee(); + int ret = 0; + ret = (*km_handle->QSEECom_set_bandwidth)(handle,high); + return ret; +} + diff --git a/fingerprint/QSEEComAPI.h b/fingerprint/QSEEComAPI.h new file mode 100644 index 0000000..a96cda3 --- /dev/null +++ b/fingerprint/QSEEComAPI.h @@ -0,0 +1,299 @@ +/* + * Copyright (c) 2012, 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. + */ + +#ifndef __QSEECOMAPI_H_ +#define __QSEECOMAPI_H_ + + +/*---------------------------------------------------------------------------- + * Include Files +* -------------------------------------------------------------------------*/ +#include +#include + +#define QSEECOM_ALIGN_SIZE 0x40 +#define QSEECOM_ALIGN_MASK (QSEECOM_ALIGN_SIZE - 1) +#define QSEECOM_ALIGN(x) \ + ((x + QSEECOM_ALIGN_SIZE) & (~QSEECOM_ALIGN_MASK)) + +#ifdef __cplusplus +extern "C" { +#endif + +/*---------------------------------------------------------------------------- + * Preprocessor Definitions and Constants + * -------------------------------------------------------------------------*/ +/** The memory is locked and non-pageable */ +#define MEM_LOCKED 0x00000001 +/** The memory is marked non-cacheable */ +#define MEM_NON_CACHED 0x00000002 + +#define QSEECOM_APP_QUERY_FAILED -6 +#define QSEECOM_APP_NOT_LOADED -5 +#define QSEECOM_APP_ALREADY_LOADED -4 +#define QSEECOM_LISTENER_UNREGISTERED -3 +#define QSEECOM_LISTENER_ALREADY_REGISTERED -2 +#define QSEECOM_LISTENER_REGISTER_FAIL -1 + +/*---------------------------------------------------------------------------- + * Type Declarations + * -------------------------------------------------------------------------*/ +struct QSEECom_handle { + unsigned char *ion_sbuffer; +}; + +struct QSEECom_ion_fd_data { + int32_t fd; + uint32_t cmd_buf_offset; +}; + +struct QSEECom_ion_fd_info { + struct QSEECom_ion_fd_data data[4]; +}; + +/*---------------------------------------------------------------------------- + * Function Declarations and Documentation + * -------------------------------------------------------------------------*/ +/** + * @brief Open a handle to the QSEECom device. + * + * - Load a secure application. The application will be verified that it is + * secure by digital signature verification. + * Allocate memory for sending requests to the QSAPP + * + * Note/Comments: + * There is a one-to-one relation for a HLOS client and a QSAPP; + * meaning that only one app can communicate to a QSAPP at a time. + * + * Please note that there is difference between an application and a listener + * service. A QSAPP must be loaded at the request of the HLOS, + * and all requests are orginated by the HLOS client. + * A listener service on the otherhand is started during start-up by a + * daemon, qseecomd. + * + * A HLOS application may create mutiple handles to the QSAPP + * + * @param[in/out] handle The device handle + * @param[in] fname The directory and filename to load. + * @param[in] sb_size Size of the shared buffer memory for sending requests. + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_start_app(struct QSEECom_handle **clnt_handle, const char *path, + const char *fname, uint32_t sb_size); + +/** + * @brief Close the application associated with the handle. + * + * - Unload a secure application. The driver will verify if there exists + * any other applications that are communicating with the QSAPP to which + * the "handle" is tied. + * - De-allocate memory for sending requests to QSAPP. + * + * @param[in] handle The device handle + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_shutdown_app(struct QSEECom_handle **handle); + +/** + * @brief Open a handle to the QSEECom device. + * + * - Load an external elf. The elf will be verified that it is + * secure by digital signature verification. + * + * A HLOS application may create mutiple opens (only one is permitted for the + * app, but each listener service can open a unique device in the same HLOS app + * /executable. + * @param[in/out] handle The device handle + * @param[in] fname The directory and filename to load. + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_load_external_elf(struct QSEECom_handle **clnt_handle, const char *path, + const char *fname); + +/** + * @brief Close the external elf + * + * - Unload an external elf. + * + * @param[in] handle The device handle + * + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_unload_external_elf(struct QSEECom_handle **handle); + +/** + * @brief Register an HLOS listener service. This allows messages from QSAPP + * to be received. + * + * @param[in] handle The device handle + * @param[in] lstnr_id The listener service identifier. This ID must be uniquely + * assigned to avoid any collisions. + * @param[in] sb_length Shared memory buffer between OS and QSE. + * @param[in] flags Provide the shared memory flags attributes. + * + * @return Zero on success, negative on failure. errno will be set on + * error. + * + */ +int QSEECom_register_listener(struct QSEECom_handle **handle, + uint32_t lstnr_id, uint32_t sb_length, uint32_t flags); + +/** + * @brief Unregister a listener service. + * + * @param[in] handle The device handle + * + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_unregister_listener(struct QSEECom_handle *handle); + + +/** + * @brief Send QSAPP a "user" defined buffer (may contain some message/ + * command request) and receives a response from QSAPP in receive buffer. + * The HLOS client writes to the send_buf, where QSAPP writes to the rcv_buf. + * This is a blocking call. + * + * @param[in] handle The device handle + * @param[in] send_buf The buffer to be sent. + * If using ion_sbuffer, ensure this + * QSEECOM_BUFFER_ALIGN'ed. + * @param[in] sbuf_len The send buffer length + * If using ion_sbuffer, ensure length is + * multiple of QSEECOM_BUFFER_ALIGN. + * @param[in] rcv_buf The QSEOS returned buffer. + * If using ion_sbuffer, ensure this is + * QSEECOM_BUFFER_ALIGN'ed. + * @param[in] rbuf_len The returned buffer length. + * If using ion_sbuffer, ensure length is + * multiple of QSEECOM_BUFFER_ALIGN. + * @param[in] rbuf_len The returned buffer length. + * + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_send_cmd(struct QSEECom_handle *handle, void *send_buf, + uint32_t sbuf_len, void *rcv_buf, uint32_t rbuf_len); + + +/** + * @brief Send QSAPP a "user" defined buffer (may contain some message/ + * command request) and receives a response from QSAPP in receive buffer. + * This API is same as send_cmd except it takes in addition parameter, + * "ifd_data". This "ifd_data" holds information (ion fd handle and + * cmd_buf_offset) used for modifying data in the message in send_buf + * at an offset. Essentailly, it has the ion fd handle information to + * retrieve physical address and modify the message in send_buf at the + * mentioned offset. + * + * The HLOS client writes to the send_buf, where QSAPP writes to the rcv_buf. + * This is a blocking call. + * + * @param[in] handle The device handle + * @param[in] send_buf The buffer to be sent. + * If using ion_sbuffer, ensure this + * QSEECOM_BUFFER_ALIGN'ed. + * @param[in] sbuf_len The send buffer length + * If using ion_sbuffer, ensure length is + * multiple of QSEECOM_BUFFER_ALIGN. + * @param[in] rcv_buf The QSEOS returned buffer. + * If using ion_sbuffer, ensure this is + * QSEECOM_BUFFER_ALIGN'ed. + * @param[in] rbuf_len The returned buffer length. + * If using ion_sbuffer, ensure length is + * multiple of QSEECOM_BUFFER_ALIGN. + * @param[in] QSEECom_ion_fd_info data related to memory allocated by ion. + * + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_send_modified_cmd(struct QSEECom_handle *handle, void *send_buf, + uint32_t sbuf_len, void *resp_buf, uint32_t rbuf_len, + struct QSEECom_ion_fd_info *ifd_data); + +/** + * @brief Receive a service defined buffer. + * + * @param[in] handle The device handle + * @param[out] buf The buffer that is received + * @param[in] len The receive buffer length + * + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_receive_req(struct QSEECom_handle *handle, + void *buf, uint32_t len); + +/** + * @brief Send a response based on the previous QSEECom_receive_req. + * + * This allows a listener service to receive a command (e.g. read file abc). + * The service can then handle the request from QSEECom_receive_req, and provide + * that information back to QSAPP. + * + * This allows the HLOS to act as the server and QSAPP to behave as the client. + * + * @param[in] handle The device handle + * @param[out] send_buf The buffer to be returned back to QSAPP + * @param[in] len The send buffer length + * + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_send_resp(struct QSEECom_handle *handle, + void *send_buf, uint32_t len); + +/** + * @brief Set the bandwidth for QSEE. + * + * This API resulst in improving the performance on the Crypto hardware + * in QSEE. It should be called before issuing send_cmd/send_modified_cmd + * for commands that requires using the crypto hardware on the QSEE. + * Typically this API should be called before issuing the send request to + * enable high performance mode and after completion of the send_cmd to + * resume to low performance and hence to low power mode. + * + * This allows the clients of QSEECom to set the QSEE cyptpo HW bus + * bandwidth to high/low. + * + * @param[in] high Set to 1 to enable bandwidth. + * + * @return Zero on success, negative on failure. errno will be set on + * error. + */ +int QSEECom_set_bandwidth(struct QSEECom_handle *handle, bool high); + +/** + * @brief Query QSEE to check if app is loaded. + * + * This API queries QSEE to see if the app is loaded or not. + * + * @param[in] app_name Name of the app. + * + * @return QSEECOM_APP_QUERY_FAILED/QSEECOM_APP_NOT_LOADED/QSEECOM_APP_LOADED. + */ +int QSEECom_app_load_query(struct QSEECom_handle *handle, char *app_name); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/fingerprint/fingerprint.c b/fingerprint/fingerprint.c index e619f14..543f04c 100644 --- a/fingerprint/fingerprint.c +++ b/fingerprint/fingerprint.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2014 The Android Open Source Project + * Copyright (C) 2016 The Android Open Source Project * Copyright (C) 2016 The Mokee Project * Copyright (C) 2016 The CyanogenMod Project * @@ -21,71 +21,288 @@ #include #include +#include #include #include +#include +#include #include -#include -#include -#include -#include #include +#include +#include + +#include +#include + #include "fp_klte.h" +#include "fingerprint_tz.h" +#include "hash.h" -#define MAX_COMM_CHARS 128 -#define MAX_NUM_FINGERS 5 -#define SOCKET_NAME_SEND "validityservice" -#define SOCKET_NAME_RECEIVE "validityservice_callback" +typedef struct vcs_fingerprint_device_t { + fingerprint_device_t device; // "inheritance" + uint64_t op_id; + uint64_t challenge; + uint64_t user_id; + uint64_t group_id; + uint64_t secure_user_id; + uint64_t authenticator_id; + uint32_t active_gid; + sqlite3 *db; + pthread_mutex_t lock; +} vcs_fingerprint_device_t; -/******************************************************************************/ -static void checkinit(vcs_fingerprint_device_t* vdev) { //wait for hal connect validity service - while(!vdev->init) - sleep(1); -} +extern trust_zone_t tz; +vcs_sensor_t sensor; -static int sendcommand(vcs_fingerprint_device_t* vdev, uint8_t* command, int num) { - int ret = -1; - char answer[255]; - if (fd_write(vdev->send_fd, command, num) != num) { - ALOGE("cannot send command to service"); - //close(vdev->send_fd); +/***************************************Sensor***************************************/ +int sensor_uninit() { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + int ret = 0; + if (!sensor.init) return ret; - } - if (fd_read(vdev->send_fd, answer, 255)) - ret = atoi(answer); + ioctl(sensor.fd, VFSSPI_IOCTL_RESET_SPI_CONFIGURATION); + ioctl(sensor.fd, VFSSPI_IOCTL_DISABLE_SPI_CLOCK); + ioctl(sensor.fd, VFSSPI_IOCTL_DEVICE_SUSPEND); + ioctl(sensor.fd, VFSSPI_IOCTL_POWER_OFF); + sensor.init = false; return ret; } -static int getfingermask(vcs_fingerprint_device_t* vdev) { - uint8_t command_getlist[2] = {CALL_GET_ENROLLED_FINGER_LIST, (uint8_t)vdev->active_gid}; - return sendcommand(vdev, command_getlist, 2); +int sensor_init() { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + int ret = 0; + int clock = 0; + if (sensor.init) + return ret; + ioctl(sensor.fd, VFSSPI_IOCTL_POWER_ON); + clock = 65535; + ioctl(sensor.fd, VFSSPI_IOCTL_SET_CLK, &clock); + ioctl(sensor.fd, VFSSPI_IOCTL_DEVICE_RESET); + ioctl(sensor.fd, VFSSPI_IOCTL_SET_SPI_CONFIGURATION); + clock = 4800; + ioctl(sensor.fd, VFSSPI_IOCTL_SET_CLK, &clock); + sensor.init = true; + return ret; } -static int initService(vcs_fingerprint_device_t* vdev) { +void sensor_process_signal(int signum) { ALOGV("----------------> %s ----------------->", __FUNCTION__); - int ret = -EINVAL; - while (vdev->send_fd <= 0) { - vdev->send_fd = socket_local_client(SOCKET_NAME_SEND, ANDROID_SOCKET_NAMESPACE_ABSTRACT,SOCK_STREAM); - if (vdev->send_fd < 0) { - ALOGW("cannot open validity service!"); - sleep(1); + ALOGV("%s: signal %d received", __FUNCTION__, signum); + int flag = 0; + if (tz.timeout.timeout_thread) { + pthread_mutex_lock(&tz.timeout.lock); + pthread_cond_signal(&tz.timeout.cond); + pthread_mutex_unlock(&tz.timeout.lock); + //pthread_join(tz.timeout.timeout_thread, NULL); + tz.timeout.timeout_thread = 0; + } + pthread_mutex_lock(&sensor.lock); + if (get_tz_state() != STATE_IDLE && get_tz_state() != STATE_CANCEL) + sensor.signal = true; + ioctl(sensor.fd, VFSSPI_IOCTL_SET_DRDY_INT, &flag); + pthread_cond_signal(&sensor.cond); + pthread_mutex_unlock(&sensor.lock); +} + +int sensor_register() { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + struct vfsspi_iocRegSignal usrSignal; + int ret = 0; + struct sigaction sa_usr; + sa_usr.sa_flags = 0; + sa_usr.sa_handler = sensor_process_signal; + sigaction(SIGUSR2, &sa_usr, NULL); + usrSignal.userPID = getpid(); + usrSignal.signalID = SIGUSR2; + ioctl(sensor.fd, VFSSPI_IOCTL_REGISTER_DRDY_SIGNAL, &usrSignal); + return ret; +} + +int sensor_capture_start() { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + int ret = 0; + int flag = 1; + ret = ioctl(sensor.fd, VFSSPI_IOCTL_SET_DRDY_INT, &flag); + return ret; +} + +/***************************************Database***************************************/ +int db_check_and_create_table(void* device) { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; + char* errmsg; + int ret = 0; + char cmd[MAX_DATABASE_CMD]; + sprintf(cmd, "create table gid_%d(id integer, data blob, payload blob)", vdev->active_gid); + ret = sqlite3_exec(vdev->db, cmd, NULL, NULL, &errmsg); + return ret; +} + +int db_convert_old_db(vcs_fingerprint_device_t* vdev) { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + int ret = 0; + sqlite3 *db; + sqlite3_stmt *stat; + char cmd[MAX_DATABASE_CMD]; + int idx = 0; + + memset(tz.finger, 0, MAX_NUM_FINGERS * sizeof(finger_t)); + ret = sqlite3_open(SAMSUNG_FP_DB_PATH, &db); + if (ret != SQLITE_OK) { + ALOGE("Open samsung finger database failed!"); + return -1; + } + + sprintf(cmd, "select * from enrollments"); + sqlite3_prepare(db, cmd, -1, &stat, 0); + while(1) { + int ret = sqlite3_step(stat); + if (ret != SQLITE_ROW) { + break; + } + int id = sqlite3_column_int(stat, 1); + const void *data = sqlite3_column_blob(stat, 2); + int len = sqlite3_column_bytes(stat, 2); + memcpy(tz.finger[id].data, data, len); + ALOGV("read fingerprint data from samsung fp database: id=%d", id); + tz.finger[id].exist = true; + } + sqlite3_finalize(stat); + + memset(cmd, 0, MAX_DATABASE_CMD); + sprintf(cmd, "select * from properties"); + sqlite3_prepare(db, cmd, -1, &stat, 0); + sqlite3_step(stat); + const void *payload = sqlite3_column_blob(stat, 2); + int len = sqlite3_column_bytes(stat, 2); + for (idx = 1; idx <= MAX_NUM_FINGERS; idx++) { + if (tz.finger[idx].exist) { + memcpy(tz.finger[idx].payload, payload, len); + db_write_to_db(vdev, false, idx); } } - uint8_t command[1] = {CALL_INITSERVICE}; + sqlite3_finalize(stat); - ret = sendcommand(vdev, command, 1); - vdev->authenticator_id = getfingermask(vdev); - vdev->init = true; + ret = sqlite3_close(db); + if (ret != SQLITE_OK) { + ALOGE("Close samsung finger database failed!"); + return -1; + } + + ret = remove(SAMSUNG_FP_DB_PATH); + if (ret) { + ALOGE("Cannot remove Samsung fingerprint database"); + } return ret; } -static void send_error_notice(vcs_fingerprint_device_t* vdev, fingerprint_error_t error_info) { +int db_read_to_tz(void* device) { ALOGV("----------------> %s ----------------->", __FUNCTION__); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; + char* errmsg; + int ret = 0; + char cmd[MAX_DATABASE_CMD]; + sqlite3_stmt *stat; + + db_check_and_create_table(vdev); + + if (!access(SAMSUNG_FP_DB_PATH, 0)) { + ALOGI("Samsung fingerprint database exist! Convert it"); + return db_convert_old_db(vdev); + } + + memset(tz.finger, 0, MAX_NUM_FINGERS * sizeof(finger_t)); + sprintf(cmd, "select * from gid_%d", vdev->active_gid); + sqlite3_prepare(vdev->db, cmd, -1, &stat, 0); + while(1) { + int ret = sqlite3_step(stat); + if (ret != SQLITE_ROW) { + break; + } + int id = sqlite3_column_int(stat, 0); + const void *data = sqlite3_column_blob(stat, 1); + memcpy(tz.finger[id].data, data, FINGER_DATA_MAX_LENGTH); + const void *payload = sqlite3_column_blob(stat, 2); + memcpy(tz.finger[id].payload, payload, PAYLOAD_MAX_LENGTH); + ALOGV("read fingerprint data from database: id=%d", id); + tz.finger[id].exist = true; + } + sqlite3_finalize(stat); + + return 0; +} + +int db_write_to_db(void* device, bool remove, int fid) { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; + char* errmsg; + int ret = 0; + char cmd[MAX_DATABASE_CMD]; + sqlite3_stmt *stat; + if (remove) { + sprintf(cmd, "delete from gid_%d where id=%d", vdev->active_gid, fid); + ret = sqlite3_exec(vdev->db, cmd, NULL, NULL, &errmsg); + if (ret != SQLITE_OK) { + ALOGE("Remove finger from database failed!"); + } + memset(&tz.finger[fid], 0, sizeof(finger_t)); + } else { + sprintf(cmd, "insert into gid_%d(id, data, payload) values( %d, ?, ?)", vdev->active_gid, fid); + sqlite3_prepare(vdev->db, cmd, -1, &stat, 0); + sqlite3_bind_blob(stat, 1, tz.finger[fid].data, (int)FINGER_DATA_MAX_LENGTH, NULL); + sqlite3_bind_blob(stat, 2, tz.finger[fid].payload, (int)PAYLOAD_MAX_LENGTH, NULL); + ret = sqlite3_step(stat); + sqlite3_finalize(stat); + } + return ret; +} + +int db_init(void* device) { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; + int ret = 0; + ret = sqlite3_open(FINGER_DATABASE_FILENAME, &vdev->db); + if (ret != SQLITE_OK) { + ALOGE("Open finger database failed!"); + return -1; + } + return db_read_to_tz(vdev); +} + +int db_uninit(void* device) { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; + int ret = 0; + ret = sqlite3_close(vdev->db); + if (ret != SQLITE_OK) { + ALOGE("Close finger database failed!"); + } + return ret; +} + +/***************************************notice***************************************/ +fingerprint_acquired_info_t convert_ret_to_acquired_info(int acquired_ret) { //TODO + ALOGV("----------------> %s ----------------->acquired_ret=%d", __FUNCTION__, acquired_ret); + fingerprint_acquired_info_t ret = FINGERPRINT_ACQUIRED_GOOD; + switch (acquired_ret) { + case 0: + break; + default: + ret = FINGERPRINT_ACQUIRED_INSUFFICIENT; + } + return ret; +} + +void send_error_notice(void* device, int error_info_int) { + ALOGV("----------------> %s ----------------->", __FUNCTION__); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; + fingerprint_error_t error_info = (fingerprint_error_t)error_info_int; fingerprint_msg_t msg = {0}; msg.type = FINGERPRINT_ERROR; msg.data.error = error_info; - ALOGI("error_info=%d", (int)error_info); + ALOGV("recevied error notice! error_info=%d", (int)error_info); pthread_mutex_lock(&vdev->lock); vdev->device.notify(&msg); @@ -94,8 +311,10 @@ static void send_error_notice(vcs_fingerprint_device_t* vdev, fingerprint_error_ return; } -static void send_acquired_notice(vcs_fingerprint_device_t* vdev, fingerprint_acquired_info_t acquired_info) { +void send_acquired_notice(void* device, int acquired_ret) { ALOGV("----------------> %s ----------------->", __FUNCTION__); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; + fingerprint_acquired_info_t acquired_info = convert_ret_to_acquired_info(acquired_ret); fingerprint_msg_t acqu_msg = {0}; acqu_msg.type = FINGERPRINT_ACQUIRED; @@ -109,22 +328,21 @@ static void send_acquired_notice(vcs_fingerprint_device_t* vdev, fingerprint_acq return; } -static void send_enroll_notice(vcs_fingerprint_device_t* vdev, int fid, int remaining) { +void send_enroll_notice(void* device, int fid, int remaining) { ALOGV("----------------> %s -----------------> fid %d", __FUNCTION__, fid); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; if (fid == 0) { - ALOGD("Fingerprint ID is zero (invalid)"); + ALOGE("Fingerprint ID is zero (invalid)"); return; } if (vdev->secure_user_id == 0) { - ALOGD("Secure user ID is zero (invalid)"); + ALOGE("Secure user ID is zero (invalid)"); return; } pthread_mutex_lock(&vdev->lock); - vdev->listener.state = STATE_SCAN; - fingerprint_msg_t msg = {0}; msg.type = FINGERPRINT_TEMPLATE_ENROLLING; msg.data.enroll.finger.fid = fid; @@ -136,8 +354,9 @@ static void send_enroll_notice(vcs_fingerprint_device_t* vdev, int fid, int rema return; } -static void send_authenticated_notice(vcs_fingerprint_device_t* vdev, int fid) { +void send_authenticated_notice(void* device, int fid) { ALOGV("----------------> %s ----------------->", __FUNCTION__); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; send_acquired_notice(vdev, FINGERPRINT_ACQUIRED_GOOD); @@ -163,8 +382,9 @@ static void send_authenticated_notice(vcs_fingerprint_device_t* vdev, int fid) { return; } -static void send_remove_notice(vcs_fingerprint_device_t* vdev, int fid) { +void send_remove_notice(void* device, int fid) { ALOGV("----------------> %s ----------------->fid=%d", __FUNCTION__, fid); + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; fingerprint_msg_t msg = {0}; msg.type = FINGERPRINT_TEMPLATE_REMOVED; @@ -177,20 +397,14 @@ static void send_remove_notice(vcs_fingerprint_device_t* vdev, int fid) { return; } -/******************************************************************************/ - -static uint64_t get_64bit_rand() { - ALOGV("----------------> %s ----------------->", __FUNCTION__); - uint64_t r = (((uint64_t)rand()) << 32) | ((uint64_t)rand()); - return r != 0 ? r : 1; -} +/***************************************HAL function***************************************/ static uint64_t fingerprint_get_auth_id(struct fingerprint_device* device) { vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; ALOGV("----------------> %s ----------------->", __FUNCTION__); uint64_t authenticator_id = 0; pthread_mutex_lock(&vdev->lock); - vdev->authenticator_id = getfingermask(vdev); + vdev->authenticator_id = hash_file(FINGER_DATABASE_FILENAME); authenticator_id = vdev->authenticator_id; pthread_mutex_unlock(&vdev->lock); @@ -199,9 +413,11 @@ static uint64_t fingerprint_get_auth_id(struct fingerprint_device* device) { static int fingerprint_set_active_group(struct fingerprint_device *device, uint32_t gid, const char __unused *path) { + ALOGV("----------------> %s ----------------->", __FUNCTION__); vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; pthread_mutex_lock(&vdev->lock); vdev->active_gid = gid; + db_read_to_tz(vdev); pthread_mutex_unlock(&vdev->lock); return 0; @@ -215,33 +431,24 @@ static int fingerprint_authenticate(struct fingerprint_device *device, int ret = 0; ALOGI("auth: op_id=%llu ",operation_id); - checkinit(vdev); - pthread_mutex_lock(&vdev->lock); vdev->op_id = operation_id; - vdev->listener.state = STATE_SCAN; - uint8_t command[2] = {CALL_IDENTIFY, (uint8_t)vdev->active_gid}; - ret = sendcommand(vdev, command, 2); + ret = vcs_start_authenticate(vdev); pthread_mutex_unlock(&vdev->lock); - // Always return successful - return 0; + return ret; } 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"); + uint32_t timeout_sec) { + ALOGV("----------------> %s ----------------->", __FUNCTION__); vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; int ret = -EINVAL; - int fingermask = 0; int idx = 1; - uint8_t command[3] = {CALL_ENROLL, (uint8_t)vdev->active_gid, 0}; - - checkinit(vdev); if (!hat) { ALOGW("%s: null auth token", __func__); @@ -263,26 +470,21 @@ static int fingerprint_enroll(struct fingerprint_device *device, vdev->user_id = hat->user_id; pthread_mutex_lock(&vdev->lock); - vdev->listener.state = STATE_ENROLL; - fingermask = getfingermask(vdev); - ALOGI("fingerprint_enroll: fingermask=%d", fingermask); - for (idx = 1; idx <= MAX_NUM_FINGERS; idx++) - if (!((fingermask >> idx) & 1)) + for (idx = 1; idx <= MAX_NUM_FINGERS; idx++) { + if (!tz.finger[idx].exist) { break; - - command[2] = (uint8_t)idx; - ret = sendcommand(vdev, command, 3); + } + } + if (idx > MAX_NUM_FINGERS) { + send_error_notice(vdev, FINGERPRINT_ERROR_NO_SPACE); + pthread_mutex_unlock(&vdev->lock); + return -1; + } + ret = vcs_start_enroll(vdev, timeout_sec); pthread_mutex_unlock(&vdev->lock); - ALOGI("enroll ret=%d",ret); - - // workaround - if (ret == 1) { - ret = 0; - } - - vdev->authenticator_id = getfingermask(vdev); + ALOGV("enroll ret=%d",ret); return ret; } @@ -292,7 +494,7 @@ static uint64_t fingerprint_pre_enroll(struct fingerprint_device *device) { uint64_t challenge = 0; vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; - challenge = get_64bit_rand(); + challenge = hash_string(tz.auth_token); pthread_mutex_lock(&vdev->lock); vdev->challenge = challenge; @@ -316,15 +518,27 @@ static int fingerprint_cancel(struct fingerprint_device *device) { ALOGV("----------------> %s ----------------->", __FUNCTION__); vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; int ret = 0; + int flag = 0; - checkinit(vdev); - - pthread_mutex_lock(&vdev->lock); - vdev->listener.state = STATE_IDLE; - - uint8_t command[1] = {CALL_CANCEL}; - ret = sendcommand(vdev, command, 1); - pthread_mutex_unlock(&vdev->lock); + if (tz.timeout.timeout_thread) { + pthread_mutex_lock(&tz.timeout.lock); + pthread_cond_signal(&tz.timeout.cond); + pthread_mutex_unlock(&tz.timeout.lock); + pthread_join(tz.timeout.timeout_thread, NULL); + tz.timeout.timeout_thread = 0; + } + if (get_tz_state() != STATE_IDLE && get_tz_state() != STATE_CANCEL) { + set_tz_state(STATE_CANCEL); + ioctl(sensor.fd, VFSSPI_IOCTL_SET_DRDY_INT, &flag); + pthread_mutex_lock(&sensor.lock); + pthread_cond_signal(&sensor.cond); + pthread_mutex_unlock(&sensor.lock); + while (1) { + usleep(100000); + if (tz.state == STATE_IDLE) + break; + } + } return ret; } @@ -337,17 +551,12 @@ static int fingerprint_enumerate(struct fingerprint_device *device, return -1; } - vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; int num = 0; + + vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; + pthread_mutex_lock(&vdev->lock); - - int fingermask = getfingermask(vdev); - - ALOGI("fingerprint_enumerate: fingermask=%d", fingermask); - int idx = 0; - for (idx = 0; idx < MAX_NUM_FINGERS; idx++) - if ((fingermask >> (idx + 1)) & 1) - num++; + num = vcs_get_enrolled_finger_num(); pthread_mutex_unlock(&vdev->lock); return num; @@ -355,7 +564,7 @@ static int fingerprint_enumerate(struct fingerprint_device *device, static int fingerprint_remove(struct fingerprint_device *device, uint32_t __unused gid, uint32_t fid) { - int idx = 0, ret = 0; + int ret = 0; ALOGV("----------------> %s -----------------> fid %d", __FUNCTION__, fid); if (device == NULL) { ALOGE("Can't remove fingerprint (gid=%d, fid=%d); " @@ -366,50 +575,31 @@ static int fingerprint_remove(struct fingerprint_device *device, vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; - uint8_t command[3] = {CALL_REMOVE, (uint8_t)vdev->active_gid, 0}; - - checkinit(vdev); - if (fid == 0) { // Delete all fingerprints - command[2] = 21; - int fingermask = getfingermask(vdev); - pthread_mutex_lock(&vdev->lock); - ret = sendcommand(vdev, command, 3); - pthread_mutex_unlock(&vdev->lock); - if (ret == 0){ - pthread_mutex_lock(&vdev->lock); - pthread_mutex_unlock(&vdev->lock); - int idx = 0; - for (idx = 0; idx < MAX_NUM_FINGERS; idx++) - if ((fingermask >> (idx + 1)) & 1) { - send_remove_notice(vdev, idx + 1); + int idx = 1; + for (idx = 1; idx <= MAX_NUM_FINGERS; idx++) + if (tz.finger[idx].exist) { + pthread_mutex_lock(&vdev->lock); + ret = db_write_to_db(vdev, true, idx); + pthread_mutex_unlock(&vdev->lock); + if (ret == 0) { + send_remove_notice(vdev, idx); } - } // end if - vdev->listener.state = STATE_IDLE; + } } else { // Delete one fingerprint pthread_mutex_lock(&vdev->lock); - - command[2] = (uint8_t)fid; - ret = sendcommand(vdev, command, 3); - vdev->listener.state = STATE_IDLE; + ret = db_write_to_db(vdev, true, fid); pthread_mutex_unlock(&vdev->lock); + if (ret == 0) { + send_remove_notice(vdev, fid); + } - // Always send remove notice - send_remove_notice(vdev, fid); } - pthread_mutex_lock(&vdev->lock); - - int fingermask = getfingermask(vdev); - if (fingermask == 0) { // All finger are removed - command[2] = 21; - sendcommand(vdev, command, 3); - } - - pthread_mutex_unlock(&vdev->lock); if (ret) { + ALOGE("Can't remove finger %d", fid); send_error_notice(vdev, FINGERPRINT_ERROR_UNABLE_TO_REMOVE); } @@ -427,7 +617,6 @@ static int set_notify_callback(struct fingerprint_device *device, vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; pthread_mutex_lock(&vdev->lock); - vdev->listener.state = STATE_IDLE; device->notify = notify; pthread_mutex_unlock(&vdev->lock); ALOGD("fingerprint callback notification set"); @@ -435,78 +624,6 @@ static int set_notify_callback(struct fingerprint_device *device, return 0; } -static worker_state_t getListenerState(vcs_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; -} - -static void* listenerSocket(void* data) { - ALOGI("----------------> %s ----------------->", __FUNCTION__); - vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)data; - - while (vdev->receive_fd <= 0) { - vdev->receive_fd = socket_local_client(SOCKET_NAME_RECEIVE, ANDROID_SOCKET_NAMESPACE_ABSTRACT,SOCK_STREAM); - if (vdev->receive_fd < 0) { - ALOGW("listener cannot open fingerprint listener service"); - sleep(1); - } - } - initService(vdev); - pthread_mutex_lock(&vdev->lock); - vdev->listener.state = STATE_IDLE; - pthread_mutex_unlock(&vdev->lock); - - while (1) { - int size = 0; - char buffer[MAX_COMM_CHARS] = {0}; - if (getListenerState(vdev) == STATE_EXIT) { - ALOGD("Received request to exit listener thread"); - goto done; - } - - if ((size = fd_read(vdev->receive_fd, buffer, - sizeof(buffer) - 1)) > 0) { - buffer[size] = '\0'; - int type, info, info_ex; - sscanf(buffer, "%d:%d:%d", &type, &info, &info_ex); - switch (type) { - case 1: //error - send_error_notice(vdev, info); - break; - case 2: //enroll - send_enroll_notice(vdev, info, info_ex); - break; - case 3: //removed - send_remove_notice(vdev, info); - break; - case 4: //acquired - send_acquired_notice(vdev, info); - break; - case 5: //authenticated - send_authenticated_notice(vdev, info); - break; - default: - ALOGE("unknow type:%d", type); - } - } else { - ALOGE("fingerprint listener receive failure"); - break; - } - } - -done: - ALOGD("Listener exit !!"); -done_quiet: - close(vdev->receive_fd); - return NULL; -} - static int fingerprint_close(hw_device_t* device) { ALOGV("----------------> %s ----------------->", __FUNCTION__); if (device == NULL) { @@ -516,18 +633,18 @@ static int fingerprint_close(hw_device_t* device) { vcs_fingerprint_device_t* vdev = (vcs_fingerprint_device_t*)device; - checkinit(vdev); - pthread_mutex_lock(&vdev->lock); - // Ask listener thread to exit - vdev->listener.state = STATE_EXIT; - uint8_t command[1] = {CALL_CLEANUP}; - sendcommand(vdev, command, 1); + db_uninit(vdev); + vcs_init(); + vcs_stop_auth_session(); + vcs_uninit(); + sensor_uninit(); pthread_mutex_unlock(&vdev->lock); - pthread_join(vdev->listener.thread, NULL); pthread_mutex_destroy(&vdev->lock); - close(vdev->send_fd); + pthread_mutex_destroy(&sensor.lock); + pthread_mutex_destroy(&tz.lock); + pthread_mutex_destroy(&tz.timeout.lock); free(vdev); return 0; @@ -568,15 +685,39 @@ static int fingerprint_open(const hw_module_t* module, const char __unused *id, vdev->device.notify = NULL; vdev->active_gid = 0; - vdev->init = false; + memset(&tz, 0, sizeof(trust_zone_t)); pthread_mutex_init(&vdev->lock, NULL); - if (pthread_create(&vdev->listener.thread, NULL, listenerSocket, vdev) != - 0) - return -1; + pthread_mutex_init(&sensor.lock, NULL); + pthread_mutex_init(&tz.lock, NULL); + pthread_mutex_init(&tz.timeout.lock, NULL); + pthread_cond_init(&tz.timeout.cond, NULL); + pthread_cond_init(&sensor.cond, NULL); + tz.timeout.timeout_thread = 0; *device = &vdev->device.common; + memset(&sensor, 0, sizeof(vcs_sensor_t)); + sensor.fd = open(SENSOR_FILE_NAME, O_RDWR); + if (sensor.fd < 0) { + ALOGE("Open sensor error!"); + return -1; + } + sensor_init(); + sensor_register(); + sensor_uninit(); + + pthread_mutex_lock(&vdev->lock); + sensor_init(); + db_init(vdev); + vcs_init(); + vcs_uninit(); + vcs_init(); + vcs_start_auth_session(); + vcs_uninit(); + sensor_uninit(); + pthread_mutex_unlock(&vdev->lock); + return 0; } diff --git a/fingerprint/fingerprint_common.h b/fingerprint/fingerprint_common.h new file mode 100644 index 0000000..549429a --- /dev/null +++ b/fingerprint/fingerprint_common.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * Copyright (C) 2016 The CyanogenMod Project + * Copyright (C) 2016 The Mokee 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. + */ + +#ifndef __FINGERPRINT_COMMON_H_ +#define __FINGERPRINT_COMMON_H_ + +#include + +#define SB_LENGTH (0x100000) +#define BUFFER_LENGTH (0x19000) +#define AUTH_TOKEN_LENGTH (0x70) +#define AUTH_SESSION_TOKEN_LENGTH (0x20) +#define CALIBRATE_DATA_MAX_LENGTH (0x500c) +#define FINGER_DATA_MAX_LENGTH (0x2900) +#define PAYLOAD_MAX_LENGTH (0x24) +#define MAX_NUM_FINGERS (5) + +typedef enum worker_state_t { + STATE_IDLE = 0, + STATE_ENROLL, + STATE_SCAN, + STATE_CANCEL +} worker_state_t; + +typedef struct vcs_sensor_t { + int fd; + bool init; + bool signal; + pthread_cond_t cond; + pthread_mutex_t lock; +}vcs_sensor_t; + +typedef struct finger_t { + bool exist; + char data[FINGER_DATA_MAX_LENGTH]; + char payload[PAYLOAD_MAX_LENGTH]; +}finger_t; + +typedef struct timeout_t { + uint32_t timeout; + pthread_t timeout_thread; + pthread_cond_t cond; + pthread_mutex_t lock; +}timeout_t; + +typedef struct trust_zone_t { + bool init; + worker_state_t state; + struct QSEECom_handle *qhandle; + bool auth_session_opend; + char auth_token[AUTH_TOKEN_LENGTH]; + char auth_session_token[AUTH_SESSION_TOKEN_LENGTH]; + int calibrate_len; + char calibrate_data[CALIBRATE_DATA_MAX_LENGTH]; + finger_t finger[MAX_NUM_FINGERS + 1]; // Start from finger[1] + timeout_t timeout; + pthread_t auth_thread; + pthread_t enroll_thread; + pthread_mutex_t lock; +}trust_zone_t; + +#endif //__FINGERPRINT_COMMON_H_ diff --git a/fingerprint/fingerprint_tz.c b/fingerprint/fingerprint_tz.c new file mode 100644 index 0000000..659a519 --- /dev/null +++ b/fingerprint/fingerprint_tz.c @@ -0,0 +1,735 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * Copyright (C) 2016 The CyanogenMod Project + * Copyright (C) 2016 The Mokee 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. + */ + +#define LOG_TAG "Fingerprint_tz" +#define LOG_NDEBUG 1 + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "fingerprint_tz.h" +#include "fp_klte.h" + +extern vcs_sensor_t sensor; +trust_zone_t tz; + +worker_state_t get_tz_state() { + worker_state_t state; + + pthread_mutex_lock(&tz.lock); + state = tz.state; + pthread_mutex_unlock(&tz.lock); + + return state; +} + +void set_tz_state(worker_state_t state) { + pthread_mutex_lock(&tz.lock); + tz.state = state; + pthread_mutex_unlock(&tz.lock); +} + +/* + * cmd: vendorUpdateCalData + */ +int vcs_update_cal_data() { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_vendor_cmd_t *send_vendor_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + send_vendor_cmd = (trust_zone_vendor_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_vendor_cmd_t))); + + memset(send_vendor_cmd, 0, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_vendor_cmd->cmd = vfmVendorDefinedOperation; + send_vendor_cmd->vendor_cmd = vendorUpdateCalData; + resp->data[0] = CALIBRATE_DATA_MAX_LENGTH; + ret = QSEECom_send_cmd(handle, send_vendor_cmd, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret || resp->result) { + ALOGE("Update Cal Data error"); + return ret; + } + tz.calibrate_len = resp->data[3] + 0xf; + memcpy(&tz.calibrate_data, &resp->data[2], tz.calibrate_len); + ALOGV("Sended vendorUpdateCalData"); + return ret; +} + +int vcs_check_state() { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_base_cmd_t *send_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + send_cmd = (trust_zone_base_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(int))); + + if (get_tz_state() == STATE_IDLE) + return 1; + if (get_tz_state() == STATE_CANCEL) { + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(int)) + QSEECOM_ALIGN(sizeof(int))); + send_cmd->cmd = vfmCaptureAbort; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(int)), resp, QSEECOM_ALIGN(sizeof(int))); + set_tz_state(STATE_IDLE); + return 1; + } + return 0; +} + +/* + * cmd: 1.vfmCaptureStart + * 2.vfmCaptureReadData * N + * 3.vfmCaptureProcessData + */ +int vcs_start_capture(void *vdev, time_t t) { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_base_cmd_t *send_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + send_cmd = (trust_zone_base_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_base_cmd_t))); + + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(*send_cmd)) + QSEECOM_ALIGN(sizeof(int))); + send_cmd->cmd = vfmCaptureStart; + send_cmd->len = 0x1c; + send_cmd->data[16] = 0x1; + if (t) { + *(time_t*)(&send_cmd->data[20]) = t; + } + send_cmd->data[24] = 0xc0; + send_cmd->data[25] = 0x12; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(*send_cmd)), resp, QSEECOM_ALIGN(sizeof(int))); + if (ret || resp->result) { + ALOGE("Send vfmCaptureStart error"); + return ret; + } + vcs_update_cal_data(); + pthread_mutex_lock(&sensor.lock); + sensor_capture_start(); + pthread_mutex_unlock(&sensor.lock); + + pthread_mutex_lock(&sensor.lock); + while ((!vcs_check_state()) && !sensor.signal) { + pthread_cond_wait(&sensor.cond, &sensor.lock); + } + pthread_mutex_unlock(&sensor.lock); + if (vcs_check_state()) { + return -1; + } + pthread_mutex_lock(&sensor.lock); + if (sensor.signal == true) { + sensor.signal = false; + } + pthread_mutex_unlock(&sensor.lock); + + while(1) { + if (vcs_check_state()) { + return -1; + } + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(int))); + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(int)) + QSEECOM_ALIGN(sizeof(*resp))); + send_cmd->cmd = vfmCaptureReadData; + send_cmd->len = 0x8000; + resp->data[0] = 0xc; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(int)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret || resp->result) { + ALOGE("Send vfmCaptureReadData error"); + continue; + } + if (resp->data[2] == 2) { + ALOGV("User's finger removed from sensor"); + break; + } + //usleep(200000); + } + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_base_cmd_t))); + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(*send_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_cmd->cmd = vfmCaptureProcessData; + send_cmd->len = 0x1c; + send_cmd->data[16] = 0x1; + *(time_t*)(&send_cmd->data[20]) = time(NULL); + send_cmd->data[24] = 0xc0; + send_cmd->data[25] = 0x12; + resp->data[0] = 0xc; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(int)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret) { + ALOGE("Send vfmCaptureProcessData error"); + return -1; + } + if (resp->result != 0) { + ALOGE("resp->result=%d",resp->result); + send_acquired_notice(vdev, resp->result); + return vcs_start_capture(vdev, time(NULL)); + } + return 0; +} + +/* + * cmd: 1.vendorUnknown0 + * 2.vcs_start_capture + * 3.vfmMatchImageToTemplates + * 4.vfmPayloadRelease + */ + +void* vcs_authenticate(void* vdev) { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_vendor_cmd_t *send_vendor_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + send_vendor_cmd = (trust_zone_vendor_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_vendor_cmd_t))); + int fingerindex = 0; + int len = 0; + int fake_fid = 0; + + memset(send_vendor_cmd, 0, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_vendor_cmd->cmd = vfmVendorDefinedOperation; + send_vendor_cmd->vendor_cmd = vendorUnknown0; + resp->data[0] = 0x4; + ret = QSEECom_send_cmd(handle, send_vendor_cmd, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (resp->result) { + ALOGE("%s:Send vendor unknown 0 cmd error", __FUNCTION__); + } + while (get_tz_state() == STATE_SCAN) { + ret = vcs_start_capture(vdev, 0); + if (ret == -1) + goto out; + trust_zone_5x_cmd_t *send_5x_cmd = NULL; + trust_zone_2x_result_t *resp_2x = NULL; + int idx = 1; + send_5x_cmd = (trust_zone_5x_cmd_t *)handle->ion_sbuffer; + resp_2x = (trust_zone_2x_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_5x_cmd_t))); + + memset(send_5x_cmd, 0, QSEECOM_ALIGN(sizeof(*send_5x_cmd)) + QSEECOM_ALIGN(sizeof(*resp_2x))); + send_5x_cmd->cmd = vfmMatchImageToTemplates; + send_5x_cmd->len = 0x14; + send_5x_cmd->unknown[0] = 1; + send_5x_cmd->unknown[1] = 100000; + send_5x_cmd->time_now = time(NULL); + send_5x_cmd->data[0] = 0x1; + send_5x_cmd->data[102388] = vcs_get_enrolled_finger_num(); + len = 0; + for (idx = 1; idx <= MAX_NUM_FINGERS; idx++) + if (tz.finger[idx].exist) { + len++; + int address = 102392 + (len - 1) * 15364; + send_5x_cmd->data[address] = 0x45; + send_5x_cmd->data[address + 1] = 0x28; + memcpy(&send_5x_cmd->data[address + 4], &tz.finger[idx].data, FINGER_DATA_MAX_LENGTH); + } + resp_2x->data[0] = 0x5c; + resp_2x->data[25602] = 0x3000; + ret = QSEECom_send_cmd(handle, send_5x_cmd, QSEECOM_ALIGN(sizeof(*send_5x_cmd)), resp_2x, QSEECOM_ALIGN(sizeof(*resp_2x))); + if (ret) { + ALOGE("%s:send vfmMatchImageToTemplates error", __FUNCTION__); + send_error_notice(vdev, FINGERPRINT_ERROR_UNABLE_TO_PROCESS); + goto out; + } + if (resp_2x->result != 0) { + send_acquired_notice(vdev, resp_2x->result); + continue; + } + fake_fid = (int)resp_2x->data[22] + 1; + len = 0; + for (idx = 1; idx <= MAX_NUM_FINGERS; idx++) { + if (tz.finger[idx].exist) { + len++; + if (len == fake_fid) { + fingerindex = idx; + break; + } + } + } + ALOGV("Auth fingerindex=%d", fingerindex); + //memcpy(&tz.finger[fingerindex].data, &resp_2x->data[102419], FINGER_DATA_MAX_LENGTH); + //db_write_to_db(vdev, false, fingerindex); + + trust_zone_2x_cmd_t *send_2x_cmd = NULL; + send_2x_cmd = (trust_zone_2x_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_2x_cmd_t))); + memset(send_2x_cmd, 0, QSEECOM_ALIGN(sizeof(*send_2x_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_2x_cmd->cmd = vfmPayloadRelease; + send_2x_cmd->len = PAYLOAD_MAX_LENGTH; + memcpy(&send_2x_cmd->data, &tz.finger[fingerindex].payload, PAYLOAD_MAX_LENGTH); + resp->data[0] = 0x24; + ret = QSEECom_send_cmd(handle, send_2x_cmd, QSEECOM_ALIGN(sizeof(*send_2x_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + break; + } +out: + sensor_uninit(); + vcs_uninit(); + set_tz_state(STATE_IDLE); + if (fingerindex) { + send_authenticated_notice(vdev, fingerindex); + } + return NULL; +} + +/* + * cmd: 1.vfmEnrollBegin + * 2.vendorUnknownA + * 3.vcs_start_capture * 8 + * 4.vfmEnrollAddImage + * 5.vfmEnrollFinish + * 6.vfmPayloadBind + * 7.vfmEnrollmentPasswordSet + */ + +void* vcs_enroll(void* vdev) { + int count = 8; + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_base_cmd_t *send_cmd = NULL; + trust_zone_vendor_cmd_t *send_vendor_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + int i = 0; + send_cmd = (trust_zone_base_cmd_t *)handle->ion_sbuffer; + send_vendor_cmd = (trust_zone_vendor_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_base_cmd_t))); + + int idx = 1; + for (idx = 1; idx <= MAX_NUM_FINGERS; idx++) { + if (!tz.finger[idx].exist) { + break; + } + } + + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(*send_cmd)) + QSEECOM_ALIGN(sizeof(int))); + send_cmd->cmd = vfmEnrollBegin; + send_cmd->data[102400] = idx; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(*send_cmd)), resp, QSEECOM_ALIGN(sizeof(int))); + if (ret || resp->result) { + ALOGE("send EnrollBegin error"); + set_tz_state(STATE_IDLE); + send_error_notice(vdev, FINGERPRINT_ERROR_UNABLE_TO_PROCESS); + return NULL; + } + memset(send_vendor_cmd, 0, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_vendor_cmd->cmd = vfmVendorDefinedOperation; + send_vendor_cmd->vendor_cmd = vendorUnknownA; + resp->data[0] = 0x4; + ret = QSEECom_send_cmd(handle, send_vendor_cmd, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret || resp->result) { + ALOGE("send vendorUnknownA error"); + set_tz_state(STATE_IDLE); + send_error_notice(vdev, FINGERPRINT_ERROR_UNABLE_TO_PROCESS); + return NULL; + } + while (get_tz_state() == STATE_ENROLL) { + ret = vcs_start_capture(vdev, 0); + if (ret == -1) + goto out; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(int))); + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(int)) + QSEECOM_ALIGN(sizeof(*resp))); + send_cmd->cmd = vfmEnrollAddImage; + resp->data[0] = 0x8; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(int)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret) { + ALOGE("%s:send vfmEnrollAddImage error", __FUNCTION__); + set_tz_state(STATE_IDLE); + send_error_notice(vdev, FINGERPRINT_ERROR_UNABLE_TO_PROCESS); + return NULL; + } + if (resp->result != 0) { + send_acquired_notice(vdev, resp->result); + continue; + } + count--; + if (resp->data[2] == 0x1) + count = 0; + if (resp->data[2] != 0x1 && count == 0) + count = 1; + send_enroll_notice(vdev, idx, count); + if (count == 0) + break; + } + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_base_cmd_t))); + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(*send_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_cmd->cmd = vfmEnrollFinish; + send_cmd->len = AUTH_SESSION_TOKEN_LENGTH; + resp->data[0] = 0x2845; + memcpy(&send_cmd->data, &tz.auth_session_token, AUTH_SESSION_TOKEN_LENGTH); + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(*send_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret || resp->result) { + ALOGE("Send vfmEnrollFinish error"); + } + memcpy(&tz.finger[idx].data, &resp->data[2], FINGER_DATA_MAX_LENGTH); + for (i = 0; i < 2; i++) { + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(*send_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_cmd->cmd = vfmPayloadBind; + send_cmd->len = 0x1; + send_cmd->zero = 0x7; + sprintf(&send_cmd->data[4], "User_0"); + if (i == 1) { + resp->data[0] = 0x50; + } + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(*send_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + } + if (ret || resp->result) { + ALOGE("Send vfmPayloadBind error"); + } + memcpy(&tz.finger[idx].payload, &resp->data[2], PAYLOAD_MAX_LENGTH); + tz.finger[idx].exist = true; + db_write_to_db(vdev, false, idx); + + // We may not need to send vfmEnrollmentPasswordSet. + for (i = 0; i < 2; i++) { + trust_zone_3x_cmd_t *send_3x_cmd = NULL; + send_3x_cmd = (trust_zone_3x_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_3x_cmd_t))); + memset(send_3x_cmd, 0, QSEECOM_ALIGN(sizeof(*send_3x_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_3x_cmd->cmd = vfmEnrollmentPasswordSet; + send_3x_cmd->len = AUTH_SESSION_TOKEN_LENGTH; + memcpy(&send_3x_cmd->data, &tz.auth_session_token, AUTH_SESSION_TOKEN_LENGTH); + if (i == 0) { + resp->data[0] = 0x90; + } else { + resp->data[0] = 0x80; + } + ret = QSEECom_send_cmd(handle, send_3x_cmd, QSEECOM_ALIGN(sizeof(*send_3x_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + } + if (ret || resp->result) { + ALOGE("Send vfmEnrollmentPasswordSet error"); + } +out: + set_tz_state(STATE_IDLE); + sensor_uninit(); + vcs_uninit(); + return NULL; +} + +void* vcs_timeout(void* vdev) { + struct timeval now; + struct timespec outtime; + int ret = 0; + + pthread_mutex_lock(&tz.timeout.lock); + gettimeofday(&now, NULL); + outtime.tv_sec = now.tv_sec + tz.timeout.timeout; + outtime.tv_nsec = now.tv_usec * 1000; + ret = pthread_cond_timedwait(&tz.timeout.cond, &tz.timeout.lock, &outtime); + pthread_mutex_unlock(&tz.timeout.lock); + + if (ret == ETIMEDOUT) { + ALOGI("Enroll timeout! Exit!"); + int flag = 0; + if (get_tz_state() != STATE_IDLE && get_tz_state() != STATE_CANCEL) { + set_tz_state(STATE_CANCEL); + ioctl(sensor.fd, VFSSPI_IOCTL_SET_DRDY_INT, &flag); + while (1) { + usleep(100000); + if (get_tz_state() == STATE_IDLE) + break; + } + } + send_error_notice(vdev, FINGERPRINT_ERROR_TIMEOUT); + } + return NULL; +} + +int vcs_start_authenticate(void *vdev) { + int times = 0; + for (times = 0; times < 5; times++) + if (get_tz_state() != STATE_IDLE) { + ALOGE("%s:Sensor is busy!", __FUNCTION__); + if (times < 4) { + usleep(100000); + continue; + } + return -1; + } + set_tz_state(STATE_SCAN); + int ret = 0; + + sensor_init(); + + ret = vcs_init(); + if (ret) return ret; + ret = pthread_create(&tz.auth_thread, NULL, vcs_authenticate, vdev); + if (ret) { + ALOGE("Can't create authenticate thread!!"); + } + return ret; +} + +int vcs_start_enroll(void *vdev, uint32_t timeout) { + if (get_tz_state() != STATE_IDLE) { + ALOGE("%s:Sensor is busy!", __FUNCTION__); + return -1; + } + set_tz_state(STATE_ENROLL); + int ret = 0; + + sensor_init(); + + ret = vcs_init(); + if (ret) { + return ret; + } + ret = pthread_create(&tz.enroll_thread, NULL, vcs_enroll, vdev); + if (ret) { + ALOGE("Can't create enroll thread!!"); + return ret; + } + if (timeout) { + tz.timeout.timeout = timeout; + ret = pthread_create(&tz.timeout.timeout_thread, NULL, vcs_timeout, vdev); + if (ret) { + ALOGE("Can't create timeout thread!!"); + } + } + return ret; +} + +int vcs_get_enrolled_finger_num() { + int num = 0; + int idx = 1; + for (idx = 1; idx <= MAX_NUM_FINGERS; idx++) + if (tz.finger[idx].exist) + num++; + ALOGV("%s: num=%d", __FUNCTION__, num); + return num; +} + +/* + * cmd: vendorGetAuthToken + */ +int vcs_update_auth_token() { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_vendor_cmd_t *send_vendor_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + send_vendor_cmd = (trust_zone_vendor_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_vendor_cmd_t))); + int i = 0; + + for (i = 0;i < 2; i++) { + memset(send_vendor_cmd, 0, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_vendor_cmd->cmd = vfmVendorDefinedOperation; + send_vendor_cmd->vendor_cmd = vendorGetAuthToken; + if (i == 1) { + resp->data[0] = 0x80; + } + ret = QSEECom_send_cmd(handle, send_vendor_cmd, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + } + if (resp->result) { + ALOGE("send vendorGetAuthToken failed, qsapp result=%d", resp->result); + return resp->result; + } + memcpy(&tz.auth_token, &resp->data[2], AUTH_TOKEN_LENGTH); + ALOGV("Sended vendorGetAuthToken"); + return ret; +} + +/* + * cmd: vfmAuthSessionBegin + */ + +int vcs_start_auth_session() { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_base_cmd_t *send_cmd = NULL; + trust_zone_vendor_cmd_t *send_vendor_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + send_cmd = (trust_zone_base_cmd_t *)handle->ion_sbuffer; + send_vendor_cmd = (trust_zone_vendor_cmd_t *)handle->ion_sbuffer; + int i = 0; + + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(int))); + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(int)) + QSEECOM_ALIGN(sizeof(*resp))); + send_cmd->cmd = vfmAuthSessionBegin; + resp->data[0] = AUTH_SESSION_TOKEN_LENGTH; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(int)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret || resp->result) { + ALOGE("send vfmAuthSessionBegin failed, qsapp result=%d", resp->result); + return ret; + } + memcpy(&tz.auth_session_token, &resp->data[2], AUTH_SESSION_TOKEN_LENGTH); + tz.auth_session_opend = true; + ALOGV("Sended vfmAuthSessionBegin"); + return ret; +} + +/* + * cmd: vfmAuthSessionEnd + */ + +int vcs_stop_auth_session() { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_base_cmd_t *send_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + send_cmd = (trust_zone_base_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(int))); + + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(int)) + QSEECOM_ALIGN(sizeof(int))); + send_cmd->cmd = vfmAuthSessionEnd; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(int)), resp, QSEECOM_ALIGN(sizeof(int))); + if (ret || resp->result) { + ALOGE("send vfmAuthSessionEnd failed, qsapp result=%d", resp->result); + } + memset(tz.auth_session_token, 0, AUTH_SESSION_TOKEN_LENGTH); + tz.auth_session_opend = false; + ALOGV("Sended vfmAuthSessionEnd"); + return ret; +} + +/* + * cmd: 1.vfmInitialize + * 2.vendorEnterAuthSession + * 3.vfmDeviceInitialize + * 4.vfmDeviceCalibrate + */ + +int vcs_resume() { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_base_cmd_t *send_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + int ret = 0; + send_cmd = (trust_zone_base_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_base_cmd_t))); + + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(*send_cmd)) + QSEECOM_ALIGN(sizeof(int))); + send_cmd->cmd = vfmInitialize; + send_cmd->len = 4; + send_cmd->data[0] = 2; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(*send_cmd)), resp, QSEECOM_ALIGN(sizeof(int))); + if (ret || resp->result) { + ALOGE("send vfmInitialize failed, qsapp result=%d", resp->result); + return ret; + } + ALOGV("Sended vfmInitialize"); + + if (tz.auth_session_opend) { + trust_zone_vendor_cmd_t *send_vendor_cmd = NULL; + send_vendor_cmd = (trust_zone_vendor_cmd_t *)handle->ion_sbuffer; + memset(send_vendor_cmd, 0, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_vendor_cmd->cmd = vfmVendorDefinedOperation; + send_vendor_cmd->vendor_cmd = vendorEnterAuthSession; + send_vendor_cmd->len = 0x70; + memcpy(&send_vendor_cmd->data, &tz.auth_token, 0x70); + ret = QSEECom_send_cmd(handle, send_vendor_cmd, QSEECOM_ALIGN(sizeof(*send_vendor_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret || resp->result) { + ALOGE("send EnterAuthSession failed, qsapp result=%d", resp->result); + return resp->result; + } + } + ALOGV("Sended EnterAuthSession"); + + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(*send_cmd)) + QSEECOM_ALIGN(sizeof(int))); + send_cmd->cmd = vfmDeviceInitialize; + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(*send_cmd)), resp, QSEECOM_ALIGN(sizeof(int))); + if (ret || resp->result) { + ALOGE("send vfmDeviceInitialize failed, qsapp result=%d", resp->result); + return ret; + } + ALOGV("Sended vfmDeviceInitialize"); + + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(*send_cmd)) + QSEECOM_ALIGN(sizeof(*resp))); + send_cmd->cmd = vfmDeviceCalibrate; + send_cmd->data[0] = 0xc0; + send_cmd->data[1] = 0x12; + resp->data[0] = CALIBRATE_DATA_MAX_LENGTH; + if (tz.calibrate_len) { + send_cmd->len = tz.calibrate_len; + memcpy(&send_cmd->data[4], &tz.calibrate_data, tz.calibrate_len); + } else { + send_cmd->len = 0x10; + } + ret = QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(*send_cmd)), resp, QSEECOM_ALIGN(sizeof(*resp))); + if (ret || resp->result) { + ALOGE("send vfmDeviceCalibrate failed, qsapp result=%d", resp->result); + return ret; + } + if (tz.calibrate_len == 0) { + tz.calibrate_len = resp->data[3] + 0xf; + memcpy(&tz.calibrate_data, &resp->data[2], tz.calibrate_len); + } + ALOGV("Sended vfmDeviceCalibrate"); + return ret; +} + +/* + * cmd: vfmUninitialize + * set bandwidth to low and shutdown app + */ + +int vcs_uninit() { + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + trust_zone_base_cmd_t *send_cmd = NULL; + trust_zone_normal_result_t *resp = NULL; + send_cmd = (trust_zone_base_cmd_t *)handle->ion_sbuffer; + resp = (trust_zone_normal_result_t *)(handle->ion_sbuffer + QSEECOM_ALIGN(sizeof(trust_zone_base_cmd_t))); + + if (tz.auth_session_opend) { + vcs_update_auth_token(); + } + + memset(send_cmd, 0, QSEECOM_ALIGN(sizeof(int)) + QSEECOM_ALIGN(sizeof(int))); + send_cmd->cmd = vfmUninitialize; + QSEECom_send_cmd(handle, send_cmd, QSEECOM_ALIGN(sizeof(int)), resp, QSEECOM_ALIGN(sizeof(int))); + QSEECom_set_bandwidth(handle, false); + QSEECom_shutdown_app((struct QSEECom_handle **)&tz.qhandle); + tz.init = false; + set_tz_state(STATE_IDLE); + ALOGV("Closed securefp qsapp"); + return 0; +} + +/* + * start app and set bandwidth to high + * Call vcs_resume + */ + +int vcs_init() { + int ret = 0; + if (tz.init) { + ALOGI("securefp qsapp is already running!"); + return ret; + } + ret = QSEECom_start_app((struct QSEECom_handle **)&tz.qhandle, + "/firmware/image", "securefp", SB_LENGTH); + if (ret) { + ALOGE("Loading securefp app failed"); + return -1; + } + struct QSEECom_handle *handle = (struct QSEECom_handle *)(tz.qhandle); + ret = QSEECom_set_bandwidth(handle, true); + if (ret) { + ALOGE("Set bandwidth failed"); + return -1; + } + tz.init = true; + ALOGV("securefp qsapp init success!"); + ret = vcs_resume(); + return ret; +} diff --git a/fingerprint/fingerprint_tz.h b/fingerprint/fingerprint_tz.h new file mode 100644 index 0000000..225d1d4 --- /dev/null +++ b/fingerprint/fingerprint_tz.h @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * Copyright (C) 2016 The CyanogenMod Project + * Copyright (C) 2016 The Mokee 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. + */ +#ifndef __FINGERPRINT_TZ_H_ +#define __FINGERPRINT_TZ_H_ + +#include "fingerprint_common.h" +#include "QSEEComAPI.h" + +/* QSEE cmd */ +typedef enum trust_zone_cmd_id_t { + vfmProvision = 0x1, + vfmInitialize = 0x2, + vfmUninitialize = 0x3, + vfmDeviceInitialize = 0x4, + vfmDeviceCalibrate = 0x5, + vfmAuthSessionBegin = 0x6, + vfmAuthSessionEnd = 0x7, + vfmCaptureStart = 0x8, + vfmCaptureReadData = 0x9, + vfmCaptureProcessData = 0xa, + vfmCaptureAbort = 0xb, + vfmCaptureGetStatus = 0xc, + /* QSEE cmd id 0xd is unused. */ + vfmCaptureFlushImage = 0xe, + vfmEnrollBegin = 0xf, + vfmEnrollAddImage = 0x10, + vfmEnrollFinish = 0x11, + vfmEnrollmentPasswordSet = 0x12, + vfmEnrollmentPasswordVerify = 0x13, + vfmMatchImageToTemplates = 0x14, + vfmPayloadBind = 0x15, + vfmPayloadRelease = 0x16, + vfmVendorDefinedOperation = 0x17 +}trust_zone_cmd_id_t; + +typedef enum trust_zone_vendor_cmd_id_t { + vendorUnknown0 = 0x0, + vendorGetVersion = 0x1,//0x10 + vendorUnknownA = 0xa, + vendorGetAuthToken = 0x14, + vendorEnterAuthSession = 0x15, + vendorUpdateCalData = 0x17 +}trust_zone_vendor_cmd_id_t; + +typedef struct trust_zone_normal_cmd_t { + trust_zone_cmd_id_t cmd; + int len; + int zero; + char data[BUFFER_LENGTH - 12]; +}trust_zone_base_cmd_t; + +typedef struct trust_zone_vendor_cmd_t { + trust_zone_cmd_id_t cmd; + trust_zone_vendor_cmd_id_t vendor_cmd; + int len; + int zero; + char data[BUFFER_LENGTH - 16]; +}trust_zone_vendor_cmd_t; + +typedef struct trust_zone_2x_cmd_t { + trust_zone_cmd_id_t cmd; + int len; + int zero; + char data[BUFFER_LENGTH * 2 - 12]; +}trust_zone_2x_cmd_t; + +typedef struct trust_zone_3x_cmd_t { + trust_zone_cmd_id_t cmd; + int len; + int zero; + char data[BUFFER_LENGTH * 3 - 12]; +}trust_zone_3x_cmd_t; + +typedef struct trust_zone_5x_cmd_t { //only use on vfmMatchImageToTemplates + trust_zone_cmd_id_t cmd; + int len; + int zero; + int unknown[2]; + time_t time_now; + char data[563304]; +}trust_zone_5x_cmd_t; + +typedef struct trust_zone_normal_result_t { + int zero; + int result; + int data[BUFFER_LENGTH/4 - 2]; +}trust_zone_normal_result_t; + +typedef struct trust_zone_2x_result_t { + int zero; + int result; + int data[(BUFFER_LENGTH * 2)/4 - 2]; +}trust_zone_2x_result_t; + +#define FINGERPRINT_ERROR_HW_UNAVAILABLE (1) +#define FINGERPRINT_ERROR_UNABLE_TO_PROCESS (2) +#define FINGERPRINT_ERROR_TIMEOUT (3) +#define FINGERPRINT_ERROR_NO_SPACE (4) +#define FINGERPRINT_ERROR_CANCELED (5) +#define FINGERPRINT_ERROR_UNABLE_TO_REMOVE (6) +#define FINGERPRINT_ERROR_VENDOR_BASE (1000) + +worker_state_t get_tz_state(); +void set_tz_state(worker_state_t state); + +int vcs_update_cal_data(); +int vcs_check_state(); +int vcs_start_capture(); +void* vcs_authenticate(void* vdev); +void* vcs_enroll(void* vdev); +int vcs_start_authenticate(void *vdev); +int vcs_start_enroll(void *vdev, uint32_t timeout); +int vcs_get_enrolled_finger_num(); +int vcs_update_auth_token(); +int vcs_start_auth_session(); +int vcs_stop_auth_session(); +int vcs_resume(); +int vcs_uninit(); +int vcs_init(); + +#endif /* __FINGERPRINT_TZ_H_ */ diff --git a/fingerprint/fp_klte.h b/fingerprint/fp_klte.h index ae0463c..fea9b89 100644 --- a/fingerprint/fp_klte.h +++ b/fingerprint/fp_klte.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2014 The Android Open Source Project + * Copyright (C) 2016 The Android Open Source Project * Copyright (C) 2016 The CyanogenMod Project * Copyright (C) 2016 The Mokee Project * @@ -16,101 +16,30 @@ * limitations under the License. */ -#include -#include +#include "fingerprint_common.h" +#include "vfs61xx_ioctl.h" -#define CALL_BASE 0 +#define FINGER_DATABASE_FILENAME "/data/validity/finger.db" +#define SAMSUNG_FP_DB_PATH "/data/validity/template.db" +#define SENSOR_FILE_NAME "/dev/vfsspi" +#define MAX_DATABASE_CMD 255 -#define CALL_INITSERVICE 1 -#define CALL_ENROLL 2 -//userId ,fingerIndex -#define CALL_CANCEL 3 -#define CALL_REMOVE 4 -//userId ,fingerIndex -#define CALL_IDENTIFY 5 -//userId -#define CALL_GET_ENROLLED_FINGER_LIST 6 -//userId -#define CALL_CLEANUP 7 +int sensor_uninit(); +int sensor_init(); +void sensor_process_signal(int signum); +int sensor_register(); +int sensor_capture_start(); -typedef enum worker_state_t { - STATE_IDLE = 0, - STATE_ENROLL, - STATE_SCAN, - STATE_EXIT -} worker_state_t; +int db_check_and_create_table(void* device); +int db_read_to_tz(void *device); +int db_write_to_db(void *device, bool remove, int fid); +int db_init(void *device); +int db_uninit(void *device); -typedef struct worker_thread_t { - pthread_t thread; - worker_state_t state; -} worker_thread_t; +void send_error_notice(void* device, int error_info_int); +void send_acquired_notice(void* device, int acquired_ret); +void send_enroll_notice(void *device, int fid, int remaining); +void send_authenticated_notice(void *device, int fid); +void send_remove_notice(void *device, int fid); -typedef struct vcs_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; - uint32_t active_gid; - int send_fd; //send to validity service - int receive_fd; //recevie from validity service - bool init; - pthread_mutex_t lock; -} vcs_fingerprint_device_t; - -static __inline__ int fd_write(int fd, const void* buff, int len){ - int len2; - do { - len2 = write(fd, buff, len); - } while (len2 < 0 && errno == EINTR); - return len2; -} -static __inline__ int fd_read(int fd, void* buff, int len){ - int len2; - do { - len2 = read(fd, buff, len); - } while (len2 < 0 && errno == EINTR); - return len2; -} - -static void checkinit(vcs_fingerprint_device_t* vdev); -static int sendcommand(vcs_fingerprint_device_t* vdev, uint8_t* command, int num); -static int getfingermask(vcs_fingerprint_device_t* vdev); -static int initService(vcs_fingerprint_device_t* vdev); - -static void send_error_notice(vcs_fingerprint_device_t* vdev, fingerprint_error_t error_info); -static void send_acquired_notice(vcs_fingerprint_device_t* vdev, fingerprint_acquired_info_t acquired_info); -static void send_enroll_notice(vcs_fingerprint_device_t* vdev, int fid, int remaining); -static void send_authenticated_notice(vcs_fingerprint_device_t* vdev, int fid); -static void send_remove_notice(vcs_fingerprint_device_t* vdev, int fid); - -static uint64_t get_64bit_rand(); -static uint64_t fingerprint_get_auth_id(struct fingerprint_device* device); -static int fingerprint_set_active_group(struct fingerprint_device *device, uint32_t gid, - const char __unused *path); -static int fingerprint_authenticate(struct fingerprint_device *device, - uint64_t operation_id, __unused uint32_t gid); -static int fingerprint_enroll(struct fingerprint_device *device, - const hw_auth_token_t *hat, - uint32_t __unused gid, - uint32_t __unused timeout_sec); -static uint64_t fingerprint_pre_enroll(struct fingerprint_device *device); -static int fingerprint_post_enroll(struct fingerprint_device* device); -static int fingerprint_cancel(struct fingerprint_device *device); -static int fingerprint_enumerate(struct fingerprint_device *device, - fingerprint_finger_id_t *results, uint32_t *max_size); -static int fingerprint_remove(struct fingerprint_device *device, - uint32_t __unused gid, uint32_t fid); -static int set_notify_callback(struct fingerprint_device *device, - fingerprint_notify_t notify); - -static worker_state_t getListenerState(vcs_fingerprint_device_t* dev); -static void* listenerSocket(void* data); - -static int fingerprint_close(hw_device_t* device); -static int fingerprint_open(const hw_module_t* module, const char __unused *id, - hw_device_t** device); diff --git a/fingerprint/hash.c b/fingerprint/hash.c new file mode 100644 index 0000000..aa2ebef --- /dev/null +++ b/fingerprint/hash.c @@ -0,0 +1,206 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * Copyright (C) 2016 The CyanogenMod Project + * Copyright (C) 2016 The Mokee 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. + */ + +#include +#include + +#include "hash.h" + +SHA1Context sha; + +/* + * HASH method: SHA1 + */ + +uint64_t convert_hash_to_number() { + uint64_t num = 0; + num = ((uint64_t)sha.Message_Digest[0] << 32) + sha.Message_Digest[1]; + return num; +} + +uint64_t hash_file(const char *file_path) { + FILE * file; + char str[MAX_FILE_LENGTH]; + int len = 0; + file = fopen(file_path, "rb"); + if (!file) + return 1; + len = fread(str, sizeof(char), MAX_FILE_LENGTH, file); + fclose(file); + sha1_hash(str, len); + return convert_hash_to_number(); +} + +uint64_t hash_string(const char *str) { + sha1_hash(str, strlen(str)); + return convert_hash_to_number(); +} + +void SHA1Reset(SHA1Context *context){ + context->Length_Low = 0; + context->Length_High = 0; + context->Message_Block_Index = 0; + + context->Message_Digest[0] = 0x67452301; + context->Message_Digest[1] = 0xEFCDAB89; + context->Message_Digest[2] = 0x98BADCFE; + context->Message_Digest[3] = 0x10325476; + context->Message_Digest[4] = 0xC3D2E1F0; + + context->Computed = 0; + context->Corrupted = 0; +} + + +int SHA1Result(SHA1Context *context){ + if (context->Corrupted) { + return 0; + } + if (!context->Computed) { + SHA1PadMessage(context); + context->Computed = 1; + } + return 1; +} + + +void SHA1Input(SHA1Context *context,const char *message_array,unsigned length){ + if (!length) return; + + if (context->Computed || context->Corrupted){ + context->Corrupted = 1; + return; + } + + while(length-- && !context->Corrupted){ + context->Message_Block[context->Message_Block_Index++] = (*message_array & 0xFF); + + context->Length_Low += 8; + + context->Length_Low &= 0xFFFFFFFF; + if (context->Length_Low == 0){ + context->Length_High++; + context->Length_High &= 0xFFFFFFFF; + if (context->Length_High == 0) context->Corrupted = 1; + } + + if (context->Message_Block_Index == 64){ + SHA1ProcessMessageBlock(context); + } + message_array++; + } +} + +void SHA1ProcessMessageBlock(SHA1Context *context){ + const unsigned K[] = {0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 }; + int t; + unsigned temp; + unsigned W[80]; + unsigned A, B, C, D, E; + + for(t = 0; t < 16; t++) { + W[t] = ((unsigned) context->Message_Block[t * 4]) << 24; + W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16; + W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8; + W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]); + } + + for(t = 16; t < 80; t++) W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]); + + A = context->Message_Digest[0]; + B = context->Message_Digest[1]; + C = context->Message_Digest[2]; + D = context->Message_Digest[3]; + E = context->Message_Digest[4]; + + for(t = 0; t < 20; t++) { + temp = SHA1CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0]; + temp &= 0xFFFFFFFF; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + for(t = 20; t < 40; t++) { + temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1]; + temp &= 0xFFFFFFFF; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + for(t = 40; t < 60; t++) { + temp = SHA1CircularShift(5,A) + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2]; + temp &= 0xFFFFFFFF; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + for(t = 60; t < 80; t++) { + temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3]; + temp &= 0xFFFFFFFF; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + context->Message_Digest[0] = (context->Message_Digest[0] + A) & 0xFFFFFFFF; + context->Message_Digest[1] = (context->Message_Digest[1] + B) & 0xFFFFFFFF; + context->Message_Digest[2] = (context->Message_Digest[2] + C) & 0xFFFFFFFF; + context->Message_Digest[3] = (context->Message_Digest[3] + D) & 0xFFFFFFFF; + context->Message_Digest[4] = (context->Message_Digest[4] + E) & 0xFFFFFFFF; + context->Message_Block_Index = 0; +} + +void SHA1PadMessage(SHA1Context *context){ + if (context->Message_Block_Index > 55) { + context->Message_Block[context->Message_Block_Index++] = 0x80; + while(context->Message_Block_Index < 64) context->Message_Block[context->Message_Block_Index++] = 0; + SHA1ProcessMessageBlock(context); + while(context->Message_Block_Index < 56) context->Message_Block[context->Message_Block_Index++] = 0; + } else { + context->Message_Block[context->Message_Block_Index++] = 0x80; + while(context->Message_Block_Index < 56) context->Message_Block[context->Message_Block_Index++] = 0; + } + context->Message_Block[56] = (context->Length_High >> 24 ) & 0xFF; + context->Message_Block[57] = (context->Length_High >> 16 ) & 0xFF; + context->Message_Block[58] = (context->Length_High >> 8 ) & 0xFF; + context->Message_Block[59] = (context->Length_High) & 0xFF; + context->Message_Block[60] = (context->Length_Low >> 24 ) & 0xFF; + context->Message_Block[61] = (context->Length_Low >> 16 ) & 0xFF; + context->Message_Block[62] = (context->Length_Low >> 8 ) & 0xFF; + context->Message_Block[63] = (context->Length_Low) & 0xFF; + + SHA1ProcessMessageBlock(context); +} + +int sha1_hash(const char *source, int len){ + SHA1Reset(&sha); + SHA1Input(&sha, source, len); + + if (!SHA1Result(&sha)){ + return -1; + } + return 0; +} + diff --git a/fingerprint/hash.h b/fingerprint/hash.h new file mode 100644 index 0000000..f1df67a --- /dev/null +++ b/fingerprint/hash.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * Copyright (C) 2016 The CyanogenMod Project + * Copyright (C) 2016 The Mokee 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. + */ + +#ifndef __HASH_H_ +#define __HASH_H_ + + +#define SHA1CircularShift(bits,word) ((((word) << (bits)) & 0xFFFFFFFF) | ((word) >> (32-(bits)))) +#define MAX_FILE_LENGTH (300000) + +typedef struct SHA1Context{ + unsigned Message_Digest[5]; + unsigned Length_Low; + unsigned Length_High; + unsigned char Message_Block[64]; + int Message_Block_Index; + int Computed; + int Corrupted; +} SHA1Context; + +void SHA1Reset(SHA1Context *); +int SHA1Result(SHA1Context *); +void SHA1Input( SHA1Context *,const char *,unsigned); + +void SHA1ProcessMessageBlock(SHA1Context *); +void SHA1PadMessage(SHA1Context *); +int sha1_hash(const char *source, int len); + +uint64_t hash_file(const char *file_path); +uint64_t hash_string(const char *str); + +#endif //__HASH_H_ diff --git a/fingerprint/vfs61xx_ioctl.h b/fingerprint/vfs61xx_ioctl.h new file mode 100644 index 0000000..966abef --- /dev/null +++ b/fingerprint/vfs61xx_ioctl.h @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * Copyright (C) 2016 The Mokee Project + * Copyright (C) 2016 The CyanogenMod Project + * + * Copied from kernel - drivers/fingerprint/vfs61xx.h + * + * 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. + */ + +#ifndef VFS61XX_IOCTL_H_ +#define VFS61XX_IOCTL_H_ + +/* See kernel/include/linux/fprint_secure.h */ +#ifndef ENABLE_SENSORS_FPRINT_SECURE +#define ENABLE_SENSORS_FPRINT_SECURE +#endif + +#include + +/* Pass to VFSSPI_IOCTL_REGISTER_DRDY_SIGNAL command */ +struct vfsspi_iocRegSignal { + /* Process ID to which SPI driver sends signal + * indicating that DRDY is asserted */ + int userPID; + int signalID; /* Signal number */ +}; + +/* Magic number of IOCTL command */ +#define VFSSPI_IOCTL_MAGIC 'k' + +/* + * IOCTL commands definitions + */ + +#ifndef ENABLE_SENSORS_FPRINT_SECURE +/* Transmit data to the device +and retrieve data from it simultaneously */ +#define VFSSPI_IOCTL_RW_SPI_MESSAGE \ + _IOWR(VFSSPI_IOCTL_MAGIC, 1, unsigned int) +#endif +/* Hard reset the device */ +#define VFSSPI_IOCTL_DEVICE_RESET \ + _IO(VFSSPI_IOCTL_MAGIC, 2) +/* Set the baud rate of SPI master clock */ +#define VFSSPI_IOCTL_SET_CLK \ + _IOW(VFSSPI_IOCTL_MAGIC, 3, unsigned int) +#ifndef ENABLE_SENSORS_FPRINT_SECURE +/* Get level state of DRDY GPIO */ +#define VFSSPI_IOCTL_CHECK_DRDY \ + _IO(VFSSPI_IOCTL_MAGIC, 4) +#endif +/* Register DRDY signal. It is used by SPI driver + * for indicating host that DRDY signal is asserted. */ +#define VFSSPI_IOCTL_REGISTER_DRDY_SIGNAL \ + _IOW(VFSSPI_IOCTL_MAGIC, 5, unsigned int) +/* Store the user data into the SPI driver. Currently user data is a + * device info data, which is obtained from announce packet. */ +#ifndef ENABLE_SENSORS_FPRINT_SECURE +#define VFSSPI_IOCTL_SET_USER_DATA \ + _IOW(VFSSPI_IOCTL_MAGIC, 6, unsigned int) +#endif +#ifndef ENABLE_SENSORS_FPRINT_SECURE +/* Retrieve user data from the SPI driver*/ +#define VFSSPI_IOCTL_GET_USER_DATA \ + _IOWR(VFSSPI_IOCTL_MAGIC, 7, unsigned int) +#endif +/* Enable/disable DRDY interrupt handling in the SPI driver */ +#define VFSSPI_IOCTL_SET_DRDY_INT \ + _IOW(VFSSPI_IOCTL_MAGIC, 8, unsigned int) +/* Put device in Low power mode */ +#define VFSSPI_IOCTL_DEVICE_SUSPEND \ + _IO(VFSSPI_IOCTL_MAGIC, 9) +#ifndef ENABLE_SENSORS_FPRINT_SECURE +/* Indicate the fingerprint buffer size for read */ +#define VFSSPI_IOCTL_STREAM_READ_START \ + _IOW(VFSSPI_IOCTL_MAGIC, 10, unsigned int) +/* Indicate that fingerprint acquisition is completed */ +#define VFSSPI_IOCTL_STREAM_READ_STOP \ + _IO(VFSSPI_IOCTL_MAGIC, 11) +/* Retrieve supported SPI baud rate table */ +#define VFSSPI_IOCTL_GET_FREQ_TABLE \ + _IOWR(VFSSPI_IOCTL_MAGIC, 12, unsigned int) +#endif +/* Turn on the power to the sensor */ +#define VFSSPI_IOCTL_POWER_ON \ + _IO(VFSSPI_IOCTL_MAGIC, 13) +/* Turn off the power to the sensor */ +#define VFSSPI_IOCTL_POWER_OFF \ + _IO(VFSSPI_IOCTL_MAGIC, 14) +#ifdef ENABLE_SENSORS_FPRINT_SECURE +/* To disable spi core clock */ +#define VFSSPI_IOCTL_DISABLE_SPI_CLOCK \ + _IO(VFSSPI_IOCTL_MAGIC, 15) +/* To set SPI configurations like gpio, clks */ +#define VFSSPI_IOCTL_SET_SPI_CONFIGURATION \ + _IO(VFSSPI_IOCTL_MAGIC, 16) +/* To reset SPI configurations */ +#define VFSSPI_IOCTL_RESET_SPI_CONFIGURATION \ + _IO(VFSSPI_IOCTL_MAGIC, 17) +#endif +/* get sensor orienation from the SPI driver*/ +#define VFSSPI_IOCTL_GET_SENSOR_ORIENT \ + _IOR(VFSSPI_IOCTL_MAGIC, 18, unsigned int) +#endif /* VFS61XX_IOCTL_H_ */ diff --git a/klte.mk b/klte.mk index f9acf8f..f37c9e6 100644 --- a/klte.mk +++ b/klte.mk @@ -76,8 +76,7 @@ PRODUCT_PACKAGES += \ # Fingerprint PRODUCT_PACKAGES += \ fingerprintd \ - fingerprint.msm8974 \ - ValidityService + fingerprint.msm8974 # Gello PRODUCT_PACKAGES += \ diff --git a/rootdir/etc/init.qcom.rc b/rootdir/etc/init.qcom.rc index 52c014a..5fcaadd 100644 --- a/rootdir/etc/init.qcom.rc +++ b/rootdir/etc/init.qcom.rc @@ -1074,12 +1074,6 @@ service sec-sh /system/bin/sh /system/etc/init.sec.boot.sh user root oneshot -# SENSOR FRAMEWORK : starts fingerprintService -service vcsFPService /system/bin/vcsFPService - class late_start - user system - group system - on property:persist.sys.ssr.restart_level=1 write /sys/module/subsystem_restart/parameters/restart_level 1 diff --git a/sepolicy/file_contexts b/sepolicy/file_contexts index 601b6c0..a3fc738 100644 --- a/sepolicy/file_contexts +++ b/sepolicy/file_contexts @@ -20,7 +20,6 @@ /dev/block/platform/msm_sdcc.1/by-name/efs u:object_r:modem_efs_partition_device:s0 # Fingerprint -/system/bin/vcsFPService u:object_r:vcs_exec:s0 /data/validity(/.*)? u:object_r:vcs_data_file:s0 /dev/validity(/.*)? u:object_r:vcs_device:s0 /dev/vfsspi u:object_r:vcs_device:s0 diff --git a/sepolicy/fingerprintd.te b/sepolicy/fingerprintd.te index 0844bf1..c03c97b 100644 --- a/sepolicy/fingerprintd.te +++ b/sepolicy/fingerprintd.te @@ -1 +1,13 @@ -allow fingerprintd system_app:unix_stream_socket { connectto read write setopt }; +allow fingerprintd vcs_data_file:dir create_dir_perms; +allow fingerprintd vcs_data_file:file create_file_perms; + +allow fingerprintd vcs_device:dir create_dir_perms; +allow fingerprintd vcs_device:file create_file_perms; +allow fingerprintd vcs_device:fifo_file create_file_perms; +allow fingerprintd vcs_device:chr_file create_file_perms; + +allow fingerprintd tee_device:chr_file rw_file_perms; + +allow fingerprintd firmware_file:dir r_dir_perms; +allow fingerprintd firmware_file:file r_file_perms; + diff --git a/sepolicy/system_app.te b/sepolicy/system_app.te deleted file mode 100644 index 027926f..0000000 --- a/sepolicy/system_app.te +++ /dev/null @@ -1,7 +0,0 @@ -# For com.validity.fingerprint -allow system_app vcs:process signull; -allow system_app vcs_data_file:dir r_dir_perms; -allow system_app vcs_data_file:file r_file_perms; -allow system_app vcs_device:dir r_dir_perms; -allow system_app vcs_device:file r_file_perms; -allow system_app vcs_device:fifo_file create_file_perms; diff --git a/sepolicy/vcs.te b/sepolicy/vcs.te deleted file mode 100644 index dcc28f1..0000000 --- a/sepolicy/vcs.te +++ /dev/null @@ -1,22 +0,0 @@ -type vcs, domain; -type vcs_exec, exec_type, file_type; - -# vcs -init_daemon_domain(vcs) -binder_use(vcs) - -allow vcs system_app:process signull; - -allow vcs vcs_data_file:dir create_dir_perms; -allow vcs vcs_data_file:file create_file_perms; - -allow vcs vcs_device:dir create_dir_perms; -allow vcs vcs_device:file create_file_perms; -allow vcs vcs_device:fifo_file create_file_perms; -allow vcs vcs_device:chr_file create_file_perms; - -allow vcs tee_device:chr_file rw_file_perms; - -allow vcs firmware_file:dir r_dir_perms; -allow vcs firmware_file:file r_file_perms; - diff --git a/validityservice/Android.mk b/validityservice/Android.mk deleted file mode 100644 index eb55cac..0000000 --- a/validityservice/Android.mk +++ /dev/null @@ -1,33 +0,0 @@ -# Copyright (C) 2016 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. - -LOCAL_PATH:= $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_PACKAGE_NAME := ValidityService - -LOCAL_SRC_FILES := $(call all-java-files-under, src) - -LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res -LOCAL_AAPT_FLAGS := --auto-add-overlay - -LOCAL_PROGUARD_FLAG_FILES := proguard.flags - -LOCAL_CERTIFICATE := platform -LOCAL_PRIVILEGED_MODULE := true - -LOCAL_JACK_ENABLED := disabled - -include $(BUILD_PACKAGE) diff --git a/validityservice/AndroidManifest.xml b/validityservice/AndroidManifest.xml deleted file mode 100644 index 50d1d79..0000000 --- a/validityservice/AndroidManifest.xml +++ /dev/null @@ -1,37 +0,0 @@ - - - - - - - - - - - - - - diff --git a/validityservice/proguard.flags b/validityservice/proguard.flags deleted file mode 100644 index 47c2f15..0000000 --- a/validityservice/proguard.flags +++ /dev/null @@ -1,2 +0,0 @@ --verbose --keep class com.validity.fingerprint.* {*;} diff --git a/validityservice/res/drawable/icon.png b/validityservice/res/drawable/icon.png deleted file mode 100644 index aee44e138434630332d88b1680f33c4b24c70ab3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10486 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 - - - Validity service - diff --git a/validityservice/src/com/validity/fingerprint/ConsumerInfo.java b/validityservice/src/com/validity/fingerprint/ConsumerInfo.java deleted file mode 100644 index c81267d..0000000 --- a/validityservice/src/com/validity/fingerprint/ConsumerInfo.java +++ /dev/null @@ -1,32 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - - -public class ConsumerInfo { - public Object info; - public int type; - - public ConsumerInfo() { - } - - public ConsumerInfo(int type) { - this.type = type; - } -} diff --git a/validityservice/src/com/validity/fingerprint/EnrollCaptureStatus.java b/validityservice/src/com/validity/fingerprint/EnrollCaptureStatus.java deleted file mode 100644 index 94d87d0..0000000 --- a/validityservice/src/com/validity/fingerprint/EnrollCaptureStatus.java +++ /dev/null @@ -1,32 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class EnrollCaptureStatus { - - public int badSwipes; - public int cumulativeCoverageMap; - public int currentCoverageMap; - public int imageQuality; - public int positionFeedback; - public int progress; - public int templateResult; - public int totalSwipes; - -} diff --git a/validityservice/src/com/validity/fingerprint/EnrollUser.java b/validityservice/src/com/validity/fingerprint/EnrollUser.java deleted file mode 100644 index 2710f52..0000000 --- a/validityservice/src/com/validity/fingerprint/EnrollUser.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class EnrollUser { - public int fingerIndex; - public int mode; - public String userId; - - public EnrollUser() { - mode = 1; - } - -} diff --git a/validityservice/src/com/validity/fingerprint/Fingerprint.java b/validityservice/src/com/validity/fingerprint/Fingerprint.java deleted file mode 100644 index 50a5bdd..0000000 --- a/validityservice/src/com/validity/fingerprint/Fingerprint.java +++ /dev/null @@ -1,211 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -import android.content.Context; -import android.util.Log; - -public class Fingerprint extends FingerprintCore { - - public static final int VCS_ENROLL_MODE_DEFAULT = 1; - public static final int VCS_ENROLL_MODE_REENROLL = 2; - public static final int VCS_ENROLL_MODE_SECONDARY = 3; - - public static final int VCS_FINGER_POSITION_FEEDBACK_SWIPE_MIDDLE = 11; - public static final int VCS_FINGER_POSITION_FEEDBACK_SWIPE_MIDDLE_FULL = 12; - public static final int VCS_FINGER_POSITION_FEEDBACK_SWIPE_LEFT = 21; - public static final int VCS_FINGER_POSITION_FEEDBACK_SWIPE_RIGHT = 31; - public static final int VCS_FINGER_POSITION_FEEDBACK_SWIPE_ANY = 41; - - public static final int VCS_NOTIFY_SNSR_TEST_CONTINUE = 1; - public static final int VCS_NOTIFY_SNSR_TEST_STOP = 2; - public static final int VCS_NOTIFY_ENROLL_BEGIN = 3; - public static final int VCS_NOTIFY_ENROLL_END = 4; - - public static final int VCS_REQUEST_PROCESS_FIDO = 1; - public static final int VCS_REQUEST_PROCESS_ALIPAY = 2; - public static final int VCS_REQUEST_COMMAND_SENSOR_TEST = 11; - public static final int VCS_REQUEST_GET_SENSOR_INFO = 12; - public static final int VCS_REQUEST_GET_ENROLL_REPEAT_COUNT = 13; - private static final int VCS_REQUEST_ENABLE_WOF = 21; - private static final int VCS_REQUEST_GET_WOF_STATE = 22; - - public static final int VCS_SENSOR_STATUS_OK = 0; - public static final int VCS_SENSOR_STATUS_WORKING = 46; - public static final int VCS_SENSOR_STATUS_INITIALISING = 358; - public static final int VCS_SENSOR_STATUS_INITIALIZING = 358; - public static final int VCS_SENSOR_STATUS_OUT_OF_ORDER = 360; - public static final int VCS_SENSOR_STATUS_MALFUNCTIONED = 534; - public static final int VCS_SENSOR_STATUS_FAILURE = 535; - - public static final int VCS_WOF_STATE_INACTIVE = 0; - public static final int VCS_WOF_STATE_ACTIVE = 1; - - private native int jniEnableSensorDevice(int enable); - private native int jniEnrollUser(Object enrollInfo); - private native int jniEnrollUser(String userId, int fingerIndex, int mode); - private native int jniEnrollUser(String userId, String appData, int fingerIndex); - private native int jniGetSensorStatus(); - private native int jniNotify(int code, Object data); - private native int jniProcessFIDO(byte requestData[], VcsByteArray responseData); - private native int jniReEnrollUser(String userId, String appData, int fingerIndex, int mode); - private native int jniRemoveEnrolledFinger(Object enrollInfo); - private native int jniRemoveEnrolledFinger(String userId, int fingerIndex); - private native int jniRequest(int command, Object data); - private native int jniSetPassword(String userId, byte abyte0[], byte newPwdHash[]); // What is abyte0 means? - private native int jniVerifyPassword(String userId, byte pwdHash[]); - - public Fingerprint(Context ctx) { - super(ctx); - } - - public Fingerprint(Context ctx, FingerprintCore.EventListener listener) { - super(ctx, listener); - } - - public int enableSensorDevice(boolean enable) { - if (mOperation != 150) - return VCS_RESULT_ALREADY_INPROGRESS; - return jniEnableSensorDevice((enable? 1: 0)); - } - - public int enableWakeOnFinger() { - return jniRequest(VCS_REQUEST_ENABLE_WOF, null); - } - - public int enroll(EnrollUser enrollInfo) { - int ret = VCS_RESULT_FAILED; - if (mOperation != 150) - return ret; - ret = jniEnrollUser(enrollInfo); - if (ret == VCS_RESULT_OK) - mOperation = 151; - return ret; - } - - public int enroll(String userId, int fingerIndex) { - int ret = VCS_RESULT_FAILED; - if (mOperation != 150) - return ret; - if (null == userId) - userId = ""; - ret = jniEnrollUser(userId, fingerIndex, VCS_ENROLL_MODE_DEFAULT); - if (ret == VCS_RESULT_OK) - mOperation = 151; - return ret; - } - - public int enroll(String userId, int fingerIndex, int mode) { - int ret = VCS_RESULT_FAILED; - if (mOperation != 150) - return ret; - if (null == userId) - userId = ""; - ret = jniEnrollUser(userId, fingerIndex, mode); - if (ret == VCS_RESULT_OK) - mOperation = 151; - return ret; - } - - public int enroll(String userId, String appData, int fingerIndex) { - int ret = VCS_RESULT_FAILED; - if (mOperation != 150) - return ret; - if (null == userId) - userId = ""; - if (null == appData) - appData = ""; - ret = jniEnrollUser(userId, appData, fingerIndex); - if (ret == VCS_RESULT_OK) - mOperation = 151; - return ret; - } - - public int enroll(String userId, String appData, int fingerIndex, int mode) { - int ret = VCS_RESULT_FAILED; - if (mOperation != 150) - return ret; - if (null == userId) - userId = ""; - if (null == appData) - appData = ""; - ret = jniReEnrollUser(userId, appData, fingerIndex, mode); - if (ret == VCS_RESULT_OK) - mOperation = 151; - return ret; - } - - public int getSensorStatus() { - if (mOperation != 150) - return VCS_RESULT_ALREADY_INPROGRESS; - return jniGetSensorStatus(); - } - - public int getWakeOnFingerState(VcsInt wofState) { - if (wofState == null) - return VCS_RESULT_INVALID_ARGUMENT; - return jniRequest(VCS_REQUEST_GET_WOF_STATE, wofState); - } - - public int notify(int code, Object data) { - return jniNotify(code, data); - } - - public int processFIDO(byte requestData[], VcsByteArray responseData) { - if ((requestData == null) || (responseData == null)) - return VCS_RESULT_INVALID_ARGUMENT; - return jniProcessFIDO(requestData, responseData); - } - - public int removeEnrolledFinger(RemoveEnroll enrollInfo) { - return jniRemoveEnrolledFinger(enrollInfo); - } - - public int removeEnrolledFinger(String userId, int fingerIndex) { - if (mOperation != 150) - return VCS_RESULT_ALREADY_INPROGRESS; - if (null == userId) - userId = ""; - return jniRemoveEnrolledFinger(userId, fingerIndex); - } - - public int removeEnrolledUser(String userId) { - if (mOperation != 150) - return VCS_RESULT_ALREADY_INPROGRESS; - if (null == userId) - userId = ""; - return jniRemoveEnrolledFinger(userId, FINGER_INDEX_LEFT_THUMB_SECOND); - } - - public int request(int command, Object data) { - return jniRequest(command, data); - } - - public int setPassword(String userId, byte newPwdHash[]) { - if (userId == null || newPwdHash == null) - return VCS_RESULT_INVALID_ARGUMENT; - return jniSetPassword(userId, "".getBytes(), newPwdHash); - } - - public int verifyPassword(String userId, byte pwdHash[]) { - if (userId == null || pwdHash == null) - return VCS_RESULT_INVALID_ARGUMENT; - return jniVerifyPassword(userId, pwdHash); - } -} diff --git a/validityservice/src/com/validity/fingerprint/FingerprintBitmap.java b/validityservice/src/com/validity/fingerprint/FingerprintBitmap.java deleted file mode 100644 index 9b4d1cc..0000000 --- a/validityservice/src/com/validity/fingerprint/FingerprintBitmap.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -import android.graphics.Bitmap; - -public class FingerprintBitmap { - public Bitmap fingerprint; - public int quality; -} diff --git a/validityservice/src/com/validity/fingerprint/FingerprintCore.java b/validityservice/src/com/validity/fingerprint/FingerprintCore.java deleted file mode 100644 index d83b246..0000000 --- a/validityservice/src/com/validity/fingerprint/FingerprintCore.java +++ /dev/null @@ -1,230 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -import android.content.Context; -import android.util.Log; - -public class FingerprintCore extends VcsEvents { - public static interface EventListener { - public abstract void onEvent(FingerprintEvent fingerprintevent); - } - public static final String API_VERSION = "0.7"; - public static final String VCS_POLICY_VERSION = "0.1"; - protected static final boolean DBG = false; - protected static final int IDLE = 150; - protected static final int ENROLL = 151; - protected static final int IDENTIFY = 152; - protected static final int STOREDATATOUSER = 153; - protected static final int GETDATAFROMUSER = 154; - protected static final int REMOVEDATAFROMUSER = 155; - protected static final int GETPRINT = 156; - protected static final String TAG = "Fingerprint"; - protected static final String USER_ID = "android"; - protected int mOperation; - private EventListener mEventListener; - private String mAppId; - private String mUserId; - private String mAppKey; - private String mKeyData; - - private native int jniCancelOp(); - private native int jniCleanupVcs(); - private native int jniGetEnrolledFingerList(String userId, VcsInt fingermask); - private native int jniGetFingerprintImage(); - private native int jniGetFingerprintImageEx(Object info); - private native String[] jniGetUserList(VcsInt retCode); - private native String jniGetVersion(); - private native int jniIdentify(String userId); - private native int jniInitVcs(); - private native int jniInitVcs(FingerprintCore fingerprintcore); - private native int jniProtect(byte toProtect[], VcsAddInfo addInfo, VcsByteArray protectedData); - private native int jniRegisterEventsCB(FingerprintCore fingerprintcore); - private native int jniSetDetectFinger(int timeout); - private native int jniSetSecurityLevel(int level); - private native int jniUnprotect(byte protectedData[], VcsAddInfo addInfo, VcsByteArray unProtectedData); - - static { - try { - System.loadLibrary("vcsfp"); - } - catch (Throwable e) { - Log.e("Fingerprint", "Error loading library libvcsfp: " + e); - } - } - - public FingerprintCore(Context ctx) { - mOperation = IDLE; - mEventListener = null; - mAppId = ""; - mUserId = ""; - mAppKey = ""; - mKeyData = ""; - jniInitVcs(this); - } - - public FingerprintCore(Context ctx, EventListener listener) { - mOperation = IDLE; - mEventListener = null; - mAppId = ""; - mUserId = ""; - mAppKey = ""; - mKeyData = ""; - VLog.i("init ret="+jniInitVcs(this)); - mEventListener = listener; - } - - private boolean isOperationComplete(int eventId) { - if (eventId == VCS_EVT_ENROLL_SUCCESS || eventId == VCS_EVT_IDENTIFY_SUCCESS || - eventId == VCS_EVT_VERIFY_SUCCESS || eventId == VCS_EVT_ENROLL_FAILED || - eventId == VCS_EVT_IDENTIFY_FAILED || eventId == VCS_EVT_VERIFY_FAILED || - eventId == VCS_EVT_GESTURE) - return true; - return false; - } - - public synchronized void FingerprintEventCallback(FingerprintEvent event) { - if (event == null) { - Log.e("Fingerprint", "FP - EventsCB()::Invalid event data!"); - return; - } - if (isOperationComplete(event.eventId)) { - Log.i("Fingerprint", "Operation complete, setting to IDLE"); - this.mOperation = IDLE; - } - if ((this.mOperation == GETPRINT) && ((event.eventId == VCS_EVT_EIV_FINGERPRINT_CAPTURED) || - (event.eventId == VCS_EVT_SENSOR_FINGERPRINT_CAPTURE_FAILED))) { - this.mOperation = IDLE; - } - if (this.mEventListener != null) { - this.mEventListener.onEvent(event); - } - } - - public int cancel() { - int ret = VCS_RESULT_FAILED; - if (mOperation == IDLE) - return ret; - ret = jniCancelOp(); - mOperation = IDLE; - return ret; - } - - public int cleanUp() { - int ret = VCS_RESULT_FAILED; - mEventListener = null; - ret = jniCleanupVcs(); - return ret; - } - - public int getEnrolledFingerList(String userId, VcsInt fingermask) { - if (null == userId) - userId = ""; - int ret = jniGetEnrolledFingerList(userId, fingermask);; - return ret; - } - - public int getFingerprintImage(){ - int ret = VCS_RESULT_FAILED; - if (mOperation != IDLE) - return ret; - ret = jniGetFingerprintImage(); - if (ret == VCS_RESULT_OK) - mOperation = GETPRINT; - return ret; - } - - public int getFingerprintImage(ConsumerInfo info) { - int ret = VCS_RESULT_FAILED; - if (mOperation != IDLE) - return ret; - if (info == null) - Log.i("Fingerprint", "ConsumerInfo is null"); - ret = jniGetFingerprintImageEx(info); - if (ret == VCS_RESULT_OK) - mOperation = GETPRINT; - return ret; - } - - public int getUserList(VcsStringArray userList) { - VcsInt retCode = new VcsInt(); - userList.strlist = jniGetUserList(retCode); - if (userList.strlist == null) - return retCode.num; - return VCS_RESULT_OK; - } - - public String getVersion() { - if (mOperation != IDLE) { - Log.e("Fingerprint", "Other operation is in progress, cancelling request"); - return null; - } - return jniGetVersion(); - } - - public int identify(String userId) { - int ret = VCS_RESULT_FAILED; - if (mOperation == IDENTIFY) - return VCS_RESULT_ALREADY_INPROGRESS; - if (mOperation != IDLE) { - return ret; - } else { - if (null == userId) - userId = ""; - ret = jniIdentify(userId); - if (ret == VCS_RESULT_OK) - mOperation = IDENTIFY; - } - return ret; - } - - public int protect(byte toProtect[], VcsAddInfo addInfo, VcsByteArray protectedData) { - if (toProtect == null || addInfo == null || protectedData == null) - return VCS_RESULT_INVALID_ARGUMENT; - return jniProtect(toProtect, addInfo, protectedData); - } - - public int registerListener(EventListener listener) { - if (mOperation != IDLE) - return VCS_RESULT_FAILED; - mEventListener = listener; - return VCS_RESULT_OK; - } - - public int setDetectFinger(int timeout) { - return jniSetDetectFinger(timeout); - } - - public int setSecurityLevel(int level) { - if (mOperation != IDLE) - return VCS_RESULT_FAILED; - if (level == VCS_SECURITY_LEVEL_LOW || level == VCS_SECURITY_LEVEL_REGULAR || - level == VCS_SECURITY_LEVEL_HIGH || level == VCS_SECURITY_LEVEL_VERY_HIGH) - return jniSetSecurityLevel(level); - return VCS_RESULT_INVALID_ARGUMENT; - } - - public int unProtect(byte protectedData[], VcsAddInfo addInfo, VcsByteArray unProtectedData) { - if (protectedData == null || unProtectedData == null) - return VCS_RESULT_INVALID_ARGUMENT; - if (null == addInfo) - addInfo = new VcsAddInfo(); - return jniUnprotect(protectedData, addInfo, unProtectedData); - } -} diff --git a/validityservice/src/com/validity/fingerprint/FingerprintEvent.java b/validityservice/src/com/validity/fingerprint/FingerprintEvent.java deleted file mode 100644 index 905fda5..0000000 --- a/validityservice/src/com/validity/fingerprint/FingerprintEvent.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class FingerprintEvent { - public Object eventData; - public int eventId; -} diff --git a/validityservice/src/com/validity/fingerprint/IdentifyResult.java b/validityservice/src/com/validity/fingerprint/IdentifyResult.java deleted file mode 100644 index 504a5d0..0000000 --- a/validityservice/src/com/validity/fingerprint/IdentifyResult.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class IdentifyResult { - public byte templateId[] = new byte[16]; - public int matchedFingerIndexes[] = new int[20]; - public int corrMinuCount[] = new int[4]; - public int vMinuCount[] = new int[4]; - public String appData; - public int fMinuCount; - public int fingerIndex; - public float matchRate; - public int matchScore; - public int templateUpdated; - public String userId; -} diff --git a/validityservice/src/com/validity/fingerprint/RemoveEnroll.java b/validityservice/src/com/validity/fingerprint/RemoveEnroll.java deleted file mode 100644 index f6681d9..0000000 --- a/validityservice/src/com/validity/fingerprint/RemoveEnroll.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class RemoveEnroll { - public int fingerIndex; - public String userId; -} diff --git a/validityservice/src/com/validity/fingerprint/SensorInfo.java b/validityservice/src/com/validity/fingerprint/SensorInfo.java deleted file mode 100644 index 0af01f1..0000000 --- a/validityservice/src/com/validity/fingerprint/SensorInfo.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class SensorInfo { - public int flexId; - public String fwVersion; - public int productId; -} diff --git a/validityservice/src/com/validity/fingerprint/VLog.java b/validityservice/src/com/validity/fingerprint/VLog.java deleted file mode 100644 index 7d65d0b..0000000 --- a/validityservice/src/com/validity/fingerprint/VLog.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (C) 2016 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. - */ - -package com.validity.fingerprint; - -import android.util.Log; - -public class VLog { - private static final String TAG = "ValidityService"; - private static final boolean DEBUG = false; - - public static void i(final String message) { - Log.i(TAG, message); - } - - public static void d(final String message) { - if (DEBUG) { - Log.d(TAG, message); - } - } - - public static void v(final String message) { - if (DEBUG) { - Log.v(TAG, message); - } - } - - public static void e(final String message, final Throwable t) { - Log.e(TAG, message, t); - } - - public static void e(final String message) { - Log.e(TAG, message); - } - - public static void w(final String message, final Throwable t) { - Log.w(TAG, message, t); - } - - public static void w(final String message) { - Log.w(TAG, message); - } -} diff --git a/validityservice/src/com/validity/fingerprint/ValidityService.java b/validityservice/src/com/validity/fingerprint/ValidityService.java deleted file mode 100644 index b827e9c..0000000 --- a/validityservice/src/com/validity/fingerprint/ValidityService.java +++ /dev/null @@ -1,390 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -import android.app.Service; -import android.content.BroadcastReceiver; -import android.content.Context; -import android.content.Intent; -import android.content.IntentFilter; -import android.net.LocalServerSocket; -import android.net.LocalSocket; -import android.os.Bundle; -import android.os.IBinder; -import android.util.Log; - -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.io.OutputStream; -import java.io.OutputStreamWriter; - -public class ValidityService extends Service implements FingerprintCore.EventListener { - public static final String SOCKET_NAME = "validityservice"; - public static final String SOCKET_NAME_CB = "validityservice_callback"; - private LocalServerSocket mServerSocket = null; - private LocalServerSocket mServerSocketCB = null; - private LocalSocket mSocketCB = null; - - public static final int CALL_BASE = 0; - - public static final int CALL_INITSERVICE = CALL_BASE + 1; - public static final int CALL_ENROLL = CALL_BASE + 2; // userId ,fingerIndex - public static final int CALL_CANCEL = CALL_BASE + 3; - public static final int CALL_REMOVE = CALL_BASE + 4; // userId ,fingerIndex - public static final int CALL_IDENTIFY = CALL_BASE + 5; // userId - public static final int CALL_GET_ENROLLED_FINGER_LIST = CALL_BASE + 6; // userId - public static final int CALL_CLEANUP = CALL_BASE + 7; - - public static final int CB_ERROR = 1; - public static final int CB_ENROLL = 2; - public static final int CB_REMOVED = 3; - public static final int CB_ACQUIRED = 4; - public static final int CB_AUTHENTICATED = 5; - - private boolean mIsIdentify = false; - private int mLastEnrollFingerindex = 0; - private IdentifyResult mIdresult = null; - private boolean mEnrollBad = false; - private int mEnrollRepeatCount = 0; - private int mActiveGid = 0; - private boolean mIsNeedIdentify = false; - private int mIdentifyImage = 0; - - Fingerprint fp = new Fingerprint(this, this); - - /** We should set a password after we enroll one finger. This password is "123456q" - * The password hash method is SHA-1. - */ - public static final byte[] pwdhash = "bfff2dd4f1b310eb0dbf593bd83f94dd8d34077e".getBytes(); - - public int initService() { - int ret = fp.getSensorStatus(); - VLog.i("init: ret=" + ret); - VLog.i("init: version=" + fp.getVersion()); - notify_start(); - if (ret != 0 && ret != 1004) return -1; - return 0; - } - - public void notify_start() { - fp.cancel(); - fp.notify(Fingerprint.VCS_NOTIFY_ENROLL_BEGIN, null); - } - - public void notify_end() { - fp.cancel(); - fp.notify(Fingerprint.VCS_NOTIFY_ENROLL_END, null); - } - - @Override - public IBinder onBind(Intent intent) { - return null; - } - - @Override - public void onCreate() { - super.onCreate(); - VLog.v("onCreate"); - try { - mServerSocket = new LocalServerSocket(SOCKET_NAME); - mServerSocketCB = new LocalServerSocket(SOCKET_NAME_CB); - } catch (IOException e) { - VLog.v("in onCreate, making server socket: " + e); - return; - } - Thread t_server = new Thread() { - @Override - public void run() { - LocalSocket socket = null; - while (true) { - try { - VLog.v("Waiting for connection..."); - socket = mServerSocket.accept(); - VLog.v(".....Got socket: " + socket); - if (socket != null) { - startService(socket); - } else { - return; - } - } catch (IOException e) { - VLog.v("in accept: " + e); - } - } - } - }; - Thread t_server_cb = new Thread() { - @Override - public void run() { - while (true) { - try { - VLog.v("Waiting for connection..."); - mSocketCB = mServerSocketCB.accept(); - VLog.v(".....Got socket: " + mSocketCB); - if (mSocketCB == null) { - return; - } - } catch (IOException e) { - VLog.v("in accept: " + e); - } - } - } - }; - t_server.start(); - t_server_cb.start(); - - ScreenReceiver receiver = new ScreenReceiver(); - IntentFilter filter = new IntentFilter(); - filter.addAction(Intent.ACTION_SCREEN_ON); - filter.addAction(Intent.ACTION_SCREEN_OFF); - registerReceiver(receiver, filter); - } - - private void startService(final LocalSocket socket) { - Thread t = new Thread() { - @Override - public void run() { - try { - InputStream is = socket.getInputStream(); - OutputStream os = socket.getOutputStream(); - InputStreamReader isr = new InputStreamReader(is); - OutputStreamWriter osr = new OutputStreamWriter(os); - while (true) { - byte[] data = new byte[128]; - int count = is.read(data); - int ret = -1; - String userId; - int fingerIndex; - for (int i = 0;i < count;i++){ - VLog.d("data["+i+"]="+data[i]); - } - switch (data[0]) { - case CALL_INITSERVICE: - ret = initService(); - break; - case CALL_ENROLL: - userId = "User_" + data[1]; - fingerIndex = data[2]; - mLastEnrollFingerindex = fingerIndex; - mEnrollBad = false; - mEnrollRepeatCount = 8; - fp.verifyPassword(userId, pwdhash); - ret = fp.enroll(userId, "", fingerIndex, Fingerprint.VCS_ENROLL_MODE_DEFAULT); - break; - case CALL_CANCEL: - ret = fp.cancel(); - break; - case CALL_REMOVE: - userId = "User_" + data[1]; - fingerIndex = data[2]; - ret = fp.removeEnrolledFinger(userId, fingerIndex); - if (fingerIndex == VcsEvents.FINGER_INDEX_ALL) { - notify_end(); - notify_start(); - } - break; - case CALL_IDENTIFY: - userId = "User_" + data[1]; - mIsIdentify = true; - fp.setSecurityLevel(VcsEvents.VCS_SECURITY_LEVEL_HIGH); - mIdresult = null; - mActiveGid = data[1]; - ret = fp.identify(userId); - break; - case CALL_GET_ENROLLED_FINGER_LIST: - userId = "User_" + data[1]; - VcsInt fingermask = new VcsInt(); - fp.getEnrolledFingerList(userId, fingermask); - ret = fingermask.num; - break; - case CALL_CLEANUP: - notify_end(); - ret = fp.cleanUp(); - break; - default: - VLog.e("unknown function:" + data[0]); - } - String str = ret + ""; - osr.write(str); - osr.flush(); - } - } catch (IOException e) { - VLog.e("in startService loop: " + e.getMessage()); - try { - socket.close(); - } catch (IOException es) { - VLog.e("Cannot close socket: " + es.getMessage()); - } - return; - } - } - }; - t.start(); - } - - public int convertImageQuality(int imageQuality) { - switch (imageQuality) { - case VcsEvents.VCS_IMAGE_QUALITY_GOOD: - return 0; // FINGERPRINT_ACQUIRED_GOOD - case VcsEvents.VCS_IMAGE_QUALITY_REVERSE_MOTION: - case VcsEvents.VCS_IMAGE_QUALITY_TOO_SHORT: - case VcsEvents.VCS_IMAGE_QUALITY_WET_FINGER: - return 1; // FINGERPRINT_ACQUIRED_PARTIAL - case VcsEvents.VCS_IMAGE_QUALITY_STICTION: - case VcsEvents.VCS_IMAGE_QUALITY_SOMETHING_ON_THE_SENSOR: - return 3; // FINGERPRINT_ACQUIRED_IMAGER_DIRTY - case VcsEvents.VCS_IMAGE_QUALITY_TOO_SLOW: - return 4; // FINGERPRINT_ACQUIRED_TOO_SLOW - case VcsEvents.VCS_IMAGE_QUALITY_TOO_FAST: - return 5; // FINGERPRINT_ACQUIRED_TOO_FAST - default: - VLog.d("imageQuality="+imageQuality); - return 2; // FINGERPRINT_ACQUIRED_INSUFFICIENT - } - } - - /** Get which finger we detected. */ - public int getIdentifyFid() { - if (mIdresult == null) return 1; - return mIdresult.fingerIndex; - } - - public void onEvent(final FingerprintEvent event) { - VLog.v("identify onEvent: receive event :" + event.eventId); - OutputStreamWriter osr = null; - try { - OutputStream os = mSocketCB.getOutputStream(); - osr = new OutputStreamWriter(os); - String str = null; - switch (event.eventId) { - case VcsEvents.VCS_EVT_EIV_FINGERPRINT_CAPTURE_REDUNDANT: - str = CB_ACQUIRED + ":" + 1; - mEnrollBad = true; - break; - case VcsEvents.VCS_EVT_ENROLL_CAPTURE_STATUS: - EnrollCaptureStatus data_status = (EnrollCaptureStatus)event.eventData; - if (mEnrollBad) mEnrollBad = false; - else mEnrollRepeatCount = mEnrollRepeatCount - 1; - if (mEnrollRepeatCount != 0) { - str = CB_ENROLL + ":" + mLastEnrollFingerindex + ":" + mEnrollRepeatCount; - } - break; - case VcsEvents.VCS_EVT_EIV_FINGERPRINT_CAPTURED_BAD: - str = CB_ACQUIRED + ":" + convertImageQuality((int)event.eventData); - mEnrollBad = true; - break; - case VcsEvents.VCS_EVT_ENROLL_SUCCESS: - str = CB_ENROLL + ":" + mLastEnrollFingerindex + ":" + 0; - fp.setPassword("User_0", pwdhash); - break; - case VcsEvents.VCS_EVT_ENROLL_FAILED: - str = CB_ERROR + ":" + 2; //FINGERPRINT_ERROR_UNABLE_TO_PROCESS - VLog.e("enroll onEvent: enroll error, result=" + (int)event.eventData); - break; - case VcsEvents.VCS_EVT_VERIFY_COMPLETED: - case VcsEvents.VCS_EVT_IDENTIFY_COMPLETED: - mIdresult = (IdentifyResult)event.eventData; - break; - case VcsEvents.VCS_EVT_EIV_FINGERPRINT_CAPTURED: - FingerprintBitmap data_map = (FingerprintBitmap)event.eventData; - mIdentifyImage = convertImageQuality(data_map.quality); - break; - case VcsEvents.VCS_EVT_VERIFY_SUCCESS: - case VcsEvents.VCS_EVT_IDENTIFY_SUCCESS: - mIsIdentify = false; - str = CB_AUTHENTICATED + ":" + getIdentifyFid(); - break; - case VcsEvents.VCS_EVT_SENSOR_REMOVED: - mIsIdentify = false; - str = CB_ERROR + ":" + 1; //FINGERPRINT_ERROR_HW_UNAVAILABLE - VLog.e("identify onEvent: identify error, result=" + (int)event.eventData); - break; - case VcsEvents.VCS_EVT_VERIFY_FAILED: - case VcsEvents.VCS_EVT_IDENTIFY_FAILED: - mIsIdentify = false; - VLog.e("identify onEvent: identify error, result=" + (int)event.eventData); - switch ((int)event.eventData) { - case VcsEvents.VCS_RESULT_BAD_QUALITY_IMAGE: - str = CB_ACQUIRED + ":" + mIdentifyImage; - case VcsEvents.VCS_RESULT_USER_DOESNT_EXIST: - fp.setSecurityLevel(VcsEvents.VCS_SECURITY_LEVEL_HIGH); - mIdresult = null; - mIsIdentify = true; - fp.identify("User_" + mActiveGid); - if (str == null) { - str = CB_ACQUIRED + ":" + 1; // FINGERPRINT_ACQUIRED_PARTIAL - } - break; - case VcsEvents.VCS_RESULT_OPERATION_CANCELED: - break; - default: - str = CB_ERROR + ":" + 2; //FINGERPRINT_ERROR_UNABLE_TO_PROCESS - } - break; - default: - VLog.v("identify onEvent: No need to process event :" + event.eventId); - } - if (str != null) { - osr.write(str); - osr.flush(); - } - } catch (IOException e) { - VLog.e("in onEvent: " + e.getMessage()); - try { - osr.close(); - mSocketCB.close(); - } catch (IOException es) { - VLog.e("Cannot close socket: " + es.getMessage()); - } - return; - } - } - - /** Our Keyguard will not call identify when turn on screen, so we need call it. */ - public void onScreenOn() { - if (mIsNeedIdentify) { - mIsNeedIdentify = false; - fp.setSecurityLevel(VcsEvents.VCS_SECURITY_LEVEL_HIGH); - mIdresult = null; - mIsIdentify = true; - fp.identify("User_" + mActiveGid); - } - } - - public void onScreenOff() { - if (mIsIdentify) { - mIsNeedIdentify = true; - } - } - - public class ScreenReceiver extends BroadcastReceiver { - - @Override - public void onReceive(Context context, Intent intent) { - if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) { - onScreenOn(); - } - else if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) { - onScreenOff(); - } - else VLog.e("Unknown intent:" + intent.getAction()); - } - } - -} diff --git a/validityservice/src/com/validity/fingerprint/ValidityServiceStarter.java b/validityservice/src/com/validity/fingerprint/ValidityServiceStarter.java deleted file mode 100644 index 9552e7e..0000000 --- a/validityservice/src/com/validity/fingerprint/ValidityServiceStarter.java +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -import android.app.Application; -import android.content.Context; -import android.content.Intent; -import android.util.Log; - -public class ValidityServiceStarter extends Application { - - @Override - public void onCreate() { - super.onCreate(); - VLog.v("onCreate"); - Intent serviceintent = new Intent(this, ValidityService.class); - startService(serviceintent); - } - -} diff --git a/validityservice/src/com/validity/fingerprint/VcsAddInfo.java b/validityservice/src/com/validity/fingerprint/VcsAddInfo.java deleted file mode 100644 index ae6522c..0000000 --- a/validityservice/src/com/validity/fingerprint/VcsAddInfo.java +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class VcsAddInfo { - public int algID; - public byte data[]; - - public VcsAddInfo() { - } - - public VcsAddInfo(int algorithmID) { - algID = algorithmID; - } -} diff --git a/validityservice/src/com/validity/fingerprint/VcsByteArray.java b/validityservice/src/com/validity/fingerprint/VcsByteArray.java deleted file mode 100644 index d0225e5..0000000 --- a/validityservice/src/com/validity/fingerprint/VcsByteArray.java +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class VcsByteArray { - public byte data[]; -} diff --git a/validityservice/src/com/validity/fingerprint/VcsEvents.java b/validityservice/src/com/validity/fingerprint/VcsEvents.java deleted file mode 100644 index 44ace90..0000000 --- a/validityservice/src/com/validity/fingerprint/VcsEvents.java +++ /dev/null @@ -1,179 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class VcsEvents { - - public static final int FINGER_INDEX_LEFT_THUMB = 1; - public static final int FINGER_INDEX_LEFT_INDEX = 2; - public static final int FINGER_INDEX_LEFT_MIDDLE = 3; - public static final int FINGER_INDEX_LEFT_RING = 4; - public static final int FINGER_INDEX_LEFT_LITTLE = 5; - public static final int FINGER_INDEX_RIGHT_THUMB = 6; - public static final int FINGER_INDEX_RIGHT_INDEX = 7; - public static final int FINGER_INDEX_RIGHT_MIDDLE = 8; - public static final int FINGER_INDEX_RIGHT_RING = 9; - public static final int FINGER_INDEX_RIGHT_LITTLE = 10; - public static final int FINGER_INDEX_LEFT_THUMB_SECOND = 11; - public static final int FINGER_INDEX_LEFT_INDEX_SECOND = 12; - public static final int FINGER_INDEX_LEFT_MIDDLE_SECOND = 13; - public static final int FINGER_INDEX_LEFT_RING_SECOND = 14; - public static final int FINGER_INDEX_LEFT_LITTLE_SECOND = 15; - public static final int FINGER_INDEX_RIGHT_THUMB_SECOND = 16; - public static final int FINGER_INDEX_RIGHT_INDEX_SECOND = 17; - public static final int FINGER_INDEX_RIGHT_MIDDLE_SECOND = 18; - public static final int FINGER_INDEX_RIGHT_RING_SECOND = 19; - public static final int FINGER_INDEX_RIGHT_LITTLE_SECOND = 20; - public static final int FINGER_INDEX_ALL = 21; - - public static final int VCS_EVT_SENSOR_REMOVED = 1; - public static final int VCS_EVT_SENSOR_DETECTED = 2; - public static final int VCS_EVT_SENSOR_READY_FOR_USE = 3; - public static final int VCS_EVT_SENSOR_FAILED_INITIALIZATION = 4; - public static final int VCS_EVT_SENSOR_FINGERPRINT_CAPTURE_COMPLETE = 5; - public static final int VCS_EVT_SENSOR_RAW_FINGERPRINT_CAPTURE_COMPLETE = 6; - public static final int VCS_EVT_SENSOR_FINGERPRINT_CAPTURE_FAILED = 7; - public static final int VCS_EVT_SENSOR_FINGERPRINT_CAPTURE_START = 8; - public static final int VCS_EVT_ALL_SENSORS_INITIALIZED = 9; - public static final int VCS_EVT_SENSOR_FINGERPRINT_FAILED_SWIPE_RETRY = 10; - public static final int VCS_EVT_FINGER_DETECTED = 11; - public static final int VCS_EVT_ENROLL_COMPLETED = 13; - public static final int VCS_EVT_VERIFY_COMPLETED = 14; - public static final int VCS_EVT_IDENTIFY_COMPLETED = 15; - public static final int VCS_EVT_ENROLL_NEXT_CAPTURE_START = 16; - public static final int VCS_EVT_EIV_FINGERPRINT_CAPTURED = 17; - public static final int VCS_EVT_FINGER_REMOVED = 20; - public static final int VCS_EVT_ENROLL_CAPTURE_STATUS = 32; - public static final int VCS_EVT_FINGER_SETTLED = 33; - public static final int VCS_EVT_SET_IR_FLAGS = 37; - public static final int VCS_EVT_SWIPE_DIRECTION = 41; - public static final int VCS_EVT_SWIPE_SPEED_UPDATE = 42; - public static final int VCS_EVT_EIV_FINGERPRINT_CAPTURED_BAD = 45; - public static final int VCS_EVT_SENSOR_NON_RECOVERABLE = 46; - public static final int VCS_EVT_ENVIRONMENT_NOISE_DETECTED = 47; - public static final int VCS_EVT_EIV_FINGERPRINT_CAPTURE_REDUNDANT = 49; - public static final int VCS_EVT_EIV_FINGERPRINT_CAPTURE_EARLY = 50; - - public static final int VCS_EVT_ENROLL_SUCCESS = 421; - public static final int VCS_EVT_VERIFY_SUCCESS = 422; - public static final int VCS_EVT_IDENTIFY_SUCCESS = 423; - public static final int VCS_EVT_ENROLL_FAILED = 424; - public static final int VCS_EVT_VERIFY_FAILED = 425; - public static final int VCS_EVT_IDENTIFY_FAILED = 426; - public static final int VCS_EVT_GESTURE = 427; - public static final int VCS_EVT_SENSOR_INFO = 428; - - public static final int VCS_IMAGE_QUALITY_GOOD = 0; - public static final int VCS_IMAGE_QUALITY_STICTION = 1; - public static final int VCS_IMAGE_QUALITY_TOO_FAST = 2; - public static final int VCS_IMAGE_QUALITY_TOO_SHORT = 4; - public static final int VCS_IMAGE_QUALITY_REVERSE_MOTION = 8; - public static final int VCS_IMAGE_QUALITY_TOO_SLOW = 16; - public static final int VCS_IMAGE_QUALITY_SOMETHING_ON_THE_SENSOR = 512; - public static final int VCS_IMAGE_QUALITY_ONE_HAND_SWIPE = 1024; - public static final int VCS_IMAGE_QUALITY_FINGER_OFFSET = 4096; - public static final int VCS_IMAGE_QUALITY_BAD_SWIPE = 8192; - public static final int VCS_IMAGE_QUALITY_SKEW_TOO_LARGE = 32768; - public static final int VCS_IMAGE_QUALITY_PRESSURE_TOO_LIGHT = 0x10000; - public static final int VCS_IMAGE_QUALITY_FINGER_OFFSET_TOO_FAR_LEFT = 0x20000; - public static final int VCS_IMAGE_QUALITY_FINGER_OFFSET_TOO_FAR_RIGHT = 0x40000; - public static final int VCS_IMAGE_QUALITY_PRESSURE_TOO_HARD = 0x80000; - public static final int VCS_IMAGE_QUALITY_ASP_DATA_INVALID = 0x100000; - public static final int VCS_IMAGE_QUALITY_NOT_A_FINGER_SWIPE = 0x200000; - public static final int VCS_IMAGE_QUALITY_BASELINE_DATA_INVALID = 0x400000; - public static final int VCS_IMAGE_QUALITY_WET_FINGER = 0x1000000; - public static final int VCS_IMAGE_QUALITY_FINGER_TOO_THIN = 0x2000000; - public static final int VCS_IMAGE_QUALITY_PARTIAL_TOUCH = 0x8000000; - public static final int VCS_IMAGE_QUALITY_EMPTY_TOUCH = 0x10000000; - public static final int VCS_IMAGE_QUALITY_GESTURE = 0x20000000; - public static final int VCS_IMAGE_QUALITY_PROCESS_FAILED = 0x40000000; - public static final int VCS_IMAGE_QUALITY_PROCESS_FAILED_FATAL = 0x80000000; - - public static final int VCS_NOTIFY_AUTH_SESSION_BEGIN = 5; - public static final int VCS_NOTIFY_AUTH_SESSION_END = 6; - - public static final int VCS_POLICY_AUTHENTICATE_ALWAYS = 1; - public static final int VCS_POLICY_AUTHENTICATE_ON_SCREEN_UNLOCK_TIMEOUT = 2; - public static final int VCS_POLICY_AUTHENTICATE_ON_PREVIOUS_IDENTIFY_TIMEOUT = 3; - - public static final int VCS_PROTECT_ALG_SIMPLE_USER_DATA = 1; - public static final int VCS_PROTECT_ALG_SIMPLE_APP_DATA = 2; - - public static final int VCS_RESULT_FAILED = -1; - public static final int VCS_RESULT_OK = 0; - public static final int VCS_RESULT_CANCEL = 1; - public static final int VCS_RESULT_OUT_OF_MEMORY = 2; - public static final int VCS_RESULT_NO_MORE_ENTRIES = 3; - public static final int VCS_RESULT_BAD_PARAM = 17; - public static final int VCS_RESULT_SENSOR_NOT_FOUND = 19; - public static final int VCS_RESULT_SENSOR_OPEN_FAILED = 22; - public static final int VCS_RESULT_TIMEOUT = 34; - public static final int VCS_RESULT_NULL_POINTER = 40; - public static final int VCS_RESULT_SENSOR_BUSY = 46; - public static final int VCS_RESULT_ERROR = 54; - public static final int VCS_RESULT_TEMPLATE_FILE_CREATION_FAILED = 64; - public static final int VCS_RESULT_USER_DOESNT_EXIST = 65; - public static final int VCS_RESULT_TEMPLATE_DOESNT_EXIST = 66; - public static final int VCS_RESULT_INVALID_USER_HANDLE = 70; - public static final int VCS_RESULT_TEMPLATE_CORRUPTED = 87; - public static final int VCS_RESULT_USER_FINGER_ALREADY_ENROLLED = 88; - public static final int VCS_RESULT_USER_DATA_CORRUPTED = 91; - public static final int VCS_RESULT_MATCHER_OPEN_FAILED = 300; - public static final int VCS_RESULT_MATCHER_CLOSE_FAILED = 301; - public static final int VCS_RESULT_MATCHER_MATCH_FAILED = 302; - public static final int VCS_RESULT_MATCHER_EXTRACT_FAILED = 303; - public static final int VCS_RESULT_MATCHER_ENROLL_FAILED = 304; - public static final int VCS_RESULT_MATCHER_VERIFY_FAILED = 305; - public static final int VCS_RESULT_MATCHER_ADD_IMAGE_FAILED = 306; - public static final int VCS_RESULT_MATCHER_MATCH_IMAGE_FAILED = 307; - public static final int VCS_RESULT_MATCHER_CHECK_QUALITY_FAILED = 308; - public static final int VCS_RESULT_SERVICE_NOT_RUNNING = 321; - public static final int VCS_RESULT_SENSOR_NOT_READY_FOR_USE = 358; - public static final int VCS_RESULT_SENSOR_IS_REMOVED = 360; - public static final int VCS_RESULT_OPERATION_CANCELED = 361; - public static final int VCS_RESULT_USER_IDENTIFICATION_FAILED = 362; - public static final int VCS_RESULT_USER_VERIFICATION_FAILED = 363; - public static final int VCS_RESULT_MATCH_FAILED = 367; - public static final int VCS_RESULT_SERVICE_STOPPED = 500; - public static final int VCS_RESULT_GET_PRINT_STOPPED = 501; - public static final int VCS_RESULT_OPERATION_DENIED = 510; - public static final int VCS_RESULT_PIPE_ERROR = 511; - public static final int VCS_RESULT_SENSOR_KEYS_NOT_READY = 512; - public static final int VCS_RESULT_BAD_DEVICE = 513; - public static final int VCS_RESULT_TOO_MANY_BAD_SWIPES = 515; - public static final int VCS_RESULT_BAD_QUALITY_IMAGE = 601; - public static final int VCS_RESULT_KEYDATA_NOT_FOUND = 777; - public static final int VCS_RESULT_DATA_STORE_FAILED = 1001; - public static final int VCS_RESULT_DATA_RETRIEVE_FAILED = 1002; - public static final int VCS_RESULT_DATA_REMOVE_FAILED = 1003; - public static final int VCS_RESULT_ALREADY_INPROGRESS = 1004; - public static final int VCS_RESULT_NOT_IMPLEMENTED = 1005; - public static final int VCS_RESULT_INVALID_ARGUMENT = 1006; - - public static final int VCS_SECURITY_LEVEL_LOW = 0; - public static final int VCS_SECURITY_LEVEL_REGULAR = 1; - public static final int VCS_SECURITY_LEVEL_HIGH = 2; - public static final int VCS_SECURITY_LEVEL_VERY_HIGH = 3; - - public static final int VCS_SWIPE_DIRECTION_UP = 0; - public static final int VCS_SWIPE_DIRECTION_DOWN = 1; - public static final int VCS_SWIPE_DIRECTION_LEFT = 3; - public static final int VCS_SWIPE_DIRECTION_RIGHT = 4; - public static final int VCS_SWIPE_DIRECTION_REST = 5; -} diff --git a/validityservice/src/com/validity/fingerprint/VcsInt.java b/validityservice/src/com/validity/fingerprint/VcsInt.java deleted file mode 100644 index bd4bb56..0000000 --- a/validityservice/src/com/validity/fingerprint/VcsInt.java +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class VcsInt { - public int num; -} diff --git a/validityservice/src/com/validity/fingerprint/VcsStringArray.java b/validityservice/src/com/validity/fingerprint/VcsStringArray.java deleted file mode 100644 index e250496..0000000 --- a/validityservice/src/com/validity/fingerprint/VcsStringArray.java +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * Copyright (C) 2016 The Mokee Project - * Copyright (C) 2016 The CyanogenMod 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. - */ - -package com.validity.fingerprint; - -public class VcsStringArray { - public String strlist[]; -}