biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #define LOG_TAG "android.hardware.biometrics.fingerprint@2.1-service"
  17 #define LOG_VERBOSE "android.hardware.biometrics.fingerprint@2.1-service"
  18
  19 // For communication with Keystore binder interface
  20 #include <keystore/keystore.h> // for error codes
  21 #include <hardware/hw_auth_token.h>
  22
  23 #include <hardware/hardware.h>
  24 #include <hardware/fingerprint.h>
  25 #include "BiometricsFingerprint.h"
  26
  27 #include <inttypes.h>
  28 #include <unistd.h>
  29
  30 namespace android {
  31 namespace hardware {
  32 namespace biometrics {
  33 namespace fingerprint {
  34 namespace V2_1 {
  35 namespace implementation {
  36
  37 // Supported fingerprint HAL version
  38 static const uint16_t kVersion = HARDWARE_MODULE_API_VERSION(2, 1);
  39
  40 using RequestStatus =
  41         android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
  42
  43 BiometricsFingerprint *BiometricsFingerprint::sInstance = nullptr;
  44
  45 BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr), mDevice(nullptr) {
  46     sInstance = this; // keep track of the most recent instance
  47     mDevice = openHal();
  48     if (!mDevice) {
  49         ALOGE("Can't open HAL module");
  50     }
  51 }
  52
  53 BiometricsFingerprint::~BiometricsFingerprint() {
  54     ALOGV("~BiometricsFingerprint()");
  55     if (mDevice == nullptr) {
  56         ALOGE("No valid device");
  57         return;
  58     }
  59     int err;
  60     if (0 != (err = mDevice->common.close(
  61             reinterpret_cast<hw_device_t*>(mDevice)))) {
  62         ALOGE("Can't close fingerprint module, error: %d", err);
  63         return;
  64     }
  65     mDevice = nullptr;
  66 }
  67
  68 Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
  69     switch(error) {
  70         case 0: return RequestStatus::SYS_OK;
  71         case -2: return RequestStatus::SYS_ENOENT;
  72         case -4: return RequestStatus::SYS_EINTR;
  73         case -5: return RequestStatus::SYS_EIO;
  74         case -11: return RequestStatus::SYS_EAGAIN;
  75         case -12: return RequestStatus::SYS_ENOMEM;
  76         case -13: return RequestStatus::SYS_EACCES;
  77         case -14: return RequestStatus::SYS_EFAULT;
  78         case -16: return RequestStatus::SYS_EBUSY;
  79         case -22: return RequestStatus::SYS_EINVAL;
  80         case -28: return RequestStatus::SYS_ENOSPC;
  81         case -110: return RequestStatus::SYS_ETIMEDOUT;
  82         default:
  83             ALOGE("An unknown error returned from fingerprint vendor library");
  84             return RequestStatus::SYS_UNKNOWN;
  85     }
  86 }
  87
  88 // Translate from errors returned by traditional HAL (see fingerprint.h) to
  89 // HIDL-compliant FingerprintError.
  90 FingerprintError BiometricsFingerprint::VendorErrorFilter(int32_t error,
  91             int32_t* vendorCode) {
  92     *vendorCode = 0;
  93     switch(error) {
  94         case FINGERPRINT_ERROR_HW_UNAVAILABLE:
  95             return FingerprintError::ERROR_HW_UNAVAILABLE;
  96         case FINGERPRINT_ERROR_UNABLE_TO_PROCESS:
  97             return FingerprintError::ERROR_UNABLE_TO_PROCESS;
  98         case FINGERPRINT_ERROR_TIMEOUT:
  99             return FingerprintError::ERROR_TIMEOUT;
 100         case FINGERPRINT_ERROR_NO_SPACE:
 101             return FingerprintError::ERROR_NO_SPACE;
 102         case FINGERPRINT_ERROR_CANCELED:
 103             return FingerprintError::ERROR_CANCELED;
 104         case FINGERPRINT_ERROR_UNABLE_TO_REMOVE:
 105             return FingerprintError::ERROR_UNABLE_TO_REMOVE;
 106         case FINGERPRINT_ERROR_LOCKOUT:
 107             return FingerprintError::ERROR_LOCKOUT;
 108         default:
 109             if (error >= FINGERPRINT_ERROR_VENDOR_BASE) {
 110                 // vendor specific code.
 111                 *vendorCode = error - FINGERPRINT_ERROR_VENDOR_BASE;
 112                 return FingerprintError::ERROR_VENDOR;
 113             }
 114     }
 115     ALOGE("Unknown error from fingerprint vendor library: %d", error);
 116     return FingerprintError::ERROR_UNABLE_TO_PROCESS;
 117 }
 118
 119 // Translate acquired messages returned by traditional HAL (see fingerprint.h)
 120 // to HIDL-compliant FingerprintAcquiredInfo.
 121 FingerprintAcquiredInfo BiometricsFingerprint::VendorAcquiredFilter(
 122         int32_t info, int32_t* vendorCode) {
 123     *vendorCode = 0;
 124     switch(info) {
 125         case FINGERPRINT_ACQUIRED_GOOD:
 126             return FingerprintAcquiredInfo::ACQUIRED_GOOD;
 127         case FINGERPRINT_ACQUIRED_PARTIAL:
 128             return FingerprintAcquiredInfo::ACQUIRED_PARTIAL;
 129         case FINGERPRINT_ACQUIRED_INSUFFICIENT:
 130             return FingerprintAcquiredInfo::ACQUIRED_INSUFFICIENT;
 131         case FINGERPRINT_ACQUIRED_IMAGER_DIRTY:
 132             return FingerprintAcquiredInfo::ACQUIRED_IMAGER_DIRTY;
 133         case FINGERPRINT_ACQUIRED_TOO_SLOW:
 134             return FingerprintAcquiredInfo::ACQUIRED_TOO_SLOW;
 135         case FINGERPRINT_ACQUIRED_TOO_FAST:
 136             return FingerprintAcquiredInfo::ACQUIRED_TOO_FAST;
 137         default:
 138             if (info >= FINGERPRINT_ACQUIRED_VENDOR_BASE) {
 139                 // vendor specific code.
 140                 *vendorCode = info - FINGERPRINT_ACQUIRED_VENDOR_BASE;
 141                 return FingerprintAcquiredInfo::ACQUIRED_VENDOR;
 142             }
 143     }
 144     ALOGE("Unknown acquiredmsg from fingerprint vendor library: %d", info);
 145     return FingerprintAcquiredInfo::ACQUIRED_INSUFFICIENT;
 146 }
 147
 148 Return<uint64_t> BiometricsFingerprint::setNotify(
 149         const sp<IBiometricsFingerprintClientCallback>& clientCallback) {
 150     mClientCallback = clientCallback;
 151     // This is here because HAL 2.1 doesn't have a way to propagate a
 152     // unique token for its driver. Subsequent versions should send a unique
 153     // token for each call to setNotify(). This is fine as long as there's only
 154     // one fingerprint device on the platform.
 155     return reinterpret_cast<uint64_t>(mDevice);
 156 }
 157
 158 Return<uint64_t> BiometricsFingerprint::preEnroll()  {
 159     return mDevice->pre_enroll(mDevice);
 160 }
 161
 162 Return<RequestStatus> BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69>& hat,
 163         uint32_t gid, uint32_t timeoutSec) {
 164     const hw_auth_token_t* authToken =
 165         reinterpret_cast<const hw_auth_token_t*>(hat.data());
 166     return ErrorFilter(mDevice->enroll(mDevice, authToken, gid, timeoutSec));
 167 }
 168
 169 Return<RequestStatus> BiometricsFingerprint::postEnroll() {
 170     return ErrorFilter(mDevice->post_enroll(mDevice));
 171 }
 172
 173 Return<uint64_t> BiometricsFingerprint::getAuthenticatorId() {
 174     return mDevice->get_authenticator_id(mDevice);
 175 }
 176
 177 Return<RequestStatus> BiometricsFingerprint::cancel() {
 178     return ErrorFilter(mDevice->cancel(mDevice));
 179 }
 180
 181 Return<RequestStatus> BiometricsFingerprint::enumerate()  {
 182     return ErrorFilter(mDevice->enumerate(mDevice));
 183 }
 184
 185 Return<RequestStatus> BiometricsFingerprint::remove(uint32_t gid, uint32_t fid) {
 186     return ErrorFilter(mDevice->remove(mDevice, gid, fid));
 187 }
 188
 189 Return<RequestStatus> BiometricsFingerprint::setActiveGroup(uint32_t gid,
 190         const hidl_string& storePath) {
 191     if (storePath.size() >= PATH_MAX || storePath.size() <= 0) {
 192         ALOGE("Bad path length: %zd", storePath.size());
 193         return RequestStatus::SYS_EINVAL;
 194     }
 195     if (access(storePath.c_str(), W_OK)) {
 196         return RequestStatus::SYS_EINVAL;
 197     }
 198
 199     return ErrorFilter(mDevice->set_active_group(mDevice, gid,
 200                                                     storePath.c_str()));
 201 }
 202
 203 Return<RequestStatus> BiometricsFingerprint::authenticate(uint64_t operationId,
 204         uint32_t gid) {
 205     return ErrorFilter(mDevice->authenticate(mDevice, operationId, gid));
 206 }
 207
 208 IBiometricsFingerprint* BiometricsFingerprint::getInstance() {
 209     if (!sInstance) {
 210       sInstance = new BiometricsFingerprint();
 211     }
 212     return sInstance;
 213 }
 214
 215 fingerprint_device_t* BiometricsFingerprint::openHal() {
 216     int err;
 217     const hw_module_t *hw_mdl = nullptr;
 218     ALOGD("Opening fingerprint hal library...");
 219     if (0 != (err = hw_get_module(FINGERPRINT_HARDWARE_MODULE_ID, &hw_mdl))) {
 220         ALOGE("Can't open fingerprint HW Module, error: %d", err);
 221         return nullptr;
 222     }
 223
 224     if (hw_mdl == nullptr) {
 225         ALOGE("No valid fingerprint module");
 226         return nullptr;
 227     }
 228
 229     fingerprint_module_t const *module =
 230         reinterpret_cast<const fingerprint_module_t*>(hw_mdl);
 231     if (module->common.methods->open == nullptr) {
 232         ALOGE("No valid open method");
 233         return nullptr;
 234     }
 235
 236     hw_device_t *device = nullptr;
 237
 238     if (0 != (err = module->common.methods->open(hw_mdl, nullptr, &device))) {
 239         ALOGE("Can't open fingerprint methods, error: %d", err);
 240         return nullptr;
 241     }
 242
 243     if (kVersion != device->version) {
 244         // enforce version on new devices because of HIDL@2.1 translation layer
 245         ALOGE("Wrong fp version. Expected %d, got %d", kVersion, device->version);
 246         return nullptr;
 247     }
 248
 249     fingerprint_device_t* fp_device =
 250         reinterpret_cast<fingerprint_device_t*>(device);
 251
 252     if (0 != (err =
 253             fp_device->set_notify(fp_device, BiometricsFingerprint::notify))) {
 254         ALOGE("Can't register fingerprint module callback, error: %d", err);
 255         return nullptr;
 256     }
 257
 258     return fp_device;
 259 }
 260
 261 void BiometricsFingerprint::notify(const fingerprint_msg_t *msg) {
 262     BiometricsFingerprint* thisPtr = static_cast<BiometricsFingerprint*>(
 263             BiometricsFingerprint::getInstance());
 264     if (thisPtr == nullptr || thisPtr->mClientCallback == nullptr) {
 265         ALOGE("Receiving callbacks before the client callback is registered.");
 266         return;
 267     }
 268     const uint64_t devId = reinterpret_cast<uint64_t>(thisPtr->mDevice);
 269     switch (msg->type) {
 270         case FINGERPRINT_ERROR: {
 271                 int32_t vendorCode = 0;
 272                 FingerprintError result = VendorErrorFilter(msg->data.error, &vendorCode);
 273                 if (!thisPtr->mClientCallback->onError(devId, result, vendorCode).isOk()) {
 274                     ALOGE("failed to invoke fingerprint onError callback");
 275                 }
 276             }
 277             break;
 278         case FINGERPRINT_ACQUIRED: {
 279                 int32_t vendorCode = 0;
 280                 FingerprintAcquiredInfo result =
 281                     VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode);
 282                 if (!thisPtr->mClientCallback->onAcquired(devId, result, vendorCode).isOk()) {
 283                     ALOGE("failed to invoke fingerprint onAcquired callback");
 284                 }
 285             }
 286             break;
 287         case FINGERPRINT_TEMPLATE_ENROLLING:
 288             if (!thisPtr->mClientCallback->onEnrollResult(devId,
 289                     msg->data.enroll.finger.fid,
 290                     msg->data.enroll.finger.gid,
 291                     msg->data.enroll.samples_remaining).isOk()) {
 292                 ALOGE("failed to invoke fingerprint onEnrollResult callback");
 293             }
 294             break;
 295         case FINGERPRINT_TEMPLATE_REMOVED:
 296             if (!thisPtr->mClientCallback->onRemoved(devId,
 297                     msg->data.removed.finger.fid,
 298                     msg->data.removed.finger.gid,
 299                     msg->data.removed.remaining_templates).isOk()) {
 300                 ALOGE("failed to invoke fingerprint onRemoved callback");
 301             }
 302             break;
 303         case FINGERPRINT_AUTHENTICATED:
 304             if (msg->data.authenticated.finger.fid != 0) {
 305                 const uint8_t* hat =
 306                     reinterpret_cast<const uint8_t *>(&msg->data.authenticated.hat);
 307                 const hidl_vec<uint8_t> token(
 308                     std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat)));
 309                 if (!thisPtr->mClientCallback->onAuthenticated(devId,
 310                         msg->data.authenticated.finger.fid,
 311                         msg->data.authenticated.finger.gid,
 312                         token).isOk()) {
 313                     ALOGE("failed to invoke fingerprint onAuthenticated callback");
 314                 }
 315             } else {
 316                 // Not a recognized fingerprint
 317                 if (!thisPtr->mClientCallback->onAuthenticated(devId,
 318                         msg->data.authenticated.finger.fid,
 319                         msg->data.authenticated.finger.gid,
 320                         hidl_vec<uint8_t>()).isOk()) {
 321                     ALOGE("failed to invoke fingerprint onAuthenticated callback");
 322                 }
 323             }
 324             break;
 325         case FINGERPRINT_TEMPLATE_ENUMERATING:
 326             if (!thisPtr->mClientCallback->onEnumerate(devId,
 327                     msg->data.enumerated.finger.fid,
 328                     msg->data.enumerated.finger.gid,
 329                     msg->data.enumerated.remaining_templates).isOk()) {
 330                 ALOGE("failed to invoke fingerprint onEnumerate callback");
 331             }
 332             break;
 333     }
 334 }
 335
 336 } // namespace implementation
 337 }  // namespace V2_1
 338 }  // namespace fingerprint
 339 }  // namespace biometrics
 340 }  // namespace hardware
 341 }  // namespace android