summaryrefslogtreecommitdiff
path: root/src/irmd/main.c
diff options
context:
space:
mode:
authordimitri staessens <dimitri.staessens@intec.ugent.be>2016-04-01 15:01:51 +0200
committerdimitri staessens <dimitri.staessens@intec.ugent.be>2016-04-01 15:01:51 +0200
commit65591e5211fb3c44450c52d7534918902e0760d5 (patch)
treeb3f21e0bdb9cf0e773962db73be041bb86d0ee44 /src/irmd/main.c
parent3d859bb9a75932a6cffdd37466d510b479c9aa71 (diff)
parent0e1aeba4f2d2de3ce827bfaeb1d9f2480e628529 (diff)
downloadouroboros-65591e5211fb3c44450c52d7534918902e0760d5.tar.gz
ouroboros-65591e5211fb3c44450c52d7534918902e0760d5.zip
Merge branch 'be' of bitbucket.org:ouroboros-rina/ouroboros into be-build
Diffstat (limited to 'src/irmd/main.c')
-rw-r--r--src/irmd/main.c385
1 files changed, 275 insertions, 110 deletions
diff --git a/src/irmd/main.c b/src/irmd/main.c
index 622b367d..0256248b 100644
--- a/src/irmd/main.c
+++ b/src/irmd/main.c
@@ -29,7 +29,7 @@
#include <ouroboros/ipcp.h>
#include <ouroboros/da.h>
#include <ouroboros/list.h>
-#include <ouroboros/rina_name.h>
+#include <ouroboros/instance_name.h>
#include <sys/socket.h>
#include <sys/un.h>
@@ -37,17 +37,18 @@
#include <errno.h>
struct name_to_pid_entry {
- struct list_head next;
- pid_t pid;
- rina_name_t * name;
+ struct list_head next;
+ pid_t pid;
+ instance_name_t * api;
};
struct irm {
struct list_head name_to_pid;
};
-static pid_t find_pid_by_name(struct irm * instance,
- rina_name_t * name)
+struct irm * instance = NULL;
+
+static pid_t find_pid_by_name(instance_name_t * api)
{
struct list_head * pos;
@@ -55,57 +56,56 @@ static pid_t find_pid_by_name(struct irm * instance,
struct name_to_pid_entry * tmp =
list_entry(pos, struct name_to_pid_entry, next);
- LOG_DBG("name is %s", name->ap_name);
+ LOG_DBG("name is %s", api->name);
- if (name_is_equal(name, tmp->name))
+ if (instance_name_cmp(api, tmp->api) == 0)
return tmp->pid;
}
return 0;
}
-static void create_ipcp(struct irm * instance,
- rina_name_t name,
- char * ipcp_type)
+static int create_ipcp(instance_name_t * api,
+ char * ipcp_type)
{
pid_t pid;
struct name_to_pid_entry * tmp;
- pid = ipcp_create(name, ipcp_type);
+ pid = ipcp_create(api, ipcp_type);
if (pid == -1) {
LOG_ERR("Failed to create IPCP");
- return;
+ return -1;
}
tmp = malloc(sizeof(*tmp));
if (tmp == NULL)
- return;
+ return -1;
INIT_LIST_HEAD(&tmp->next);
tmp->pid = pid;
- tmp->name = name_dup(&name);
- if (tmp->name == NULL) {
+ tmp->api = instance_name_dup(api);
+ if (tmp->api == NULL) {
free(tmp);
- return;
+ return -1;
}
LOG_DBG("Created IPC process with pid %d", pid);
list_add(&tmp->next, &instance->name_to_pid);
+ return 0;
}
-static void destroy_ipcp(struct irm * instance,
- rina_name_t name)
+static int destroy_ipcp(instance_name_t * api)
{
pid_t pid = 0;
struct list_head * pos;
struct list_head * n;
- pid = find_pid_by_name(instance, &name);
+ pid = find_pid_by_name(api);
if (pid == 0) {
LOG_ERR("No such IPCP");
- return;
+ return -1;
}
LOG_DBG("Destroying ipcp with pid %d", pid);
@@ -117,94 +117,178 @@ static void destroy_ipcp(struct irm * instance,
struct name_to_pid_entry * tmp =
list_entry(pos, struct name_to_pid_entry, next);
- if (name_is_equal(&name, tmp->name))
+ if (instance_name_cmp(api, tmp->api) == 0)
list_del(&tmp->next);
}
+
+ return 0;
}
-static void bootstrap_ipcp(struct irm * instance,
- rina_name_t name,
- struct dif_config conf)
+static int bootstrap_ipcp(instance_name_t * api,
+ struct dif_config * conf)
{
pid_t pid = 0;
- pid = find_pid_by_name(instance, &name);
+ pid = find_pid_by_name(api);
if (pid == 0) {
LOG_ERR("No such IPCP");
- return;
+ return -1;
}
- if (ipcp_bootstrap(pid, conf))
+ if (ipcp_bootstrap(pid, conf)) {
LOG_ERR("Could not bootstrap IPCP");
+ return -1;
+ }
+
+ return 0;
}
-static void enroll_ipcp(struct irm * instance,
- rina_name_t name,
- char * dif_name)
+static int enroll_ipcp(instance_name_t * api,
+ char * dif_name)
{
- pid_t pid = 0;
- char * member;
+ pid_t pid = 0;
+ char * member;
char ** n_1_difs = NULL;
ssize_t n_1_difs_size = 0;
- pid = find_pid_by_name(instance, &name);
+ pid = find_pid_by_name(api);
if (pid == 0) {
LOG_ERR("No such IPCP");
- return;
+ return -1;
}
member = da_resolve_daf(dif_name);
if (member == NULL) {
LOG_ERR("Could not find a member of that DIF");
- return;
+ return -1;
}
n_1_difs_size = da_resolve_dap(member, n_1_difs);
if (n_1_difs_size != 0)
- if (ipcp_enroll(pid, dif_name, member,
- n_1_difs, n_1_difs_size))
+ if (ipcp_enroll(pid, member, n_1_difs[0])) {
LOG_ERR("Could not enroll IPCP");
+ return -1;
+ }
+
+ return 0;
}
-static void reg_ipcp(struct irm * instance,
- rina_name_t name,
- char ** difs,
- size_t difs_size)
+static int reg_ipcp(instance_name_t * api,
+ char ** difs,
+ size_t difs_size)
{
pid_t pid = 0;
- pid = find_pid_by_name(instance, &name);
+ pid = find_pid_by_name(api);
if (pid == 0) {
LOG_ERR("No such IPCP");
- return;
+ return -1;
}
- if (ipcp_reg(pid, difs, difs_size))
+ if (ipcp_reg(pid, difs, difs_size)) {
LOG_ERR("Could not register IPCP to N-1 DIF(s)");
+ return -1;
+ }
+
+ return 0;
}
-static void unreg_ipcp(struct irm * instance,
- rina_name_t name,
- char ** difs,
- size_t difs_size)
+static int unreg_ipcp(instance_name_t * api,
+ char ** difs,
+ size_t difs_size)
{
pid_t pid = 0;
- pid = find_pid_by_name(instance, &name);
+ pid = find_pid_by_name(api);
if (pid == 0) {
LOG_ERR("No such IPCP");
- return;
+ return -1;
}
- if (ipcp_unreg(pid, difs, difs_size))
+ if (ipcp_unreg(pid, difs, difs_size)) {
LOG_ERR("Could not unregister IPCP from N-1 DIF(s)");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int ap_reg(char * ap_name,
+ char ** difs,
+ size_t difs_size)
+{
+ return -1;
+}
+
+static int ap_unreg(char * ap_name,
+ char ** difs,
+ size_t difs_size)
+{
+ return -1;
+}
+
+static int flow_accept(int fd,
+ char * ap_name,
+ char * ae_name)
+{
+ return -1;
+}
+
+static int flow_alloc_resp(int fd,
+ int result)
+{
+
+ return -1;
+}
+
+static int flow_alloc(char * dst_ap_name,
+ char * src_ap_name,
+ char * src_ae_name,
+ struct qos_spec * qos,
+ int oflags)
+{
+ return -1;
+}
+
+static int flow_alloc_res(int fd)
+{
+
+ return -1;
+}
+
+static int flow_dealloc(int fd)
+{
+ return -1;
+}
+
+static int flow_cntl(int fd,
+ int oflags)
+{
+ return -1;
+}
+
+static int flow_req_arr(uint32_t reg_api_id,
+ char * ap_name,
+ char * ae_name)
+{
+ return -1;
+}
+
+static int flow_alloc_reply(uint32_t port_id,
+ int result)
+{
+ return -1;
+}
+
+static int flow_dealloc_ipcp(uint32_t port_id)
+{
+ return -1;
}
/* FIXME: Close sockfd on closing and release irm */
int main()
{
- struct irm * instance = NULL;
- int sockfd;
+ int sockfd;
uint8_t buf[IRM_MSG_BUF_SIZE];
instance = malloc(sizeof(*instance));
@@ -219,10 +303,13 @@ int main()
while (true) {
int cli_sockfd;
- struct irm_msg * msg;
+ irm_msg_t * msg;
ssize_t count;
+ instance_name_t api;
buffer_t buffer;
- int i;
+ irm_msg_t ret_msg = IRM_MSG__INIT;
+
+ ret_msg.code = IRM_MSG_CODE__IRM_REPLY;
cli_sockfd = accept(sockfd, 0, 0);
if (cli_sockfd < 0) {
@@ -231,62 +318,140 @@ int main()
}
count = read(cli_sockfd, buf, IRM_MSG_BUF_SIZE);
- if (count > 0) {
- buffer.size = count;
- buffer.data = buf;
- msg = deserialize_irm_msg(&buffer);
- if (msg == NULL)
- continue;
-
- switch (msg->code) {
- case IRM_CREATE_IPCP:
- create_ipcp(instance,
- *(msg->name),
- msg->ipcp_type);
- free(msg->ipcp_type);
- break;
- case IRM_DESTROY_IPCP:
- destroy_ipcp(instance,
- *(msg->name));
- break;
- case IRM_BOOTSTRAP_IPCP:
- bootstrap_ipcp(instance,
- *(msg->name),
- *(msg->conf));
- free(msg->conf);
- break;
- case IRM_ENROLL_IPCP:
- enroll_ipcp(instance,
- *(msg->name),
- msg->dif_name);
- free(msg->dif_name);
- break;
- case IRM_REG_IPCP:
- reg_ipcp(instance,
- *(msg->name),
- msg->difs,
- msg->difs_size);
- for (i = 0; i < msg->difs_size; i++)
- free(msg->difs[i]);
- free(msg->difs);
- break;
- case IRM_UNREG_IPCP:
- unreg_ipcp(instance,
- *(msg->name),
- msg->difs,
- msg->difs_size);
- for (i = 0; i < msg->difs_size; i++)
- free(msg->difs[i]);
- free(msg->difs);
- break;
- default:
- LOG_ERR("Don't know that message code");
- break;
- }
- name_destroy(msg->name);
- free(msg);
+ if (count <= 0) {
+ LOG_ERR("Failed to read from socket");
+ close(cli_sockfd);
+ continue;
+ }
+
+ msg = irm_msg__unpack(NULL, count, buf);
+ if (msg == NULL) {
+ close(cli_sockfd);
+ continue;
+ }
+
+ api.name = msg->ap_name;
+ api.id = msg->api_id;
+
+ switch (msg->code) {
+ case IRM_MSG_CODE__IRM_CREATE_IPCP:
+ ret_msg.has_result = true;
+ ret_msg.result = create_ipcp(&api,
+ msg->ipcp_type);
+ break;
+ case IRM_MSG_CODE__IRM_DESTROY_IPCP:
+ ret_msg.has_result = true;
+ ret_msg.result = destroy_ipcp(&api);
+ break;
+ case IRM_MSG_CODE__IRM_BOOTSTRAP_IPCP:
+ ret_msg.has_result = true;
+ ret_msg.result = bootstrap_ipcp(&api, NULL);
+ break;
+ case IRM_MSG_CODE__IRM_ENROLL_IPCP:
+ ret_msg.has_result = true;
+ ret_msg.result = enroll_ipcp(&api,
+ msg->dif_name[0]);
+ break;
+ case IRM_MSG_CODE__IRM_REG_IPCP:
+ ret_msg.has_result = true;
+ ret_msg.result = reg_ipcp(&api,
+ msg->dif_name,
+ msg->n_dif_name);
+ break;
+ case IRM_MSG_CODE__IRM_UNREG_IPCP:
+ ret_msg.has_result = true;
+ ret_msg.result = unreg_ipcp(&api,
+ msg->dif_name,
+ msg->n_dif_name);
+ break;
+ case IRM_MSG_CODE__IRM_AP_REG:
+ ret_msg.has_fd = true;
+ ret_msg.fd = ap_reg(msg->ap_name,
+ 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->dif_name,
+ msg->n_dif_name);
+ break;
+ case IRM_MSG_CODE__IRM_FLOW_ACCEPT:
+ ret_msg.has_fd = true;
+ ret_msg.fd = flow_accept(msg->fd,
+ ret_msg.ap_name,
+ ret_msg.ae_name);
+ break;
+ case IRM_MSG_CODE__IRM_FLOW_ALLOC_RESP:
+ ret_msg.has_result = true;
+ ret_msg.result = flow_alloc_resp(msg->fd,
+ msg->result);
+ break;
+ case IRM_MSG_CODE__IRM_FLOW_ALLOC:
+ ret_msg.has_fd = true;
+ ret_msg.fd = flow_alloc(msg->dst_ap_name,
+ msg->ap_name,
+ msg->ae_name,
+ NULL,
+ msg->oflags);
+ break;
+ case IRM_MSG_CODE__IRM_FLOW_ALLOC_RES:
+ ret_msg.has_result = true;
+ ret_msg.result = flow_alloc_res(msg->fd);
+ break;
+ case IRM_MSG_CODE__IRM_FLOW_DEALLOC:
+ ret_msg.has_result = true;
+ ret_msg.result = flow_dealloc(msg->fd);
+ break;
+ case IRM_MSG_CODE__IRM_FLOW_CONTROL:
+ ret_msg.has_result = true;
+ ret_msg.result = flow_cntl(msg->fd,
+ msg->oflags);
+ break;
+ case IRM_MSG_CODE__IPCP_FLOW_REQ_ARR:
+ ret_msg.has_fd = true;
+ ret_msg.fd = flow_req_arr(msg->port_id,
+ msg->ap_name,
+ msg->ae_name);
+ break;
+ case IRM_MSG_CODE__IPCP_FLOW_ALLOC_REPLY:
+ ret_msg.has_result = true;
+ ret_msg.result = flow_alloc_reply(msg->port_id,
+ msg->result);
+ break;
+ case IRM_MSG_CODE__IPCP_FLOW_DEALLOC:
+ ret_msg.has_result = true;
+ ret_msg.result = flow_dealloc_ipcp(msg->port_id);
+ break;
+ default:
+ LOG_ERR("Don't know that message code");
+ break;
+ }
+
+ irm_msg__free_unpacked(msg, NULL);
+
+ buffer.size = irm_msg__get_packed_size(&ret_msg);
+ if (buffer.size == 0) {
+ LOG_ERR("Failed to send reply message");
+ close(cli_sockfd);
+ continue;
+ }
+
+ buffer.data = malloc(buffer.size);
+ if (buffer.data == NULL) {
+ close(cli_sockfd);
+ continue;
+ }
+
+ irm_msg__pack(&ret_msg, buffer.data);
+
+ if (write(cli_sockfd, buffer.data, buffer.size) == -1) {
+ free(buffer.data);
+ close(cli_sockfd);
+ continue;
}
+ free(buffer.data);
close(cli_sockfd);
}