static void generic_acquire_stop(struct fp_img_dev *imgdev) { imgdev->action_state = IMG_ACQUIRE_STATE_DEACTIVATING; dev_deactivate(imgdev); fp_print_data_free(imgdev->acquire_data); fp_print_data_free(imgdev->enroll_data); fp_img_free(imgdev->acquire_img); imgdev->acquire_data = NULL; imgdev->enroll_data = NULL; imgdev->acquire_img = NULL; imgdev->action_result = 0; }
void fpi_imgdev_report_finger_status(struct fp_img_dev *imgdev, gboolean present) { int r = imgdev->action_result; struct fp_print_data *data = imgdev->acquire_data; struct fp_img *img = imgdev->acquire_img; fp_dbg(present ? "finger on sensor" : "finger removed"); if (present && imgdev->action_state == IMG_ACQUIRE_STATE_AWAIT_FINGER_ON) { dev_change_state(imgdev, IMGDEV_STATE_CAPTURE); imgdev->action_state = IMG_ACQUIRE_STATE_AWAIT_IMAGE; return; } else if (present || imgdev->action_state != IMG_ACQUIRE_STATE_AWAIT_FINGER_OFF) { fp_dbg("ignoring status report"); return; } /* clear these before reporting results to avoid complications with * call cascading in and out of the library */ imgdev->acquire_img = NULL; imgdev->acquire_data = NULL; /* finger removed, report results */ switch (imgdev->action) { case IMG_ACTION_ENROLL: fp_dbg("reporting enroll result"); fpi_drvcb_enroll_stage_completed(imgdev->dev, r, data, img); if (r > 0 && r != FP_ENROLL_COMPLETE && r != FP_ENROLL_FAIL) { imgdev->action_result = 0; imgdev->action_state = IMG_ACQUIRE_STATE_AWAIT_FINGER_ON; dev_change_state(imgdev, IMG_ACQUIRE_STATE_AWAIT_FINGER_ON); } break; case IMG_ACTION_VERIFY: fpi_drvcb_report_verify_result(imgdev->dev, r, img); fp_print_data_free(data); break; case IMG_ACTION_IDENTIFY: fpi_drvcb_report_identify_result(imgdev->dev, r, imgdev->identify_match_offset, img); fp_print_data_free(data); break; default: fp_err("unhandled action %d", imgdev->action); break; } }
/** \ingroup print_data * Loads a previously stored print from disk. The print must have been saved * earlier using the fp_print_data_save() function. * * A return code of -ENOENT indicates that the fingerprint requested could not * be found. Other error codes (both positive and negative) are possible for * obscure error conditions (e.g. corruption). * * \param dev the device you are loading the print for * \param finger the finger of the file you are loading * \param data output location to put the corresponding stored print. Must be * freed with fp_print_data_free() after use. * \returns 0 on success, non-zero on error */ API_EXPORTED int fp_print_data_load(struct fp_dev *dev, enum fp_finger finger, struct fp_print_data **data) { gchar *path; struct fp_print_data *fdata; int r; if (!base_store) storage_setup(); path = get_path_to_print(dev, finger); r = load_from_file(path, &fdata); g_free(path); if (r) return r; if (!fp_dev_supports_print_data(dev, fdata)) { fp_err("print data is not compatible!"); fp_print_data_free(fdata); return -EINVAL; } *data = fdata; return 0; }
void fpi_imgdev_image_captured(struct fp_img_dev *imgdev, struct fp_img *img) { struct fp_print_data *print; int r; fp_dbg(""); if (imgdev->action_state != IMG_ACQUIRE_STATE_AWAIT_IMAGE) { fp_dbg("ignoring due to current state %d", imgdev->action_state); return; } if (imgdev->action_result) { fp_dbg("not overwriting existing action result"); return; } r = sanitize_image(imgdev, &img); if (r < 0) { imgdev->action_result = r; fp_img_free(img); goto next_state; } fp_img_standardize(img); imgdev->acquire_img = img; r = fpi_img_to_print_data(imgdev, img, &print); if (r < 0) { fp_dbg("image to print data conversion error: %d", r); imgdev->action_result = FP_ENROLL_RETRY; goto next_state; } else if (img->minutiae->num < MIN_ACCEPTABLE_MINUTIAE) { fp_dbg("not enough minutiae, %d/%d", img->minutiae->num, MIN_ACCEPTABLE_MINUTIAE); fp_print_data_free(print); /* depends on FP_ENROLL_RETRY == FP_VERIFY_RETRY */ imgdev->action_result = FP_ENROLL_RETRY; goto next_state; } imgdev->acquire_data = print; switch (imgdev->action) { case IMG_ACTION_ENROLL: imgdev->action_result = FP_ENROLL_COMPLETE; break; case IMG_ACTION_VERIFY: verify_process_img(imgdev); break; case IMG_ACTION_IDENTIFY: identify_process_img(imgdev); break; default: BUG(); break; } next_state: imgdev->action_state = IMG_ACQUIRE_STATE_AWAIT_FINGER_OFF; dev_change_state(imgdev, IMGDEV_STATE_AWAIT_FINGER_OFF); }
/** * Enrolls a finger and returns the associated fp-data. * * @param env the Java Environment pointer. * @param obj the jobject of the type jlibfprint/JlibFprint. * @return the jlibfprint/JlibFprint$fp_print_data with the data just given by the scanner. * @throws an enroll_exception is raised is something gone wrong. */ JNIEXPORT jobject JNICALL Java_jlibfprint_JlibFprint_enroll_1finger(JNIEnv* env, jobject ref) { const jclass fpClass = env->FindClass("jlibfprint/JlibFprint$fp_print_data"); const jclass eeClass = env->FindClass("jlibfprint/JlibFprint$EnrollException"); /* Starts the library */ if (fp_init()) // Se differente da 0 => Exception { jobject enrollException = env->AllocObject(eeClass); jfieldID eeExcp_id = env->GetFieldID(eeClass, "enroll_exception", "I"); env->SetIntField(enrollException, eeExcp_id, UNABLE_TO_LOAD_LIBFPRINT); env->Throw((jthrowable)enrollException); return NULL; } fp_dev *device; fp_print_data* pdp; /* Gets the pointer to the device */ if (!get_device_id(env, ref, &device)) { jobject enrollException = env->AllocObject(eeClass); jfieldID eeExcp_id = env->GetFieldID(eeClass, "enroll_exception", "I"); env->SetIntField(enrollException, eeExcp_id, DEVICE_NOT_FOUND); env->Throw((jthrowable)enrollException); return NULL; } /* Enrolls the finger */ int ef = fp_enroll_finger(device, &pdp); /* Create a new obj to store the data */ jobject obj = env->AllocObject(fpClass); /* Raises an exception if the enrollment was not completed */ if (ef != FP_ENROLL_COMPLETE) { jobject enrollException = env->AllocObject(eeClass); jfieldID eeExcp_id = env->GetFieldID(eeClass, "enroll_exception", "I"); env->SetIntField(enrollException, eeExcp_id, ef); env->Throw((jthrowable)enrollException); } else { /* Fills the object with the enrollment data */ cfp2jfp(env, obj, pdp); memset(pdp, 0, sizeof(fp_print_data)); fp_print_data_free(pdp); } fp_dev_close(device); fp_exit(); return obj; }
static void vwin_cb_fing_changed(GtkWidget *widget, gpointer user_data) { struct fp_dscv_print *dprint; GtkTreeIter iter; int r; fp_print_data_free(enroll_data); enroll_data = NULL; if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(vwin_fingcombo), &iter)) return; gtk_tree_model_get(GTK_TREE_MODEL(vwin_fingmodel), &iter, FC_COL_PRINT, &dprint, -1); r = fp_print_data_from_dscv_print(dprint, &enroll_data); vwin_vfy_status_print_loaded(r); }
static struct fp_print_data *fpi_print_data_from_fp2_data(unsigned char *buf, size_t buflen) { size_t total_data_len, item_len; struct fp_print_data *data; struct fp_print_data_item *item; struct fpi_print_data_fp2 *raw = (struct fpi_print_data_fp2 *) buf; unsigned char *raw_buf; struct fpi_print_data_item_fp2 *raw_item; total_data_len = buflen - sizeof(*raw); data = print_data_new(GUINT16_FROM_LE(raw->driver_id), GUINT32_FROM_LE(raw->devtype), raw->data_type); raw_buf = raw->data; while (total_data_len) { if (total_data_len < sizeof(*raw_item)) break; total_data_len -= sizeof(*raw_item); raw_item = (struct fpi_print_data_item_fp2 *)raw_buf; item_len = GUINT32_FROM_LE(raw_item->length); fp_dbg("item len %d, total_data_len %d", item_len, total_data_len); if (total_data_len < item_len) { fp_err("corrupted fingerprint data"); break; } total_data_len -= item_len; item = fpi_print_data_item_new(item_len); /* FIXME: fp_print_data->data content is not endianess agnostic */ memcpy(item->data, raw_item->data, item_len); data->prints = g_slist_prepend(data->prints, item); raw_buf += sizeof(*raw_item); raw_buf += item_len; } if (g_slist_length(data->prints) == 0) { fp_print_data_free(data); data = NULL; } return data; }
static void vwin_clear(void) { fp_img_free(img_normal); img_normal = NULL; fp_img_free(img_bin); img_bin = NULL; fp_print_data_free(enroll_data); enroll_data = NULL; gtk_image_clear(GTK_IMAGE(vwin_verify_img)); gtk_widget_set_sensitive(vwin_img_save_btn, FALSE); gtk_list_store_clear(GTK_LIST_STORE(vwin_fingmodel)); gtk_label_set_text(GTK_LABEL(vwin_vfy_status), NULL); gtk_label_set_text(GTK_LABEL(vwin_minutiae_cnt), NULL); gtk_widget_set_sensitive(vwin_fingcombo, FALSE); gtk_widget_set_sensitive(vwin_vfy_button, FALSE); }
int main(int argc, char *argv[]) { int r = 1, i; int next_option; enum fp_finger finger = RIGHT_INDEX; struct fp_dscv_dev *ddev; struct fp_dscv_dev **discovered_devs; struct fp_dev *dev; struct fp_print_data *data; const char * const short_options = "hf:"; const struct option long_options[] = { { "help", 0, NULL, 'h'}, { "enroll-finger", 1, NULL, 'f'}, { NULL, 0, NULL, 0} }; do { next_option = getopt_long(argc, argv, short_options, long_options, NULL); switch (next_option) { case 'h': /* Printing usage */ printf("Usage: %s options\n", argv[0]); printf(" -h --help Display this usage information.\n" " -f --enroll-finger index Enroll finger with index.\n\n"); printf(" Valid indexes are:\n"); for (i = LEFT_THUMB; i <= RIGHT_LITTLE; i++) { printf(" %d - %s\n", i, finger_names[i]); } exit(1); break; case 'f': sscanf(optarg, "%d", &finger); if (finger < LEFT_THUMB || finger > RIGHT_LITTLE) { printf("%s: Invalid finger index.\n", argv[0]); printf("%s: Valid indexes are:\n", argv[0]); for (i = LEFT_THUMB; i <= RIGHT_LITTLE; i++) { printf("%s: %d - %s\n", argv[0], i, finger_names[i]); } exit(1); } break; case -1: /* Done with options. */ break; default: /* Unexpected option */ exit(1); } } while (next_option != -1); printf("This program will enroll your finger, " "unconditionally overwriting any selected print that was enrolled " "previously. If you want to continue, press enter, otherwise hit " "Ctrl+C\n"); getchar(); r = fp_init(); if (r < 0) { fprintf(stderr, "Failed to initialize libfprint\n"); exit(1); } discovered_devs = fp_discover_devs(); if (!discovered_devs) { fprintf(stderr, "Could not discover devices\n"); goto out; } ddev = discover_device(discovered_devs); if (!ddev) { fprintf(stderr, "No devices detected.\n"); goto out; } dev = fp_dev_open(ddev); fp_dscv_devs_free(discovered_devs); if (!dev) { fprintf(stderr, "Could not open device.\n"); goto out; } printf("Opened device. It's now time to enroll your finger.\n\n"); data = enroll(dev, finger); if (!data) goto out_close; r = fp_print_data_save(data, finger); if (r < 0) fprintf(stderr, "Data save failed, code %d\n", r); fp_print_data_free(data); out_close: fp_dev_close(dev); out: fp_exit(); return r; }
int main(){ //initialize if (fp_init()){ printf("libfprint patladi!\n"); exit(1); //failure } //dev discovery struct fp_dscv_dev** ddevicelist; struct fp_dscv_dev* ddevice; if (!(ddevicelist = fp_discover_devs())){ //listeyi al printf("Device discovery calismadi!\n"); exit(1); //failure } if(!(ddevice = ddevicelist[0])){ //bos? TODO: 2 alet varsa nolacak? printf("Alet nerde?\n"); exit(1); //failure } print_driver_info(ddevice); //open device struct fp_dev* device; if(!(device = fp_dev_open(ddevice))){ printf("Okuyucu baslamadi!\n"); exit(1); //failure } //enroll //printf("%d", fp_dev_get_nr_enroll_stages(device)); //tek olmali, cunku laptop. int done = 0; struct fp_print_data* guvenliparmak = NULL; while(!done){ switch(fp_enroll_finger_img(device, &guvenliparmak, NULL)){ case FP_ENROLL_FAIL: printf("Parmakizi alimi tamamlanamadi!\n"); exit(1); //fail case FP_ENROLL_COMPLETE: done = 1; printf("Parmakizi alimi basariyla tamamlandi.\n"); break; case FP_ENROLL_PASS: printf("Tanima asamasi basarili..\n"); break; default: printf("Yeniden deneyin!\n"); break; } } fp_print_data_free(guvenliparmak); //cleanup fp_dev_close(device); fp_exit(); return 0; }
int main(void) { struct fp_dscv_dev *ddev; struct fp_dscv_dev **discovered_devs; struct fp_dev *dev; struct fp_print_data *data; int r = fp_init(); if (r < 0) { fprintf(stderr, "Failed to initialize libfprint\n"); exit(1); } fp_set_debug(3); discovered_devs = fp_discover_devs(); if (!discovered_devs) { fprintf(stderr, "Could not discover devices\n"); goto out; } ddev = discover_device(discovered_devs); if (!ddev) { fprintf(stderr, "No devices detected.\n"); goto out; } dev = fp_dev_open(ddev); fp_dscv_devs_free(discovered_devs); if (!dev) { fprintf(stderr, "Could not open device.\n"); goto out; } printf("Opened device. It's now time to enroll your finger.\n\n"); data = enroll(dev); if (!data) goto out_close; printf("Normally we'd save that print to disk, and recall it at some " "point later when we want to authenticate the user who just " "enrolled. In the interests of demonstration, we'll authenticate " "that user immediately.\n"); do { char buffer[20]; verify(dev, data); printf("Verify again? [Y/n]? "); fgets(buffer, sizeof(buffer), stdin); if (buffer[0] != '\n' && buffer[0] != 'y' && buffer[0] != 'Y') break; } while (1); fp_print_data_free(data); out_close: fp_dev_close(dev); out: fp_exit(); return r; }
int main (int argc, char **argv) { int r = 1; struct fp_dscv_dev *ddev; struct fp_dscv_dev **discovered_devs; struct fp_dev *dev; struct fp_print_data *data; int finger; finger = atoi(argv[3]); printf ("This program will enroll your right index finger, " "unconditionally overwriting any right-index print that was enrolled " "previously. If you want to continue, press enter, otherwise hit " "Ctrl+C\n"); getchar (); r = fp_init (); if (r < 0) { fprintf (stderr, "Failed to initialize libfprint\n"); exit (1); } fp_set_debug (3); discovered_devs = fp_discover_devs (); if (!discovered_devs) { fprintf (stderr, "Could not discover devices\n"); goto out; } ddev = discover_device (discovered_devs); if (!ddev) { fprintf (stderr, "No devices detected.\n"); goto out; } dev = fp_dev_open (ddev); fp_dscv_devs_free (discovered_devs); if (!dev) { fprintf (stderr, "Could not open device.\n"); goto out; } printf ("Opened device. It's now time to enroll your finger.\n\n"); data = enroll (dev); if (!data) goto out_close; r = fp_print_data_save (data, finger, argv[1], argv[2]); if (r < 0) fprintf (stderr, "Data save failed, code %d\n", r); fp_print_data_free (data); out_close: fp_dev_close (dev); out: fp_exit (); return r; }
int main(void) { struct fp_dscv_dev *ddev; struct fp_dscv_dev **discovered_devs; struct fp_dev *dev; struct fp_print_data *data; int r = fp_init(); if (r < 0) { fprintf(stderr, "Failed to initialize libfprint\n"); exit(1); } fp_set_debug(3); discovered_devs = fp_discover_devs(); if (!discovered_devs) { fprintf(stderr, "Could not discover devices\n"); goto out; } ddev = discover_device(discovered_devs); if (!ddev) { fprintf(stderr, "No devices detected.\n"); goto out; } dev = fp_dev_open(ddev); fp_dscv_devs_free(discovered_devs); if (!dev) { fprintf(stderr, "Could not open device.\n"); goto out; } printf("Opened device. Loading previously enrolled right index finger " "data...\n"); r = fp_print_data_load(dev, RIGHT_INDEX, &data); if (r != 0) { fprintf(stderr, "Failed to load fingerprint, error %d\n", r); fprintf(stderr, "Did you remember to enroll your right index finger " "first?\n"); goto out_close; } printf("Print loaded. Time to verify!\n"); do { char buffer[20]; verify(dev, data); printf("Verify again? [Y/n]? "); fgets(buffer, sizeof(buffer), stdin); if (buffer[0] != '\n' && buffer[0] != 'y' && buffer[0] != 'Y') break; } while (1); fp_print_data_free(data); out_close: fp_dev_close(dev); out: fp_exit(); return r; }
int main(void) { int r = 1; struct fp_dscv_dev *ddev; struct fp_dscv_dev **discovered_devs; struct fp_dev *dev; struct fp_print_data *data; r = fp_init(); if (r < 0) { printf("Failed to initialize fprint\n"); exit(1); } fp_set_debug(3); discovered_devs = fp_discover_devs(); if (!discovered_devs) { printf("Could not discover devices\n"); goto out; } ddev = discover_device(discovered_devs); if (!ddev) { printf("No devices detected.\n"); goto out; } dev = fp_dev_open(ddev); fp_dscv_devs_free(discovered_devs); if (!dev) { printf("Could not open device.\n"); goto out; } printf("Opened device. " "enrolling...\n"); r = fp_print_data_load(dev, RIGHT_INDEX, &data); if (r != 0) { printf("Failed to load fingerprint,\n"); goto out_close; } printf("Print loaded. Try to verify!\n"); do { char buffer[20]; verify(dev, data); printf("Verify again? [Y/n]? "); fgets(buffer, sizeof(buffer), stdin); if (buffer[0] != '\n' && buffer[0] != 'y' && buffer[0] != 'Y') break; } while (1); fp_print_data_free(data); out_close: fp_dev_close(dev); out: fp_exit(); return r; }
void fpi_imgdev_image_captured(struct fp_img_dev *imgdev, struct fp_img *img) { struct fp_print_data *print; int r; fp_dbg(""); if (imgdev->action_state != IMG_ACQUIRE_STATE_AWAIT_IMAGE) { fp_dbg("ignoring due to current state %d", imgdev->action_state); return; } if (imgdev->action_result) { fp_dbg("not overwriting existing action result"); return; } r = sanitize_image(imgdev, &img); if (r < 0) { imgdev->action_result = r; fp_img_free(img); goto next_state; } fp_img_standardize(img); imgdev->acquire_img = img; if (imgdev->action != IMG_ACTION_CAPTURE) { r = fpi_img_to_print_data(imgdev, img, &print); if (r < 0) { fp_dbg("image to print data conversion error: %d", r); imgdev->action_result = FP_ENROLL_RETRY; goto next_state; } else if (img->minutiae->num < MIN_ACCEPTABLE_MINUTIAE) { fp_dbg("not enough minutiae, %d/%d", img->minutiae->num, MIN_ACCEPTABLE_MINUTIAE); fp_print_data_free(print); /* depends on FP_ENROLL_RETRY == FP_VERIFY_RETRY */ imgdev->action_result = FP_ENROLL_RETRY; goto next_state; } } imgdev->acquire_data = print; switch (imgdev->action) { case IMG_ACTION_ENROLL: if (!imgdev->enroll_data) { imgdev->enroll_data = fpi_print_data_new(imgdev->dev); } BUG_ON(g_slist_length(print->prints) != 1); /* Move print data from acquire data into enroll_data */ imgdev->enroll_data->prints = g_slist_prepend(imgdev->enroll_data->prints, print->prints->data); print->prints = g_slist_remove(print->prints, print->prints->data); fp_print_data_free(imgdev->acquire_data); imgdev->acquire_data = NULL; imgdev->enroll_stage++; if (imgdev->enroll_stage == imgdev->dev->nr_enroll_stages) imgdev->action_result = FP_ENROLL_COMPLETE; else imgdev->action_result = FP_ENROLL_PASS; break; case IMG_ACTION_VERIFY: verify_process_img(imgdev); break; case IMG_ACTION_IDENTIFY: identify_process_img(imgdev); break; case IMG_ACTION_CAPTURE: imgdev->action_result = FP_CAPTURE_COMPLETE; break; default: BUG(); break; } next_state: imgdev->action_state = IMG_ACQUIRE_STATE_AWAIT_FINGER_OFF; dev_change_state(imgdev, IMGDEV_STATE_AWAIT_FINGER_OFF); }