static void drcomd_daemon(struct drcom_handle *h)
{
int s;
int r;
s = init_daemon_socket();
if(s < 0)
exit(-1);
if(setup_sig_handlers()<0){
logerr("sig handlers not setup, exit.\n");
exit(1);
}
loginfo("drcomd %s started.\n", DRCOM_VERSION);
while (1) {
int maxfd;
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(s, &readfds);
FD_SET(sigusr1_pipe[READ_END], &readfds);
maxfd = s;
if(maxfd < sigusr1_pipe[READ_END])
maxfd = sigusr1_pipe[READ_END];
unblock_sigusr1();
r = select(maxfd+1, &readfds, NULL,NULL, NULL);
if(r<0){
if(errno != EINTR)
logerr("signal caught\n");
continue;
}
if(FD_ISSET(sigusr1_pipe[READ_END], &readfds)){
char buf[256];
int *sig = (int*)buf;
read(sigusr1_pipe[READ_END], &buf, sizeof(buf));
do_signals(h, *sig);
}
if(!FD_ISSET(s, &readfds))
continue;
block_sigusr1();
do_one_client(s, h);
}
/* FIXME:
* drcom_clean_up();
* drcom_destroy_handle();
* close_daemon_socket();
*/
}
int main(int argc, char *argv[])
{
static struct option long_options[] = {
{ "block-size", required_argument, 0, 'b' },
{ "hash-algo", required_argument, 0, 'h' },
{ "hash-algorithm", required_argument, 0, 'h' },
{ "max-iter", required_argument, 0, 'i' },
{ "freeze", required_argument, 0, 'f' },
{ "loop", no_argument, 0, 'l' },
{ 0, 0, 0, 0 },
};
int i;
int freeze_count = 0;
gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
if (!gcry_check_version(GCRYPT_VERSION)) {
fprintf(stderr, "libgcrypt version mismatch\n");
return 1;
}
while (1) {
int c;
c = getopt_long(argc, argv, "b:h:i:f:l", long_options, NULL);
if (c == -1)
break;
switch (c) {
case 'b':
if (sscanf(optarg, "%i", &block_size) != 1) {
fprintf(stderr, "cannot parse block size: "
"%s\n", optarg);
return 1;
}
if ((block_size & 7) != 0) {
fprintf(stderr, "error: block size must be "
"a multiple of 8\n");
return 1;
}
break;
case 'h':
hash_algo = gcry_md_map_name(optarg);
if (hash_algo == 0) {
fprintf(stderr, "unknown hash algorithm "
"name: %s\n", optarg);
return 1;
}
break;
case 'i':
if (sscanf(optarg, "%i", &max_iterations) != 1) {
fprintf(stderr, "cannot parse iteration "
"count: %s\n", optarg);
return 1;
}
break;
case 'f':
if (freeze_count == MAX_FREEZE) {
fprintf(stderr, "too many --freeze options\n");
return 1;
}
freeze_fs[freeze_count++] = optarg;
break;
case 'l':
loop = 1;
break;
case '?':
return 1;
default:
abort();
}
}
if (optind + 4 != argc) {
fprintf(stderr, "%s: [opts] <src> <srchashmap> <dst> "
"<dsthashmap>\n", argv[0]);
fprintf(stderr, " -b, --block-size=SIZE hash block size\n");
fprintf(stderr, " -f, --freeze=MOUNTPOINT freeze "
"filesystem\n");
fprintf(stderr, " -h, --hash-algo=ALGO hash algorithm\n");
fprintf(stderr, " -i, --max-iter=ITER maximum number of "
"iterations\n");
fprintf(stderr, " -l, --loop create consistent "
"image copy\n");
return 1;
}
hash_size = gcry_md_get_algo_dlen(hash_algo);
fd_src = open(argv[optind], O_RDONLY);
if (fd_src < 0) {
perror("opening src");
return 1;
}
sizeblocks = lseek(fd_src, 0, SEEK_END);
if (sizeblocks < 0) {
perror("lseek");
return 1;
}
sizeblocks = (sizeblocks + block_size - 1) / block_size;
if (strcmp(argv[optind + 1], "-")) {
int fd_srchashmap;
if (loop) {
fprintf(stderr, "consistent image copy requested, "
"but source hashmap specified\n");
return 1;
}
fd_srchashmap = open(argv[optind + 1], O_RDONLY);
if (fd_srchashmap < 0) {
perror("opening srchashmap");
return 1;
}
srchashmap = malloc(sizeblocks * hash_size);
if (srchashmap == NULL) {
fprintf(stderr, "out of memory allocating hash map\n");
return 1;
}
if (read(fd_srchashmap, srchashmap, sizeblocks * hash_size)
!= sizeblocks * hash_size) {
fprintf(stderr, "error reading hash map\n");
return 1;
}
close(fd_srchashmap);
} else {
srchashmap = NULL;
}
fd_dst = open(argv[optind + 2], O_CREAT | O_RDWR, 0666);
if (fd_dst < 0) {
perror("opening dst");
return 1;
}
fd_dsthashmap = open(argv[optind + 3], O_CREAT | O_RDWR, 0666);
if (fd_dsthashmap < 0) {
perror("opening dsthashmap");
return 1;
}
dsthashmap = malloc(sizeblocks * hash_size);
if (dsthashmap == NULL) {
fprintf(stderr, "out of memory allocating hash map\n");
return 1;
}
if (read(fd_dsthashmap, dsthashmap, sizeblocks * hash_size)
!= sizeblocks * hash_size) {
fprintf(stderr, "error reading hash map\n");
return 1;
}
setup_sig_handlers();
if (freeze_count) {
for (i = 0; i < MAX_FREEZE; i++)
freeze_fd[i] = -1;
atexit(thaw_fs);
fprintf(stderr, "freezing filesystems\n");
for (i = 0; i < freeze_count; i++) {
int fd;
fd = open(freeze_fs[i], O_RDONLY);
if (fd < 0) {
fprintf(stderr, "error opening freeze mount "
"point %s (%s)\n", freeze_fs[i],
strerror(errno));
return 1;
}
if (ioctl(fd, FIFREEZE, 0) < 0) {
fprintf(stderr, "error freezing fs %s (%s)\n",
freeze_fs[i], strerror(errno));
return 1;
}
freeze_fd[i] = fd;
}
}
if (loop) {
for (i = 0; i < max_iterations; i++) {
fd_off = 0;
again = 0;
fprintf(stderr, "scanning for differences... ");
run_threads(copy_thread_no_hashmap);
if (!signal_quit_flag) {
fprintf(stderr, "done "
" \n");
}
if (!again)
break;
if (i == max_iterations - 1) {
fprintf(stderr, "maximum iteration count "
"reached, bailing out\n");
} else {
fprintf(stderr, "repeating scanning due to "
"differences\n");
}
}
} else {
fd_off = 0;
if (srchashmap == NULL) {
fprintf(stderr, "scanning for differences... ");
run_threads(copy_thread_no_hashmap);
} else {
off_t off;
mismatch_idx = 0;
mismatch_cnt = 0;
for (off = 0; off < sizeblocks; off++) {
if (memcmp(srchashmap + off * hash_size,
dsthashmap + off * hash_size,
hash_size)) {
mismatch_cnt++;
}
}
fprintf(stderr, "copying differences... ");
run_threads(copy_thread_hashmap);
}
if (!signal_quit_flag) {
fprintf(stderr, "done "
" \n");
}
}
fprintf(stderr, "flushing buffers... ");
close(fd_src);
close(fd_dst);
close(fd_dsthashmap);
fprintf(stderr, "done\n");
return signal_quit_flag ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
catcierge_args_t *args = &grb.args;
fprintf(stderr, "\nCatcierge Grabber v" CATCIERGE_VERSION_STR " (" CATCIERGE_GIT_HASH_SHORT "");
// Was this built with changes in the git sources?
#ifdef CATCIERGE_GIT_TAINTED
fprintf(stderr, "-tainted");
#endif
fprintf(stderr, ")\n(C) Joakim Soderberg 2013-2016\n\n");
fprintf(stderr, "Library versions:\n");
fprintf(stderr, " OpenCV v%d.%d.%d\n", CV_MAJOR_VERSION, CV_MINOR_VERSION, CV_SUBMINOR_VERSION);
#ifdef WITH_ZMQ
fprintf(stderr, " CZMQ v%d.%d.%d\n", CZMQ_VERSION_MAJOR, CZMQ_VERSION_MINOR, CZMQ_VERSION_PATCH);
#endif
fprintf(stderr, "\n");
// TODO: Enable specifying pid path on command line.
#ifndef _WIN32
pid_fd = create_pid_file(argv[0], PID_PATH, FD_CLOEXEC);
#endif
if (catcierge_grabber_init(&grb))
{
fprintf(stderr, "Failed to init\n");
return -1;
}
if (catcierge_args_init(args, argv[0]))
{
fprintf(stderr, "Failed to init args\n");
return -1;
}
if (catcierge_args_parse(args, argc, argv))
{
return -1;
}
if (args->nocolor)
{
catcierge_nocolor = 1;
}
catcierge_print_settings(args);
setup_sig_handlers();
if (args->log_path)
{
if (!(grb.log_file = fopen(args->log_path, "a+")))
{
CATERR("Failed to open log file \"%s\"\n", args->log_path);
}
}
#ifdef RPI
if (catcierge_setup_gpio(&grb))
{
CATERR("Failed to setup GPIO pins\n");
return -1;
}
CATLOG("Initialized GPIO pins\n");
#endif // RPI
assert((args->matcher_type == MATCHER_TEMPLATE)
|| (args->matcher_type == MATCHER_HAAR));
if (catcierge_matcher_init(&grb.matcher, catcierge_get_matcher_args(args)))
{
CATERR("Failed to init %s matcher\n", grb.matcher->name);
return -1;
}
CATLOG("Initialized catcierge image recognition\n");
if (catcierge_output_init(&grb, &grb.output))
{
CATERR("Failed to init output template system\n");
return -1;
}
if (catcierge_output_load_templates(&grb.output,
args->inputs, args->input_count))
{
CATERR("Failed to load output templates\n");
return -1;
}
CATLOG("Initialized output templates\n");
#ifdef WITH_RFID
catcierge_init_rfid_readers(&grb);
#endif
catcierge_setup_camera(&grb);
#ifdef WITH_ZMQ
catcierge_zmq_init(&grb);
#endif
CATLOG("Starting detection!\n");
// TODO: Create a catcierge_grb_start(grb) function that does this instead.
catcierge_fsm_start(&grb);
// Run the program state machine.
do
{
if (!catcierge_timer_isactive(&grb.frame_timer))
{
catcierge_timer_start(&grb.frame_timer);
}
// Always feed the RFID readers.
#ifdef WITH_RFID
if ((args->rfid_inner_path || args->rfid_outer_path)
&& catcierge_rfid_ctx_service(&grb.rfid_ctx))
{
CATERRFPS("Failed to service RFID readers\n");
}
#endif // WITH_RFID
grb.img = catcierge_get_frame(&grb);
catcierge_run_state(&grb);
catcierge_print_spinner(&grb);
} while (
grb.running
#ifdef WITH_ZMQ
&& !zctx_interrupted
#endif
);
catcierge_matcher_destroy(&grb.matcher);
catcierge_output_destroy(&grb.output);
catcierge_destroy_camera(&grb);
#ifdef WITH_ZMQ
catcierge_zmq_destroy(&grb);
#endif
catcierge_grabber_destroy(&grb);
catcierge_args_destroy(&grb.args);
if (grb.log_file)
{
fclose(grb.log_file);
}
#ifndef _WIN32
if (pid_fd > 0)
{
close(pid_fd);
unlink(PID_PATH);
}
#endif
return 0;
}
