summaryrefslogtreecommitdiff
path: root/src/ipcpd/ipcp-data.c
diff options
context:
space:
mode:
authordimitri staessens <dimitri.staessens@intec.ugent.be>2016-10-26 09:56:31 +0000
committerdimitri staessens <dimitri.staessens@intec.ugent.be>2016-10-26 09:56:31 +0000
commitcc64e52dee3559128293a17a669e94acb48f9309 (patch)
treee4ef544c225e3b118c8a73d868dccaa073b55f11 /src/ipcpd/ipcp-data.c
parent0fd97235ecf670f1fc6db2723c530934b5376458 (diff)
parentf0646875d0bc941e339d305d0c68b13543cd6f2a (diff)
downloadouroboros-cc64e52dee3559128293a17a669e94acb48f9309.tar.gz
ouroboros-cc64e52dee3559128293a17a669e94acb48f9309.zip
Merged in sandervrijders/ouroboros/be-directory (pull request #280)
lib, irmd, ipcpd: Add name querying to IPCPs
Diffstat (limited to 'src/ipcpd/ipcp-data.c')
-rw-r--r--src/ipcpd/ipcp-data.c308
1 files changed, 227 insertions, 81 deletions
diff --git a/src/ipcpd/ipcp-data.c b/src/ipcpd/ipcp-data.c
index ed7e578d..b3078054 100644
--- a/src/ipcpd/ipcp-data.c
+++ b/src/ipcpd/ipcp-data.c
@@ -21,14 +21,16 @@
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-#include <ouroboros/config.h>
-#include <ouroboros/list.h>
-
#define OUROBOROS_PREFIX "ipcp-utils"
+#include <ouroboros/config.h>
+#include <ouroboros/list.h>
+#include <ouroboros/time_utils.h>
#include <ouroboros/logs.h>
+#include <ouroboros/errno.h>
#include "ipcp-data.h"
+#include "ipcp.h"
#include <string.h>
#include <stdlib.h>
@@ -41,8 +43,8 @@ struct reg_entry {
struct dir_entry {
struct list_head list;
- char * ap_name;
- uint64_t addr;
+ char * name;
+ uint64_t addr;
};
static struct reg_entry * reg_entry_create(char * name)
@@ -70,18 +72,18 @@ static void reg_entry_destroy(struct reg_entry * entry)
free(entry);
}
-static struct dir_entry * dir_entry_create(char * ap_name,
+static struct dir_entry * dir_entry_create(char * name,
uint64_t addr)
{
struct dir_entry * entry = malloc(sizeof(*entry));
if (entry == NULL)
return NULL;
- assert(ap_name);
+ assert(name);
entry->addr = addr;
- entry->ap_name = ap_name;
- if (entry->ap_name == NULL)
+ entry->name = name;
+ if (entry->name == NULL)
return NULL;
return entry;
@@ -91,8 +93,8 @@ static void dir_entry_destroy(struct dir_entry * entry)
{
assert(entry);
- if (entry->ap_name != NULL)
- free(entry->ap_name);
+ if (entry->name != NULL)
+ free(entry->name);
free(entry);
}
@@ -120,10 +122,12 @@ struct ipcp_data * ipcp_data_init(struct ipcp_data * dst,
/* init the lists */
INIT_LIST_HEAD(&dst->registry);
INIT_LIST_HEAD(&dst->directory);
+ INIT_LIST_HEAD(&dst->dir_queries);
/* init the locks */
pthread_rwlock_init(&dst->reg_lock, NULL);
pthread_rwlock_init(&dst->dir_lock, NULL);
+ pthread_mutex_init(&dst->dir_queries_lock, NULL);
return dst;
}
@@ -156,6 +160,20 @@ static void clear_directory(struct ipcp_data * data)
}
}
+static void clear_dir_queries(struct ipcp_data * data)
+{
+ struct list_head * h;
+ struct list_head * t;
+
+ assert(data);
+
+ list_for_each_safe(h, t, &data->dir_queries) {
+ struct dir_query * e = list_entry(h, struct dir_query, next);
+ list_del(&e->next);
+ ipcp_data_dir_query_destroy(e);
+ }
+}
+
void ipcp_data_destroy(struct ipcp_data * data)
{
if (data == NULL)
@@ -163,27 +181,27 @@ void ipcp_data_destroy(struct ipcp_data * data)
/* clear the lists */
pthread_rwlock_wrlock(&data->reg_lock);
-
clear_registry(data);
-
pthread_rwlock_unlock(&data->reg_lock);
- pthread_rwlock_wrlock(&data->dir_lock);
+ pthread_rwlock_wrlock(&data->dir_lock);
clear_directory(data);
-
pthread_rwlock_unlock(&data->dir_lock);
+ pthread_mutex_lock(&data->dir_queries_lock);
+ clear_dir_queries(data);
+ pthread_mutex_unlock(&data->dir_queries_lock);
+
if (data->dif_name != NULL)
free(data->dif_name);
pthread_rwlock_destroy(&data->dir_lock);
pthread_rwlock_destroy(&data->reg_lock);
+ pthread_mutex_destroy(&data->dir_queries_lock);
free(data);
}
-
-
static struct reg_entry * find_reg_entry_by_name(struct ipcp_data * data,
const char * name)
{
@@ -202,13 +220,13 @@ static struct reg_entry * find_reg_entry_by_name(struct ipcp_data * data,
}
static struct dir_entry * find_dir_entry(struct ipcp_data * data,
- const char * ap_name,
+ const char * name,
uint64_t addr)
{
struct list_head * h;
list_for_each(h, &data->directory) {
struct dir_entry * e = list_entry(h, struct dir_entry, list);
- if (e->addr == addr && !strcmp(e->ap_name, ap_name))
+ if (e->addr == addr && !strcmp(e->name, name))
return e;
}
@@ -216,33 +234,47 @@ static struct dir_entry * find_dir_entry(struct ipcp_data * data,
}
static struct dir_entry * find_dir_entry_any(struct ipcp_data * data,
- const char * ap_name)
+ const char * name)
{
struct list_head * h;
list_for_each(h, &data->directory) {
struct dir_entry * e = list_entry(h, struct dir_entry, list);
- if (!strcmp(e->ap_name, ap_name))
+ if (!strcmp(e->name, name))
return e;
}
return NULL;
}
-bool ipcp_data_is_in_directory(struct ipcp_data * data,
- const char * ap_name)
+int ipcp_data_reg_add_entry(struct ipcp_data * data,
+ char * name)
{
- bool ret = false;
+ struct reg_entry * entry;
- pthread_rwlock_rdlock(&data->dir_lock);
+ if (data == NULL || name == NULL)
+ return -1;
- ret = (find_dir_entry_any(data, ap_name) != NULL);
+ pthread_rwlock_wrlock(&data->reg_lock);
- pthread_rwlock_unlock(&data->dir_lock);
+ if (find_reg_entry_by_name(data, name)) {
+ pthread_rwlock_unlock(&data->reg_lock);
+ return -1;
+ }
- return ret;
+ entry = reg_entry_create(name);
+ if (entry == NULL) {
+ pthread_rwlock_unlock(&data->reg_lock);
+ return -1;
+ }
+
+ list_add(&entry->list, &data->registry);
+
+ pthread_rwlock_unlock(&data->reg_lock);
+
+ return 0;
}
-int ipcp_data_del_reg_entry(struct ipcp_data * data,
+int ipcp_data_reg_del_entry(struct ipcp_data * data,
const char * name)
{
struct reg_entry * e;
@@ -266,114 +298,109 @@ int ipcp_data_del_reg_entry(struct ipcp_data * data,
return 0;
}
-int ipcp_data_del_dir_entry(struct ipcp_data * data,
- const char * ap_name,
- uint64_t addr)
+bool ipcp_data_reg_has(struct ipcp_data * data,
+ const char * name)
{
- struct dir_entry * e;
- if (data == NULL)
- return -1;
-
- pthread_rwlock_wrlock(&data->dir_lock);
+ bool ret = false;
- e = find_dir_entry(data, ap_name, addr);
- if (e == NULL) {
- pthread_rwlock_unlock(&data->dir_lock);
- return 0; /* nothing to do */
- }
+ if (data == NULL || name == NULL)
+ return false;
- list_del(&e->list);
+ pthread_rwlock_rdlock(&data->reg_lock);
- pthread_rwlock_unlock(&data->dir_lock);
+ ret = (find_reg_entry_by_name(data, name) != NULL);
- dir_entry_destroy(e);
+ pthread_rwlock_unlock(&data->reg_lock);
- return 0;
+ return ret;
}
-int ipcp_data_add_reg_entry(struct ipcp_data * data,
- char * name)
+int ipcp_data_dir_add_entry(struct ipcp_data * data,
+ char * name,
+ uint64_t addr)
{
- struct reg_entry * entry;
+ struct dir_entry * entry;
+ char * entry_name;
if (data == NULL || name == NULL)
return -1;
- pthread_rwlock_wrlock(&data->reg_lock);
+ pthread_rwlock_wrlock(&data->dir_lock);
- if (find_reg_entry_by_name(data, name)) {
- pthread_rwlock_unlock(&data->reg_lock);
+ if (find_dir_entry(data, name, addr) != NULL) {
+ pthread_rwlock_unlock(&data->dir_lock);
return -1;
}
- entry = reg_entry_create(name);
+ entry_name = strdup(name);
+ if (entry_name == NULL) {
+ pthread_rwlock_unlock(&data->dir_lock);
+ return -1;
+ }
+
+ entry = dir_entry_create(entry_name, addr);
if (entry == NULL) {
- pthread_rwlock_unlock(&data->reg_lock);
+ pthread_rwlock_unlock(&data->dir_lock);
return -1;
}
- list_add(&entry->list, &data->registry);
+ list_add(&entry->list,&data->directory);
- pthread_rwlock_unlock(&data->reg_lock);
+ pthread_rwlock_unlock(&data->dir_lock);
+
+ LOG_DBG("Added directory entry for %s.", entry_name);
return 0;
}
-int ipcp_data_add_dir_entry(struct ipcp_data * data,
- char * ap_name,
+int ipcp_data_dir_del_entry(struct ipcp_data * data,
+ const char * name,
uint64_t addr)
{
- struct dir_entry * entry;
-
- if (data == NULL || ap_name == NULL)
+ struct dir_entry * e;
+ if (data == NULL)
return -1;
pthread_rwlock_wrlock(&data->dir_lock);
- if (find_dir_entry(data, ap_name, addr) != NULL) {
- pthread_rwlock_unlock(&data->dir_lock);
- return -1;
- }
-
- entry = dir_entry_create(ap_name, addr);
- if (entry == NULL) {
+ e = find_dir_entry(data, name, addr);
+ if (e == NULL) {
pthread_rwlock_unlock(&data->dir_lock);
- return -1;
+ return 0; /* nothing to do */
}
- list_add(&entry->list,&data->directory);
+ list_del(&e->list);
pthread_rwlock_unlock(&data->dir_lock);
+ dir_entry_destroy(e);
+
return 0;
}
-bool ipcp_data_is_in_registry(struct ipcp_data * data,
- const char * ap_name)
+bool ipcp_data_dir_has(struct ipcp_data * data,
+ const char * name)
{
bool ret = false;
- if (data == NULL || ap_name == NULL)
- return false;
-
- pthread_rwlock_rdlock(&data->reg_lock);
+ pthread_rwlock_rdlock(&data->dir_lock);
- ret = (find_reg_entry_by_name(data, ap_name) != NULL);
+ ret = (find_dir_entry_any(data, name) != NULL);
- pthread_rwlock_unlock(&data->reg_lock);
+ pthread_rwlock_unlock(&data->dir_lock);
return ret;
}
-uint64_t ipcp_data_get_addr(struct ipcp_data * data,
- const char * ap_name)
+uint64_t ipcp_data_dir_get_addr(struct ipcp_data * data,
+ const char * name)
{
struct dir_entry * entry;
uint64_t addr;
pthread_rwlock_rdlock(&data->dir_lock);
- entry = find_dir_entry_any(data, ap_name);
+ entry = find_dir_entry_any(data, name);
if (entry == NULL) {
pthread_rwlock_unlock(&data->dir_lock);
@@ -386,3 +413,122 @@ uint64_t ipcp_data_get_addr(struct ipcp_data * data,
return addr;
}
+
+struct dir_query * ipcp_data_dir_query_create(char * name)
+{
+ struct dir_query * query;
+ pthread_condattr_t cattr;
+
+ query = malloc(sizeof(*query));
+ if (query == NULL)
+ return NULL;
+
+ query->name = strdup(name);
+ if (query->name == NULL) {
+ free(query);
+ return NULL;
+ }
+
+ query->state = QUERY_INIT;
+
+ pthread_condattr_init(&cattr);
+#ifndef __APPLE__
+ pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK);
+#endif
+ pthread_cond_init(&query->cond, &cattr);
+ pthread_mutex_init(&query->lock, NULL);
+
+ INIT_LIST_HEAD(&query->next);
+
+ return query;
+}
+
+void ipcp_data_dir_query_respond(struct dir_query * query)
+{
+ assert(query);
+
+ pthread_mutex_lock(&query->lock);
+
+ if (query->state != QUERY_PENDING) {
+ pthread_mutex_unlock(&query->lock);
+ return;
+ }
+
+ query->state = QUERY_RESPONSE;
+ pthread_cond_broadcast(&query->cond);
+
+ while (query->state == QUERY_RESPONSE)
+ pthread_cond_wait(&query->cond, &query->lock);
+
+ pthread_mutex_unlock(&query->lock);
+}
+
+void ipcp_data_dir_query_destroy(struct dir_query * query)
+{
+ assert(query);
+
+ pthread_mutex_lock(&query->lock);
+
+ if (query->state == QUERY_DESTROY) {
+ pthread_mutex_unlock(&query->lock);
+ return;
+ }
+
+ if (query->state == QUERY_INIT)
+ query->state = QUERY_DONE;
+
+ if (query->state == QUERY_PENDING) {
+ query->state = QUERY_DESTROY;
+ pthread_cond_broadcast(&query->cond);
+ }
+
+ while (query->state != QUERY_DONE)
+ pthread_cond_wait(&query->cond, &query->lock);
+
+ pthread_mutex_unlock(&query->lock);
+
+ pthread_cond_destroy(&query->cond);
+ pthread_mutex_destroy(&query->lock);
+
+ free(query->name);
+ free(query);
+}
+
+int ipcp_data_dir_query_wait(struct dir_query * query,
+ const struct timespec * timeout)
+{
+ struct timespec abstime;
+ int ret = 0;
+
+ assert(query);
+ assert(timeout);
+
+ clock_gettime(PTHREAD_COND_CLOCK, &abstime);
+ ts_add(&abstime, timeout, &abstime);
+
+ pthread_mutex_lock(&query->lock);
+
+ if (query->state != QUERY_INIT) {
+ pthread_mutex_unlock(&query->lock);
+ return -EINVAL;
+ }
+
+ query->state = QUERY_PENDING;
+
+ while (query->state == QUERY_PENDING) {
+ if ((ret = -pthread_cond_timedwait(&query->cond,
+ &query->lock,
+ &abstime)) == -ETIMEDOUT)
+ break;
+ }
+
+ if (query->state == QUERY_DESTROY)
+ ret = -1;
+
+ query->state = QUERY_DONE;
+ pthread_cond_broadcast(&query->cond);
+
+ pthread_mutex_unlock(&query->lock);
+
+ return ret;
+}