int knet_handle_crypto(knet_handle_t knet_h, struct knet_handle_crypto_cfg *knet_handle_crypto_cfg)
{
int savederrno = 0;
int err;
if ((!knet_h) || (!knet_handle_crypto_cfg)) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->list_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
crypto_fini(knet_h);
if ((!strncmp("none", knet_handle_crypto_cfg->crypto_model, 4)) ||
((!strncmp("none", knet_handle_crypto_cfg->crypto_cipher_type, 4)) &&
(!strncmp("none", knet_handle_crypto_cfg->crypto_hash_type, 4)))) {
log_debug(knet_h, KNET_SUB_CRYPTO, "crypto is not enabled");
err = 0;
goto exit_unlock;
}
err = crypto_init(knet_h, knet_handle_crypto_cfg);
if (err) {
err = -2;
}
exit_unlock:
pthread_rwlock_unlock(&knet_h->list_rwlock);
return err;
}
int knet_handle_free(knet_handle_t knet_h)
{
int savederrno = 0;
savederrno = pthread_mutex_lock(&handle_config_mutex);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get handle mutex lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!knet_h) {
pthread_mutex_unlock(&handle_config_mutex);
errno = EINVAL;
return -1;
}
if (knet_h->fini_in_progress) {
pthread_mutex_unlock(&handle_config_mutex);
errno = EBUSY;
return -1;
}
/*
* we take a chance here to read a value that should be 0
* only if we could not init properly. Nothing else
* is started if lock_init_done is 0.
*/
if (!knet_h->lock_init_done) {
goto exit_nolock;
}
savederrno = pthread_rwlock_wrlock(&knet_h->list_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if ((knet_h->host_head != NULL) || (knet_h->listener_head != NULL)) {
savederrno = EBUSY;
log_err(knet_h, KNET_SUB_HANDLE,
"Unable to free handle: host(s) or listener(s) are still active: %s",
strerror(savederrno));
pthread_rwlock_unlock(&knet_h->list_rwlock);
errno = savederrno;
return -1;
}
knet_h->fini_in_progress = 1;
pthread_rwlock_unlock(&knet_h->list_rwlock);
_stop_threads(knet_h);
_close_epolls(knet_h);
_destroy_buffers(knet_h);
_close_socks(knet_h);
crypto_fini(knet_h);
_destroy_locks(knet_h);
exit_nolock:
free(knet_h);
knet_h = NULL;
pthread_mutex_unlock(&handle_config_mutex);
return 0;
}
int
main (int argc, char *argv[])
{
int fd = -1;
char *log_identity = argv[0];
int log_priority = LOG_INFO;
int log_options = LOG_OPT_PRIORITY;
#ifndef NDEBUG
log_priority = LOG_DEBUG;
log_options |= LOG_OPT_TIMESTAMP;
#endif /* NDEBUG */
log_open_file (stderr, log_identity, log_priority, log_options);
disable_core_dumps ();
conf = create_conf ();
parse_cmdline (conf, argc, argv);
auth_recv_init (conf->auth_server_dir, conf->auth_client_dir,
conf->got_force);
if (!conf->got_foreground) {
fd = daemonize_init (argv[0]);
if (conf->got_syslog) {
log_open_file (NULL, NULL, 0, 0);
log_open_syslog (log_identity, LOG_DAEMON);
}
else {
open_logfile (conf->logfile_name, log_priority, conf->got_force);
}
}
handle_signals ();
lookup_ip_addr (conf);
write_pidfile (conf->pidfile_name, conf->got_force);
if (conf->got_mlockall) {
lock_memory ();
}
crypto_init ();
if (random_init (conf->seed_name) < 0) {
if (conf->seed_name) {
free (conf->seed_name);
conf->seed_name = NULL;
}
}
create_subkeys (conf);
conf->gids = gids_create (conf->gids_update_secs, conf->got_group_stat);
replay_init ();
timer_init ();
sock_create (conf);
if (!conf->got_foreground) {
daemonize_fini (fd);
}
log_msg (LOG_NOTICE, "Starting %s daemon (pid %d)",
META_ALIAS, (int) getpid ());
job_accept (conf);
sock_destroy (conf);
timer_fini ();
replay_fini ();
gids_destroy (conf->gids);
random_fini (conf->seed_name);
crypto_fini ();
destroy_conf (conf);
log_msg (LOG_NOTICE, "Stopping %s daemon (pid %d)",
META_ALIAS, (int) getpid ());
exit (EMUNGE_SUCCESS);
}
