*/
#include <string.h>
-#include <pthread.h>
#include "peer_cfg.h"
+#include <utils/mutex.h>
#include <utils/linked_list.h>
#include <utils/identification.h>
/**
* mutex to lock access to list of child_cfgs
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* id to use to identify us
*/
static void add_child_cfg(private_peer_cfg_t *this, child_cfg_t *child_cfg)
{
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->child_cfgs->insert_last(this->child_cfgs, child_cfg);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
}
/**
*/
static void remove_child_cfg(private_peer_cfg_t *this, enumerator_t *enumerator)
{
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->child_cfgs->remove_at(this->child_cfgs, enumerator);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
}
/**
{
enumerator_t *enumerator;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
enumerator = this->child_cfgs->create_enumerator(this->child_cfgs);
return enumerator_create_cleaner(enumerator,
- (void*)pthread_mutex_unlock, &this->mutex);
+ (void*)this->mutex->unlock, this->mutex);
}
/**
DESTROY_IF(this->mediated_by);
DESTROY_IF(this->peer_id);
#endif /* ME */
+ this->mutex->destroy(this->mutex);
free(this->name);
free(this->pool);
free(this);
this->ike_version = ike_version;
this->ike_cfg = ike_cfg;
this->child_cfgs = linked_list_create();
- pthread_mutex_init(&this->mutex, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
this->my_id = my_id;
this->other_id = other_id;
this->cert_policy = cert_policy;
#include <daemon.h>
#include <network/socket.h>
#include <processing/jobs/callback_job.h>
+#include <utils/mutex.h>
typedef struct private_sender_t private_sender_t;
/**
* mutex to synchronize access to list
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* condvar to signal for packets added to list
*/
- pthread_cond_t gotone;
+ condvar_t *got;
/**
* condvar to signal for packets sent
*/
- pthread_cond_t sentone;
+ condvar_t *sent;
};
/**
dst = packet->get_destination(packet);
DBG1(DBG_NET, "sending packet: from %#H to %#H", src, dst);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->list->insert_last(this->list, packet);
- pthread_cond_signal(&this->gotone);
- pthread_mutex_unlock(&this->mutex);
+ this->got->signal(this->got);
+ this->mutex->unlock(this->mutex);
}
/**
packet_t *packet;
int oldstate;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
while (this->list->get_count(this->list) == 0)
{
/* add cleanup handler, wait for packet, remove cleanup handler */
- pthread_cleanup_push((void(*)(void*))pthread_mutex_unlock, (void*)&this->mutex);
+ pthread_cleanup_push((void(*)(void*))this->mutex->unlock, this->mutex);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
- pthread_cond_wait(&this->gotone, &this->mutex);
+ this->got->wait(this->got, this->mutex);
pthread_setcancelstate(oldstate, NULL);
pthread_cleanup_pop(0);
}
this->list->remove_first(this->list, (void**)&packet);
- pthread_cond_signal(&this->sentone);
- pthread_mutex_unlock(&this->mutex);
+ this->sent->signal(this->sent);
+ this->mutex->unlock(this->mutex);
charon->socket->send(charon->socket, packet);
packet->destroy(packet);
static void destroy(private_sender_t *this)
{
/* send all packets in the queue */
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
while (this->list->get_count(this->list))
{
- pthread_cond_wait(&this->sentone, &this->mutex);
+ this->sent->wait(this->sent, this->mutex);
}
- pthread_mutex_unlock(&this->mutex);
- pthread_mutex_destroy(&this->mutex);
+ this->mutex->unlock(this->mutex);
+ this->got->destroy(this->got);
+ this->sent->destroy(this->sent);
+ this->mutex->destroy(this->mutex);
this->job->cancel(this->job);
this->list->destroy(this->list);
free(this);
sender_t * sender_create()
{
private_sender_t *this = malloc_thing(private_sender_t);
-
+
this->public.send = (void(*)(sender_t*,packet_t*))send_;
this->public.destroy = (void(*)(sender_t*)) destroy;
-
+
this->list = linked_list_create();
- pthread_mutex_init(&this->mutex, NULL);
- pthread_cond_init(&this->gotone, NULL);
- pthread_cond_init(&this->sentone, NULL);
-
+ this->mutex = mutex_create(MUTEX_DEFAULT);
+ this->got = condvar_create(CONDVAR_DEFAULT);
+ this->sent = condvar_create(CONDVAR_DEFAULT);
+
this->job = callback_job_create((callback_job_cb_t)send_packets,
this, NULL, NULL);
charon->processor->queue_job(charon->processor, (job_t*)this->job);
-
+
return &this->public;
}
#include "kernel_netlink_shared.h"
#include <daemon.h>
+#include <utils/mutex.h>
#include <utils/linked_list.h>
#include <processing/jobs/callback_job.h>
#include <processing/jobs/acquire_job.h>
/**
* mutex to lock access to various lists
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* List of installed policies (policy_entry_t)
policy->direction = direction;
/* find the policy, which matches EXACTLY */
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
iterator = this->policies->create_iterator(this->policies, TRUE);
while (iterator->iterate(iterator, (void**)¤t))
{
policy_info->priority -= policy->sel.sport_mask ? 1 : 0;
policy_info->action = XFRM_POLICY_ALLOW;
policy_info->share = XFRM_SHARE_ANY;
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
/* policies don't expire */
policy_info->lft.soft_byte_limit = XFRM_INF;
policy.direction = direction;
/* find the policy */
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
enumerator = this->policies->create_enumerator(this->policies);
while (enumerator->enumerate(enumerator, ¤t))
{
{
/* is used by more SAs, keep in kernel */
DBG2(DBG_KNL, "policy still used by another CHILD_SA, not removed");
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
enumerator->destroy(enumerator);
return SUCCESS;
}
break;
}
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
enumerator->destroy(enumerator);
if (!to_delete)
{
close(this->socket_xfrm_events);
this->socket_xfrm->destroy(this->socket_xfrm);
this->policies->destroy(this->policies);
+ this->mutex->destroy(this->mutex);
free(this);
}
/* private members */
this->policies = linked_list_create();
- pthread_mutex_init(&this->mutex, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
this->install_routes = lib->settings->get_bool(lib->settings,
"charon.install_routes", TRUE);
#include "kernel_netlink_shared.h"
#include <daemon.h>
+#include <utils/mutex.h>
#include <utils/linked_list.h>
#include <processing/jobs/callback_job.h>
#include <processing/jobs/roam_job.h>
/**
* mutex to lock access to various lists
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* condition variable to signal virtual IP add/removal
*/
- pthread_cond_t cond;
+ condvar_t *condvar;
/**
* Cached list of interfaces and its addresses (iface_entry_t)
name = "(unknown)";
}
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
switch (hdr->nlmsg_type)
{
case RTM_NEWLINK:
break;
}
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
/* send an update to all IKE_SAs */
if (update && event)
return;
}
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
ifaces = this->ifaces->create_enumerator(this->ifaces);
while (ifaces->enumerate(ifaces, &iface))
{
}
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
host->destroy(host);
/* send an update to all IKE_SAs */
}
if (host)
{
+ this->mutex->lock(this->mutex);
if (!get_vip_refcount(this, host))
{ /* ignore routes added for virtual IPs */
fire_roam_job(this, FALSE);
}
+ this->mutex->unlock(this->mutex);
host->destroy(host);
}
}
case RTM_NEWADDR:
case RTM_DELADDR:
process_addr(this, hdr, TRUE);
- pthread_cond_broadcast(&this->cond);
+ this->condvar->broadcast(this->condvar);
break;
case RTM_NEWLINK:
case RTM_DELLINK:
process_link(this, hdr, TRUE);
- pthread_cond_broadcast(&this->cond);
+ this->condvar->broadcast(this->condvar);
break;
case RTM_NEWROUTE:
case RTM_DELROUTE:
*/
static void address_enumerator_destroy(address_enumerator_t *data)
{
- pthread_mutex_unlock(&data->this->mutex);
+ data->this->mutex->unlock(data->this->mutex);
free(data);
}
data->include_down_ifaces = include_down_ifaces;
data->include_virtual_ips = include_virtual_ips;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
return enumerator_create_nested(
enumerator_create_filter(this->ifaces->create_enumerator(this->ifaces),
(void*)filter_interfaces, data, NULL),
DBG2(DBG_KNL, "getting interface name for %H", ip);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
ifaces = this->ifaces->create_enumerator(this->ifaces);
while (ifaces->enumerate(ifaces, &iface))
{
}
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
if (name)
{
DBG2(DBG_KNL, "getting iface index for %s", name);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
ifaces = this->ifaces->create_enumerator(this->ifaces);
while (ifaces->enumerate(ifaces, &iface))
{
}
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
if (ifindex == 0)
{
DBG1(DBG_KNL, "getting address to %H failed", dest);
return NULL;
}
+ this->mutex->lock(this->mutex);
current = out;
while (NLMSG_OK(current, len))
{
else
{
/* no source addr, get one from the interfaces */
- pthread_mutex_lock(&this->mutex);
ifaces = this->ifaces->create_enumerator(this->ifaces);
while (ifaces->enumerate(ifaces, &iface))
{
}
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
}
}
/* FALL through */
break;
}
free(out);
+ this->mutex->unlock(this->mutex);
if (nexthop)
{
DBG2(DBG_KNL, "adding virtual IP %H", virtual_ip);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
ifaces = this->ifaces->create_enumerator(this->ifaces);
while (ifaces->enumerate(ifaces, &iface))
{
virtual_ip, iface->ifname);
addrs->destroy(addrs);
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
}
{
while (get_vip_refcount(this, virtual_ip) == 0)
{ /* wait until address appears */
- pthread_cond_wait(&this->cond, &this->mutex);
+ this->condvar->wait(this->condvar, this->mutex);
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
DBG1(DBG_KNL, "adding virtual IP %H failed", virtual_ip);
return FAILED;
}
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
DBG1(DBG_KNL, "interface address %H not found, unable to install"
"virtual IP %H", iface_ip, virtual_ip);
DBG2(DBG_KNL, "deleting virtual IP %H", virtual_ip);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
ifaces = this->ifaces->create_enumerator(this->ifaces);
while (ifaces->enumerate(ifaces, &iface))
{
{ /* wait until the address is really gone */
while (get_vip_refcount(this, virtual_ip) > 0)
{
- pthread_cond_wait(&this->cond, &this->mutex);
+ this->condvar->wait(this->condvar, this->mutex);
}
}
addrs->destroy(addrs);
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return status;
}
else
virtual_ip);
addrs->destroy(addrs);
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
}
addrs->destroy(addrs);
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
DBG2(DBG_KNL, "virtual IP %H not cached, unable to delete", virtual_ip);
return FAILED;
}
free(out);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
ifaces = this->ifaces->create_enumerator(this->ifaces);
while (ifaces->enumerate(ifaces, &iface))
{
}
}
ifaces->destroy(ifaces);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
close(this->socket_events);
this->socket->destroy(this->socket);
this->ifaces->destroy_function(this->ifaces, (void*)iface_entry_destroy);
+ this->condvar->destroy(this->condvar);
+ this->mutex->destroy(this->mutex);
free(this);
}
/* private members */
this->ifaces = linked_list_create();
- pthread_mutex_init(&this->mutex, NULL);
- pthread_cond_init(&this->cond, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
+ this->condvar = condvar_create(CONDVAR_DEFAULT);
timerclear(&this->last_roam);
this->routing_table = lib->settings->get_int(lib->settings,
"charon.routing_table", IPSEC_ROUTING_TABLE);
#include <linux/rtnetlink.h>
#include <errno.h>
#include <unistd.h>
-#include <pthread.h>
#include "kernel_netlink_shared.h"
#include <daemon.h>
+#include <utils/mutex.h>
typedef struct private_netlink_socket_t private_netlink_socket_t;
/**
* mutex to lock access to netlink socket
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* current sequence number for netlink request
chunk_t result = chunk_empty, tmp;
struct nlmsghdr *msg, peek;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
in->nlmsg_seq = ++this->seq;
in->nlmsg_pid = getpid();
/* interrupted, try again */
continue;
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
DBG1(DBG_KNL, "error sending to netlink socket: %s", strerror(errno));
return FAILED;
}
continue;
}
DBG1(DBG_KNL, "error reading from netlink socket: %s", strerror(errno));
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
free(result.ptr);
return FAILED;
}
if (!NLMSG_OK(msg, len))
{
DBG1(DBG_KNL, "received corrupted netlink message");
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
free(result.ptr);
return FAILED;
}
{
continue;
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
free(result.ptr);
return FAILED;
}
*out_len = result.len;
*out = (struct nlmsghdr*)result.ptr;
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
static void destroy(private_netlink_socket_t *this)
{
close(this->socket);
+ this->mutex->destroy(this->mutex);
free(this);
}
/* private members */
this->seq = 200;
- pthread_mutex_init(&this->mutex, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
#include <daemon.h>
#include <utils/host.h>
+#include <utils/mutex.h>
#include <processing/jobs/callback_job.h>
#include <processing/jobs/acquire_job.h>
#include <processing/jobs/migrate_job.h>
/**
* mutex to lock access to various lists
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* List of installed policies (policy_entry_t)
/**
* mutex to lock access to the PF_KEY socket
*/
- pthread_mutex_t mutex_pfkey;
-
+ mutex_t *mutex_pfkey;
/**
* PF_KEY socket to communicate with the kernel
*/
int socket;
-
/**
* PF_KEY socket to receive acquire and expire events
*/
int socket_events;
-
/**
* sequence number for messages sent to the kernel
*/
struct sadb_msg *msg;
int in_len, len;
- pthread_mutex_lock(&this->mutex_pfkey);
+ this->mutex_pfkey->lock(this->mutex_pfkey);
in->sadb_msg_seq = ++this->seq;
in->sadb_msg_pid = getpid();
/* interrupted, try again */
continue;
}
- pthread_mutex_unlock(&this->mutex_pfkey);
+ this->mutex_pfkey->unlock(this->mutex_pfkey);
DBG1(DBG_KNL, "error sending to PF_KEY socket: %s", strerror(errno));
return FAILED;
}
continue;
}
DBG1(DBG_KNL, "error reading from PF_KEY socket: %s", strerror(errno));
- pthread_mutex_unlock(&this->mutex_pfkey);
+ this->mutex_pfkey->unlock(this->mutex_pfkey);
return FAILED;
}
if (len < sizeof(struct sadb_msg) ||
msg->sadb_msg_len < PFKEY_LEN(sizeof(struct sadb_msg)))
{
DBG1(DBG_KNL, "received corrupted PF_KEY message");
- pthread_mutex_unlock(&this->mutex_pfkey);
+ this->mutex_pfkey->unlock(this->mutex_pfkey);
return FAILED;
}
if (msg->sadb_msg_len > len / PFKEY_ALIGNMENT)
{
DBG1(DBG_KNL, "buffer was too small to receive the complete PF_KEY message");
- pthread_mutex_unlock(&this->mutex_pfkey);
+ this->mutex_pfkey->unlock(this->mutex_pfkey);
return FAILED;
}
if (msg->sadb_msg_pid != in->sadb_msg_pid)
{
continue;
}
- pthread_mutex_unlock(&this->mutex_pfkey);
+ this->mutex_pfkey->unlock(this->mutex_pfkey);
return FAILED;
}
if (msg->sadb_msg_type != in->sadb_msg_type)
*out = (struct sadb_msg*)malloc(len);
memcpy(*out, buf, len);
- pthread_mutex_unlock(&this->mutex_pfkey);
+ this->mutex_pfkey->unlock(this->mutex_pfkey);
return SUCCESS;
}
}
index = response.x_policy->sadb_x_policy_id;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
if (this->policies->find_first(this->policies,
(linked_list_match_t)policy_entry_match_byindex, (void**)&policy, &index) == SUCCESS)
{
}
src_ts = sadb_address2ts(response.src);
dst_ts = sadb_address2ts(response.dst);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
DBG1(DBG_KNL, "creating acquire job for policy %R === %R with reqid {%u}",
src_ts, dst_ts, reqid);
policy = create_policy_entry(src_ts, dst_ts, direction, reqid);
/* find a matching policy */
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
if (this->policies->find_first(this->policies,
(linked_list_match_t)policy_entry_equals, (void**)&found, policy) == SUCCESS)
{
host2ext(policy->dst.net, addr);
PFKEY_EXT_ADD(msg, addr);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
if (pfkey_send(this, msg, &out, &len) != SUCCESS)
{
return FAILED;
}
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
/* we try to find the policy again and update the kernel index */
if (this->policies->find_last(this->policies, NULL, (void**)&policy) != SUCCESS)
{
DBG2(DBG_KNL, "unable to update index, the policy %R === %R %N is "
"already gone, ignoring", src_ts, dst_ts, policy_dir_names, direction);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
free(out);
return SUCCESS;
}
}
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
policy = create_policy_entry(src_ts, dst_ts, direction, 0);
/* find a matching policy */
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
if (this->policies->find_first(this->policies,
(linked_list_match_t)policy_entry_equals, (void**)&found, policy) != SUCCESS)
{
DBG1(DBG_KNL, "querying policy %R === %R %N failed, not found", src_ts,
dst_ts, policy_dir_names, direction);
policy_entry_destroy(policy);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return NOT_FOUND;
}
policy_entry_destroy(policy);
host2ext(policy->dst.net, addr);
PFKEY_EXT_ADD(msg, addr);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
if (pfkey_send(this, msg, &out, &len) != SUCCESS)
{
policy = create_policy_entry(src_ts, dst_ts, direction, 0);
/* find a matching policy */
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
if (this->policies->find_first(this->policies,
(linked_list_match_t)policy_entry_equals, (void**)&found, policy) == SUCCESS)
{
/* is used by more SAs, keep in kernel */
DBG2(DBG_KNL, "policy still used by another CHILD_SA, not removed");
policy_entry_destroy(policy);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
/* remove if last reference */
DBG1(DBG_KNL, "deleting policy %R === %R %N failed, not found", src_ts,
dst_ts, policy_dir_names, direction);
policy_entry_destroy(policy);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return NOT_FOUND;
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
memset(&request, 0, sizeof(request));
close(this->socket);
close(this->socket_events);
this->policies->destroy_function(this->policies, (void*)policy_entry_destroy);
+ this->mutex->destroy(this->mutex);
+ this->mutex_pfkey->destroy(this->mutex_pfkey);
free(this);
}
/* private members */
this->policies = linked_list_create();
- pthread_mutex_init(&this->mutex, NULL);
- this->install_routes = lib->settings->get_bool(lib->settings, "charon.install_routes", TRUE);
- pthread_mutex_init(&this->mutex_pfkey, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
+ this->mutex_pfkey = mutex_create(MUTEX_DEFAULT);
+ this->install_routes = lib->settings->get_bool(lib->settings,
+ "charon.install_routes", TRUE);
this->seq = 0;
/* create a PF_KEY socket to communicate with the kernel */
#include <pthread.h>
#include <daemon.h>
+#include <utils/mutex.h>
typedef struct private_callback_job_t private_callback_job_t;
* thread ID of the job, if running
*/
pthread_t thread;
-
+
/**
* mutex to access jobs interna
*/
- pthread_mutex_t mutex;
-
+ mutex_t *mutex;
+
/**
* list of asociated child jobs
*/
this->cleanup(this->data);
}
this->children->destroy(this->children);
+ this->mutex->destroy(this->mutex);
free(this);
}
iterator_t *iterator;
private_callback_job_t *child;
- pthread_mutex_lock(&this->parent->mutex);
+ this->parent->mutex->lock(this->parent->mutex);
iterator = this->parent->children->create_iterator(this->parent->children, TRUE);
while (iterator->iterate(iterator, (void**)&child))
{
}
}
iterator->destroy(iterator);
- pthread_mutex_unlock(&this->parent->mutex);
+ this->parent->mutex->unlock(this->parent->mutex);
}
}
{
pthread_t thread;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
thread = this->thread;
/* terminate its children */
this->children->invoke_offset(this->children, offsetof(callback_job_t, cancel));
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
/* terminate thread */
if (thread)
{
bool cleanup = FALSE;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->thread = pthread_self();
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
pthread_cleanup_push((void*)destroy, this);
while (TRUE)
this->public.cancel = (void(*)(callback_job_t*))cancel;
/* private variables */
- pthread_mutex_init(&this->mutex, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
this->callback = cb;
this->data = data;
this->cleanup = cleanup;
/* register us at parent */
if (parent)
{
- pthread_mutex_lock(&this->parent->mutex);
+ this->parent->mutex->lock(this->parent->mutex);
this->parent->children->insert_last(this->parent->children, this);
- pthread_mutex_unlock(&this->parent->mutex);
+ this->parent->mutex->unlock(this->parent->mutex);
}
return &this->public;
#include "processor.h"
#include <daemon.h>
+#include <utils/mutex.h>
#include <utils/linked_list.h>
/**
* access to linked_list is locked through this mutex
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* Condvar to wait for new jobs
*/
- pthread_cond_t jobadded;
+ condvar_t *job_added;
/**
* Condvar to wait for terminated threads
*/
- pthread_cond_t threadterminated;
+ condvar_t *thread_terminated;
};
static void process_jobs(private_processor_t *this);
if (pthread_create(&thread, NULL, (void*)process_jobs, this) != 0)
{
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->total_threads--;
- pthread_cond_broadcast(&this->threadterminated);
- pthread_mutex_unlock(&this->mutex);
+ this->thread_terminated->broadcast(this->thread_terminated);
+ this->mutex->unlock(this->mutex);
}
}
DBG2(DBG_JOB, "started worker thread, thread_ID: %06u", (int)pthread_self());
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
while (this->desired_threads >= this->total_threads)
{
job_t *job;
if (this->list->get_count(this->list) == 0)
{
this->idle_threads++;
- pthread_cond_wait(&this->jobadded, &this->mutex);
+ this->job_added->wait(this->job_added, this->mutex);
this->idle_threads--;
continue;
}
this->list->remove_first(this->list, (void**)&job);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
/* terminated threads are restarted, so we have a constant pool */
pthread_cleanup_push((void*)restart, this);
job->execute(job);
pthread_cleanup_pop(0);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
}
this->total_threads--;
- pthread_cond_signal(&this->threadterminated);
- pthread_mutex_unlock(&this->mutex);
+ this->thread_terminated->signal(this->thread_terminated);
+ this->mutex->unlock(this->mutex);
}
/**
static u_int get_total_threads(private_processor_t *this)
{
u_int count;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
count = this->total_threads;
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return count;
}
static u_int get_idle_threads(private_processor_t *this)
{
u_int count;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
count = this->idle_threads;
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return count;
}
static u_int get_job_load(private_processor_t *this)
{
u_int load;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
load = this->list->get_count(this->list);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return load;
}
*/
static void queue_job(private_processor_t *this, job_t *job)
{
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->list->insert_last(this->list, job);
- pthread_cond_signal(&this->jobadded);
- pthread_mutex_unlock(&this->mutex);
+ this->job_added->signal(this->job_added);
+ this->mutex->unlock(this->mutex);
}
/**
*/
static void set_threads(private_processor_t *this, u_int count)
{
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
if (count > this->total_threads)
{ /* increase thread count */
int i;
{ /* decrease thread count */
this->desired_threads = count;
}
- pthread_cond_broadcast(&this->jobadded);
- pthread_mutex_unlock(&this->mutex);
+ this->job_added->broadcast(this->job_added);
+ this->mutex->unlock(this->mutex);
}
/**
static void destroy(private_processor_t *this)
{
set_threads(this, 0);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
while (this->total_threads > 0)
{
- pthread_cond_broadcast(&this->jobadded);
- pthread_cond_wait(&this->threadterminated, &this->mutex);
+ this->job_added->broadcast(this->job_added);
+ this->thread_terminated->wait(this->thread_terminated, this->mutex);
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
+ this->thread_terminated->destroy(this->thread_terminated);
+ this->job_added->destroy(this->job_added);
+ this->mutex->destroy(this->mutex);
this->list->destroy_offset(this->list, offsetof(job_t, destroy));
free(this);
}
this->public.destroy = (void(*)(processor_t*))destroy;
this->list = linked_list_create();
- pthread_mutex_init(&this->mutex, NULL);
- pthread_cond_init(&this->jobadded, NULL);
- pthread_cond_init(&this->threadterminated, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
+ this->job_added = condvar_create(CONDVAR_DEFAULT);
+ this->thread_terminated = condvar_create(CONDVAR_DEFAULT);
this->total_threads = 0;
this->desired_threads = 0;
this->idle_threads = 0;
#include "eap_manager.h"
-#include <pthread.h>
-
#include <utils/linked_list.h>
+#include <utils/mutex.h>
typedef struct private_eap_manager_t private_eap_manager_t;
typedef struct eap_entry_t eap_entry_t;
/**
* mutex to lock methods
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
};
/**
entry->role = role;
entry->constructor = constructor;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->methods->insert_last(this->methods, entry);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
}
/**
enumerator_t *enumerator;
eap_entry_t *entry;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
enumerator = this->methods->create_enumerator(this->methods);
while (enumerator->enumerate(enumerator, &entry))
{
}
}
enumerator->destroy(enumerator);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
}
/**
eap_entry_t *entry;
eap_method_t *method = NULL;
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
enumerator = this->methods->create_enumerator(this->methods);
while (enumerator->enumerate(enumerator, &entry))
{
}
}
enumerator->destroy(enumerator);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return method;
}
static void destroy(private_eap_manager_t *this)
{
this->methods->destroy_function(this->methods, free);
+ this->mutex->destroy(this->mutex);
free(this);
}
this->public.destroy = (void(*)(eap_manager_t*))destroy;
this->methods = linked_list_create();
- pthread_mutex_init(&this->mutex, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
return &this->public;
}
#include "connect_manager.h"
-#include <pthread.h>
#include <math.h>
#include <daemon.h>
+#include <utils/mutex.h>
#include <utils/linked_list.h>
#include <crypto/hashers/hasher.h>
/**
* Lock for exclusivly accessing the manager.
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* Hasher to generate signatures
{
private_connect_manager_t *this = data->connect_manager;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
check_list_t *checklist;
if (get_checklist_by_id(this, data->connect_id, &checklist) != SUCCESS)
{
DBG1(DBG_IKE, "checklist with id '%#B' not found, can't finish connectivity checks",
&data->connect_id);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return JOB_REQUEUE_NONE;
}
finish_checks(this, checklist);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return JOB_REQUEUE_NONE;
}
{
private_connect_manager_t *this = data->connect_manager;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
check_list_t *checklist;
if (get_checklist_by_id(this, data->connect_id, &checklist) != SUCCESS)
{
DBG1(DBG_IKE, "checklist with id '%#B' not found, can't retransmit connectivity check",
&data->connect_id);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return JOB_REQUEUE_NONE;
}
break;
}
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
/* we reschedule it manually */
return JOB_REQUEUE_NONE;
{
private_connect_manager_t *this = data->connect_manager;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
check_list_t *checklist;
if (get_checklist_by_id(this, data->connect_id, &checklist) != SUCCESS)
{
DBG1(DBG_IKE, "checklist with id '%#B' not found, can't send connectivity check",
&data->connect_id);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return JOB_REQUEUE_NONE;
}
if (checklist->pairs->find_first(checklist->pairs,
(linked_list_match_t)match_waiting_pair, (void**)&pair) != SUCCESS)
{
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
DBG1(DBG_IKE, "no pairs in waiting state, aborting");
return JOB_REQUEUE_NONE;
}
/* schedule this job again */
schedule_checks(this, checklist, ME_INTERVAL);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
/* we reschedule it manually */
return JOB_REQUEUE_NONE;
return;
}
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
check_list_t *checklist;
if (get_checklist_by_id(this, check->connect_id, &checklist) != SUCCESS)
DBG1(DBG_IKE, "checklist with id '%#B' not found",
&check->connect_id);
check_destroy(check);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return;
}
DBG1(DBG_IKE, "connectivity check verification failed");
check_destroy(check);
chunk_free(&sig);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return;
}
chunk_free(&sig);
process_response(this, check, checklist);
}
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
check_destroy(check);
}
initiated_t *initiated;
bool already_there = TRUE;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_initiated_by_ids(this, id, peer_id, &initiated) != SUCCESS)
{
initiated->mediated->insert_last(initiated->mediated, mediated_sa->clone(mediated_sa));
}
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return already_there;
}
{
initiated_t *initiated;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_initiated_by_ids(this, id, peer_id, &initiated) != SUCCESS)
{
DBG2(DBG_IKE, "no waiting mediated connections with '%D'", peer_id);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return;
}
}
iterator->destroy(iterator);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
}
/**
{
check_list_t *checklist;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_checklist_by_id(this, connect_id, NULL) == SUCCESS)
{
DBG1(DBG_IKE, "checklist with id '%#B' already exists, aborting",
&connect_id);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return FAILED;
}
checklist = check_list_create(initiator, responder, connect_id, key, endpoints, is_initiator);
this->checklists->insert_last(this->checklists, checklist);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
{
check_list_t *checklist;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_checklist_by_id(this, connect_id, &checklist) != SUCCESS)
{
DBG1(DBG_IKE, "checklist with id '%#B' not found",
&connect_id);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return NOT_FOUND;
}
/* send the first check immediately */
schedule_checks(this, checklist, 0);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
{
check_list_t *checklist;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_checklist_by_id(this, connect_id, &checklist) != SUCCESS)
{
DBG1(DBG_IKE, "checklist with id '%#B' not found",
&connect_id);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return NOT_FOUND;
}
remove_checklist(this, checklist);
check_list_destroy(checklist);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return SUCCESS;
}
*/
static void destroy(private_connect_manager_t *this)
{
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
this->hasher->destroy(this->hasher);
this->checklists->destroy_function(this->checklists, (void*)check_list_destroy);
this->initiated->destroy_function(this->initiated, (void*)initiated_destroy);
- pthread_mutex_unlock(&(this->mutex));
- pthread_mutex_destroy(&(this->mutex));
+ this->mutex->unlock(this->mutex);
+ this->mutex->destroy(this->mutex);
free(this);
}
this->checklists = linked_list_create();
this->initiated = linked_list_create();
- pthread_mutex_init(&(this->mutex), NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
return (connect_manager_t*)this;
}
* $Id$
*/
-#include <pthread.h>
#include <string.h>
#include "ike_sa_manager.h"
#include <daemon.h>
#include <sa/ike_sa_id.h>
#include <bus/bus.h>
+#include <utils/mutex.h>
#include <utils/linked_list.h>
#include <crypto/hashers/hasher.h>
/**
* Condvar where threads can wait until ike_sa_t object is free for use again.
*/
- pthread_cond_t condvar;
+ condvar_t *condvar;
/**
* Is this ike_sa currently checked out?
DESTROY_IF(this->other);
DESTROY_IF(this->my_id);
DESTROY_IF(this->other_id);
+ this->condvar->destroy(this->condvar);
free(this);
return SUCCESS;
}
entry_t *this = malloc_thing(entry_t);
this->waiting_threads = 0;
- pthread_cond_init(&this->condvar, NULL);
+ this->condvar = condvar_create(CONDVAR_DEFAULT);
/* we set checkout flag when we really give it out */
this->checked_out = FALSE;
/**
* Lock for exclusivly accessing the manager.
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* Linked list with entries for the ike_sa_t objects.
while (entry->waiting_threads)
{
/* wake up all */
- pthread_cond_broadcast(&(entry->condvar));
+ entry->condvar->broadcast(entry->condvar);
/* they will wake us again when their work is done */
- pthread_cond_wait(&(entry->condvar), &(this->mutex));
+ entry->condvar->wait(entry->condvar, this->mutex);
}
DBG2(DBG_MGR, "found entry by pointer, deleting it");
/* so wait until we can get it for us.
* we register us as waiting. */
entry->waiting_threads++;
- pthread_cond_wait(&(entry->condvar), &(this->mutex));
+ entry->condvar->wait(entry->condvar, this->mutex);
entry->waiting_threads--;
}
/* hm, a deletion request forbids us to get this SA, get next one */
if (entry->driveout_waiting_threads)
{
/* we must signal here, others may be waiting on it, too */
- pthread_cond_signal(&(entry->condvar));
+ entry->condvar->signal(entry->condvar);
return FALSE;
}
return TRUE;
DBG2(DBG_MGR, "checkout IKE_SA, %d IKE_SAs in manager",
this->ike_sa_list->get_count(this->ike_sa_list));
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_entry_by_id(this, ike_sa_id, &entry) == SUCCESS)
{
if (wait_for_entry(this, entry))
ike_sa = entry->ike_sa;
}
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
charon->bus->set_sa(charon->bus, ike_sa);
return ike_sa;
}
}
entry = entry_create(id);
id->destroy(id);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->ike_sa_list->insert_last(this->ike_sa_list, entry);
entry->checked_out = TRUE;
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
DBG2(DBG_MGR, "created IKE_SA, %d IKE_SAs in manager",
this->ike_sa_list->get_count(this->ike_sa_list));
return entry->ike_sa;
this->hasher->allocate_hash(this->hasher, data, &hash);
chunk_free(&data);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
enumerator = this->ike_sa_list->create_enumerator(this->ike_sa_list);
while (enumerator->enumerate(enumerator, &entry))
{
if (entry->message_id == 0)
{
enumerator->destroy(enumerator);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
chunk_free(&hash);
id->destroy(id);
DBG1(DBG_MGR, "ignoring IKE_SA_INIT, already processing");
}
}
enumerator->destroy(enumerator);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
if (ike_sa == NULL)
{
id->set_responder_spi(id, get_next_spi(this));
entry = entry_create(id);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
this->ike_sa_list->insert_last(this->ike_sa_list, entry);
entry->checked_out = TRUE;
entry->message_id = message->get_message_id(message);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
entry->init_hash = hash;
ike_sa = entry->ike_sa;
}
return ike_sa;
}
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_entry_by_id(this, id, &entry) == SUCCESS)
{
/* only check out if we are not processing this request */
ike_sa = entry->ike_sa;
}
}
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
id->destroy(id);
charon->bus->set_sa(charon->bus, ike_sa);
return ike_sa;
my_host = host_create_from_dns(ike_cfg->get_my_addr(ike_cfg), 0, 0);
other_host = host_create_from_dns(ike_cfg->get_other_addr(ike_cfg), 0, 0);
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (my_host && other_host && this->reuse_ikesa)
{
new_entry->checked_out = TRUE;
ike_sa = new_entry->ike_sa;
}
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
charon->bus->set_sa(charon->bus, ike_sa);
return ike_sa;
}
ike_sa_t *ike_sa = NULL;
child_sa_t *child_sa;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
enumerator = this->ike_sa_list->create_enumerator(this->ike_sa_list);
while (enumerator->enumerate(enumerator, &entry))
}
}
enumerator->destroy(enumerator);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
charon->bus->set_sa(charon->bus, ike_sa);
return ike_sa;
ike_sa_t *ike_sa = NULL;
child_sa_t *child_sa;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
enumerator = this->ike_sa_list->create_enumerator(this->ike_sa_list);
while (enumerator->enumerate(enumerator, &entry))
}
}
enumerator->destroy(enumerator);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
charon->bus->set_sa(charon->bus, ike_sa);
return ike_sa;
me = ike_sa->get_my_id(ike_sa);
other = ike_sa->get_other_id(ike_sa);
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
enumerator = this->ike_sa_list->create_enumerator(this->ike_sa_list);
while (enumerator->enumerate(enumerator, &entry))
{
}
}
enumerator->destroy(enumerator);
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
return duplicate;
}
*/
static void enumerator_unlock(private_ike_sa_manager_t *this)
{
- pthread_mutex_unlock(&this->mutex);
+ this->mutex->unlock(this->mutex);
}
/**
*/
static enumerator_t *create_enumerator(private_ike_sa_manager_t* this)
{
- pthread_mutex_lock(&this->mutex);
+ this->mutex->lock(this->mutex);
return enumerator_create_filter(
this->ike_sa_list->create_enumerator(this->ike_sa_list),
(void*)enumerator_filter, this, (void*)enumerator_unlock);
DBG2(DBG_MGR, "checkin IKE_SA");
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
/* look for the entry */
if (get_entry_by_sa(this, ike_sa, &entry) == SUCCESS)
entry->other_id = other_id->clone(other_id);
}
DBG2(DBG_MGR, "check-in of IKE_SA successful.");
- pthread_cond_signal(&(entry->condvar));
+ entry->condvar->signal(entry->condvar);
retval = SUCCESS;
}
else
DBG2(DBG_MGR, "%d IKE_SAs in manager now",
this->ike_sa_list->get_count(this->ike_sa_list));
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
charon->bus->set_sa(charon->bus, NULL);
return retval;
ike_sa_id = ike_sa->get_id(ike_sa);
DBG2(DBG_MGR, "checkin and destroy IKE_SA");
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_entry_by_sa(this, ike_sa, &entry) == SUCCESS)
{
}
charon->bus->set_sa(charon->bus, NULL);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return retval;
}
entry_t *entry;
int count = 0;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
enumerator = this->ike_sa_list->create_enumerator(this->ike_sa_list);
while (enumerator->enumerate(enumerator, &entry))
{
}
enumerator->destroy(enumerator);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return count;
}
enumerator_t *enumerator;
entry_t *entry;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
DBG2(DBG_MGR, "going to destroy IKE_SA manager and all managed IKE_SA's");
/* Step 1: drive out all waiting threads */
DBG2(DBG_MGR, "set driveout flags for all stored IKE_SA's");
while (entry->waiting_threads)
{
/* wake up all */
- pthread_cond_broadcast(&(entry->condvar));
+ entry->condvar->broadcast(entry->condvar);
/* go sleeping until they are gone */
- pthread_cond_wait(&(entry->condvar), &(this->mutex));
+ entry->condvar->wait(entry->condvar, this->mutex);
}
}
enumerator->destroy(enumerator);
entry_destroy(entry);
}
charon->bus->set_sa(charon->bus, NULL);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
}
/**
this->ike_sa_list->destroy(this->ike_sa_list);
this->rng->destroy(this->rng);
this->hasher->destroy(this->hasher);
-
+ this->mutex->destroy(this->mutex);
free(this);
}
return NULL;
}
this->ike_sa_list = linked_list_create();
- pthread_mutex_init(&this->mutex, NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
this->reuse_ikesa = lib->settings->get_bool(lib->settings,
"charon.reuse_ikesa", TRUE);
return &this->public;
#include "mediation_manager.h"
-#include <pthread.h>
#include <daemon.h>
+#include <utils/mutex.h>
#include <utils/linked_list.h>
#include <processing/jobs/mediation_job.h>
/**
* Lock for exclusivly accessing the manager.
*/
- pthread_mutex_t mutex;
+ mutex_t *mutex;
/**
* Linked list with state entries.
iterator_t *iterator;
peer_t *peer;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
iterator = this->peers->create_iterator(this->peers, TRUE);
while (iterator->iterate(iterator, (void**)&peer))
}
iterator->destroy(iterator);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
}
/**
peer_t *peer;
bool found = FALSE;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
iterator = this->peers->create_iterator(this->peers, TRUE);
while (iterator->iterate(iterator, (void**)&peer))
requester->destroy(requester);
}
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
}
/**
peer_t *peer;
ike_sa_id_t *ike_sa_id;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_peer_by_id(this, peer_id, &peer) != SUCCESS)
{
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return NULL;
}
ike_sa_id = peer->ike_sa_id;
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return ike_sa_id;
}
peer_t *peer;
ike_sa_id_t *ike_sa_id;
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
if (get_peer_by_id(this, peer_id, &peer) != SUCCESS)
{
/* the peer is not online */
DBG2(DBG_IKE, "requested peer '%D' is offline, registering peer '%D'", peer_id, requester);
register_peer(peer, requester);
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return NULL;
}
ike_sa_id = peer->ike_sa_id;
- pthread_mutex_unlock(&(this->mutex));
+ this->mutex->unlock(this->mutex);
return ike_sa_id;
}
*/
static void destroy(private_mediation_manager_t *this)
{
- pthread_mutex_lock(&(this->mutex));
+ this->mutex->lock(this->mutex);
this->peers->destroy_function(this->peers, (void*)peer_destroy);
- pthread_mutex_unlock(&(this->mutex));
- pthread_mutex_destroy(&(this->mutex));
+ this->mutex->unlock(this->mutex);
+ this->mutex->destroy(this->mutex);
free(this);
}
this->public.check_and_register = (ike_sa_id_t*(*)(mediation_manager_t*,identification_t*,identification_t*))check_and_register;
this->peers = linked_list_create();
- pthread_mutex_init(&(this->mutex), NULL);
+ this->mutex = mutex_create(MUTEX_DEFAULT);
return (mediation_manager_t*)this;
}
#include "openssl_plugin.h"
#include <library.h>
+#include <utils/mutex.h>
#include "openssl_crypter.h"
#include "openssl_hasher.h"
#include "openssl_diffie_hellman.h"
/**
* Array of static mutexs, with CRYPTO_num_locks() mutex
*/
-static pthread_mutex_t *mutex;
+static mutex_t **mutex;
/**
* Locking callback for static locks
{
if (mode & CRYPTO_LOCK)
{
- pthread_mutex_lock(&mutex[type]);
+ mutex[type]->lock(mutex[type]);
}
else
{
- pthread_mutex_unlock(&mutex[type]);
+ mutex[type]->unlock(mutex[type]);
}
}
* Implementation of dynlock
*/
struct CRYPTO_dynlock_value {
- pthread_mutex_t mutex;
+ mutex_t *mutex;
};
/**
struct CRYPTO_dynlock_value *lock;
lock = malloc_thing(struct CRYPTO_dynlock_value);
- pthread_mutex_init(&lock->mutex, NULL);
+ lock->mutex = mutex_create(MUTEX_DEFAULT);
return lock;
}
{
if (mode & CRYPTO_LOCK)
{
- pthread_mutex_lock(&lock->mutex);
+ lock->mutex->lock(lock->mutex);
}
else
{
- pthread_mutex_unlock(&lock->mutex);
+ lock->mutex->unlock(lock->mutex);
}
}
static void destroy_function(struct CRYPTO_dynlock_value *lock,
const char *file, int line)
{
- pthread_mutex_destroy(&lock->mutex);
+ lock->mutex->destroy(lock->mutex);
free(lock);
}
CRYPTO_set_dynlock_destroy_callback(destroy_function);
num_locks = CRYPTO_num_locks();
- mutex = malloc(sizeof(pthread_mutex_t) * num_locks);
+ mutex = malloc(sizeof(mutex_t*) * num_locks);
for (i = 0; i < num_locks; i++)
{
- pthread_mutex_init(&mutex[i], NULL);
+ mutex[i] = mutex_create(MUTEX_DEFAULT);
}
}
num_locks = CRYPTO_num_locks();
for (i = 0; i < num_locks; i++)
{
- pthread_mutex_destroy(&mutex[i]);
+ mutex[i]->destroy(mutex[i]);
}
free(mutex);
}
ENGINE_cleanup();
EVP_cleanup();
- threading_cleanup();
-
free(this);
}
projects / strongswan.git / commitdiff