irmd: reg/unreg whatevercast names

Unregistering ap's now works. An AP now registers/unregisters its AP-I
by sending its AP name and its pid to the IRMd. The IPCPs register
whatevercast names. An AP name is currently mapped on a whatevercast
name represented by the same string literal.  The IRMd allows
registration of only one AP-I per AP. A Name Space Management system
is needed in the processing system so we can resolve this completely.

Changing the stack to register whatevercast names required some changes
all over the ipcpd implemented and in the library.

11 files changed, 443 insertions, 258 deletions

diff --git a/src/ipcpd/ipcp-data.c b/src/ipcpd/ipcp-data.c
index 1828fda9..e6997e3e 100644
--- a/src/ipcpd/ipcp-data.c
+++ b/src/ipcpd/ipcp-data.c
@@ -35,8 +35,7 @@
 
 struct reg_entry {
         struct list_head list;
-        char *           ap_name;
-        uint32_t         reg_ap_id;
+        char *           name;
 };
 
 struct dir_entry {
@@ -45,16 +44,14 @@ struct dir_entry {
         uint64_t   addr;
 };
 
-static struct reg_entry * reg_entry_create(const char * ap_name,
-                                           uint32_t     reg_ap_id)
+static struct reg_entry * reg_entry_create(const char * name)
 {
         struct reg_entry * entry = malloc(sizeof *entry);
         if (entry == NULL)
                 return NULL;
 
-        entry->reg_ap_id = reg_ap_id;
-        entry->ap_name = strdup(ap_name);
-        if (entry->ap_name == NULL)
+        entry->name = strdup(name);
+        if (entry->name == NULL)
                 return NULL;
 
         return entry;
@@ -65,7 +62,7 @@ static void reg_entry_destroy(struct reg_entry * entry)
         if (entry == NULL)
                 return;
 
-        free(entry->ap_name);
+        free(entry->name);
         free(entry);
 }
 
@@ -194,25 +191,12 @@ void ipcp_data_destroy(struct ipcp_data * data)
 
 
 static struct reg_entry * find_reg_entry_by_name(struct ipcp_data * data,
-                                                 const char *       ap_name)
+                                                 const char *       name)
 {
         struct list_head * h;
         list_for_each(h, &data->registry) {
                 struct reg_entry * e = list_entry(h, struct reg_entry, list);
-                if (!strcmp(e->ap_name, ap_name))
-                        return e;
-        }
-
-        return NULL;
-}
-
-static struct reg_entry * find_reg_entry_by_id(struct ipcp_data * data,
-                                               uint32_t           reg_ap_id)
-{
-        struct list_head * h;
-        list_for_each(h, &data->registry) {
-                struct reg_entry * e = list_entry(h, struct reg_entry, list);
-                if (e->reg_ap_id == reg_ap_id)
+                if (!strcmp(e->name, name))
                         return e;
         }
 
@@ -253,7 +237,7 @@ bool ipcp_data_is_in_directory(struct ipcp_data * data,
 }
 
 int ipcp_data_del_reg_entry(struct ipcp_data * data,
-                            uint32_t           reg_ap_id)
+                            const char *       name)
 {
         struct reg_entry * e;
         if (data == NULL)
@@ -261,7 +245,7 @@ int ipcp_data_del_reg_entry(struct ipcp_data * data,
 
         pthread_mutex_lock(&data->reg_lock);
 
-        e = find_reg_entry_by_id(data, reg_ap_id);
+        e = find_reg_entry_by_name(data, name);
         if (e == NULL) {
                 pthread_mutex_unlock(&data->reg_lock);
                 return 0; /* nothing to do */
@@ -302,23 +286,21 @@ int ipcp_data_del_dir_entry(struct ipcp_data * data,
 }
 
 int ipcp_data_add_reg_entry(struct ipcp_data * data,
-                            char *             ap_name,
-                            uint32_t           reg_ap_id)
+                            const char *       name)
 {
         struct reg_entry * entry;
 
-        if (data == NULL || ap_name == NULL)
+        if (data == NULL || name == NULL)
                 return -1;
 
         pthread_mutex_lock(&data->reg_lock);
 
-        if (find_reg_entry_by_name(data, ap_name) ||
-            find_reg_entry_by_id(data, reg_ap_id)) {
+        if (find_reg_entry_by_name(data, name)) {
                 pthread_mutex_unlock(&data->reg_lock);
                 return -2;
         }
 
-        entry = reg_entry_create(ap_name, reg_ap_id);
+        entry = reg_entry_create(name);
         if (entry == NULL) {
                 pthread_mutex_unlock(&data->reg_lock);
                 return -1;
@@ -332,7 +314,7 @@ int ipcp_data_add_reg_entry(struct ipcp_data * data,
 }
 
 int ipcp_data_add_dir_entry(struct ipcp_data * data,
-                            char *             ap_name,
+                            const char *       ap_name,
                             uint64_t           addr)
 {
         struct dir_entry * entry;
@@ -366,54 +348,6 @@ bool ipcp_data_is_in_registry(struct ipcp_data * data,
         return find_reg_entry_by_name(data, ap_name) != NULL;
 }
 
-uint32_t ipcp_data_get_reg_ap_id(struct ipcp_data * data,
-                                 const char *       ap_name)
-{
-        struct reg_entry * entry;
-        uint32_t id;
-
-        pthread_mutex_lock(&data->reg_lock);
-
-        entry = find_reg_entry_by_name(data, ap_name);
-
-        if (entry == NULL) {
-                pthread_mutex_unlock(&data->reg_lock);
-                return 0; /* undefined behaviour */
-        }
-
-        id = entry->reg_ap_id;
-
-        pthread_mutex_unlock(&data->reg_lock);
-
-        return id;
-}
-
-const char * ipcp_data_get_reg_ap_name(struct ipcp_data * data,
-                                   uint32_t           reg_ap_id)
-{
-        struct reg_entry * entry;
-        char * name;
-
-        pthread_mutex_lock(&data->reg_lock);
-
-        entry = find_reg_entry_by_id(data, reg_ap_id);
-
-        if (entry == NULL) {
-                pthread_mutex_unlock(&data->reg_lock);
-                return NULL;
-        }
-
-        name = strdup(entry->ap_name);
-        if (name == NULL) {
-                pthread_mutex_unlock(&data->reg_lock);
-                return NULL;
-        }
-
-        pthread_mutex_unlock(&data->reg_lock);
-
-        return name;
-}
-
 uint64_t ipcp_data_get_addr(struct ipcp_data * data,
                             const char *       ap_name)
 {
diff --git a/src/ipcpd/ipcp-data.h b/src/ipcpd/ipcp-data.h
index 3f036ef5..7e48df24 100644
--- a/src/ipcpd/ipcp-data.h
+++ b/src/ipcpd/ipcp-data.h
@@ -58,22 +58,17 @@ struct ipcp_data * ipcp_data_init(struct ipcp_data * dst,
 void               ipcp_data_destroy(struct ipcp_data * data);
 
 int          ipcp_data_add_reg_entry(struct ipcp_data * data,
-                                     char *             ap_name,
-                                     uint32_t           reg_ap_id);
+                                     const char *       name);
 int          ipcp_data_del_reg_entry(struct ipcp_data * data,
-                                     uint32_t           reg_ap_id);
+                                     const char *       name);
 int          ipcp_data_add_dir_entry(struct ipcp_data * data,
-                                     char *             ap_name,
+                                     const char *       ap_name,
                                      uint64_t           addr);
 int          ipcp_data_del_dir_entry(struct ipcp_data * data,
                                      const char *       ap_name,
                                      uint64_t           addr);
 bool         ipcp_data_is_in_registry(struct ipcp_data * data,
-                                      const char *       ap_name);
-uint32_t     ipcp_data_get_reg_ap_id(struct ipcp_data * data,
-                                     const char *       ap_name);
-const char * ipcp_data_get_reg_ap_name(struct ipcp_data * data,
-                                       uint32_t           reg_ap_id);
+                                      const char *       name);
 bool         ipcp_data_is_in_directory(struct ipcp_data * data,
                                        const char *       ap_name);
 uint64_t     ipcp_data_get_addr(struct ipcp_data * data,
diff --git a/src/ipcpd/ipcp-ops.h b/src/ipcpd/ipcp-ops.h
index 5c917229..2ccb2e59 100644
--- a/src/ipcpd/ipcp-ops.h
+++ b/src/ipcpd/ipcp-ops.h
@@ -36,9 +36,8 @@ struct ipcp_ops {
                            size_t len);
         int   (* ipcp_unreg)(char ** dif_names,
                              size_t len);
-        int   (* ipcp_ap_reg)(char *   ap_name,
-                              uint32_t reg_ap_id);
-        int   (* ipcp_ap_unreg)(uint32_t reg_ap_id);
+        int   (* ipcp_name_reg)(char *   name);
+        int   (* ipcp_name_unreg)(char * name);
         int   (* ipcp_flow_alloc)(uint32_t port_id,
                                   char *   dst_ap_name,
                                   char *   src_ap_name,
diff --git a/src/ipcpd/ipcp.c b/src/ipcpd/ipcp.c
index e0dac20b..c1071e05 100644
--- a/src/ipcpd/ipcp.c
+++ b/src/ipcpd/ipcp.c
@@ -151,23 +151,23 @@ int ipcp_main_loop(struct ipcp * _ipcp)
                         ret_msg.result = _ipcp->ops->ipcp_unreg(
                                 msg->dif_names, msg->len);
                         break;
-                case IPCP_MSG_CODE__IPCP_AP_REG:
-                        if (_ipcp->ops->ipcp_ap_reg == NULL) {
+                case IPCP_MSG_CODE__IPCP_NAME_REG:
+                        if (_ipcp->ops->ipcp_name_reg == NULL) {
                                 LOG_ERR("Ap_reg unsupported.");
                                 break;
                         }
                         ret_msg.has_result = true;
-                        ret_msg.result = _ipcp->ops->ipcp_ap_reg(
-                                msg->ap_name, msg->reg_ap_id);
+                        ret_msg.result = _ipcp->ops->ipcp_name_reg(
+                                msg->name);
                         break;
-                case IPCP_MSG_CODE__IPCP_AP_UNREG:
-                        if (_ipcp->ops->ipcp_ap_unreg == NULL) {
+                case IPCP_MSG_CODE__IPCP_NAME_UNREG:
+                        if (_ipcp->ops->ipcp_name_unreg == NULL) {
                                 LOG_ERR("Ap_unreg unsupported.");
                                 break;
                         }
                         ret_msg.has_result = true;
-                        ret_msg.result = _ipcp->ops->ipcp_ap_unreg(
-                                msg->reg_ap_id);
+                        ret_msg.result = _ipcp->ops->ipcp_name_unreg(
+                                msg->name);
                         break;
                 case IPCP_MSG_CODE__IPCP_FLOW_ALLOC:
                         if (_ipcp->ops->ipcp_flow_alloc == NULL) {
@@ -177,9 +177,9 @@ int ipcp_main_loop(struct ipcp * _ipcp)
                         ret_msg.has_fd = true;
                         ret_msg.fd = _ipcp->ops->ipcp_flow_alloc(
                                 msg->port_id,
-                                msg->dst_ap_name,
-                                msg->ap_name,
-                                msg->ae_name,
+                                msg->dst_name,
+                                msg->src_ap_name,
+                                msg->src_ae_name,
                                 NULL);
                         break;
                 case IPCP_MSG_CODE__IPCP_FLOW_ALLOC_RESP:
diff --git a/src/ipcpd/shim-udp/main.c b/src/ipcpd/shim-udp/main.c
index 14b08ba8..a65aa11d 100644
--- a/src/ipcpd/shim-udp/main.c
+++ b/src/ipcpd/shim-udp/main.c
@@ -214,8 +214,7 @@ static void * ipcp_udp_listener()
                 msg.code = IRM_MSG_CODE__IPCP_FLOW_REQ_ARR;
                 msg.ap_name = ANONYMOUS_AP;
                 msg.ae_name = ""; /* no AE */
-                msg.has_reg_ap_id = true;
-                msg.reg_ap_id = ipcp_data_get_reg_ap_id(_ipcp->data, buf);
+                msg.dst_name = buf;
 
                 ret_msg = send_recv_irm_msg(&msg);
                 if (ret_msg == NULL) {
@@ -247,8 +246,9 @@ static void * ipcp_udp_listener()
 
                 FD_SET(flow->fd, &shim_data(_ipcp)->flow_fd_s);
                 shim_data(_ipcp)->fd_to_flow_ptr[flow->fd] = &flow->flow;
-
         }
+
+        return 0;
 }
 
 static void * ipcp_udp_sdu_reader()
@@ -364,19 +364,19 @@ int ipcp_udp_bootstrap(struct dif_config * conf)
         return 0;
 }
 
-int ipcp_udp_ap_reg(char * ap_name, uint32_t reg_ap_id)
+int ipcp_udp_name_reg(char * name)
 {
         if (_ipcp->state != IPCP_ENROLLED) {
                 LOG_DBGF("Won't register with non-enrolled IPCP.");
                 return -1;
         }
 
-        if (ipcp_data_add_reg_entry(_ipcp->data, ap_name, reg_ap_id)) {
-                LOG_ERR("Failed to add AP to local registry.");
+        if (ipcp_data_add_reg_entry(_ipcp->data, name)) {
+                LOG_ERR("Failed to add %s to local registry.", name);
                 return -1;
         }
 
-        LOG_DBG("Registered local ap %s, %u.", ap_name, reg_ap_id);
+        LOG_DBG("Registered %s", name);
 
         /* FIXME: register application with DNS server */
         LOG_MISSING;
@@ -384,9 +384,11 @@ int ipcp_udp_ap_reg(char * ap_name, uint32_t reg_ap_id)
         return 0;
 }
 
-int ipcp_udp_ap_unreg(uint32_t reg_ap_id)
+int ipcp_udp_name_unreg(char * name)
 {
-        ipcp_data_del_reg_entry(_ipcp->data, reg_ap_id);
+        ipcp_data_del_reg_entry(_ipcp->data, name);
+
+        LOG_DBG("Unregistered %s.", name);
 
         /* FIXME: unregister application from DNS server */
         LOG_MISSING;
@@ -573,8 +575,8 @@ struct ipcp * ipcp_udp_create(char * ap_name, char * i_id)
         ops->ipcp_enroll          = NULL;                       /* shim */
         ops->ipcp_reg             = NULL;                       /* shim */
         ops->ipcp_unreg           = NULL;                       /* shim */
-        ops->ipcp_ap_reg          = ipcp_udp_ap_reg;
-        ops->ipcp_ap_unreg        = ipcp_udp_ap_unreg;
+        ops->ipcp_name_reg        = ipcp_udp_name_reg;
+        ops->ipcp_name_unreg      = ipcp_udp_name_unreg;
         ops->ipcp_flow_alloc      = ipcp_udp_flow_alloc;
         ops->ipcp_flow_alloc_resp = ipcp_udp_flow_alloc_resp;
         ops->ipcp_flow_dealloc    = ipcp_udp_flow_dealloc;
diff --git a/src/ipcpd/shim-udp/tests/shim_udp_test.c b/src/ipcpd/shim-udp/tests/shim_udp_test.c
index 427d0e1e..0fcf9f4d 100644
--- a/src/ipcpd/shim-udp/tests/shim_udp_test.c
+++ b/src/ipcpd/shim-udp/tests/shim_udp_test.c
@@ -68,21 +68,21 @@ int shim_udp_test(int argc, char ** argv)
                 LOG_ERR("Could not bootstrap.");
         }
 
-        if(ipcp_udp_ap_reg("bogus ap", 1865)) {
+        if(ipcp_udp_name_reg("bogus name")) {
                 LOG_ERR("Failed to register application.");
                 shm_du_map_close(dum);
                 exit(1);
         }
 
-        if (ipcp_udp_ap_unreg(1865)) {
+        if (ipcp_udp_name_unreg("bogus name")) {
                 LOG_ERR("Failed to unregister application.");
                 shm_du_map_close(dum);
                 exit(1);
         }
 
         for (i = 0; i  < 1000; ++i) {
-                sprintf (bogus, "bogus ap %4d", i);
-                if(ipcp_udp_ap_reg(bogus, i)) {
+                sprintf (bogus, "bogus name %4d", i);
+                if(ipcp_udp_name_reg(bogus)) {
                          LOG_ERR("Failed to register application %s.", bogus);
                          shm_du_map_close(dum);
                          exit(1);
@@ -90,8 +90,9 @@ int shim_udp_test(int argc, char ** argv)
         }
 
         for (i = 0; i  < 1000; ++i) {
-                if(ipcp_udp_ap_unreg(i)) {
-                         LOG_ERR("Failed to unregister application %d.", i);
+                sprintf (bogus, "bogus name %4d", i);
+                if(ipcp_udp_name_unreg(bogus)) {
+                         LOG_ERR("Failed to unregister application %s.", bogus);
                          shm_du_map_close(dum);
                          exit(1);
                 }
diff --git a/src/irmd/main.c b/src/irmd/main.c
index 374bfb6c..fcd93bd5 100644
--- a/src/irmd/main.c
+++ b/src/irmd/main.c
@@ -41,6 +41,10 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
+#include <limits.h>
+
+/* FIXME: this smells like part of namespace management */
+#define ALL_DIFS "*"
 
 struct ipcp_entry {
         struct list_head  next;
@@ -49,12 +53,27 @@ struct ipcp_entry {
         char *            dif_name;
 };
 
+/* currently supports only registering whatevercast groups of a single AP */
+struct reg_name_entry {
+        struct list_head next;
+
+        /* generic whatevercast name */
+        char *             name;
+
+        /* FIXME: resolve name instead */
+        instance_name_t  * api;
+        uint32_t           reg_ap_id;
+};
+
 struct irm {
+        /* FIXME: list of ipcps can be merged with registered names */
         struct list_head ipcps;
+        struct list_head reg_names;
+
+        struct shm_du_map * dum;
 };
 
 struct irm * instance = NULL;
-struct shm_du_map * dum;
 
 static pid_t find_pid_by_ipcp_name(instance_name_t * api)
 {
@@ -105,6 +124,101 @@ static pid_t find_pid_by_dif_name(char * dif_name)
         return 0;
 }
 
+static struct reg_name_entry * reg_name_entry_create()
+{
+        struct reg_name_entry * e = malloc(sizeof(*e));
+        if (e == NULL)
+                return NULL;
+
+        e->reg_ap_id = rand() % INT_MAX;
+        e->name  = NULL;
+
+        INIT_LIST_HEAD(&e->next);
+
+        return e;
+}
+
+static struct reg_name_entry * reg_name_entry_init(struct reg_name_entry * e,
+                                                   char *                  name,
+                                                   instance_name_t       * api)
+{
+        if (e == NULL || name == NULL || api == NULL)
+                return NULL;
+
+        e->name = name;
+        e->api  = api;
+
+        return e;
+}
+
+static int reg_name_entry_destroy(struct reg_name_entry * e)
+{
+        if (e == NULL)
+                return 0;
+
+        free(e->name);
+        instance_name_destroy(e->api);
+        return 0;
+}
+
+static struct reg_name_entry * find_reg_name_entry_by_name(char * name)
+{
+        struct list_head * pos = NULL;
+
+        list_for_each(pos, &instance->reg_names) {
+                struct reg_name_entry * e =
+                        list_entry(pos, struct reg_name_entry, next);
+
+                if (strcmp(name, e->name) == 0)
+                        return e;
+        }
+
+        return NULL;
+}
+
+static struct reg_name_entry * find_reg_name_entry_by_id(uint32_t reg_ap_id)
+{
+        struct list_head * pos = NULL;
+
+        list_for_each(pos, &instance->reg_names) {
+                struct reg_name_entry * e =
+                        list_entry(pos, struct reg_name_entry, next);
+
+                if (reg_ap_id == e->reg_ap_id)
+                        return e;
+        }
+
+        return NULL;
+}
+
+/* FIXME: add only name when we have NSM solved */
+static int reg_name_entry_add_name_instance(char * name, instance_name_t * api)
+{
+        struct reg_name_entry * e = find_reg_name_entry_by_name(name);
+        if (e == NULL) {
+                e = reg_name_entry_create();
+                e = reg_name_entry_init(e, name, api);
+                list_add(&e->next, &instance->reg_names);
+                return 0;
+        }
+
+        /* already exists, we don't have NSM yet */
+        return -1;
+}
+
+static int reg_name_entry_del_name(char * name)
+{
+        struct reg_name_entry * e = find_reg_name_entry_by_name(name);
+        if (e == NULL)
+                return 0;
+
+        list_del(&e->next);
+
+        reg_name_entry_destroy(e);
+
+        return 0;
+}
+
 static int create_ipcp(instance_name_t * api,
                        enum ipcp_type    ipcp_type)
 {
@@ -280,54 +394,161 @@ static int unreg_ipcp(instance_name_t  * api,
         return 0;
 }
 
-static int ap_reg(char * ap_name,
+static int ap_unreg_id(uint32_t reg_ap_id,
+                       pid_t    pid,
+                       char **  difs,
+                       size_t   len)
+{
+        int i;
+        int ret = 0;
+        struct reg_name_entry * rne    = NULL;
+        struct list_head      * pos  = NULL;
+
+        rne = find_reg_name_entry_by_id (reg_ap_id);
+        if (rne == NULL)
+                return 0; /* no such id */
+
+        if (instance->ipcps.next == NULL) {
+                LOG_ERR("No IPCPs in this system.");
+                return 0;
+        }
+
+        if (strcmp(difs[0], ALL_DIFS) == 0) {
+                  list_for_each(pos, &instance->ipcps) {
+                        struct ipcp_entry * e =
+                                list_entry(pos, struct ipcp_entry, next);
+
+                        if (ipcp_name_unreg(e->pid, rne->name)) {
+                                LOG_ERR("Could not unregister %s in DIF %s.",
+                                        rne->name, e->dif_name);
+                                --ret;
+                        }
+                }
+        } else {
+                for (i = 0; i < len; ++i) {
+                        pid = find_pid_by_dif_name(difs[i]);
+                        if (pid == 0) {
+                                LOG_ERR("%s: No such DIF.", difs[i]);
+                                continue;
+                        }
+
+                        if (ipcp_name_unreg(pid, rne->name)) {
+                                LOG_ERR("Could not unregister %s in DIF %s.",
+                                        rne->name, difs[i]);
+                                --ret;
+                        }
+                }
+        }
+
+        reg_name_entry_del_name(rne->name);
+
+        return ret;
+}
+
+static int ap_reg(char *  ap_name,
+                  pid_t   ap_id,
                   char ** difs,
-                  size_t difs_size)
+                  size_t  len)
 {
         pid_t pid = 0;
         int i;
         int ret = 0;
+        int reg_ap_id = 0;
+        struct list_head * pos = NULL;
+        struct reg_name_entry * rne = NULL;
+        instance_name_t * api = NULL;
+
 
         if (instance->ipcps.next == NULL)
                 LOG_ERR("No IPCPs in this system.");
 
+        /* check if this ap_name is already registered */
+        rne = find_reg_name_entry_by_name(ap_name);
+        if (rne != NULL)
+                return -1; /* can only register one instance for now */
+
+        rne = reg_name_entry_create();
+        if (rne == NULL)
+                return -1;
+
+        api = instance_name_create();
+        if (instance_name_init_from(api, ap_name, ap_id) == NULL) {
+                instance_name_destroy(api);
+                return -1;
+        }
+
         /*
-         * FIXME: this should be resolved by NSM
-         * Now it just takes the first DIF
+         * for now, the whatevercast name is the same as the ap_name and
+         * contains a single instance only
          */
 
-        if (strcmp(difs[0], "*") == 0) {
-                difs[0] = list_entry(instance->ipcps.next,
-                                     struct ipcp_entry,
-                                     next)->dif_name;
-                difs_size = 1;
+        if (reg_name_entry_init(rne, strdup(ap_name), api) == NULL) {
+                reg_name_entry_destroy(rne);
+                instance_name_destroy(api);
+                return -1;
         }
 
-        for (i = 0; i < difs_size; ++i) {
-                pid = find_pid_by_dif_name(difs[i]);
-                if (pid == 0) {
-                        LOG_ERR("%s: No such DIF.", difs[i]);
-                        continue;
+        if (strcmp(difs[0], ALL_DIFS) == 0) {
+                list_for_each(pos, &instance->ipcps) {
+                        struct ipcp_entry * e =
+                                list_entry(pos, struct ipcp_entry, next);
+
+                        if (ipcp_name_reg(e->pid, api->name)) {
+                                LOG_ERR("Could not register %s in DIF %s.",
+                                        api->name, e->dif_name);
+                        } else {
+                                ++ret;
+                        }
                 }
-
-                /* FIXME: get proper reg_ap_id */
-                if (ipcp_ap_reg(pid, rand(),ap_name)) {
-                        LOG_ERR("Could not register %s in DIF %s.",
-                                ap_name, difs[i]);
-                        ret = -1;
+        } else {
+                for (i = 0; i < len; ++i) {
+                        pid = find_pid_by_dif_name(difs[i]);
+                        if (pid == 0) {
+                                LOG_ERR("%s: No such DIF.", difs[i]);
+                                continue;
+                        }
+
+                        if (ipcp_name_reg(pid, api->name)) {
+                                LOG_ERR("Could not register %s in DIF %s.",
+                                        api->name, difs[i]);
+                        } else {
+                                ++ret;
+                        }
                 }
         }
 
-        return ret;
+        if (ret ==  0) {
+                instance_name_destroy(api);
+                return -1;
+        }
+        /* for now, we register single instances */
+        reg_name_entry_add_name_instance(strdup(ap_name), instance_name_dup(api));
+
+        return reg_ap_id;
 }
 
-static int ap_unreg(char * ap_name,
+static int ap_unreg(char *  ap_name,
+                    pid_t   ap_id,
                     char ** difs,
-                    size_t difs_size)
+                    size_t  len)
 {
-        return -1;
+        struct reg_name_entry * tmp = NULL;
+
+        instance_name_t * api = instance_name_create();
+        if (instance_name_init_from(api, ap_name, ap_id) == NULL) {
+                instance_name_destroy(api);
+                return -1;
+        }
+
+        /* check if ap_name is registered */
+        tmp = find_reg_name_entry_by_name(api->name);
+        if (tmp == NULL)
+                return 0;
+        else
+                return ap_unreg_id(tmp->reg_ap_id, api->id, difs, len);
 }
 
+
 static int flow_accept(int fd,
                        char * ap_name,
                        char * ae_name)
@@ -392,7 +613,7 @@ void irmd_sig_handler(int sig, siginfo_t * info, void * c)
         case SIGINT:
         case SIGTERM:
         case SIGHUP:
-                shm_du_map_close(dum);
+                shm_du_map_close(instance->dum);
                 free(instance);
                 exit(0);
         default:
@@ -421,14 +642,15 @@ int main()
         if (access("/dev/shm/" SHM_DU_MAP_FILENAME, F_OK) != -1)
                 unlink("/dev/shm/" SHM_DU_MAP_FILENAME);
 
-        if ((dum = shm_du_map_create()) == NULL)
-                return -1;
-
         instance = malloc(sizeof(*instance));
         if (instance == NULL)
                 return -1;
 
+        if ((instance->dum = shm_du_map_create()) == NULL)
+                return -1;
+
         INIT_LIST_HEAD(&instance->ipcps);
+        INIT_LIST_HEAD(&instance->reg_names);
 
         sockfd = server_socket_open(IRM_SOCK_PATH);
         if (sockfd < 0) {
@@ -502,12 +724,14 @@ int main()
                 case IRM_MSG_CODE__IRM_AP_REG:
                         ret_msg.has_fd = true;
                         ret_msg.fd = ap_reg(msg->ap_name,
+                                            msg->pid,
                                             msg->dif_name,
                                             msg->n_dif_name);
                         break;
                 case IRM_MSG_CODE__IRM_AP_UNREG:
                         ret_msg.has_result = true;
                         ret_msg.result = ap_unreg(msg->ap_name,
+                                                  msg->pid,
                                                   msg->dif_name,
                                                   msg->n_dif_name);
                         break;
@@ -524,7 +748,7 @@ int main()
                         break;
                 case IRM_MSG_CODE__IRM_FLOW_ALLOC:
                         ret_msg.has_fd = true;
-                        ret_msg.fd = flow_alloc(msg->dst_ap_name,
+                        ret_msg.fd = flow_alloc(msg->dst_name,
                                                 msg->ap_name,
                                                 msg->ae_name,
                                                 NULL,
diff --git a/src/lib/dev.c b/src/lib/dev.c
index c138b009..60dee701 100644
--- a/src/lib/dev.c
+++ b/src/lib/dev.c
@@ -43,9 +43,11 @@ int ap_reg(char * ap_name,
                 return -EINVAL;
         }
 
-        msg.code = IRM_MSG_CODE__IRM_AP_REG;
-        msg.ap_name = ap_name;
-        msg.dif_name = difs;
+        msg.code       = IRM_MSG_CODE__IRM_AP_REG;
+        msg.has_pid    = true;
+        msg.pid        = getpid();
+        msg.ap_name    = ap_name;
+        msg.dif_name   = difs;
         msg.n_dif_name = difs_size;
 
         recv_msg = send_recv_irm_msg(&msg);
@@ -78,9 +80,11 @@ int ap_unreg(char * ap_name,
                 return -EINVAL;
         }
 
-        msg.code = IRM_MSG_CODE__IRM_AP_UNREG;
-        msg.ap_name = ap_name;
-        msg.dif_name = difs;
+        msg.code       = IRM_MSG_CODE__IRM_AP_UNREG;
+        msg.has_pid    = true;
+        msg.pid        = getpid();
+        msg.ap_name    = ap_name;
+        msg.dif_name   = difs;
         msg.n_dif_name = difs_size;
 
         recv_msg = send_recv_irm_msg(&msg);
@@ -110,9 +114,11 @@ int flow_accept(int fd,
                 return -EINVAL;
         }
 
-        msg.code = IRM_MSG_CODE__IRM_FLOW_ACCEPT;
-        msg.has_fd = true;
-        msg.fd = fd;
+        msg.code    = IRM_MSG_CODE__IRM_FLOW_ACCEPT;
+        msg.has_pid = true;
+        msg.pid     = getpid();
+        msg.has_fd  = true;
+        msg.fd      = fd;
 
         recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL)
@@ -122,7 +128,7 @@ int flow_accept(int fd,
                 irm_msg__free_unpacked(recv_msg, NULL);
                 return -1;
         }
-        cli_fd = recv_msg->fd;
+        cli_fd  = recv_msg->fd;
         ap_name = recv_msg->ap_name;
         ae_name = recv_msg->ae_name;
 
@@ -131,17 +137,19 @@ int flow_accept(int fd,
 }
 
 int flow_alloc_resp(int fd,
-                    int result)
+                    int response)
 {
         irm_msg_t msg = IRM_MSG__INIT;
         irm_msg_t * recv_msg = NULL;
         int ret = -1;
 
-        msg.code = IRM_MSG_CODE__IRM_FLOW_ALLOC_RESP;
-        msg.has_fd = true;
+        msg.code         = IRM_MSG_CODE__IRM_FLOW_ALLOC_RESP;
+        msg.has_pid      = true;
+        msg.pid          = getpid();
+        msg.has_fd       = true;
         msg.fd = fd;
-        msg.has_result = true;
-        msg.result = result;
+        msg.has_response = true;
+        msg.response     = response;
 
         recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL)
@@ -158,7 +166,7 @@ int flow_alloc_resp(int fd,
         return ret;
 }
 
-int flow_alloc(char * dst_ap_name,
+int flow_alloc(char * dst_name,
                char * src_ap_name,
                char * src_ae_name,
                struct qos_spec * qos,
@@ -168,18 +176,18 @@ int flow_alloc(char * dst_ap_name,
         irm_msg_t * recv_msg = NULL;
         int fd = 0;
 
-        if (dst_ap_name == NULL ||
+        if (dst_name == NULL ||
             src_ap_name == NULL ||
             qos == NULL) {
                 return -EINVAL;
         }
 
-        msg.code = IRM_MSG_CODE__IRM_FLOW_ALLOC;
-        msg.dst_ap_name = dst_ap_name;
-        msg.ap_name = src_ap_name;
-        msg.ae_name = src_ae_name;
-        msg.has_oflags = true;
-        msg.oflags = oflags;
+        msg.code        = IRM_MSG_CODE__IRM_FLOW_ALLOC;
+        msg.dst_name    = dst_name;
+        msg.ap_name     = src_ap_name;
+        msg.ae_name     = src_ae_name;
+        msg.has_oflags  = true;
+        msg.oflags      = oflags;
 
         recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL)
@@ -201,9 +209,11 @@ int flow_alloc_res(int fd)
         irm_msg_t * recv_msg = NULL;
         int result = 0;
 
-        msg.code = IRM_MSG_CODE__IRM_FLOW_ALLOC_RES;
-        msg.has_fd = true;
-        msg.fd = fd;
+        msg.code    = IRM_MSG_CODE__IRM_FLOW_ALLOC_RES;
+        msg.has_pid = true;
+        msg.pid     = getpid();
+        msg.has_fd  = true;
+        msg.fd      = fd;
 
         recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL)
@@ -226,9 +236,11 @@ int flow_dealloc(int fd)
         irm_msg_t * recv_msg = NULL;
         int ret = -1;
 
-        msg.code = IRM_MSG_CODE__IRM_FLOW_DEALLOC;
-        msg.has_fd = true;
-        msg.fd = fd;
+        msg.code    = IRM_MSG_CODE__IRM_FLOW_DEALLOC;
+        msg.has_pid = true;
+        msg.pid     = getpid();
+        msg.has_fd  = true;
+        msg.fd      = fd;
 
         recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL)
@@ -251,9 +263,11 @@ int flow_cntl(int fd, int oflags)
         irm_msg_t * recv_msg = NULL;
         int ret = -1;
 
-        msg.has_fd = true;
-        msg.fd = fd;
-        msg.oflags = oflags;
+        msg.has_pid = true;
+        msg.pid     = getpid();
+        msg.has_fd  = true;
+        msg.fd      = fd;
+        msg.oflags  = oflags;
 
         recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL)
diff --git a/src/lib/ipcp.c b/src/lib/ipcp.c
index 338d8683..b93f5488 100644
--- a/src/lib/ipcp.c
+++ b/src/lib/ipcp.c
@@ -326,21 +326,18 @@ int ipcp_enroll(pid_t pid,
         return ret;
 }
 
-int ipcp_ap_reg(pid_t    pid,
-                uint32_t reg_ap_id,
-                char *   ap_name)
+int ipcp_name_reg(pid_t    pid,
+                  char *   name)
 {
         ipcp_msg_t msg = IPCP_MSG__INIT;
         ipcp_msg_t * recv_msg = NULL;
         int ret = -1;
 
-        if (ap_name == NULL)
+        if (name == NULL)
                 return -1;
 
-        msg.code          = IPCP_MSG_CODE__IPCP_AP_REG;
-        msg.ap_name       = ap_name;
-        msg.has_reg_ap_id = true;
-        msg.reg_ap_id     = reg_ap_id;
+        msg.code          = IPCP_MSG_CODE__IPCP_NAME_REG;
+        msg.name          = name;
 
         recv_msg = send_recv_ipcp_msg(pid, &msg);
         if (recv_msg == NULL)
@@ -357,16 +354,15 @@ int ipcp_ap_reg(pid_t    pid,
         return ret;
 }
 
-int ipcp_ap_unreg(pid_t    pid,
-                  uint32_t reg_ap_id)
+int ipcp_name_unreg(pid_t  pid,
+                    char * name)
 {
         ipcp_msg_t msg = IPCP_MSG__INIT;
         ipcp_msg_t * recv_msg = NULL;
         int ret = -1;
 
-        msg.code          = IPCP_MSG_CODE__IPCP_AP_UNREG;
-        msg.has_reg_ap_id = true;
-        msg.reg_ap_id     = reg_ap_id;
+        msg.code = IPCP_MSG_CODE__IPCP_NAME_UNREG;
+        msg.name = name;
 
         recv_msg = send_recv_ipcp_msg(pid, &msg);
         if (recv_msg == NULL)
@@ -385,7 +381,7 @@ int ipcp_ap_unreg(pid_t    pid,
 
 int ipcp_flow_alloc(pid_t             pid,
                     uint32_t          port_id,
-                    char *            dst_ap_name,
+                    char *            dst_name,
                     char *            src_ap_name,
                     char *            src_ae_name,
                     struct qos_spec * qos)
@@ -394,13 +390,13 @@ int ipcp_flow_alloc(pid_t             pid,
         ipcp_msg_t * recv_msg = NULL;
         int ret = -1;
 
-        if (dst_ap_name == NULL || src_ap_name == NULL || src_ae_name == NULL)
+        if (dst_name == NULL || src_ap_name == NULL || src_ae_name == NULL)
                 return -EINVAL;
 
         msg.code        = IPCP_MSG_CODE__IPCP_FLOW_ALLOC;
-        msg.ap_name     = src_ap_name;
-        msg.ae_name     = src_ae_name;
-        msg.dst_ap_name = dst_ap_name;
+        msg.src_ap_name = src_ap_name;
+        msg.src_ae_name = src_ae_name;
+        msg.dst_name    = dst_name;
         msg.port_id     = port_id;
         msg.has_port_id = true;
 
@@ -449,22 +445,21 @@ int ipcp_flow_alloc_resp(pid_t    pid,
 }
 
 int ipcp_flow_req_arr(pid_t    pid,
-                      uint32_t reg_ap_id,
-                      char *   ap_name,
-                      char *   ae_name)
+                      char *   dst_name,
+                      char *   src_ap_name,
+                      char *   src_ae_name)
 {
         irm_msg_t msg = IRM_MSG__INIT;
         irm_msg_t * recv_msg = NULL;
         int fd = -1;
 
-        if (ap_name == NULL || ae_name == NULL)
+        if (src_ap_name == NULL || src_ae_name == NULL)
                 return -EINVAL;
 
         msg.code          = IRM_MSG_CODE__IPCP_FLOW_REQ_ARR;
-        msg.ap_name       = ap_name;
-        msg.ae_name       = ae_name;
-        msg.reg_ap_id     = reg_ap_id;
-        msg.has_reg_ap_id = true;
+        msg.dst_name      = dst_name;
+        msg.ap_name       = src_ap_name;
+        msg.ae_name       = src_ae_name;
         msg.pid           = pid;
         msg.has_pid       = true;
 
@@ -485,17 +480,17 @@ int ipcp_flow_req_arr(pid_t    pid,
 
 int ipcp_flow_alloc_reply(pid_t    pid,
                           uint32_t port_id,
-                          int      result)
+                          int      response)
 {
         irm_msg_t msg = IRM_MSG__INIT;
         irm_msg_t * recv_msg = NULL;
         int ret = -1;
 
-        msg.code        = IRM_MSG_CODE__IPCP_FLOW_ALLOC_REPLY;
-        msg.port_id     = port_id;
-        msg.has_port_id = true;
-        msg.result      = result;
-        msg.has_result  = true;
+        msg.code         = IRM_MSG_CODE__IPCP_FLOW_ALLOC_REPLY;
+        msg.port_id      = port_id;
+        msg.has_port_id  = true;
+        msg.response     = response;
+        msg.has_response = true;
 
         recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL)
@@ -521,9 +516,9 @@ int ipcp_flow_dealloc(pid_t    pid,
                 ipcp_msg_t * recv_msg = NULL;
                 int ret = -1;
 
-                msg.code = IPCP_MSG_CODE__IPCP_FLOW_DEALLOC;
+                msg.code        = IPCP_MSG_CODE__IPCP_FLOW_DEALLOC;
                 msg.has_port_id = true;
-                msg.port_id = port_id;
+                msg.port_id     = port_id;
 
                 recv_msg = send_recv_ipcp_msg(pid, &msg);
                 if (recv_msg == NULL)
@@ -543,9 +538,9 @@ int ipcp_flow_dealloc(pid_t    pid,
                 irm_msg_t * recv_msg = NULL;
                 int ret = -1;
 
-                msg.code = IRM_MSG_CODE__IPCP_FLOW_DEALLOC;
+                msg.code        = IRM_MSG_CODE__IPCP_FLOW_DEALLOC;
                 msg.has_port_id = true;
-                msg.port_id = port_id;
+                msg.port_id     = port_id;
 
                 recv_msg = send_recv_irm_msg(&msg);
                 if (recv_msg == NULL)
diff --git a/src/lib/ipcpd_messages.proto b/src/lib/ipcpd_messages.proto
index 850c64e4..da4bb469 100644
--- a/src/lib/ipcpd_messages.proto
+++ b/src/lib/ipcpd_messages.proto
@@ -1,16 +1,16 @@
 import "dif_config.proto";
 
 enum ipcp_msg_code {
-        IPCP_BOOTSTRAP = 1;
-        IPCP_ENROLL = 2;
-        IPCP_REG = 3;
-        IPCP_UNREG = 4;
-        IPCP_AP_REG = 5;
-        IPCP_AP_UNREG = 6;
-        IPCP_FLOW_ALLOC = 7;
-        IPCP_FLOW_ALLOC_RESP = 8;
-        IPCP_FLOW_DEALLOC = 9;
-        IPCP_REPLY = 10;
+        IPCP_BOOTSTRAP       =  1;
+        IPCP_ENROLL          =  2;
+        IPCP_REG             =  3;
+        IPCP_UNREG           =  4;
+        IPCP_NAME_REG        =  5;
+        IPCP_NAME_UNREG      =  6;
+        IPCP_FLOW_ALLOC      =  7;
+        IPCP_FLOW_ALLOC_RESP =  8;
+        IPCP_FLOW_DEALLOC    =  9;
+        IPCP_REPLY           = 10;
 };
 
 message ipcp_msg {
@@ -19,11 +19,11 @@ message ipcp_msg {
         optional string n_1_dif      =  3;
         repeated string dif_names    =  4;
         optional int32  len          =  5;
-        optional string ap_name      =  6;
-        optional int32 reg_ap_id     =  7;
-        optional int32 port_id       =  8;
-        optional string dst_ap_name  =  9;
-        optional string ae_name      = 10;
+        optional string name         =  6;
+        optional int32 port_id       =  7;
+        optional string dst_name     =  8;
+        optional string src_ap_name  =  9;
+        optional string src_ae_name  = 10;
         optional dif_config_msg conf = 11;
         optional int32 result        = 12;
         optional int32 fd            = 13;
diff --git a/src/lib/irmd_messages.proto b/src/lib/irmd_messages.proto
index d484a007..89e2c882 100644
--- a/src/lib/irmd_messages.proto
+++ b/src/lib/irmd_messages.proto
@@ -1,42 +1,63 @@
+/*
+ * Ouroboros - Copyright (C) 2016
+ *
+ * IRM messages
+ *
+ *    Sander Vrijders <sander.vrijders@intec.ugent.be>
+ *
+ * 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.
+ */
+
 import "dif_config.proto";
 
 enum irm_msg_code {
-        IRM_CREATE_IPCP = 1;
-        IRM_DESTROY_IPCP = 2;
-        IRM_BOOTSTRAP_IPCP = 3;
-        IRM_ENROLL_IPCP = 4;
-        IRM_REG_IPCP = 5;
-        IRM_UNREG_IPCP = 6;
-        IRM_AP_REG = 7;
-        IRM_AP_UNREG = 8;
-        IRM_FLOW_ACCEPT = 9;
-        IRM_FLOW_ALLOC_RESP = 10;
-        IRM_FLOW_ALLOC = 11;
-        IRM_FLOW_ALLOC_RES = 12;
-        IRM_FLOW_DEALLOC = 13;
-        IRM_FLOW_CONTROL = 14;
-        IRM_FLOW_WRITE = 15;
-        IRM_FLOW_READ = 16;
-        IPCP_FLOW_REQ_ARR = 17;
+        IRM_CREATE_IPCP       =  1;
+        IRM_DESTROY_IPCP      =  2;
+        IRM_BOOTSTRAP_IPCP    =  3;
+        IRM_ENROLL_IPCP       =  4;
+        IRM_REG_IPCP          =  5;
+        IRM_UNREG_IPCP        =  6;
+        IRM_AP_REG            =  7;
+        IRM_AP_UNREG          =  8;
+        IRM_FLOW_ACCEPT       =  9;
+        IRM_FLOW_ALLOC_RESP   = 10;
+        IRM_FLOW_ALLOC        = 11;
+        IRM_FLOW_ALLOC_RES    = 12;
+        IRM_FLOW_DEALLOC      = 13;
+        IRM_FLOW_CONTROL      = 14;
+        IRM_FLOW_WRITE        = 15;
+        IRM_FLOW_READ         = 16;
+        IPCP_FLOW_REQ_ARR     = 17;
         IPCP_FLOW_ALLOC_REPLY = 18;
-        IPCP_FLOW_DEALLOC = 19;
-        IRM_REPLY = 20;
+        IPCP_FLOW_DEALLOC     = 19;
+        IRM_REPLY             = 20;
 };
 
 message irm_msg {
         required irm_msg_code code   =  1;
         optional string ap_name      =  2;
-        optional uint32 api_id       =  3;
         optional string ae_name      =  4;
+        optional uint32 api_id       =  3;
         optional uint32 ipcp_type    =  5;
         repeated string dif_name     =  6;
         optional int32 fd            =  7;
         optional int32 response      =  8;
         optional int32 oflags        =  9;
-        optional string dst_ap_name  = 10;
+        optional string dst_name     = 10;
         optional uint32 port_id      = 11;
-        optional uint32 reg_ap_id    = 12;
-        optional int32 pid           = 13;
-        optional dif_config_msg conf = 14;
-        optional int32 result        = 15;
+        optional int32 pid           = 12;
+        optional dif_config_msg conf = 13;
+        optional int32 result        = 14;
 };