From c80c93f11dbfb1b0c07f9a6f8b8d91024e5db507 Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Sun, 8 Mar 2020 13:29:21 +0100 Subject: irm: Revise naming API This revises the naming API to treat names (or reg_name in the source) as first-class citizens of the architecture. This is more in line with the way they are described in the article. Operations have been added to create/destroy names independently of registering. This was previously done only as part of register, and there was no way to delete a name from the IRMd. The create call now allows specifying a policy for load-balancing incoming flows for a name. The default is the new round-robin load-balancer, the previous behaviour is still available as a spillover load-balancer. The register calls will still create a name if it doesn't exist, with the default round-robin load-balancer. The tools now have a "name" section, so the format is now irm name ... Signed-off-by: Dimitri Staessens Signed-off-by: Sander Vrijders --- src/irmd/main.c | 181 ++++++++++++++++++++++++++++++--------- src/irmd/registry.c | 23 ++++- src/irmd/registry.h | 11 ++- src/lib/irm.c | 130 ++++++++++++++++++++++++++-- src/lib/irmd_messages.proto | 37 +++++--- src/tools/irm/CMakeLists.txt | 8 +- src/tools/irm/irm.c | 6 +- src/tools/irm/irm_ipcp_list.c | 4 +- src/tools/irm/irm_name.c | 98 +++++++++++++++++++++ src/tools/irm/irm_name_create.c | 96 +++++++++++++++++++++ src/tools/irm/irm_name_destroy.c | 72 ++++++++++++++++ src/tools/irm/irm_name_list.c | 115 +++++++++++++++++++++++++ src/tools/irm/irm_name_reg.c | 160 ++++++++++++++++++++++++++++++++++ src/tools/irm/irm_name_unreg.c | 135 +++++++++++++++++++++++++++++ src/tools/irm/irm_ops.h | 16 +++- src/tools/irm/irm_register.c | 136 ----------------------------- src/tools/irm/irm_unregister.c | 134 ----------------------------- 17 files changed, 1015 insertions(+), 347 deletions(-) create mode 100644 src/tools/irm/irm_name.c create mode 100644 src/tools/irm/irm_name_create.c create mode 100644 src/tools/irm/irm_name_destroy.c create mode 100644 src/tools/irm/irm_name_list.c create mode 100644 src/tools/irm/irm_name_reg.c create mode 100644 src/tools/irm/irm_name_unreg.c delete mode 100644 src/tools/irm/irm_register.c delete mode 100644 src/tools/irm/irm_unregister.c (limited to 'src') diff --git a/src/irmd/main.c b/src/irmd/main.c index 65354382..940432f1 100644 --- a/src/irmd/main.c +++ b/src/irmd/main.c @@ -108,6 +108,7 @@ struct cmd { struct { struct list_head registry; /* registered names known */ + size_t n_names; /* number of names */ struct list_head ipcps; /* list of ipcps in system */ size_t n_ipcps; /* number of ipcps */ @@ -918,7 +919,7 @@ static ssize_t list_ipcps(ipcp_info_msg_t *** ipcps, if (*ipcps == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); *n_ipcps = 0; - return -1; + return -ENOMEM; } list_for_each(p, &irmd.ipcps) { @@ -959,53 +960,140 @@ static ssize_t list_ipcps(ipcp_info_msg_t *** ipcps, return -ENOMEM; } -static int irm_update_name(const char * name) +static int name_create(const char * name, + enum pol_balance pol) { + struct reg_entry * re; struct list_head * p; + assert(name); + pthread_rwlock_wrlock(&irmd.reg_lock); - if (!registry_has_name(&irmd.registry, name)) { - struct reg_entry * re = registry_add_name(&irmd.registry, name); - if (re == NULL) { - log_err("Failed creating registry entry for %s.", name); - pthread_rwlock_unlock(&irmd.reg_lock); - return -1; - } + if (registry_has_name(&irmd.registry, name)) { + pthread_rwlock_unlock(&irmd.reg_lock); + log_err("Registry entry for %s already exists.", name); + return -ENAME; + } - /* check the tables for client programs */ - list_for_each(p, &irmd.proc_table) { - struct list_head * q; - struct proc_entry * e; - e = list_entry(p, struct proc_entry, next); - list_for_each(q, &e->names) { - struct str_el * s; - s = list_entry(q, struct str_el, next); - if (!strcmp(s->str, name)) - reg_entry_add_pid(re, e->pid); - } + re = registry_add_name(&irmd.registry, name); + if (re == NULL) { + pthread_rwlock_unlock(&irmd.reg_lock); + log_err("Failed creating registry entry for %s.", name); + return -ENOMEM; + } + ++irmd.n_names; + reg_entry_set_policy(re, pol); + + /* check the tables for existing bindings */ + list_for_each(p, &irmd.proc_table) { + struct list_head * q; + struct proc_entry * e; + e = list_entry(p, struct proc_entry, next); + list_for_each(q, &e->names) { + struct str_el * s; + s = list_entry(q, struct str_el, next); + if (!strcmp(s->str, name)) + reg_entry_add_pid(re, e->pid); } + } - list_for_each(p, &irmd.prog_table) { - struct list_head * q; - struct prog_entry * e; - e = list_entry(p, struct prog_entry, next); - list_for_each(q, &e->names) { - struct str_el * s; - s = list_entry(q, struct str_el, next); - if (!strcmp(s->str, name)) - reg_entry_add_prog(re, e); - } + list_for_each(p, &irmd.prog_table) { + struct list_head * q; + struct prog_entry * e; + e = list_entry(p, struct prog_entry, next); + list_for_each(q, &e->names) { + struct str_el * s; + s = list_entry(q, struct str_el, next); + if (!strcmp(s->str, name)) + reg_entry_add_prog(re, e); } } pthread_rwlock_unlock(&irmd.reg_lock); + log_info("Created new name: %s.", name); + + return 0; +} + +static int name_destroy(const char * name) +{ + assert(name); + + pthread_rwlock_wrlock(&irmd.reg_lock); + + if (!registry_has_name(&irmd.registry, name)) { + pthread_rwlock_unlock(&irmd.reg_lock); + log_warn("Registry entry for %s does not exist.", name); + return -ENAME; + } + + registry_del_name(&irmd.registry, name); + --irmd.n_names; + + pthread_rwlock_unlock(&irmd.reg_lock); + + log_info("Destroyed name: %s.", name); + return 0; } -static int name_reg(pid_t pid, - const char * name) +static ssize_t list_names(name_info_msg_t *** names, + size_t * n_names) +{ + struct list_head * p; + int i = 0; + + pthread_rwlock_rdlock(&irmd.reg_lock); + + *n_names = irmd.n_names; + if (*n_names == 0) { + pthread_rwlock_unlock(&irmd.reg_lock); + return 0; + } + + *names = malloc(irmd.n_names * sizeof(**names)); + if (*names == NULL) { + *n_names = 0; + pthread_rwlock_unlock(&irmd.reg_lock); + return -ENOMEM; + } + + list_for_each(p, &irmd.registry) { + struct reg_entry * e = list_entry(p, struct reg_entry, next); + + (*names)[i] = malloc(sizeof(***names)); + if ((*names)[i] == NULL) { + --i; + goto fail; + } + + name_info_msg__init((*names)[i]); + (*names)[i]->name = strdup(e->name); + if ((*names)[i]->name == NULL) + goto fail; + + (*names)[i++]->pol_lb = e->pol_lb; + } + + pthread_rwlock_unlock(&irmd.reg_lock); + + return 0; + + fail: + pthread_rwlock_unlock(&irmd.reg_lock); + while (i >= 0) { + free((*names)[i]->name); + free(*names[i--]); + } + free(*names); + *n_names = 0; + return -ENOMEM; +} + +static int name_reg(const char * name, + pid_t pid) { size_t len; struct ipcp_entry * ipcp; @@ -1016,6 +1104,11 @@ static int name_reg(pid_t pid, pthread_rwlock_wrlock(&irmd.reg_lock); + if (!registry_has_name(&irmd.registry, name)) { + err = -ENAME; + goto fail; + } + ipcp = get_ipcp_entry_by_pid(pid); if (ipcp == NULL) { err = -EIPCP; @@ -1045,8 +1138,6 @@ static int name_reg(pid_t pid, return -1; } - irm_update_name(name); - log_info("Registered %s with IPCP %d as " HASH_FMT ".", name, pid, HASH_VAL(hash)); @@ -1059,8 +1150,8 @@ fail: return err; } -static int name_unreg(pid_t pid, - const char * name) +static int name_unreg(const char * name, + pid_t pid) { struct ipcp_entry * ipcp; int err; @@ -2021,11 +2112,21 @@ static void * mainloop(void * o) case IRM_MSG_CODE__IRM_LIST_IPCPS: result = list_ipcps(&ret_msg->ipcps, &ret_msg->n_ipcps); break; - case IRM_MSG_CODE__IRM_REG: - result = name_reg(msg->pid, msg->name); + case IRM_MSG_CODE__IRM_CREATE_NAME: + result = name_create(msg->names[0]->name, + msg->names[0]->pol_lb); + break; + case IRM_MSG_CODE__IRM_DESTROY_NAME: + result = name_destroy(msg->name); + break; + case IRM_MSG_CODE__IRM_LIST_NAMES: + result = list_names(&ret_msg->names, &ret_msg->n_names); + break; + case IRM_MSG_CODE__IRM_REG_NAME: + result = name_reg(msg->name, msg->pid); break; - case IRM_MSG_CODE__IRM_UNREG: - result = name_unreg(msg->pid, msg->name); + case IRM_MSG_CODE__IRM_UNREG_NAME: + result = name_unreg(msg->name, msg->pid); break; case IRM_MSG_CODE__IRM_FLOW_ACCEPT: assert(msg->pk.len > 0 ? msg->pk.data != NULL diff --git a/src/irmd/registry.c b/src/irmd/registry.c index ef0bc8cc..66cc5af3 100644 --- a/src/irmd/registry.c +++ b/src/irmd/registry.c @@ -32,7 +32,6 @@ #include #include -#include #include #include "registry.h" @@ -72,7 +71,8 @@ static int reg_entry_init(struct reg_entry * e, list_head_init(&e->reg_progs); list_head_init(&e->reg_pids); - e->name = name; + e->name = name; + e->pol_lb = 0; if (pthread_condattr_init(&cattr)) goto fail_cattr; @@ -286,7 +286,17 @@ int reg_entry_add_pid(struct reg_entry * e, i->pid = pid; - list_add(&i->next, &e->reg_pids); + /* load balancing policy assigns queue order for this process. */ + switch(e->pol_lb) { + case LB_RR: /* Round robin policy. */ + list_add_tail(&i->next, &e->reg_pids); + break; + case LB_SPILL: /* Keep accepting flows on the current process */ + list_add(&i->next, &e->reg_pids); + break; + default: + assert(false); + }; if (e->state == REG_NAME_IDLE || e->state == REG_NAME_AUTO_ACCEPT || @@ -300,6 +310,13 @@ int reg_entry_add_pid(struct reg_entry * e, return 0; } +void reg_entry_set_policy(struct reg_entry * e, + enum pol_balance p) +{ + e->pol_lb = p; +} + + static void reg_entry_check_state(struct reg_entry * e) { assert(e); diff --git a/src/irmd/registry.h b/src/irmd/registry.h index 31c1b668..bc9aa23b 100644 --- a/src/irmd/registry.h +++ b/src/irmd/registry.h @@ -26,6 +26,7 @@ #include #include #include +#include #include "proc_table.h" #include "prog_table.h" @@ -54,9 +55,11 @@ struct reg_entry { struct list_head next; char * name; - /* Programs that can be instantiated by the irmd */ + /* Policies for this name. */ + enum pol_balance pol_lb; /* Load balance incoming flows. */ + /* Programs that can be instantiated by the irmd. */ struct list_head reg_progs; - /* Processes that are listening for this name */ + /* Processes that are listening for this name. */ struct list_head reg_pids; enum reg_name_state state; @@ -72,7 +75,6 @@ void reg_entry_del_prog(struct reg_entry * e, char * reg_entry_get_prog(struct reg_entry * e); - int reg_entry_add_pid(struct reg_entry * e, pid_t pid); @@ -84,6 +86,9 @@ void reg_entry_del_pid_el(struct reg_entry * e, pid_t reg_entry_get_pid(struct reg_entry * e); +void reg_entry_set_policy(struct reg_entry * e, + enum pol_balance p); + enum reg_name_state reg_entry_get_state(struct reg_entry * e); int reg_entry_set_state(struct reg_entry * e, diff --git a/src/lib/irm.c b/src/lib/irm.c index e4b39f2c..08dffb6c 100644 --- a/src/lib/irm.c +++ b/src/lib/irm.c @@ -543,8 +543,48 @@ int irm_unbind_process(pid_t pid, return ret; } -int irm_reg(pid_t pid, - const char * name) +int irm_create_name(const char * name, + enum pol_balance pol) +{ + irm_msg_t msg = IRM_MSG__INIT; + name_info_msg_t ni_msg = NAME_INFO_MSG__INIT; + irm_msg_t * recv_msg; + int ret; + + if (name == NULL) + return -EINVAL; + + msg.code = IRM_MSG_CODE__IRM_CREATE_NAME; + ni_msg.name = (char *) name; + ni_msg.pol_lb = pol; + msg.n_names = 1; + + msg.names = malloc(sizeof(*msg.names)); + if (msg.names == NULL) { + return -ENOMEM; + } + + msg.names[0] = &ni_msg; + + recv_msg = send_recv_irm_msg(&msg); + + free(msg.names); + + if (recv_msg == NULL) + return -EIRMD; + + if (!recv_msg->has_result) { + irm_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; +} + +int irm_destroy_name(const char * name) { irm_msg_t msg = IRM_MSG__INIT; irm_msg_t * recv_msg = NULL; @@ -553,7 +593,84 @@ int irm_reg(pid_t pid, if (name == NULL) return -EINVAL; - msg.code = IRM_MSG_CODE__IRM_REG; + msg.code = IRM_MSG_CODE__IRM_DESTROY_NAME; + msg.name = (char *) name; + + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -EIRMD; + + if (!recv_msg->has_result) { + irm_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; +} + +ssize_t irm_list_names(struct name_info ** names) +{ + irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg; + size_t nr; + size_t i; + + if (names == NULL) + return -EINVAL; + + *names = NULL; + + msg.code = IRM_MSG_CODE__IRM_LIST_NAMES; + + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -EIRMD; + + if (recv_msg->names == NULL) { + irm_msg__free_unpacked(recv_msg, NULL); + return 0; + } + + nr = recv_msg->n_names; + if (nr == 0) { + irm_msg__free_unpacked(recv_msg, NULL); + return 0; + } + + *names = malloc(nr * sizeof(**names)); + if (*names == NULL) { + irm_msg__free_unpacked(recv_msg, NULL); + return -ENOMEM; + } + + for (i = 0; i < nr; i++) { + (*names)[i].pol_lb = recv_msg->names[i]->pol_lb; + /* Truncate names > NAME_SIZE */ + if (strlen(recv_msg->names[i]->name) >= NAME_SIZE) + recv_msg->names[i]->name[NAME_SIZE - 1] = 0; + + strcpy((*names)[i].name, recv_msg->names[i]->name); + } + + irm_msg__free_unpacked(recv_msg, NULL); + + return nr; +} + +int irm_reg_name(const char * name, + pid_t pid) +{ + irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; + + if (name == NULL) + return -EINVAL; + + msg.code = IRM_MSG_CODE__IRM_REG_NAME; msg.has_pid = true; msg.pid = pid; msg.name = (char *) name; @@ -573,9 +690,8 @@ int irm_reg(pid_t pid, return ret; } - -int irm_unreg(pid_t pid, - const char * name) +int irm_unreg_name(const char * name, + pid_t pid) { irm_msg_t msg = IRM_MSG__INIT; irm_msg_t * recv_msg = NULL; @@ -584,7 +700,7 @@ int irm_unreg(pid_t pid, if (name == NULL) return -EINVAL; - msg.code = IRM_MSG_CODE__IRM_UNREG; + msg.code = IRM_MSG_CODE__IRM_UNREG_NAME; msg.has_pid = true; msg.pid = pid; msg.name = (char *) name; diff --git a/src/lib/irmd_messages.proto b/src/lib/irmd_messages.proto index c8749699..5b23ee9d 100644 --- a/src/lib/irmd_messages.proto +++ b/src/lib/irmd_messages.proto @@ -39,15 +39,18 @@ enum irm_msg_code { IRM_PROC_ANNOUNCE = 11; IRM_BIND_PROCESS = 12; IRM_UNBIND_PROCESS = 13; - IRM_REG = 14; - IRM_UNREG = 15; - IRM_FLOW_ALLOC = 16; - IRM_FLOW_ACCEPT = 17; - IRM_FLOW_JOIN = 18; - IRM_FLOW_DEALLOC = 19; - IPCP_FLOW_REQ_ARR = 20; - IPCP_FLOW_ALLOC_REPLY = 21; - IRM_REPLY = 22; + IRM_CREATE_NAME = 14; + IRM_DESTROY_NAME = 15; + IRM_LIST_NAMES = 16; + IRM_REG_NAME = 17; + IRM_UNREG_NAME = 18; + IRM_FLOW_ALLOC = 19; + IRM_FLOW_ACCEPT = 20; + IRM_FLOW_JOIN = 21; + IRM_FLOW_DEALLOC = 22; + IPCP_FLOW_REQ_ARR = 23; + IPCP_FLOW_ALLOC_REPLY = 24; + IRM_REPLY = 25; }; message ipcp_info_msg { @@ -57,6 +60,11 @@ message ipcp_info_msg { required string layer = 4; }; +message name_info_msg { + required string name = 1; + required uint32 pol_lb = 2; +}; + message irm_msg { required irm_msg_code code = 1; optional string prog = 2; @@ -73,9 +81,10 @@ message irm_msg { optional ipcp_config_msg conf = 13; optional uint32 opts = 14; repeated ipcp_info_msg ipcps = 15; - optional uint32 timeo_sec = 16; - optional uint32 timeo_nsec = 17; - optional string comp = 18; - optional bytes pk = 19; /* piggyback */ - optional sint32 result = 20; + repeated name_info_msg names = 16; + optional uint32 timeo_sec = 17; + optional uint32 timeo_nsec = 18; + optional string comp = 19; + optional bytes pk = 20; /* piggyback */ + optional sint32 result = 21; }; diff --git a/src/tools/irm/CMakeLists.txt b/src/tools/irm/CMakeLists.txt index ca32e9c7..e5e5c466 100644 --- a/src/tools/irm/CMakeLists.txt +++ b/src/tools/irm/CMakeLists.txt @@ -23,8 +23,12 @@ set(SOURCE_FILES irm_unbind.c irm_bind.c irm_ipcp.c - irm_register.c - irm_unregister.c + irm_name.c + irm_name_create.c + irm_name_destroy.c + irm_name_reg.c + irm_name_unreg.c + irm_name_list.c irm_utils.c ) diff --git a/src/tools/irm/irm.c b/src/tools/irm/irm.c index fe382bb3..2388bfd9 100644 --- a/src/tools/irm/irm.c +++ b/src/tools/irm/irm.c @@ -49,8 +49,7 @@ static void usage(void) { printf("Usage: irm [OPERATION]\n\n" - "where OPERATION = {ipcp bind unbind\n" - " register unregister}\n"); + "where OPERATION = {ipcp bind unbind name}\n"); } static int do_help(int argc, @@ -70,8 +69,7 @@ static const struct cmd { { "ipcp", ipcp_cmd }, { "bind", bind_cmd }, { "unbind", unbind_cmd }, - { "register", do_register }, - { "unregister", do_unregister }, + { "name", name_cmd }, { "help", do_help }, { NULL, NULL } }; diff --git a/src/tools/irm/irm_ipcp_list.c b/src/tools/irm/irm_ipcp_list.c index 28a31d4f..3b8612ed 100644 --- a/src/tools/irm/irm_ipcp_list.c +++ b/src/tools/irm/irm_ipcp_list.c @@ -1,7 +1,7 @@ /* * Ouroboros - Copyright (C) 2016 - 2020 * - * Create IPC Processes + * List IPC Processes * * Dimitri Staessens * Sander Vrijders @@ -46,7 +46,7 @@ #include #include -#define UNICAST "unicast" +#define UNICAST "unicast" #define UDP "udp" #define ETH_LLC "eth-llc" #define ETH_DIX "eth-dix" diff --git a/src/tools/irm/irm_name.c b/src/tools/irm/irm_name.c new file mode 100644 index 00000000..3a615b00 --- /dev/null +++ b/src/tools/irm/irm_name.c @@ -0,0 +1,98 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2020 + * + * A tool to instruct the IRM daemon + * + * Dimitri Staessens + * Sander Vrijders + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include "irm_ops.h" +#include "irm_utils.h" + +static void usage(void) +{ + printf("Usage: irm name [OPERATION]\n\n" + "where OPERATION = {create destroy\n" + " register unregister\n" + " list help}\n"); +} + +static int do_help(int argc, char **argv) +{ + (void) argc; + (void) argv; + + usage(); + return 0; +} + +static const struct cmd { + const char * cmd; + int (* func)(int argc, char ** argv); +} cmds[] = { + { "create", do_create_name }, + { "destroy", do_destroy_name }, + { "register", do_reg_name }, + { "unregister", do_unreg_name }, + { "list", do_list_name}, + { "help", do_help }, + { NULL, NULL } +}; + +static int do_cmd(const char * argv0, + int argc, + char ** argv) +{ + const struct cmd * c; + + for (c = cmds; c->cmd; ++c) { + if (matches(argv0, c->cmd) == 0) + return c->func(argc - 1, argv + 1); + } + + fprintf(stderr, "\"%s\" is unknown, try \"irm ipcp help\".\n", argv0); + + return -1; +} + +int name_cmd(int argc, char ** argv) +{ + if (argc < 1) { + usage(); + return -1; + } + + return do_cmd(argv[0], argc, argv); +} diff --git a/src/tools/irm/irm_name_create.c b/src/tools/irm/irm_name_create.c new file mode 100644 index 00000000..9b7e6a36 --- /dev/null +++ b/src/tools/irm/irm_name_create.c @@ -0,0 +1,96 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2020 + * + * Create IPC Processes + * + * Dimitri Staessens + * Sander Vrijders + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include +#include + +#include "irm_ops.h" +#include "irm_utils.h" + +#define RR "round-robin" +#define SPILL "spillover" + +static void usage(void) +{ + printf("Usage: irm name create\n" + " \n" + " lb [LB_POLICY], default: %s\n\n" + "where LB_POLICY = {" RR " " SPILL "}\n", RR); +} + +int do_create_name(int argc, + char ** argv) +{ + char * name = NULL; + char * lb_pol = RR; + enum pol_balance pol_lb = LB_RR; + + name = *(argv++); + --argc; + + while (argc > 0) { + if (matches(*argv, "lb") == 0) { + lb_pol = *(argv + 1); + } else { + printf("\"%s\" is unknown, try \"irm " + "name create\".\n", *argv); + return -1; + } + + argc -= 2; + argv += 2; + } + + if (name == NULL) { + usage(); + return -1; + } + + if (strcmp(lb_pol, RR) == 0) + pol_lb = LB_RR; + else if (strcmp(lb_pol, SPILL) == 0) + pol_lb = LB_SPILL; + else { + usage(); + return -1; + } + + return irm_create_name(name, pol_lb); +} diff --git a/src/tools/irm/irm_name_destroy.c b/src/tools/irm/irm_name_destroy.c new file mode 100644 index 00000000..70f801b2 --- /dev/null +++ b/src/tools/irm/irm_name_destroy.c @@ -0,0 +1,72 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2020 + * + * Create IPC Processes + * + * Dimitri Staessens + * Sander Vrijders + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include +#include + +#include "irm_ops.h" +#include "irm_utils.h" + +static void usage(void) +{ + printf("Usage: irm name destroy \n"); +} + +int do_destroy_name(int argc, + char ** argv) +{ + char * name = NULL; + + name = *(argv++); + --argc; + + if (argc > 0) { + printf("\"%s\" is unknown, try \"irm " + "name destroy\".\n", *argv); + return -1; + } + + if (name == NULL) { + usage(); + return -1; + } + + return irm_destroy_name(name); +} diff --git a/src/tools/irm/irm_name_list.c b/src/tools/irm/irm_name_list.c new file mode 100644 index 00000000..2e4c3194 --- /dev/null +++ b/src/tools/irm/irm_name_list.c @@ -0,0 +1,115 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2020 + * + * List names + * + * Dimitri Staessens + * Sander Vrijders + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include "irm_ops.h" +#include "irm_utils.h" + +#include +#include +#include + +#define RR "round-robin" +#define SPILL "spillover" + +static char * str_pol(enum pol_balance p) +{ + switch(p) { + case LB_RR: + return RR; + case LB_SPILL: + return SPILL; + default: + return "UNKNOWN"; + } +}; + +int do_list_name(int argc, + char ** argv) +{ + char * name = NULL; + struct name_info * names; + ssize_t len; + ssize_t i; + + while (argc > 0) { + if (matches(*argv, "list") == 0) { + name = *(argv + 1); + } else { + printf("\"%s\" is unknown, try \"irm " + "name list.\n", *argv); + return -1; + } + + argc -= 2; + argv += 2; + } + + len = irm_list_names(&names); + if (len == 0) { + printf("No names in system.\n\n"); + return 0; + } else if (len == -EIRMD) { + printf("Failed to communicate with the " + "Ouroboros IPC Resource Manager daemon.\n"); + return -1; + } else if (len < 0) + return len; + + printf("+----------------------------------------------------" + "+----------------------+\n"); + printf("| %50s | %20s |\n", "name", "load-balance policy"); + printf("+----------------------------------------------------" + "+----------------------+\n"); + + for (i = 0; i < len; i++) { + if (name != NULL && matches(names[i].name, name)) + continue; + printf("| %50s | %20s |\n", + names[i].name, + str_pol(names[i].pol_lb)); + } + printf("+----------------------------------------------------" + "+----------------------+\n"); + + free(names); + + return 0; +} diff --git a/src/tools/irm/irm_name_reg.c b/src/tools/irm/irm_name_reg.c new file mode 100644 index 00000000..52bf911b --- /dev/null +++ b/src/tools/irm/irm_name_reg.c @@ -0,0 +1,160 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2020 + * + * Register names with IPCPs + * + * Dimitri Staessens + * Sander Vrijders + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include "irm_ops.h" +#include "irm_utils.h" + +#include +#include +#include + +#define MAX_IPCPS 128 +#define MAX_LAYERS 128 + +static void usage(void) +{ + printf("Usage: irm name register \n" + " ipcp \n" + " [ipcp ]\n" + " [... (maximum %d ipcps)]\n" + " layer \n" + " [layer ]\n" + " [... (maximum %d layers)]\n" + , MAX_IPCPS, MAX_LAYERS); +} + + +int do_reg_name(int argc, + char ** argv) +{ + char * name = NULL; + char * layers[MAX_LAYERS]; + size_t layers_len = 0; + char * ipcp[MAX_IPCPS]; + size_t ipcp_len = 0; + struct ipcp_info * ipcps; + ssize_t ipcps_len; + struct name_info * names; + ssize_t names_len; + bool name_create = true; + ssize_t i; + + name = *(argv++); + --argc; + + while (argc > 0) { + if (matches(*argv, "layer") == 0) { + layers[layers_len++] = *(argv + 1); + if (layers_len > MAX_LAYERS) { + printf("Too many layers specified.\n"); + return -1; + } + } else if (matches(*argv, "ipcp") == 0) { + ipcp[ipcp_len++] = *(argv + 1); + if (ipcp_len > MAX_IPCPS) { + printf("Too many IPCPs specified.\n"); + return -1; + } + } else { + printf("\"%s\" is unknown, try \"irm name " + "register\".\n", *argv); + return -1; + } + + argc -= 2; + argv += 2; + } + + if ((layers_len < 1 && ipcp_len < 1) || name == NULL) { + usage(); + return -1; + } + + ipcps_len = irm_list_ipcps(&ipcps); + if (ipcps_len < 0) + return ipcps_len; + + names_len = irm_list_names(&names); + if (names_len < 0) { + free(ipcps); + return names_len; + } + + for (i = 0; i < names_len; ++i) { + if (strcmp(names[i].name, name) == 0) { + name_create = false; + break; + } + } + + if (name_create && irm_create_name(name, LB_SPILL)) { + printf("Error creating name."); + free(ipcps); + free(name); + return -1; + } + + for (i = 0; i < ipcps_len; ++i) { + size_t j; + for (j = 0; j < layers_len; j++) { + if (wildcard_match(layers[j], ipcps[i].layer) == 0) { + if (irm_reg_name(name, ipcps[i].pid)) { + free(ipcps); + free(names); + return -1; + } + } + } + for (j = 0; j < ipcp_len; j++) { + if (wildcard_match(ipcp[j], ipcps[i].name) == 0) { + if (irm_reg_name(name, ipcps[i].pid)) { + free(ipcps); + free(names); + return -1; + } + } + } + } + + free(ipcps); + free(names); + + return 0; +} diff --git a/src/tools/irm/irm_name_unreg.c b/src/tools/irm/irm_name_unreg.c new file mode 100644 index 00000000..48253143 --- /dev/null +++ b/src/tools/irm/irm_name_unreg.c @@ -0,0 +1,135 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2020 + * + * Unregister names from IPCPs + * + * Dimitri Staessens + * Sander Vrijders + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include "irm_ops.h" +#include "irm_utils.h" + +#include +#include +#include + +#define MAX_IPCPS 128 +#define MAX_LAYERS 128 + +static void usage(void) +{ + printf("Usage: irm name unregister \n" + " ipcp \n" + " [ipcp ]\n" + " [... (maximum %d ipcps)]\n" + " layer \n" + " [layer ]\n" + " [... (maximum %d layers)]\n" + , MAX_IPCPS, MAX_LAYERS); +} + +int do_unreg_name(int argc, + char ** argv) +{ + char * name = NULL; + char * layers[MAX_LAYERS]; + size_t layers_len = 0; + char * ipcp[MAX_IPCPS]; + size_t ipcp_len = 0; + struct ipcp_info * ipcps; + ssize_t len; + size_t i; + + name = *(argv++); + --argc; + + while (argc > 0) { + if (matches(*argv, "layer") == 0) { + layers[layers_len++] = *(argv + 1); + if (layers_len > MAX_LAYERS) { + printf("Too many layers specified.\n"); + return -1; + } + } else if (matches(*argv, "ipcp") == 0) { + ipcp[ipcp_len++] = *(argv + 1); + if (ipcp_len > MAX_IPCPS) { + printf("Too many IPCPs specified.\n"); + return -1; + } + } else { + printf("\"%s\" is unknown, try \"irm " + "unregister\".\n", *argv); + return -1; + } + + argc -= 2; + argv += 2; + } + + if ((layers_len < 1 && ipcp_len < 1) || name == NULL) { + usage(); + return -1; + } + + len = irm_list_ipcps(&ipcps); + if (len < 0) + return -1; + + for (i = 0; i < (size_t) len; ++i) { + size_t j; + for (j = 0; j < layers_len; j++) { + if (wildcard_match(ipcps[i].layer, layers[j]) == 0) { + if (irm_unreg_name(name, ipcps[i].pid)) { + free(ipcps); + return -1; + } + break; + } + } + for (j = 0; j < ipcp_len; j++) { + if (wildcard_match(ipcps[i].name, ipcp[j]) == 0) { + if (irm_unreg_name(name, ipcps[i].pid)) { + free(ipcps); + return -1; + } + break; + } + } + } + + free(ipcps); + + return 0; +} diff --git a/src/tools/irm/irm_ops.h b/src/tools/irm/irm_ops.h index a6530f61..7c1b1a8f 100644 --- a/src/tools/irm/irm_ops.h +++ b/src/tools/irm/irm_ops.h @@ -84,8 +84,20 @@ int do_unbind_process(int argc, int do_unbind_ipcp(int argc, char ** argv); -int do_register(int argc, +int name_cmd(int argc, + char ** argv); + +int do_create_name(int argc, + char ** argv); + +int do_destroy_name(int argc, + char ** argv); + +int do_reg_name(int argc, char ** argv); -int do_unregister(int argc, +int do_unreg_name(int argc, char ** argv); + +int do_list_name(int argc, + char ** argv); diff --git a/src/tools/irm/irm_register.c b/src/tools/irm/irm_register.c deleted file mode 100644 index f7b57b0b..00000000 --- a/src/tools/irm/irm_register.c +++ /dev/null @@ -1,136 +0,0 @@ -/* - * Ouroboros - Copyright (C) 2016 - 2020 - * - * Register names in IPCPs - * - * Dimitri Staessens - * Sander Vrijders - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * - * 3. Neither the name of the copyright holder nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include - - -#include "irm_ops.h" -#include "irm_utils.h" - -#include -#include -#include - -#define MAX_IPCPS 128 -#define MAX_LAYERS 128 - -static void usage(void) -{ - printf("Usage: irm register\n" - " name \n" - " ipcp \n" - " [ipcp ]\n" - " [... (maximum %d ipcps)]\n" - " layer \n" - " [layer ]\n" - " [... (maximum %d layers)]\n" - , MAX_IPCPS, MAX_LAYERS); -} - - -int do_register(int argc, - char ** argv) -{ - char * name = NULL; - char * layers[MAX_LAYERS]; - size_t layers_len = 0; - char * ipcp[MAX_IPCPS]; - size_t ipcp_len = 0; - struct ipcp_info * ipcps; - ssize_t len; - ssize_t i; - - - while (argc > 0) { - if (matches(*argv, "name") == 0) { - name = *(argv + 1); - } else if (matches(*argv, "layer") == 0) { - layers[layers_len++] = *(argv + 1); - if (layers_len > MAX_LAYERS) { - printf("Too many layers specified.\n"); - return -1; - } - } else if (matches(*argv, "ipcp") == 0) { - ipcp[ipcp_len++] = *(argv + 1); - if (ipcp_len > MAX_IPCPS) { - printf("Too many IPCPs specified.\n"); - return -1; - } - } else { - printf("\"%s\" is unknown, try \"irm " - "register\".\n", *argv); - return -1; - } - - argc -= 2; - argv += 2; - } - - if ((layers_len < 1 && ipcp_len < 1) || name == NULL) { - usage(); - return -1; - } - - len = irm_list_ipcps(&ipcps); - if (len < 0) - return len; - - for (i = 0; i < len; ++i) { - size_t j; - for (j = 0; j < layers_len; j++) { - if (wildcard_match(layers[j], ipcps[i].layer) == 0) { - if (irm_reg(ipcps[i].pid, name)) { - free(ipcps); - return -1; - } - } - } - for (j = 0; j < ipcp_len; j++) { - if (wildcard_match(ipcp[j], ipcps[i].name) == 0) { - if (irm_reg(ipcps[i].pid, name)) { - free(ipcps); - return -1; - } - } - } - } - - free(ipcps); - - return 0; -} diff --git a/src/tools/irm/irm_unregister.c b/src/tools/irm/irm_unregister.c deleted file mode 100644 index 3ef28700..00000000 --- a/src/tools/irm/irm_unregister.c +++ /dev/null @@ -1,134 +0,0 @@ -/* - * Ouroboros - Copyright (C) 2016 - 2020 - * - * Unregister names from IPCPs - * - * Dimitri Staessens - * Sander Vrijders - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * - * 3. Neither the name of the copyright holder nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include - -#include "irm_ops.h" -#include "irm_utils.h" - -#include -#include -#include - -#define MAX_IPCPS 128 -#define MAX_LAYERS 128 - -static void usage(void) -{ - printf("Usage: irm unregister\n" - " name \n" - " ipcp \n" - " [ipcp ]\n" - " [... (maximum %d ipcps)]\n" - " layer \n" - " [layer ]\n" - " [... (maximum %d layers)]\n" - , MAX_IPCPS, MAX_LAYERS); -} - -int do_unregister(int argc, char ** argv) -{ - char * name = NULL; - char * layers[MAX_LAYERS]; - size_t layers_len = 0; - char * ipcp[MAX_IPCPS]; - size_t ipcp_len = 0; - struct ipcp_info * ipcps; - ssize_t len; - size_t i; - - while (argc > 0) { - if (matches(*argv, "name") == 0) { - name = *(argv + 1); - } else if (matches(*argv, "layer") == 0) { - layers[layers_len++] = *(argv + 1); - if (layers_len > MAX_LAYERS) { - printf("Too many layers specified.\n"); - return -1; - } - } else if (matches(*argv, "ipcp") == 0) { - ipcp[ipcp_len++] = *(argv + 1); - if (ipcp_len > MAX_IPCPS) { - printf("Too many IPCPs specified.\n"); - return -1; - } - } else { - printf("\"%s\" is unknown, try \"irm " - "unregister\".\n", *argv); - return -1; - } - - argc -= 2; - argv += 2; - } - - if ((layers_len < 1 && ipcp_len < 1) || name == NULL) { - usage(); - return -1; - } - - len = irm_list_ipcps(&ipcps); - if (len < 0) - return -1; - - for (i = 0; i < (size_t) len; ++i) { - size_t j; - for (j = 0; j < layers_len; j++) { - if (wildcard_match(ipcps[i].layer, layers[j]) == 0) { - if (irm_unreg(ipcps[i].pid, name)) { - free(ipcps); - return -1; - } - break; - } - } - for (j = 0; j < ipcp_len; j++) { - if (wildcard_match(ipcps[i].name, ipcp[j]) == 0) { - if (irm_unreg(ipcps[i].pid, name)) { - free(ipcps); - return -1; - } - break; - } - } - } - - free(ipcps); - - return 0; -} -- cgit v1.2.3