void zbar_processor_destroy (zbar_processor_t *proc)
{
proc_waiter_t *w, *next;
zbar_processor_init(proc, NULL, 0);
if(proc->scanner) {
zbar_image_scanner_destroy(proc->scanner);
proc->scanner = NULL;
}
_zbar_mutex_destroy(&proc->mutex);
_zbar_processor_cleanup(proc);
assert(!proc->wait_head);
assert(!proc->wait_tail);
assert(!proc->wait_next);
for(w = proc->free_waiter; w; w = next) {
next = w->next;
_zbar_event_destroy(&w->notify);
free(w);
}
err_cleanup(&proc->err);
free(proc);
}
void zbar_window_destroy (zbar_window_t *w)
{
/* detach */
zbar_window_attach(w, NULL, 0);
err_cleanup(&w->err);
_zbar_mutex_destroy(&w->imglock);
free(w);
}
void zebra_processor_destroy (zebra_processor_t *proc)
{
(void)proc_lock(proc);
proc_destroy_thread(proc->video_thread, &proc->video_started);
proc_destroy_thread(proc->input_thread, &proc->input_started);
if(proc->window) {
zebra_window_destroy(proc->window);
proc->window = NULL;
_zebra_window_close(proc);
}
if(proc->video) {
zebra_video_destroy(proc->video);
proc->video = NULL;
}
if(proc->scanner) {
zebra_image_scanner_destroy(proc->scanner);
proc->scanner = NULL;
}
proc_unlock(proc);
err_cleanup(&proc->err);
#ifdef HAVE_LIBPTHREAD
pthread_cond_destroy(&proc->event);
pthread_cond_destroy(&proc->cond);
pthread_mutex_destroy(&proc->mutex);
#endif
if(proc->polling.fds) {
free(proc->polling.fds);
proc->polling.fds = NULL;
}
if(proc->polling.handlers) {
free(proc->polling.handlers);
proc->polling.handlers = NULL;
}
if(proc->thr_polling.fds) {
free(proc->thr_polling.fds);
proc->thr_polling.fds = NULL;
}
if(proc->thr_polling.handlers) {
free(proc->thr_polling.handlers);
proc->thr_polling.handlers = NULL;
}
free(proc);
}
void zbar_video_destroy (zbar_video_t *vdo)
{
if(vdo->intf != VIDEO_INVALID)
zbar_video_open(vdo, NULL);
if(vdo->images) {
int i;
for(i = 0; i < ZBAR_VIDEO_IMAGES_MAX; i++)
if(vdo->images[i])
_zbar_image_free(vdo->images[i]);
free(vdo->images);
}
while(vdo->shadow_image) {
zbar_image_t *img = vdo->shadow_image;
vdo->shadow_image = img->next;
free((void*)img->data);
img->data = NULL;
free(img);
}
if(vdo->buf)
free(vdo->buf);
if(vdo->formats)
free(vdo->formats);
err_cleanup(&vdo->err);
_zbar_mutex_destroy(&vdo->qlock);
#ifdef HAVE_LIBJPEG
if(vdo->jpeg_img) {
zbar_image_destroy(vdo->jpeg_img);
vdo->jpeg_img = NULL;
}
if(vdo->jpeg) {
_zbar_jpeg_decomp_destroy(vdo->jpeg);
vdo->jpeg = NULL;
}
#endif
free(vdo);
}
int main(int argc, char *argv[])
{
opt_t opt;
int retval = 0;
const char *m;
/*
* Initialize.
*/
err_init(xbasename(argv[0])); /* init err package */
/*
* If running setuid, fork a child to handle
* all privileged operations and drop privs in this process.
*/
privsep_init();
/*
* Seed options with default values:
*/
opt_default(&opt, argv[0]);
/*
* Override defaults with environment
*/
opt_env(&opt);
/*
* Process any options that need to be handled early:
*/
opt_args_early(&opt, argc, argv);
/*
* Load static or dynamic pdsh modules
*/
mod_init();
/*
* Allow module directory to be overridden, but not when
* running as root or setuid. (This is mainly for testing...)
*/
if (!(m = getenv ("PDSH_MODULE_DIR")) ||
getuid() == 0 ||
getuid() != geteuid())
m = pdsh_module_dir;
if (mod_load_modules(m, &opt) < 0)
errx("%p: Couldn't load any pdsh modules\n");
/*
* Handle options.
*/
opt_args(&opt, argc, argv); /* override with command line */
if (opt_verify(&opt)) { /* verify options, print errors */
/*
* Do the work.
*/
if (opt.info_only) /* display info only */
opt_list(&opt);
else if (pdsh_personality() == PCP && opt.pcp_server)
retval = (_pcp_remote_server (&opt) < 0);
else if (pdsh_personality() == PCP && opt.pcp_client)
retval = (_pcp_remote_client (&opt) < 0);
else if (pdsh_personality() == PCP || opt.cmd != NULL)
retval = dsh(&opt); /* single dsh/pcp command */
else /* prompt loop */
_interactive_dsh(&opt);
} else {
retval = 1;
}
mod_exit();
/*
* Clean up.
*/
privsep_fini();
opt_free(&opt); /* free heap storage in opt struct */
err_cleanup();
return retval;
}
void OPENSSL_cleanup(void)
{
OPENSSL_INIT_STOP *currhandler, *lasthandler;
/* If we've not been inited then no need to deinit */
if (!base_inited)
return;
/* Might be explicitly called and also by atexit */
if (stopped)
return;
stopped = 1;
/*
* Thread stop may not get automatically called by the thread library for
* the very last thread in some situations, so call it directly.
*/
ossl_init_thread_stop(ossl_init_get_thread_local(0));
currhandler = stop_handlers;
while (currhandler != NULL) {
currhandler->handler();
lasthandler = currhandler;
currhandler = currhandler->next;
OPENSSL_free(lasthandler);
}
stop_handlers = NULL;
CRYPTO_THREAD_lock_free(init_lock);
/*
* We assume we are single-threaded for this function, i.e. no race
* conditions for the various "*_inited" vars below.
*/
#ifndef OPENSSL_NO_COMP
if (zlib_inited) {
#ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"comp_zlib_cleanup_int()\n");
#endif
comp_zlib_cleanup_int();
}
#endif
if (async_inited) {
# ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"async_deinit()\n");
# endif
async_deinit();
}
if (load_crypto_strings_inited) {
#ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"err_free_strings_int()\n");
#endif
err_free_strings_int();
}
CRYPTO_THREAD_cleanup_local(&threadstopkey);
#ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"rand_cleanup_int()\n");
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"conf_modules_free_int()\n");
#ifndef OPENSSL_NO_ENGINE
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"engine_cleanup_int()\n");
#endif
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"crypto_cleanup_all_ex_data_int()\n");
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"bio_sock_cleanup_int()\n");
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"bio_cleanup()\n");
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"evp_cleanup_int()\n");
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"obj_cleanup_int()\n");
fprintf(stderr, "OPENSSL_INIT: OPENSSL_cleanup: "
"err_cleanup()\n");
#endif
/*
* Note that cleanup order is important:
* - rand_cleanup_int could call an ENGINE's RAND cleanup function so
* must be called before engine_cleanup_int()
* - ENGINEs use CRYPTO_EX_DATA and therefore, must be cleaned up
* before the ex data handlers are wiped in CRYPTO_cleanup_all_ex_data().
* - conf_modules_free_int() can end up in ENGINE code so must be called
* before engine_cleanup_int()
* - ENGINEs and additional EVP algorithms might use added OIDs names so
* obj_cleanup_int() must be called last
*/
rand_cleanup_int();
conf_modules_free_int();
#ifndef OPENSSL_NO_ENGINE
engine_cleanup_int();
#endif
crypto_cleanup_all_ex_data_int();
bio_cleanup();
evp_cleanup_int();
obj_cleanup_int();
err_cleanup();
base_inited = 0;
}
