examples/verify.c

   1 /*
   2  * Example fingerprint verification program, which verifies the right index
   3  * finger which has been previously enrolled to disk.
   4  * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24
  25 #include <libfprint/fprint.h>
  26
  27 struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
  28 {
  29         struct fp_dscv_dev *ddev = NULL;
  30         int i;
  31
  32         for (i = 0; ddev = discovered_devs[i]; i++) {
  33                 struct fp_driver *drv = fp_dscv_dev_get_driver(ddev);
  34                 printf("Found device claimed by %s driver\n",
  35                         fp_driver_get_full_name(drv));
  36                 return ddev;
  37         }
  38
  39         return ddev;
  40 }
  41
  42 int verify(struct fp_dev *dev, struct fp_print_data *data)
  43 {
  44         int r;
  45
  46         do {
  47                 struct fp_img *img = NULL;
  48
  49                 sleep(1);
  50                 printf("\nScan your finger now.\n");
  51                 r = fp_verify_finger_img(dev, data, &img);
  52                 if (img) {
  53                         fp_img_save_to_file(img, "verify.pgm");
  54                         printf("Wrote scanned image to verify.pgm\n");
  55                         fp_img_free(img);
  56                 }
  57                 if (r < 0) {
  58                         printf("verification failed with error %d :(\n", r);
  59                         return r;
  60                 }
  61                 switch (r) {
  62                 case FP_VERIFY_NO_MATCH:
  63                         printf("NO MATCH!\n");
  64                         return 0;
  65                 case FP_VERIFY_MATCH:
  66                         printf("MATCH!\n");
  67                         return 0;
  68                 case FP_VERIFY_RETRY:
  69                         printf("Scan didn't quite work. Please try again.\n");
  70                         break;
  71                 case FP_VERIFY_RETRY_TOO_SHORT:
  72                         printf("Swipe was too short, please try again.\n");
  73                         break;
  74                 case FP_VERIFY_RETRY_CENTER_FINGER:
  75                         printf("Please center your finger on the sensor and try again.\n");
  76                         break;
  77                 case FP_VERIFY_RETRY_REMOVE_FINGER:
  78                         printf("Please remove finger from the sensor and try again.\n");
  79                         break;
  80                 }
  81         } while (1);
  82 }
  83
  84 int main(void)
  85 {
  86         int r = 1;
  87         struct fp_dscv_dev *ddev;
  88         struct fp_dscv_dev **discovered_devs;
  89         struct fp_dev *dev;
  90         struct fp_print_data *data;
  91
  92         r = fp_init();
  93         if (r < 0) {
  94                 fprintf(stderr, "Failed to initialize libfprint\n");
  95                 exit(1);
  96         }
  97
  98         discovered_devs = fp_discover_devs();
  99         if (!discovered_devs) {
 100                 fprintf(stderr, "Could not discover devices\n");
 101                 goto out;
 102         }
 103
 104         ddev = discover_device(discovered_devs);
 105         if (!ddev) {
 106                 fprintf(stderr, "No devices detected.\n");
 107                 goto out;
 108         }
 109
 110         dev = fp_dev_open(ddev);
 111         fp_dscv_devs_free(discovered_devs);
 112         if (!dev) {
 113                 fprintf(stderr, "Could not open device.\n");
 114                 goto out;
 115         }
 116
 117         printf("Opened device. Loading previously enrolled right index finger "
 118                 "data...\n");
 119
 120         r = fp_print_data_load(dev, RIGHT_INDEX, &data);
 121         if (r != 0) {
 122                 fprintf(stderr, "Failed to load fingerprint, error %d\n", r);
 123                 fprintf(stderr, "Did you remember to enroll your right index finger "
 124                         "first?\n");
 125                 goto out_close;
 126         }
 127
 128         printf("Print loaded. Time to verify!\n");
 129         do {
 130                 char buffer[20];
 131
 132                 verify(dev, data);
 133                 printf("Verify again? [Y/n]? ");
 134                 fgets(buffer, sizeof(buffer), stdin);
 135                 if (buffer[0] != '\n' && buffer[0] != 'y' && buffer[0] != 'Y')
 136                         break;
 137         } while (1);
 138
 139         fp_print_data_free(data);
 140 out_close:
 141         fp_dev_close(dev);
 142 out:
 143         fp_exit();
 144         return r;
 145 }
 146
 147