lib, ipcpd: Add hashtable and PDU Forwarding Function

This adds a hash table that takes 64-bit integers as key and uses
separate chaining on collision. It also adds the PDU Forwarding
Function, which the Flow Manager can use to lookup the fd towards the
next hop. Routing policies will add/update/remove entries in the PFF.

3 files changed, 207 insertions, 0 deletions

diff --git a/src/ipcpd/normal/CMakeLists.txt b/src/ipcpd/normal/CMakeLists.txt
index e61c226d..67a7953b 100644
--- a/src/ipcpd/normal/CMakeLists.txt
+++ b/src/ipcpd/normal/CMakeLists.txt
@@ -32,6 +32,7 @@ set(SOURCE_FILES
   frct.c
   main.c
   path.c
+  pff.c
   ribmgr.c
   shm_pci.c
   # Add policies last
diff --git a/src/ipcpd/normal/pff.c b/src/ipcpd/normal/pff.c
new file mode 100644
index 00000000..99774ece
--- /dev/null
+++ b/src/ipcpd/normal/pff.c
@@ -0,0 +1,151 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * PDU Forwarding Function
+ *
+ *    Sander Vrijders <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define OUROBOROS_PREFIX "pff"
+
+#include <ouroboros/config.h>
+#include <ouroboros/logs.h>
+#include <ouroboros/hashtable.h>
+#include <ouroboros/errno.h>
+
+#include <assert.h>
+#include <pthread.h>
+
+#include "pff.h"
+
+struct pff {
+        struct htable * table;
+        pthread_mutex_t lock;
+};
+
+struct pff * pff_create(void)
+{
+        struct pff * tmp;
+
+        tmp = malloc(sizeof(*tmp));
+        if (tmp == NULL)
+                return NULL;
+
+        tmp->table = htable_create(PFT_SIZE, false);
+        if (tmp->table == NULL) {
+                free(tmp);
+                return NULL;
+        }
+
+        pthread_mutex_init(&tmp->lock, NULL);
+
+        return tmp;
+}
+
+int pff_destroy(struct pff * instance)
+{
+        assert(instance);
+
+        htable_destroy(instance->table);
+        pthread_mutex_destroy(&instance->lock);
+        free(instance);
+
+        return 0;
+}
+
+int pff_add(struct pff * instance, uint64_t addr, int fd)
+{
+        int * val;
+
+        assert(instance);
+
+        val = malloc(sizeof(*val));
+        if (val == NULL)
+                return -ENOMEM;
+        *val = fd;
+
+        pthread_mutex_lock(&instance->lock);
+        if (htable_insert(instance->table, addr, val)) {
+                pthread_mutex_unlock(&instance->lock);
+                free(val);
+                return -1;
+        }
+        pthread_mutex_unlock(&instance->lock);
+
+        return 0;
+}
+
+int pff_update(struct pff * instance, uint64_t addr, int fd)
+{
+        int * val;
+
+        assert(instance);
+
+        val = malloc(sizeof(*val));
+        if (val == NULL)
+                return -ENOMEM;
+        *val = fd;
+
+        pthread_mutex_lock(&instance->lock);
+        if (htable_delete(instance->table, addr)) {
+                pthread_mutex_unlock(&instance->lock);
+                free(val);
+                return -1;
+        }
+
+        if (htable_insert(instance->table, addr, val)) {
+                pthread_mutex_unlock(&instance->lock);
+                free(val);
+                return -1;
+        }
+        pthread_mutex_unlock(&instance->lock);
+
+        return 0;
+}
+
+int pff_remove(struct pff * instance, uint64_t addr)
+{
+        assert(instance);
+
+        pthread_mutex_lock(&instance->lock);
+        if (htable_delete(instance->table, addr)) {
+                pthread_mutex_unlock(&instance->lock);
+                return -1;
+        }
+        pthread_mutex_unlock(&instance->lock);
+
+        return 0;
+}
+
+int pff_nhop(struct pff * instance, uint64_t addr)
+{
+        int * j;
+        int   fd;
+
+        assert(instance);
+
+        pthread_mutex_lock(&instance->lock);
+        j = (int *) htable_lookup(instance->table, addr);
+        if (j == NULL) {
+                pthread_mutex_unlock(&instance->lock);
+                return -1;
+        }
+        fd = *j;
+        pthread_mutex_unlock(&instance->lock);
+
+        return fd;
+}
diff --git a/src/ipcpd/normal/pff.h b/src/ipcpd/normal/pff.h
new file mode 100644
index 00000000..b9ea1971
--- /dev/null
+++ b/src/ipcpd/normal/pff.h
@@ -0,0 +1,55 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * PDU Forwarding Function
+ *
+ *    Sander Vrijders   <[email protected]>
+ *    Dimitri Staessens <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef OUROBOROS_IPCPD_NORMAL_PFF_H
+#define OUROBOROS_IPCPD_NORMAL_PFF_H
+
+#include <stdint.h>
+
+struct pff;
+
+/*
+ * PFF will take a type in the future,
+ * to allow different policies.
+ * Only 1 fd per next hop for now.
+ */
+struct pff * pff_create(void);
+
+int          pff_destroy(struct pff * instance);
+
+int          pff_add(struct pff * instance,
+                     uint64_t     addr,
+                     int          fd);
+
+int          pff_update(struct pff * instance,
+                        uint64_t     addr,
+                        int          fd);
+
+int          pff_remove(struct pff * instance,
+                        uint64_t     addr);
+
+/* Returns fd towards next hop */
+int          pff_nhop(struct pff * instance,
+                      uint64_t     addr);
+
+#endif /* OUROBOROS_IPCPD_NORMAL_PFF_H */