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(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(int argc, char* argv[]) { signal_setup(); fprintf(stdout, "\nACT version %s\n", VERSION); fprintf(stdout, "Storage device IO test\n"); fprintf(stdout, "Copyright 2018 by Aerospike. All rights reserved.\n\n"); if (! storage_configure(argc, argv)) { exit(-1); } device devices[g_scfg.num_devices]; queue* trans_qs[g_scfg.num_queues]; g_devices = devices; g_trans_qs = trans_qs; histogram_scale scale = g_scfg.us_histograms ? HIST_MICROSECONDS : HIST_MILLISECONDS; if (! (g_large_block_read_hist = histogram_create(scale)) || ! (g_large_block_write_hist = histogram_create(scale)) || ! (g_raw_read_hist = histogram_create(scale)) || ! (g_read_hist = histogram_create(scale)) || ! (g_raw_write_hist = histogram_create(scale)) || ! (g_write_hist = histogram_create(scale))) { exit(-1); } for (uint32_t n = 0; n < g_scfg.num_devices; n++) { device* dev = &g_devices[n]; dev->name = (const char*)g_scfg.device_names[n]; if (g_scfg.file_size == 0) { // normally 0 set_scheduler(dev->name, g_scfg.scheduler_mode); } if (! (dev->fd_q = queue_create(sizeof(int), true)) || ! discover_device(dev) || ! (dev->raw_read_hist = histogram_create(scale)) || ! (dev->raw_write_hist = histogram_create(scale))) { exit(-1); } sprintf(dev->read_hist_tag, "%s-reads", dev->name); sprintf(dev->write_hist_tag, "%s-writes", dev->name); } rand_seed(); g_run_start_us = get_us(); uint64_t run_stop_us = g_run_start_us + g_scfg.run_us; g_running = true; if (g_scfg.write_reqs_per_sec != 0) { for (uint32_t n = 0; n < g_scfg.num_devices; n++) { device* dev = &g_devices[n]; if (pthread_create(&dev->large_block_read_thread, NULL, run_large_block_reads, (void*)dev) != 0) { fprintf(stdout, "ERROR: create large op read thread\n"); exit(-1); } if (pthread_create(&dev->large_block_write_thread, NULL, run_large_block_writes, (void*)dev) != 0) { fprintf(stdout, "ERROR: create large op write thread\n"); exit(-1); } } } if (g_scfg.tomb_raider) { for (uint32_t n = 0; n < g_scfg.num_devices; n++) { device* dev = &g_devices[n]; if (pthread_create(&dev->tomb_raider_thread, NULL, run_tomb_raider, (void*)dev) != 0) { fprintf(stdout, "ERROR: create tomb raider thread\n"); exit(-1); } } } uint32_t n_trans_tids = g_scfg.num_queues * g_scfg.threads_per_queue; pthread_t trans_tids[n_trans_tids]; for (uint32_t i = 0; i < g_scfg.num_queues; i++) { if (! (g_trans_qs[i] = queue_create(sizeof(trans_req), true))) { exit(-1); } for (uint32_t j = 0; j < g_scfg.threads_per_queue; j++) { if (pthread_create(&trans_tids[(i * g_scfg.threads_per_queue) + j], NULL, run_transactions, (void*)g_trans_qs[i]) != 0) { fprintf(stdout, "ERROR: create transaction thread\n"); exit(-1); } } } // Equivalent: g_scfg.internal_read_reqs_per_sec != 0. bool do_reads = g_scfg.read_reqs_per_sec != 0; pthread_t read_req_tids[g_scfg.read_req_threads]; if (do_reads) { for (uint32_t k = 0; k < g_scfg.read_req_threads; k++) { if (pthread_create(&read_req_tids[k], NULL, run_generate_read_reqs, NULL) != 0) { fprintf(stdout, "ERROR: create read request thread\n"); exit(-1); } } } // Equivalent: g_scfg.internal_write_reqs_per_sec != 0. bool do_commits = g_scfg.commit_to_device && g_scfg.write_reqs_per_sec != 0; pthread_t write_req_tids[g_scfg.write_req_threads]; if (do_commits) { for (uint32_t k = 0; k < g_scfg.write_req_threads; k++) { if (pthread_create(&write_req_tids[k], NULL, run_generate_write_reqs, NULL) != 0) { fprintf(stdout, "ERROR: create write request thread\n"); exit(-1); } } } fprintf(stdout, "\nHISTOGRAM NAMES\n"); if (do_reads) { fprintf(stdout, "reads\n"); fprintf(stdout, "device-reads\n"); for (uint32_t d = 0; d < g_scfg.num_devices; d++) { fprintf(stdout, "%s\n", g_devices[d].read_hist_tag); } } if (g_scfg.write_reqs_per_sec != 0) { fprintf(stdout, "large-block-reads\n"); fprintf(stdout, "large-block-writes\n"); } if (do_commits) { fprintf(stdout, "writes\n"); fprintf(stdout, "device-writes\n"); for (uint32_t d = 0; d < g_scfg.num_devices; d++) { fprintf(stdout, "%s\n", g_devices[d].write_hist_tag); } } fprintf(stdout, "\n"); uint64_t now_us = 0; uint64_t count = 0; while (g_running && (now_us = get_us()) < run_stop_us) { count++; int64_t sleep_us = (int64_t) ((count * g_scfg.report_interval_us) - (now_us - g_run_start_us)); if (sleep_us > 0) { usleep((uint32_t)sleep_us); } fprintf(stdout, "after %" PRIu64 " sec:\n", (count * g_scfg.report_interval_us) / 1000000); fprintf(stdout, "requests-queued: %" PRIu32 "\n", atomic32_get(g_reqs_queued)); if (do_reads) { histogram_dump(g_read_hist, "reads"); histogram_dump(g_raw_read_hist, "device-reads"); for (uint32_t d = 0; d < g_scfg.num_devices; d++) { histogram_dump(g_devices[d].raw_read_hist, g_devices[d].read_hist_tag); } } if (g_scfg.write_reqs_per_sec != 0) { histogram_dump(g_large_block_read_hist, "large-block-reads"); histogram_dump(g_large_block_write_hist, "large-block-writes"); } if (do_commits) { histogram_dump(g_write_hist, "writes"); histogram_dump(g_raw_write_hist, "device-writes"); for (uint32_t d = 0; d < g_scfg.num_devices; d++) { histogram_dump(g_devices[d].raw_write_hist, g_devices[d].write_hist_tag); } } fprintf(stdout, "\n"); fflush(stdout); } g_running = false; if (do_reads) { for (uint32_t k = 0; k < g_scfg.read_req_threads; k++) { pthread_join(read_req_tids[k], NULL); } } if (do_commits) { for (uint32_t k = 0; k < g_scfg.write_req_threads; k++) { pthread_join(write_req_tids[k], NULL); } } for (uint32_t j = 0; j < n_trans_tids; j++) { pthread_join(trans_tids[j], NULL); } for (uint32_t i = 0; i < g_scfg.num_queues; i++) { queue_destroy(g_trans_qs[i]); } for (uint32_t d = 0; d < g_scfg.num_devices; d++) { device* dev = &g_devices[d]; if (g_scfg.tomb_raider) { pthread_join(dev->tomb_raider_thread, NULL); } if (g_scfg.write_reqs_per_sec != 0) { pthread_join(dev->large_block_read_thread, NULL); pthread_join(dev->large_block_write_thread, NULL); } fd_close_all(dev); queue_destroy(dev->fd_q); free(dev->raw_read_hist); free(dev->raw_write_hist); } free(g_large_block_read_hist); free(g_large_block_write_hist); free(g_raw_read_hist); free(g_read_hist); free(g_raw_write_hist); free(g_write_hist); 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. 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; }