wrapped all pthread_rwlock_t in profilable rwlock_t
authorMartin Willi <martin@strongswan.org>
Wed, 5 Nov 2008 16:12:54 +0000 (16:12 -0000)
committerMartin Willi <martin@strongswan.org>
Wed, 5 Nov 2008 16:12:54 +0000 (16:12 -0000)
src/charon/credentials/credential_manager.c
src/charon/credentials/sets/cert_cache.c
src/charon/plugins/nm/nm_creds.c
src/charon/plugins/stroke/stroke_ca.c
src/charon/plugins/stroke/stroke_cred.c
src/libstrongswan/fetcher/fetcher_manager.c
src/libstrongswan/utils/mutex.c
src/libstrongswan/utils/mutex.h

index 74593aa..8420883 100644 (file)
  * $Id$
  */
 
-/* some clibs need it for rwlocks */
-#define _GNU_SOURCE
 #include <pthread.h>
 
 #include "credential_manager.h"
 
 #include <daemon.h>
+#include <utils/mutex.h>
 #include <utils/linked_list.h>
 #include <credentials/sets/cert_cache.h>
 #include <credentials/sets/auth_info_wrapper.h>
@@ -68,7 +67,7 @@ struct private_credential_manager_t {
        /**
         * read-write lock to sets list
         */
-       pthread_rwlock_t lock;
+       rwlock_t *lock;
 };
 
 /** data to pass to create_private_enumerator */
@@ -170,7 +169,7 @@ static enumerator_t *create_sets_enumerator(private_credential_manager_t *this)
  */
 static void destroy_cert_data(cert_data_t *data)
 {
-       pthread_rwlock_unlock(&data->this->lock);
+       data->this->lock->unlock(data->this->lock);
        free(data);
 }
 
@@ -197,7 +196,7 @@ static enumerator_t *create_cert_enumerator(private_credential_manager_t *this,
        data->id = id;
        data->trusted = trusted;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_nested(create_sets_enumerator(this),
                                                                        (void*)create_cert, data,
                                                                        (void*)destroy_cert_data);
@@ -229,7 +228,7 @@ static certificate_t *get_cert(private_credential_manager_t *this,
  */
 static void destroy_cdp_data(cdp_data_t *data)
 {
-       pthread_rwlock_unlock(&data->this->lock);
+       data->this->lock->unlock(data->this->lock);
        free(data);
 }
 
@@ -251,7 +250,7 @@ static enumerator_t * create_cdp_enumerator(private_credential_manager_t *this,
        data->type = type;
        data->id = id;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_nested(create_sets_enumerator(this),
                                                                        (void*)create_cdp, data,
                                                                        (void*)destroy_cdp_data);
@@ -262,7 +261,7 @@ static enumerator_t * create_cdp_enumerator(private_credential_manager_t *this,
  */
 static void destroy_private_data(private_data_t *data)
 {
-       pthread_rwlock_unlock(&data->this->lock);
+       data->this->lock->unlock(data->this->lock);
        free(data);
 }
 
@@ -287,7 +286,7 @@ static enumerator_t* create_private_enumerator(
        data->this = this;
        data->type = key;
        data->keyid = keyid;
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_nested(create_sets_enumerator(this),
                                                                        (void*)create_private, data,
                                                                        (void*)destroy_private_data);
@@ -316,7 +315,7 @@ static private_key_t *get_private_by_keyid(private_credential_manager_t *this,
  */
 static void destroy_shared_data(shared_data_t *data)
 {
-       pthread_rwlock_unlock(&data->this->lock);
+       data->this->lock->unlock(data->this->lock);
        free(data);
 }
 
@@ -341,7 +340,7 @@ static enumerator_t *create_shared_enumerator(private_credential_manager_t *this
        data->me = me;
        data->other = other;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_nested(create_sets_enumerator(this),
                                                                        (void*)create_shared, data, 
                                                                        (void*)destroy_shared_data);
@@ -412,7 +411,7 @@ static void cache_cert(private_credential_manager_t *this, certificate_t *cert)
        credential_set_t *set;
        enumerator_t *enumerator;
        
-       if (pthread_rwlock_trywrlock(&this->lock) == 0)
+       if (this->lock->try_write_lock(this->lock))
        {
                enumerator = this->sets->create_enumerator(this->sets);
                while (enumerator->enumerate(enumerator, &set))
@@ -423,10 +422,10 @@ static void cache_cert(private_credential_manager_t *this, certificate_t *cert)
        }
        else
        {       /* we can't cache now as other threads are active, queue for later */
-               pthread_rwlock_rdlock(&this->lock);
+               this->lock->read_lock(this->lock);
                this->cache_queue->insert_last(this->cache_queue, cert->get_ref(cert));
        }
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -439,7 +438,7 @@ static void cache_queue(private_credential_manager_t *this)
        enumerator_t *enumerator;
        
        if (this->cache_queue->get_count(this->cache_queue) > 0 &&
-               pthread_rwlock_trywrlock(&this->lock) == 0)
+               this->lock->try_write_lock(this->lock))
        {
                while (this->cache_queue->remove_last(this->cache_queue,
                                                                                          (void**)&cert) == SUCCESS)
@@ -452,7 +451,7 @@ static void cache_queue(private_credential_manager_t *this)
                        enumerator->destroy(enumerator);
                        cert->destroy(cert);
                }
-               pthread_rwlock_unlock(&this->lock);
+               this->lock->unlock(this->lock);
        }
 }
 
@@ -1302,7 +1301,7 @@ static void public_destroy(public_enumerator_t *this)
                remove_local_set(this->this, &this->wrapper->set);
                this->wrapper->destroy(this->wrapper);
        }
-       pthread_rwlock_unlock(&this->this->lock);
+       this->this->lock->unlock(this->this->lock);
        
        /* check for delayed certificate cache queue */
        cache_queue(this->this);
@@ -1328,7 +1327,7 @@ static enumerator_t* create_public_enumerator(private_credential_manager_t *this
                enumerator->wrapper = auth_info_wrapper_create(auth);
                add_local_set(this, &enumerator->wrapper->set);
        }
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return &enumerator->public;
 }
 
@@ -1525,9 +1524,9 @@ static void flush_cache(private_credential_manager_t *this,
 static void add_set(private_credential_manager_t *this,
                                                           credential_set_t *set)
 {
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        this->sets->insert_last(this->sets, set);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -1535,9 +1534,9 @@ static void add_set(private_credential_manager_t *this,
  */
 static void remove_set(private_credential_manager_t *this, credential_set_t *set)
 {
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        this->sets->remove(this->sets, set, NULL);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -1551,7 +1550,7 @@ static void destroy(private_credential_manager_t *this)
        this->sets->destroy(this->sets);
        pthread_key_delete(this->local_sets);
        this->cache->destroy(this->cache);
-       pthread_rwlock_destroy(&this->lock);
+       this->lock->destroy(this->lock);
        free(this);
 }
 
@@ -1580,7 +1579,7 @@ credential_manager_t *credential_manager_create()
        this->cache = cert_cache_create();
        this->cache_queue = linked_list_create();
        this->sets->insert_first(this->sets, this->cache);
-       pthread_rwlock_init(&this->lock, NULL);
+       this->lock = rwlock_create(RWLOCK_DEFAULT);
        
        return &this->public;
 }
index 4a9a971..79b5f02 100644 (file)
  * $Id$
  */
 
-#define _GNU_SOURCE
-#include <pthread.h>
-
 #include "cert_cache.h"
 
+#include <time.h>
+
 #include <daemon.h>
+#include <utils/mutex.h>
 #include <utils/linked_list.h>
 
 #define CACHE_SIZE 30
@@ -56,7 +56,7 @@ struct private_cert_cache_t {
        /**
         * read-write lock to sets list
         */
-       pthread_rwlock_t lock;
+       rwlock_t *lock;
 };
 
 /**
@@ -90,7 +90,7 @@ static void check_cache(private_cert_cache_t *this)
        {
                this->check_required = TRUE;
        }
-       else if (pthread_rwlock_trywrlock(&this->lock) == 0)
+       else if (this->lock->try_write_lock(this->lock))
        {       /* never blocks, only done if lock is available */
                while (this->relations->get_count(this->relations) > CACHE_SIZE)
                {
@@ -110,7 +110,7 @@ static void check_cache(private_cert_cache_t *this)
                        relation_destroy(oldest);
                }
                this->check_required = FALSE;
-               pthread_rwlock_unlock(&this->lock);
+               this->lock->unlock(this->lock);
        }
 }
 
@@ -124,7 +124,7 @@ static bool issued_by(private_cert_cache_t *this,
        enumerator_t *enumerator;
        
        /* lookup cache */
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        enumerator = this->relations->create_enumerator(this->relations);
        while (enumerator->enumerate(enumerator, &current))
        {
@@ -149,7 +149,7 @@ static bool issued_by(private_cert_cache_t *this,
                }
        }
        enumerator->destroy(enumerator);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
        if (found)
        {
                return TRUE;
@@ -233,7 +233,7 @@ static bool certs_filter(cert_data_t *data, relation_t **in, certificate_t **out
 static void certs_destroy(cert_data_t *data)
 {
        ref_put(&data->this->enumerating);
-       pthread_rwlock_unlock(&data->this->lock);
+       data->this->lock->unlock(data->this->lock);
        if (data->this->check_required)
        {
                check_cache(data->this);
@@ -260,7 +260,7 @@ static enumerator_t *create_enumerator(private_cert_cache_t *this,
        data->id = id;
        data->this = this;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        ref_get(&this->enumerating);
        return enumerator_create_filter(
                                                        this->relations->create_enumerator(this->relations),
@@ -275,7 +275,7 @@ static void flush(private_cert_cache_t *this, certificate_type_t type)
        enumerator_t *enumerator;
        relation_t *relation;
        
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        enumerator = this->relations->create_enumerator(this->relations);
        while (enumerator->enumerate(enumerator, &relation))
        {
@@ -287,7 +287,7 @@ static void flush(private_cert_cache_t *this, certificate_type_t type)
                }
        }
        enumerator->destroy(enumerator);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -296,7 +296,7 @@ static void flush(private_cert_cache_t *this, certificate_type_t type)
 static void destroy(private_cert_cache_t *this)
 {
        this->relations->destroy_function(this->relations, (void*)relation_destroy);
-       pthread_rwlock_destroy(&this->lock);
+       this->lock->destroy(this->lock);
        free(this);
 }
 
@@ -319,7 +319,7 @@ cert_cache_t *cert_cache_create()
        this->relations = linked_list_create();
        this->enumerating = 0;
        this->check_required = FALSE;
-       pthread_rwlock_init(&this->lock, NULL);
+       this->lock = rwlock_create(RWLOCK_DEFAULT);
        
        return &this->public;
 }
index f165653..f87928e 100644 (file)
  * $Id$
  */
 
-#define _GNU_SOURCE
-#include <pthread.h>
-
 #include "nm_creds.h"
 
 #include <daemon.h>
+#include <utils/mutex.h>
 
 typedef struct private_nm_creds_t private_nm_creds_t;
 
@@ -62,7 +60,7 @@ struct private_nm_creds_t {
        /**
         * read/write lock
         */
-       pthread_rwlock_t lock;
+       rwlock_t *lock;
 };
 
 /**
@@ -91,10 +89,10 @@ static enumerator_t *create_usercert_enumerator(private_nm_creds_t *this,
                }
                public->destroy(public);
        }
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_cleaner(
                                                                enumerator_create_single(this->usercert, NULL),
-                                                               (void*)pthread_rwlock_unlock, &this->lock);
+                                                               (void*)this->lock->unlock, this->lock);
 }
 
 /**
@@ -138,9 +136,9 @@ static enumerator_t* create_cert_enumerator(private_nm_creds_t *this,
                }
                public->destroy(public);
        }
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_cleaner(enumerator_create_single(this->cert, NULL),
-                                                                        (void*)pthread_rwlock_unlock, &this->lock);
+                                                                        (void*)this->lock->unlock, this->lock);
 }
 
 /**
@@ -167,9 +165,9 @@ static enumerator_t* create_private_enumerator(private_nm_creds_t *this,
                        return NULL;
                }
        }
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_cleaner(enumerator_create_single(this->key, NULL),
-                                                                        (void*)pthread_rwlock_unlock, &this->lock);
+                                                                        (void*)this->lock->unlock, this->lock);
 }
 
 /**
@@ -205,7 +203,8 @@ static bool shared_enumerate(shared_enumerator_t *this, shared_key_t **key,
 static void shared_destroy(shared_enumerator_t *this)
 {
        this->key->destroy(this->key);
-       pthread_rwlock_unlock(&this->this->lock);
+       this->lock->destroy(this->lock);
+       this->this->lock->unlock(this->this->lock);
        free(this);
 }
 /**
@@ -235,7 +234,7 @@ static enumerator_t* create_shared_enumerator(private_nm_creds_t *this,
        enumerator->public.destroy = (void*)shared_destroy;
        enumerator->this = this;
        enumerator->done = FALSE;
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        enumerator->key = shared_key_create(type,
                                                                                chunk_clone(chunk_create(this->pass,
                                                                                                        strlen(this->pass))));
@@ -247,10 +246,10 @@ static enumerator_t* create_shared_enumerator(private_nm_creds_t *this,
  */
 static void set_certificate(private_nm_creds_t *this, certificate_t *cert)
 {
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        DESTROY_IF(this->cert);
        this->cert = cert;
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -259,14 +258,14 @@ static void set_certificate(private_nm_creds_t *this, certificate_t *cert)
 static void set_username_password(private_nm_creds_t *this, identification_t *id,
                                                 char *password)
 {
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        DESTROY_IF(this->user);
        /* for EAP authentication, we use always use ID_EAP type */
        this->user = identification_create_from_encoding(ID_EAP,
                                                                                                         id->get_encoding(id));
        free(this->pass);
        this->pass = password ? strdup(password) : NULL;
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -275,12 +274,12 @@ static void set_username_password(private_nm_creds_t *this, identification_t *id
 static void set_cert_and_key(private_nm_creds_t *this, certificate_t *cert,    
                                                         private_key_t *key)
 {
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        DESTROY_IF(this->key);
        DESTROY_IF(this->usercert);
        this->key = key;
        this->usercert = cert;
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }      
 
 /**
@@ -306,7 +305,7 @@ static void clear(private_nm_creds_t *this)
 static void destroy(private_nm_creds_t *this)
 {
        clear(this);
-       pthread_rwlock_destroy(&this->lock);
+       this->lock->destroy(this->lock);
        free(this);
 }
 
@@ -328,7 +327,7 @@ nm_creds_t *nm_creds_create()
        this->public.clear = (void(*)(nm_creds_t*))clear;
        this->public.destroy = (void(*)(nm_creds_t*))destroy;
        
-       pthread_rwlock_init(&this->lock, NULL);
+       this->lock = rwlock_create(RWLOCK_DEFAULT);
        
        this->cert = NULL;
        this->user = NULL;
index 8569f49..5435643 100644 (file)
  * $Id$
  */
 
-#define _GNU_SOURCE
-#include <pthread.h>
-
 #include "stroke_ca.h"
 #include "stroke_cred.h"
 
+#include <utils/mutex.h>
 #include <utils/linked_list.h>
 #include <crypto/hashers/hasher.h>
 
@@ -42,7 +40,7 @@ struct private_stroke_ca_t {
        /**
         * read-write lock to lists
         */
-       pthread_rwlock_t lock;
+       rwlock_t *lock;
        
        /**
         * list of starters CA sections and its certificates (ca_section_t)
@@ -136,7 +134,7 @@ typedef struct {
  */
 static void cdp_data_destroy(cdp_data_t *data)
 {
-       pthread_rwlock_unlock(&data->this->lock);
+       data->this->lock->unlock(data->this->lock);
        free(data);
 }
 
@@ -236,7 +234,7 @@ static enumerator_t *create_cdp_enumerator(private_stroke_ca_t *this,
        data->type = type;
        data->id = id;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_nested(this->sections->create_enumerator(this->sections),
                        (type == CERT_X509) ? (void*)create_inner_cdp_hashandurl : (void*)create_inner_cdp,
                        data, (void*)cdp_data_destroy);
@@ -278,9 +276,9 @@ static void add(private_stroke_ca_t *this, stroke_msg_t *msg)
                {
                        ca->certuribase = strdup(msg->add_ca.certuribase);
                }
-               pthread_rwlock_wrlock(&this->lock);
+               this->lock->write_lock(this->lock);
                this->sections->insert_last(this->sections, ca);
-               pthread_rwlock_unlock(&this->lock);
+               this->lock->unlock(this->lock);
                DBG1(DBG_CFG, "added ca '%s'", msg->add_ca.name);
        }
 }
@@ -293,7 +291,7 @@ static void del(private_stroke_ca_t *this, stroke_msg_t *msg)
        enumerator_t *enumerator;
        ca_section_t *ca = NULL;
        
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        enumerator = this->sections->create_enumerator(this->sections);
        while (enumerator->enumerate(enumerator, &ca))
        {
@@ -305,7 +303,7 @@ static void del(private_stroke_ca_t *this, stroke_msg_t *msg)
                ca = NULL;
        }
        enumerator->destroy(enumerator);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
        if (ca == NULL)
        {
                DBG1(DBG_CFG, "no ca named '%s' found\n", msg->del_ca.name);
@@ -356,7 +354,7 @@ static void check_for_hash_and_url(private_stroke_ca_t *this, certificate_t* cer
                return;
        }
        
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        enumerator = this->sections->create_enumerator(this->sections);
        while (enumerator->enumerate(enumerator, (void**)&section))
        {
@@ -372,7 +370,7 @@ static void check_for_hash_and_url(private_stroke_ca_t *this, certificate_t* cer
                }
        }
        enumerator->destroy(enumerator);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
        
        hasher->destroy(hasher);
 }
@@ -386,7 +384,7 @@ static void list(private_stroke_ca_t *this, stroke_msg_t *msg, FILE *out)
        ca_section_t *section;
        enumerator_t *enumerator;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        enumerator = this->sections->create_enumerator(this->sections);
        while (enumerator->enumerate(enumerator, (void**)&section))
        {
@@ -419,7 +417,7 @@ static void list(private_stroke_ca_t *this, stroke_msg_t *msg, FILE *out)
                }
        }
        enumerator->destroy(enumerator);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -428,7 +426,7 @@ static void list(private_stroke_ca_t *this, stroke_msg_t *msg, FILE *out)
 static void destroy(private_stroke_ca_t *this)
 {
        this->sections->destroy_function(this->sections, (void*)ca_section_destroy);
-       pthread_rwlock_destroy(&this->lock);
+       this->lock->destroy(this->lock);
        free(this);
 }
 
@@ -451,7 +449,7 @@ stroke_ca_t *stroke_ca_create(stroke_cred_t *cred)
        this->public.destroy = (void(*)(stroke_ca_t*))destroy;
        
        this->sections = linked_list_create();
-       pthread_rwlock_init(&this->lock, NULL);
+       this->lock = rwlock_create(RWLOCK_DEFAULT);
        this->cred = cred;
        
        return &this->public;
index c699a08..23a6f99 100644 (file)
@@ -15,8 +15,6 @@
  * $Id$
  */
 
-#define _GNU_SOURCE
-#include <pthread.h>
 #include <sys/stat.h>
 #include <limits.h>
 
@@ -28,6 +26,7 @@
 #include <credentials/certificates/ac.h>
 #include <utils/linked_list.h>
 #include <utils/lexparser.h>
+#include <utils/mutex.h>
 #include <asn1/pem.h>
 #include <daemon.h>
 
@@ -73,7 +72,7 @@ struct private_stroke_cred_t {
        /**
         * read-write lock to lists
         */
-       pthread_rwlock_t lock;
+       rwlock_t *lock;
        
        /**
         * cache CRLs to disk?
@@ -94,7 +93,7 @@ typedef struct {
  */
 static void id_data_destroy(id_data_t *data)
 {
-       pthread_rwlock_unlock(&data->this->lock);
+       data->this->lock->unlock(data->this->lock);
        free(data);
 }
 
@@ -140,7 +139,7 @@ static enumerator_t* create_private_enumerator(private_stroke_cred_t *this,
        data->this = this;
        data->id = id;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_filter(this->private->create_enumerator(this->private),
                                                                        (void*)private_filter, data,
                                                                        (void*)id_data_destroy);
@@ -241,7 +240,7 @@ static enumerator_t* create_cert_enumerator(private_stroke_cred_t *this,
                data->this = this;
                data->id = id;
                
-               pthread_rwlock_rdlock(&this->lock);
+               this->lock->read_lock(this->lock);
                return enumerator_create_filter(this->certs->create_enumerator(this->certs),
                                        (cert == CERT_X509_CRL)? (void*)crl_filter : (void*)ac_filter,
                                        data, (void*)id_data_destroy);
@@ -254,7 +253,7 @@ static enumerator_t* create_cert_enumerator(private_stroke_cred_t *this,
        data->this = this;
        data->id = id;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_filter(this->certs->create_enumerator(this->certs),
                                                                        (void*)certs_filter, data,
                                                                        (void*)id_data_destroy);
@@ -272,7 +271,7 @@ typedef struct {
  */
 static void shared_data_destroy(shared_data_t *data)
 {
-       pthread_rwlock_unlock(&data->this->lock);
+       data->this->lock->unlock(data->this->lock);
        free(data);
 }
 
@@ -324,7 +323,7 @@ static enumerator_t* create_shared_enumerator(private_stroke_cred_t *this,
        data->me = me;
        data->other = other;
        data->type = type;
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        return enumerator_create_filter(this->shared->create_enumerator(this->shared),
                                                                        (void*)shared_filter, data,
                                                                        (void*)shared_data_destroy);
@@ -339,7 +338,7 @@ static certificate_t* add_cert(private_stroke_cred_t *this, certificate_t *cert)
        enumerator_t *enumerator;
        bool new = TRUE;        
 
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        enumerator = this->certs->create_enumerator(this->certs);
        while (enumerator->enumerate(enumerator, (void**)&current))
        {
@@ -358,7 +357,7 @@ static certificate_t* add_cert(private_stroke_cred_t *this, certificate_t *cert)
        {
                this->certs->insert_last(this->certs, cert);
        }
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
        return cert;
 }
        
@@ -400,7 +399,7 @@ static bool add_crl(private_stroke_cred_t *this, crl_t* crl)
        enumerator_t *enumerator;
        bool new = TRUE, found = FALSE; 
 
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        enumerator = this->certs->create_enumerator(this->certs);
        while (enumerator->enumerate(enumerator, (void**)&current))
        {
@@ -448,7 +447,7 @@ static bool add_crl(private_stroke_cred_t *this, crl_t* crl)
        {
                this->certs->insert_last(this->certs, cert);
        }
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
        return new;
 }
 
@@ -459,9 +458,9 @@ static bool add_ac(private_stroke_cred_t *this, ac_t* ac)
 {
        certificate_t *cert = &ac->certificate;
 
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        this->certs->insert_last(this->certs, cert);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
        return TRUE;
 }
 
@@ -698,7 +697,7 @@ static void load_secrets(private_stroke_cred_t *this)
        fclose(fd);
        src = chunk;
 
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        while (this->shared->remove_last(this->shared,
                                                                                   (void**)&shared) == SUCCESS)
        {
@@ -868,7 +867,7 @@ static void load_secrets(private_stroke_cred_t *this)
                }
        }
 error:
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
        chunk_clear(&chunk);
 }
 
@@ -949,7 +948,7 @@ static void destroy(private_stroke_cred_t *this)
        this->certs->destroy_offset(this->certs, offsetof(certificate_t, destroy));
        this->shared->destroy_offset(this->shared, offsetof(shared_key_t, destroy));
        this->private->destroy_offset(this->private, offsetof(private_key_t, destroy));
-       pthread_rwlock_destroy(&this->lock);
+       this->lock->destroy(this->lock);
        free(this);
 }
 
@@ -974,7 +973,7 @@ stroke_cred_t *stroke_cred_create()
        this->certs = linked_list_create();
        this->shared = linked_list_create();
        this->private = linked_list_create();
-       pthread_rwlock_init(&this->lock, NULL);
+       this->lock = rwlock_create(RWLOCK_DEFAULT);
 
        load_certs(this);
        load_secrets(this);
index bdcaf82..dc4a2db 100644 (file)
  * $Id$
  */
 
-#define _GNU_SOURCE
-#include <pthread.h>
-
 #include "fetcher_manager.h"
 
 #include <debug.h>
-#include <utils/linked_list.h>
 #include <utils/mutex.h>
+#include <utils/linked_list.h>
 
 typedef struct private_fetcher_manager_t private_fetcher_manager_t;
 
@@ -44,7 +41,7 @@ struct private_fetcher_manager_t {
        /**
         * read write lock to list
         */
-       pthread_rwlock_t lock;
+       rwlock_t *lock;
 };
 
 typedef struct {
@@ -74,7 +71,7 @@ static status_t fetch(private_fetcher_manager_t *this,
        entry_t *entry;
        bool capable = FALSE;
        
-       pthread_rwlock_rdlock(&this->lock);
+       this->lock->read_lock(this->lock);
        enumerator = this->fetchers->create_enumerator(this->fetchers);
        while (enumerator->enumerate(enumerator, &entry))
        {
@@ -132,7 +129,7 @@ static status_t fetch(private_fetcher_manager_t *this,
                break;
        }
        enumerator->destroy(enumerator);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
        if (!capable)
        {
                DBG1("unable to fetch from %s, no capable fetcher found", url);
@@ -151,9 +148,9 @@ static void add_fetcher(private_fetcher_manager_t *this,
        entry->url = strdup(url);
        entry->create = create;
 
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        this->fetchers->insert_last(this->fetchers, entry);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -165,7 +162,7 @@ static void remove_fetcher(private_fetcher_manager_t *this,
        enumerator_t *enumerator;
        entry_t *entry;
        
-       pthread_rwlock_wrlock(&this->lock);
+       this->lock->write_lock(this->lock);
        enumerator = this->fetchers->create_enumerator(this->fetchers);
        while (enumerator->enumerate(enumerator, &entry))
        {
@@ -176,7 +173,7 @@ static void remove_fetcher(private_fetcher_manager_t *this,
                }
        }
        enumerator->destroy(enumerator);
-       pthread_rwlock_unlock(&this->lock);
+       this->lock->unlock(this->lock);
 }
 
 /**
@@ -185,7 +182,7 @@ static void remove_fetcher(private_fetcher_manager_t *this,
 static void destroy(private_fetcher_manager_t *this)
 {
        this->fetchers->destroy_function(this->fetchers, (void*)entry_destroy);
-       pthread_rwlock_destroy(&this->lock);
+       this->lock->destroy(this->lock);
        free(this);
 }
 
@@ -202,7 +199,7 @@ fetcher_manager_t *fetcher_manager_create()
        this->public.destroy = (void(*)(fetcher_manager_t*))destroy;
        
        this->fetchers = linked_list_create();
-       pthread_rwlock_init(&this->lock, NULL);
+       this->lock = rwlock_create(RWLOCK_DEFAULT);
        
        return &this->public;
 }
index d6edb30..3dc274e 100644 (file)
  * $Id$
  */
 
-#include "mutex.h"
-
-#include <library.h>
-#include <debug.h>
-
+#define _GNU_SOURCE
 #include <pthread.h>
 #include <sys/time.h>
 #include <stdint.h>
 #include <time.h>
 #include <errno.h>
 
+#include "mutex.h"
+
+#include <library.h>
+#include <debug.h>
+
 typedef struct private_mutex_t private_mutex_t;
 typedef struct private_r_mutex_t private_r_mutex_t;
 typedef struct private_condvar_t private_condvar_t;
@@ -441,6 +442,14 @@ static void write_lock(private_rwlock_t *this)
 }
 
 /**
+ * Implementation of rwlock_t.try_write_lock
+ */
+static bool try_write_lock(private_rwlock_t *this)
+{
+       return pthread_rwlock_trywrlock(&this->rwlock) == 0;
+}
+
+/**
  * Implementation of rwlock_t.unlock
  */
 static void rw_unlock(private_rwlock_t *this)
@@ -472,6 +481,7 @@ rwlock_t *rwlock_create(rwlock_type_t type)
                        
                        this->public.read_lock = (void(*)(rwlock_t*))read_lock;
                        this->public.write_lock = (void(*)(rwlock_t*))write_lock;
+                       this->public.try_write_lock = (bool(*)(rwlock_t*))try_write_lock;
                        this->public.unlock = (void(*)(rwlock_t*))rw_unlock;
                        this->public.destroy = (void(*)(rwlock_t*))rw_destroy;
                        
index 626371b..a0a1980 100644 (file)
@@ -130,6 +130,15 @@ struct rwlock_t {
        void (*write_lock)(rwlock_t *this);
        
        /**
+        * Try to acquire the write lock.
+        *
+        * Never blocks, but returns FALSE if the lock was already occupied.
+        *
+        * @return              TRUE if lock acquired
+        */
+       bool (*try_write_lock)(rwlock_t *this); 
+       
+       /**
         * Release any acquired lock.
         */
        void (*unlock)(rwlock_t *this);