/* * Ouroboros - Copyright (C) 2016 * * The IPC Resource Manager * * Dimitri Staessens <dimitri.staessens@intec.ugent.be> * 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. */ #define OUROBOROS_PREFIX "irmd" #include <ouroboros/config.h> #include <ouroboros/errno.h> #include <ouroboros/logs.h> #include <ouroboros/sockets.h> #include <ouroboros/ipcp.h> #include <ouroboros/nsm.h> #include <ouroboros/list.h> #include <ouroboros/utils.h> #include <ouroboros/irm_config.h> #include <ouroboros/lockfile.h> #include <ouroboros/shm_ap_rbuff.h> #include <ouroboros/shm_rdrbuff.h> #include <ouroboros/bitmap.h> #include <ouroboros/flow.h> #include <ouroboros/qos.h> #include <ouroboros/time_utils.h> #include "utils.h" #include "registry.h" #include "irm_flow.h" #include "api_table.h" #include <sys/socket.h> #include <sys/un.h> #include <signal.h> #include <stdlib.h> #include <string.h> #include <limits.h> #include <pthread.h> #include <sys/stat.h> #include <dirent.h> #include <sys/wait.h> #define IRMD_CLEANUP_TIMER ((IRMD_FLOW_TIMEOUT / 20) * MILLION) /* ns */ struct ipcp_entry { struct list_head next; char * name; pid_t api; enum ipcp_type type; char * dif_name; pthread_cond_t init_cond; pthread_mutex_t init_lock; bool init; }; enum irm_state { IRMD_NULL = 0, IRMD_RUNNING }; struct irm { struct list_head registry; struct list_head ipcps; struct list_head api_table; struct list_head apn_table; struct list_head spawned_apis; pthread_rwlock_t reg_lock; /* keep track of all flows in this processing system */ struct bmp * port_ids; /* maps port_ids to api pair */ struct list_head irm_flows; pthread_rwlock_t flows_lock; struct lockfile * lf; struct shm_rdrbuff * rdrb; pthread_t * threadpool; int sockfd; enum irm_state state; pthread_rwlock_t state_lock; pthread_t irm_sanitize; pthread_t shm_sanitize; } * irmd = NULL; static struct irm_flow * get_irm_flow(int port_id) { struct list_head * pos = NULL; list_for_each(pos, &irmd->irm_flows) { struct irm_flow * e = list_entry(pos, struct irm_flow, next); if (e->port_id == port_id) return e; } return NULL; } static struct irm_flow * get_irm_flow_n(pid_t n_api) { struct list_head * pos = NULL; list_for_each(pos, &irmd->irm_flows) { struct irm_flow * e = list_entry(pos, struct irm_flow, next); if (e->n_api == n_api) return e; } return NULL; } static struct ipcp_entry * ipcp_entry_create() { struct ipcp_entry * e = malloc(sizeof(*e)); if (e == NULL) return NULL; e->name = NULL; e->dif_name = NULL; INIT_LIST_HEAD(&e->next); return e; } static void ipcp_entry_destroy(struct ipcp_entry * e) { if (e == NULL) return; if (e->name != NULL) free(e->name); if (e->dif_name != NULL) free(e->dif_name); free(e); } static struct ipcp_entry * get_ipcp_entry_by_api(pid_t api) { struct list_head * p = NULL; list_for_each(p, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); if (api == e->api) return e; } return NULL; } /* FIXME: Check if the name exists anywhere in a DIF. */ static pid_t get_ipcp_by_dst_name(char * dst_name) { struct list_head * p = NULL; char * dif_name = registry_get_dif_for_dst(&irmd->registry, dst_name); if (dif_name == NULL) { list_for_each(p, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); if (e->type == IPCP_NORMAL) { dif_name = e->dif_name; break; } } list_for_each(p, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); if (e->type == IPCP_SHIM_ETH_LLC) { dif_name = e->dif_name; break; } } list_for_each(p, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); if (e->type == IPCP_SHIM_UDP) { dif_name = e->dif_name; break; } } } if (dif_name == NULL) return -1; list_for_each(p, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); if (strcmp(e->dif_name, dif_name) == 0) return e->api; } return -1; } static pid_t create_ipcp(char * name, enum ipcp_type ipcp_type) { struct pid_el * api = NULL; struct ipcp_entry * tmp = NULL; struct list_head * p = NULL; api = malloc(sizeof(*api)); if (api == NULL) return -ENOMEM; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); api->pid = ipcp_create(ipcp_type); if (api->pid == -1) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Failed to create IPCP."); return -1; } tmp = ipcp_entry_create(); if (tmp == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } INIT_LIST_HEAD(&tmp->next); tmp->api = api->pid; tmp->name = strdup(name); if (tmp->name == NULL) { ipcp_entry_destroy(tmp); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_cond_init(&tmp->init_cond, NULL); pthread_mutex_init(&tmp->init_lock, NULL); tmp->dif_name = NULL; tmp->type = ipcp_type; tmp->init = false; list_for_each(p, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); if (e->type < ipcp_type) break; } list_add(&tmp->next, &irmd->ipcps); list_add(&api->next, &irmd->spawned_apis); pthread_mutex_lock(&tmp->init_lock); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); while (tmp->init == false) pthread_cond_wait(&tmp->init_cond, &tmp->init_lock); pthread_mutex_unlock(&tmp->init_lock); LOG_INFO("Created IPCP %d.", api->pid); return api->pid; } static int create_ipcp_r(pid_t api) { struct list_head * pos = NULL; pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_rdlock(&irmd->reg_lock); list_for_each(pos, &irmd->ipcps) { struct ipcp_entry * e = list_entry(pos, struct ipcp_entry, next); if (e->api == api) { pthread_mutex_lock(&e->init_lock); e->init = true; pthread_cond_broadcast(&e->init_cond); pthread_mutex_unlock(&e->init_lock); } } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return 0; } static void clear_spawned_api(pid_t api) { struct list_head * pos = NULL; struct list_head * n = NULL; list_for_each_safe(pos, n, &(irmd->spawned_apis)) { struct pid_el * a = list_entry(pos, struct pid_el, next); if (api == a->pid) { list_del(&a->next); free(a); } } } static int destroy_ipcp(pid_t api) { struct list_head * pos = NULL; struct list_head * n = NULL; pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_wrlock(&irmd->reg_lock); list_for_each_safe(pos, n, &(irmd->ipcps)) { struct ipcp_entry * tmp = list_entry(pos, struct ipcp_entry, next); if (api == tmp->api) { clear_spawned_api(api); if (ipcp_destroy(api)) LOG_ERR("Could not destroy IPCP."); list_del(&tmp->next); ipcp_entry_destroy(tmp); LOG_INFO("Destroyed IPCP %d.", api); } } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return 0; } static int bootstrap_ipcp(pid_t api, dif_config_msg_t * conf) { struct ipcp_entry * entry = NULL; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); entry = get_ipcp_entry_by_api(api); if (entry == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("No such IPCP."); return -1; } entry->dif_name = strdup(conf->dif_name); if (entry->dif_name == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Failed to strdup."); return -1; } if (ipcp_bootstrap(entry->api, conf)) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Could not bootstrap IPCP."); free(entry->dif_name); entry->dif_name = NULL; return -1; } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_INFO("Bootstrapped IPCP %d in DIF %s.", entry->api, conf->dif_name); return 0; } static int enroll_ipcp(pid_t api, char * dif_name) { struct ipcp_entry * entry = NULL; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); entry = get_ipcp_entry_by_api(api); if (entry == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("No such IPCP."); return -1; } if (entry->dif_name != NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("IPCP in wrong state"); return -1; } entry->dif_name = strdup(dif_name); if (entry->dif_name == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Failed to strdup."); return -1; } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); if (ipcp_enroll(api, dif_name)) { pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_wrlock(&irmd->reg_lock); free(entry->dif_name); entry->dif_name = NULL; pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Could not enroll IPCP."); return -1; } LOG_INFO("Enrolled IPCP %d in DIF %s.", api, dif_name); return 0; } static int bind_ap(char * ap, char * name, uint16_t flags, int argc, char ** argv) { char * aps; char * apn; char ** argv_dup = NULL; int i; char * name_dup = NULL; struct apn_entry * e = NULL; struct reg_entry * re = NULL; if (ap == NULL || name == NULL) return -EINVAL; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); e = apn_table_get(&irmd->apn_table, path_strip(ap)); if (e == NULL) { aps = strdup(path_strip(ap)); if (aps == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -ENOMEM; } apn = strdup(name); if (apn == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); free(aps); return -ENOMEM; } if ((flags & BIND_AP_AUTO) && argc) { /* we need to duplicate argv and set argv[0] to ap */ argv_dup = malloc((argc + 2) * sizeof(*argv_dup)); argv_dup[0] = strdup(ap); for (i = 1; i <= argc; ++i) { argv_dup[i] = strdup(argv[i - 1]); if (argv_dup[i] == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock( &irmd->state_lock); argvfree(argv_dup); LOG_ERR("Failed to bind ap %s to %s.", ap, name); free(aps); free(apn); return -ENOMEM; } } argv_dup[argc + 1] = NULL; } e = apn_entry_create(apn, aps, flags, argv_dup); if (e == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); free(aps); free(apn); argvfree(argv_dup); return -ENOMEM; } apn_table_add(&irmd->apn_table, e); } name_dup = strdup(name); if (name_dup == NULL) { pthread_rwlock_unlock(&irmd->state_lock); return -ENOMEM; } if (apn_entry_add_name(e, name_dup)) { LOG_ERR("Failed adding name."); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); free(name_dup); return -ENOMEM; } re = registry_get_entry(&irmd->registry, name); if (re != NULL && reg_entry_add_apn(re, e) < 0) LOG_ERR("Failed adding AP %s for name %s.", ap, name); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_INFO("Bound AP %s to name %s.", ap, name); return 0; } static int bind_api(pid_t api, char * name) { char * name_dup = NULL; struct api_entry * e = NULL; struct reg_entry * re = NULL; if (name == NULL) return -EINVAL; LOG_DBG("BIND_API called %d, %s", api, name); pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); e = api_table_get(&irmd->api_table, api); if (e == NULL) { LOG_ERR("AP-I %d does not exist.", api); pthread_rwlock_wrlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } name_dup = strdup(name); if (name_dup == NULL) { pthread_rwlock_wrlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -ENOMEM; } if (api_entry_add_name(e, name_dup)) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Failed to add name %s to api %d.", name, api); free(name_dup); return -1; } re = registry_get_entry(&irmd->registry, name); if (re != NULL && reg_entry_add_api(re, api) < 0) LOG_ERR("Failed adding AP-I %d for name %s.", api, name); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_INFO("Bound AP-I %d to name %s.", api, name); return 0; } static int unbind_ap(char * ap, char * name) { if (ap == NULL) return -EINVAL; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); if (name == NULL) apn_table_del(&irmd->apn_table, ap); else { struct apn_entry * e = apn_table_get(&irmd->apn_table, ap); apn_entry_del_name(e, name); } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); if (name == NULL) LOG_INFO("AP %s removed.", ap); else LOG_INFO("All names matching %s cleared for %s.", name, ap); return 0; } static int unbind_api(pid_t api, char * name) { pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); if (name == NULL) api_table_del(&irmd->api_table, api); else { struct api_entry * e = api_table_get(&irmd->api_table, api); api_entry_del_name(e, name); } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); if (name == NULL) LOG_INFO("AP-I %d removed.", api); else LOG_INFO("All names matching %s cleared for %d.", name, api); return 0; } static ssize_t list_ipcps(char * name, pid_t ** apis) { struct list_head * pos = NULL; ssize_t count = 0; int i = 0; pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_rdlock(&irmd->reg_lock); list_for_each(pos, &irmd->ipcps) { struct ipcp_entry * tmp = list_entry(pos, struct ipcp_entry, next); if (wildcard_match(name, tmp->name) == 0) count++; } *apis = malloc(count * sizeof(pid_t)); if (*apis == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } list_for_each(pos, &irmd->ipcps) { struct ipcp_entry * tmp = list_entry(pos, struct ipcp_entry, next); if (wildcard_match(name, tmp->name) == 0) (*apis)[i++] = tmp->api; } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return count; } static int name_reg(char * name, char ** difs, size_t len) { int i; int ret = 0; struct list_head * p = NULL; if (name == NULL || difs == NULL || len == 0 || difs[0] == NULL) return -EINVAL; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); if (list_empty(&irmd->ipcps)) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } if (!registry_has_name(&irmd->registry, name)) { struct reg_entry * re = registry_add_name(&irmd->registry, strdup(name)); if (re == NULL) { LOG_ERR("Failed creating registry entry for %s.", name); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } /* check the tables for client ap's */ list_for_each(p, &irmd->api_table) { struct list_head * q; struct api_entry * e = list_entry(p, struct api_entry, next); list_for_each(q, &e->names) { struct str_el * s = list_entry(q, struct str_el, next); if (!strcmp(s->str, name)) reg_entry_add_api(re, e->api); } } list_for_each(p, &irmd->apn_table) { struct list_head * q; struct apn_entry * e = list_entry(p, struct apn_entry, next); list_for_each(q, &e->names) { struct str_el * s = list_entry(q, struct str_el, next); if (!strcmp(s->str, name)) reg_entry_add_apn(re, e); } } } list_for_each(p, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); if (e->dif_name == NULL) continue; for (i = 0; i < len; ++i) { if (wildcard_match(difs[i], e->dif_name)) continue; if (ipcp_name_reg(e->api, name)) { LOG_ERR("Could not register %s in DIF %s.", name, e->dif_name); } else { if (registry_add_name_to_dif(&irmd->registry, name, e->dif_name, e->type) < 0) LOG_WARN("Registered unbound name %s. " "Registry may be inconsistent", name); LOG_INFO("Registered %s in %s as %s.", name, e->dif_name, name); ++ret; } } } if (ret == 0) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return ret; } static int name_unreg(char * name, char ** difs, size_t len) { int i; int ret = 0; struct list_head * pos = NULL; if (name == NULL || len == 0 || difs == NULL || difs[0] == NULL) return -1; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); list_for_each(pos, &irmd->ipcps) { struct ipcp_entry * e = list_entry(pos, struct ipcp_entry, next); if (e->dif_name == NULL) continue; for (i = 0; i < len; ++i) { if (wildcard_match(difs[i], e->dif_name)) continue; if (ipcp_name_unreg(e->api, name)) { LOG_ERR("Could not unregister %s in DIF %s.", name, e->dif_name); --ret; } else { registry_del_name_from_dif(&irmd->registry, name, e->dif_name); LOG_INFO("Unregistered %s from %s.", name, e->dif_name); } } } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return ret; } static int api_announce(pid_t api, char * apn) { struct api_entry * e = NULL; struct apn_entry * a = NULL; char * apn_dup; if (apn == NULL) return -EINVAL; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -EPERM; } apn_dup = strdup(apn); if (apn_dup == NULL) { pthread_rwlock_unlock(&irmd->state_lock); return -ENOMEM; } e = api_entry_create(api, apn_dup); if (e == NULL) { pthread_rwlock_unlock(&irmd->state_lock); return -ENOMEM; } pthread_rwlock_wrlock(&irmd->reg_lock); api_table_add(&irmd->api_table, e); /* copy listen names from apn if it exists */ a = apn_table_get(&irmd->apn_table, e->apn); if (a != NULL) { struct list_head * p; list_for_each(p, &a->names) { struct str_el * s = list_entry(p, struct str_el, next); struct str_el * n = malloc(sizeof(*n)); if (n == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return -ENOMEM; } n->str = strdup(s->str); if (n->str == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); free(n); } list_add(&n->next, &e->names); LOG_DBG("AP-I %d inherits listen name %s from AP %s.", api, n->str, e->apn); } } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return 0; } static struct irm_flow * flow_accept(pid_t api, char ** dst_ae_name) { struct irm_flow * f = NULL; struct api_entry * e = NULL; struct reg_entry * re = NULL; struct list_head * p; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return NULL; } pthread_rwlock_wrlock(&irmd->reg_lock); e = api_table_get(&irmd->api_table, api); if (e == NULL) { /* Can only happen if server called ap_init(NULL); */ LOG_ERR("Unknown instance %d calling accept.", api); return NULL; } LOG_INFO("New instance (%d) of %s added.", api, e->apn); LOG_DBG("This instance accepts flows for:"); list_for_each(p, &e->names) { struct str_el * s = list_entry(p, struct str_el, next); LOG_DBG(" %s", s->str); re = registry_get_entry(&irmd->registry, s->str); if (re != NULL) { pthread_mutex_lock(&re->state_lock); reg_entry_add_api(re, api); pthread_mutex_unlock(&re->state_lock); } } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); while (api_entry_sleep(e) == -ETIMEDOUT) { pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); break; } pthread_rwlock_unlock(&irmd->state_lock); } pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return NULL; } pthread_rwlock_rdlock(&irmd->reg_lock); e = api_table_get(&irmd->api_table, api); if (e == NULL) { LOG_DBG("Process gone while accepting flow."); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return NULL; } pthread_mutex_lock(&e->state_lock); re = e->re; pthread_mutex_unlock(&e->state_lock); pthread_mutex_lock(&re->state_lock); if (re->state != REG_NAME_FLOW_ARRIVED) { pthread_mutex_unlock(&re->state_lock); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return NULL; } pthread_mutex_unlock(&re->state_lock); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_rdlock(&irmd->flows_lock); f = get_irm_flow_n(api); if (f == NULL) { pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Port_id was not created yet."); return NULL; } if (dst_ae_name != NULL) *dst_ae_name = re->req_ae_name; pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return f; } static int flow_alloc_resp(pid_t n_api, int port_id, int response) { struct irm_flow * f = NULL; struct reg_entry * re = NULL; struct api_entry * e = NULL; int ret = -1; pid_t f_n_1_api; pid_t f_n_api; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_wrlock(&irmd->reg_lock); e = api_table_get(&irmd->api_table, n_api); if (e == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Unknown AP-I %d responding for port_id %d.", n_api, port_id); return -1; } re = e->re; if (re == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("AP-I %d is not handling a flow request.", n_api); return -1; } pthread_mutex_lock(&re->state_lock); if (re->state != REG_NAME_FLOW_ARRIVED) { pthread_mutex_unlock(&re->state_lock); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Name %s has no pending flow request.", re->name); return -1; } pthread_mutex_unlock(&re->state_lock); registry_del_api(&irmd->registry, n_api); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_wrlock(&irmd->flows_lock); f = get_irm_flow(port_id); if (f == NULL) { pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } f_n_api = f->n_api; f_n_1_api = f->n_1_api; if (!response) { f->state = FLOW_ALLOCATED; pthread_cond_signal(&f->state_cond); } pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); ret = ipcp_flow_alloc_resp(f_n_1_api, port_id, f_n_api, response); return ret; } static struct irm_flow * flow_alloc(pid_t api, char * dst_name, char * src_ae_name, struct qos_spec * qos) { struct irm_flow * f; pid_t ipcp; /* FIXME: Map qos_spec to qos_cube */ pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return NULL; } f = irm_flow_create(); if (f == NULL) { pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Failed to create irm_flow."); return NULL; } f->n_api = api; f->state = FLOW_PENDING; if (clock_gettime(CLOCK_MONOTONIC, &f->t0) < 0) LOG_WARN("Failed to set timestamp."); pthread_rwlock_rdlock(&irmd->reg_lock); ipcp = get_ipcp_by_dst_name(dst_name); if (ipcp == -1) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_INFO("Destination unreachable."); return NULL; } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_wrlock(&irmd->flows_lock); f->port_id = bmp_allocate(irmd->port_ids); f->n_1_api = ipcp; list_add(&f->next, &irmd->irm_flows); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); if (ipcp_flow_alloc(ipcp, f->port_id, f->n_api, dst_name, src_ae_name, QOS_CUBE_BE) < 0) { pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_wrlock(&irmd->flows_lock); list_del(&f->next); bmp_release(irmd->port_ids, f->port_id); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); free(f); return NULL; } return f; } static int flow_alloc_res(int port_id) { struct irm_flow * f; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_rwlock_rdlock(&irmd->flows_lock); f = get_irm_flow(port_id); if (f == NULL) { LOG_ERR("Could not find port %d.", port_id); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } if (f->state == FLOW_NULL) { LOG_INFO("Port %d is deprecated.", port_id); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } if (f->state == FLOW_ALLOCATED) { pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return 0; } pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); pthread_mutex_lock(&f->state_lock); while (f->state == FLOW_PENDING) pthread_cond_wait(&f->state_cond, &f->state_lock); pthread_mutex_unlock(&f->state_lock); pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_wrlock(&irmd->flows_lock); pthread_mutex_lock(&f->state_lock); if (f->state == FLOW_ALLOCATED) { pthread_cond_broadcast(&f->state_cond); pthread_mutex_unlock(&f->state_lock); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return 0; } f->state = FLOW_NULL; pthread_cond_broadcast(&f->state_cond); pthread_mutex_unlock(&f->state_lock); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } static int flow_dealloc(int port_id) { pid_t n_1_api; int ret = 0; struct irm_flow * f = NULL; pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_wrlock(&irmd->flows_lock); bmp_release(irmd->port_ids, port_id); f = get_irm_flow(port_id); if (f == NULL) { pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return 0; } n_1_api = f->n_1_api; list_del(&f->next); pthread_rwlock_unlock(&irmd->flows_lock); ret = ipcp_flow_dealloc(n_1_api, port_id); pthread_rwlock_unlock(&irmd->state_lock); irm_flow_destroy(f); LOG_INFO("Deallocated flow with port_id %d.", port_id); return ret; } static pid_t auto_execute(char ** argv) { pid_t api; struct stat s; if (stat(argv[0], &s) != 0) { LOG_WARN("Application %s does not exist.", argv[0]); return -1; } if (!(s.st_mode & S_IXUSR)) { LOG_WARN("Application %s is not executable.", argv[0]); return -1; } api = fork(); if (api == -1) { LOG_ERR("Failed to fork"); return api; } if (api != 0) { LOG_INFO("Instantiated %s as AP-I %d.", argv[0], api); return api; } execv(argv[0], argv); LOG_ERR("Failed to execute %s.", argv[0]); exit(EXIT_FAILURE); } static struct irm_flow * flow_req_arr(pid_t api, char * dst_name, char * ae_name) { struct reg_entry * re = NULL; struct apn_entry * a = NULL; struct api_entry * e = NULL; struct irm_flow * f = NULL; enum reg_name_state state; struct pid_el * c_api; pid_t h_api = -1; f = irm_flow_create(); if (f == NULL) { LOG_ERR("Failed to create irm_flow."); return NULL; } f->state = FLOW_PENDING; f->n_1_api = api; if (clock_gettime(CLOCK_MONOTONIC, &f->t0) < 0) LOG_WARN("Failed to set timestamp."); pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_wrlock(&irmd->reg_lock); re = registry_get_entry(&irmd->registry, dst_name); if (re == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Unknown name: %s.", dst_name); free(f); return NULL; } pthread_mutex_lock(&re->state_lock); state = re->state; pthread_mutex_unlock(&re->state_lock); switch (state) { case REG_NAME_IDLE: pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("No AP's for %s.", dst_name); free(f); return NULL; case REG_NAME_AUTO_ACCEPT: c_api = malloc(sizeof(*c_api)); if (c_api == NULL) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); free(f); return NULL; } pthread_mutex_lock(&re->state_lock); re->state = REG_NAME_AUTO_EXEC; a = apn_table_get_by_apn(&irmd->apn_table, reg_entry_get_apn(re)); pthread_mutex_unlock(&re->state_lock); if (a == NULL || (c_api->pid = auto_execute(a->argv)) < 0) { pthread_mutex_lock(&re->state_lock); re->state = REG_NAME_AUTO_ACCEPT; pthread_mutex_unlock(&re->state_lock); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Could not get start apn for reg_entry %s.", re->name); free(f); free(c_api); return NULL; } list_add(&c_api->next, &irmd->spawned_apis); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); pthread_mutex_lock(&re->state_lock); while (re->state == REG_NAME_AUTO_EXEC) pthread_cond_wait(&re->state_cond, &re->state_lock); pthread_mutex_unlock(&re->state_lock); pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_rdlock(&irmd->reg_lock); pthread_mutex_lock(&re->state_lock); if (re->state == REG_NAME_DESTROY) { re->state = REG_NAME_NULL; pthread_mutex_unlock(&re->state_lock); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); return NULL; } pthread_mutex_unlock(&re->state_lock); case REG_NAME_FLOW_ACCEPT: pthread_mutex_lock(&re->state_lock); h_api = f->n_api = reg_entry_get_api(re); pthread_mutex_unlock(&re->state_lock); if (f->n_api == -1) { pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("Invalid api returned."); return NULL; } break; default: pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); LOG_ERR("IRMd in wrong state."); free(f); return NULL; } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_wrlock(&irmd->flows_lock); f->port_id = bmp_allocate(irmd->port_ids); list_add(&f->next, &irmd->irm_flows); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_rdlock(&irmd->reg_lock); pthread_mutex_lock(&re->state_lock); re->req_ae_name = ae_name; re->state = REG_NAME_FLOW_ARRIVED; pthread_mutex_unlock(&re->state_lock); e = api_table_get(&irmd->api_table, h_api); if (e == NULL) { LOG_ERR("Could not get api table entry for %d.", h_api); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); free(f); return NULL; } api_entry_wake(e, re); pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_unlock(&irmd->state_lock); pthread_mutex_lock(&re->state_lock); while (re->state == REG_NAME_FLOW_ARRIVED) pthread_cond_wait(&re->state_cond, &re->state_lock); pthread_mutex_unlock(&re->state_lock); return f; } static int flow_alloc_reply(int port_id, int response) { struct irm_flow * f; pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_wrlock(&irmd->flows_lock); f = get_irm_flow(port_id); if (f == NULL) { pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return -1; } pthread_mutex_lock(&f->state_lock); if (!response) f->state = FLOW_ALLOCATED; else f->state = FLOW_NULL; if (pthread_cond_signal(&f->state_cond)) LOG_ERR("Failed to send signal."); pthread_mutex_unlock(&f->state_lock); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return 0; } static int flow_dealloc_ipcp(int port_id) { struct irm_flow * f = NULL; pthread_rwlock_rdlock(&irmd->state_lock); pthread_rwlock_wrlock(&irmd->flows_lock); f = get_irm_flow(port_id); if (f == NULL) { pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); return 0; } list_del(&f->next); pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); irm_flow_destroy(f); return 0; } static void irm_destroy() { struct list_head * p; struct list_head * h; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_NULL) LOG_WARN("Unsafe destroy."); if (irmd->threadpool != NULL) free(irmd->threadpool); pthread_rwlock_wrlock(&irmd->flows_lock); list_for_each_safe(p, h, &irmd->irm_flows) { struct irm_flow * f = list_entry(p, struct irm_flow, next); list_del(&f->next); ipcp_flow_dealloc(f->n_1_api, f->port_id); irm_flow_destroy(f); } close(irmd->sockfd); if (unlink(IRM_SOCK_PATH)) LOG_DBG("Failed to unlink %s.", IRM_SOCK_PATH); pthread_rwlock_wrlock(&irmd->reg_lock); /* clear the lists */ list_for_each_safe(p, h, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); list_del(&e->next); ipcp_destroy(e->api); clear_spawned_api(e->api); ipcp_entry_destroy(e); } registry_destroy(&irmd->registry); list_for_each_safe(p, h, &irmd->spawned_apis) { struct pid_el * e = list_entry(p, struct pid_el, next); int status; if (kill(e->pid, SIGTERM)) LOG_DBG("Could not send kill signal to %d.", e->pid); else if (waitpid(e->pid, &status, 0) < 0) LOG_DBG("Error waiting for %d to exit.", e->pid); list_del(&e->next); free(e); } list_for_each_safe(p, h, &irmd->apn_table) { struct apn_entry * e = list_entry(p, struct apn_entry, next); list_del(&e->next); apn_entry_destroy(e); } list_for_each_safe(p, h, &irmd->api_table) { struct api_entry * e = list_entry(p, struct api_entry, next); list_del(&e->next); api_entry_destroy(e); } pthread_rwlock_unlock(&irmd->reg_lock); if (irmd->port_ids != NULL) bmp_destroy(irmd->port_ids); pthread_rwlock_unlock(&irmd->flows_lock); if (irmd->rdrb != NULL) shm_rdrbuff_destroy(irmd->rdrb); if (irmd->lf != NULL) lockfile_destroy(irmd->lf); pthread_rwlock_unlock(&irmd->state_lock); pthread_rwlock_destroy(&irmd->reg_lock); pthread_rwlock_destroy(&irmd->state_lock); free(irmd); } void irmd_sig_handler(int sig, siginfo_t * info, void * c) { switch(sig) { case SIGINT: case SIGTERM: case SIGHUP: LOG_INFO("IRMd shutting down..."); pthread_rwlock_wrlock(&irmd->state_lock); irmd->state = IRMD_NULL; pthread_rwlock_unlock(&irmd->state_lock); break; case SIGPIPE: LOG_DBG("Ignored SIGPIPE."); default: return; } } void * irm_sanitize() { struct timespec now; struct list_head * p = NULL; struct list_head * h = NULL; struct timespec timeout = {IRMD_CLEANUP_TIMER / BILLION, IRMD_CLEANUP_TIMER % BILLION}; int s; while (true) { if (clock_gettime(CLOCK_MONOTONIC, &now) < 0) LOG_WARN("Failed to get time."); /* cleanup stale PENDING flows */ pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); return (void *) 0; } pthread_rwlock_wrlock(&irmd->reg_lock); list_for_each_safe(p, h, &irmd->spawned_apis) { struct pid_el * e = list_entry(p, struct pid_el, next); waitpid(e->pid, &s, WNOHANG); if (kill(e->pid, 0) >= 0) continue; LOG_DBG("Child process %d died, error %d.", e->pid, s); list_del(&e->next); free(e); } list_for_each_safe(p, h, &irmd->api_table) { struct api_entry * e = list_entry(p, struct api_entry, next); if (kill(e->api, 0) >= 0) continue; LOG_DBG("Dead AP-I removed: %d.", e->api); list_del(&e->next); api_entry_destroy(e); } list_for_each_safe(p, h, &irmd->ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); if (kill(e->api, 0) >= 0) continue; LOG_DBG("Dead ipcp removed: %d.", e->api); list_del(&e->next); ipcp_entry_destroy(e); } list_for_each_safe(p, h, &irmd->registry) { struct list_head * p2; struct list_head * h2; struct reg_entry * e = list_entry(p, struct reg_entry, next); list_for_each_safe(p2, h2, &e->reg_apis) { struct pid_el * a = list_entry(p2, struct pid_el, next); if (kill(a->pid, 0) >= 0) continue; LOG_DBG("Dead AP-I removed from: %d %s.", a->pid, e->name); reg_entry_del_api(e, a->pid); } } pthread_rwlock_unlock(&irmd->reg_lock); pthread_rwlock_wrlock(&irmd->flows_lock); list_for_each_safe(p, h, &irmd->irm_flows) { struct irm_flow * f = list_entry(p, struct irm_flow, next); pthread_mutex_lock(&f->state_lock); if (f->state == FLOW_PENDING && ts_diff_ms(&f->t0, &now) > IRMD_FLOW_TIMEOUT) { LOG_INFO("Pending port_id %d timed out.", f->port_id); f->state = FLOW_NULL; pthread_cond_signal(&f->state_cond); pthread_mutex_unlock(&f->state_lock); continue; } pthread_mutex_unlock(&f->state_lock); if (kill(f->n_api, 0) < 0) { struct shm_ap_rbuff * n_rb = shm_ap_rbuff_open_s(f->n_api); bmp_release(irmd->port_ids, f->port_id); list_del(&f->next); LOG_INFO("AP-I %d gone, flow %d deallocated.", f->n_api, f->port_id); ipcp_flow_dealloc(f->n_1_api, f->port_id); if (n_rb != NULL) shm_ap_rbuff_destroy(n_rb); irm_flow_destroy(f); continue; } if (kill(f->n_1_api, 0) < 0) { struct shm_ap_rbuff * n_1_rb_s = shm_ap_rbuff_open_s(f->n_1_api); struct shm_ap_rbuff * n_1_rb_n = shm_ap_rbuff_open_n(f->n_1_api); list_del(&f->next); LOG_ERR("IPCP %d gone, flow %d removed.", f->n_1_api, f->port_id); if (n_1_rb_n != NULL) shm_ap_rbuff_destroy(n_1_rb_n); if (n_1_rb_s != NULL) shm_ap_rbuff_destroy(n_1_rb_s); irm_flow_destroy(f); } } pthread_rwlock_unlock(&irmd->flows_lock); pthread_rwlock_unlock(&irmd->state_lock); nanosleep(&timeout, NULL); } } void * mainloop() { uint8_t buf[IRM_MSG_BUF_SIZE]; while (true) { int cli_sockfd; irm_msg_t * msg; ssize_t count; buffer_t buffer; irm_msg_t ret_msg = IRM_MSG__INIT; struct irm_flow * e = NULL; pid_t * apis = NULL; struct timeval tv = {(SOCKET_TIMEOUT / 1000), (SOCKET_TIMEOUT % 1000) * 1000}; pthread_rwlock_rdlock(&irmd->state_lock); if (irmd->state != IRMD_RUNNING) { pthread_rwlock_unlock(&irmd->state_lock); break; } pthread_rwlock_unlock(&irmd->state_lock); ret_msg.code = IRM_MSG_CODE__IRM_REPLY; cli_sockfd = accept(irmd->sockfd, 0, 0); if (cli_sockfd < 0) continue; if (setsockopt(cli_sockfd, SOL_SOCKET, SO_RCVTIMEO, (void *) &tv, sizeof(tv))) LOG_WARN("Failed to set timeout on socket."); count = read(cli_sockfd, buf, IRM_MSG_BUF_SIZE); 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; } switch (msg->code) { case IRM_MSG_CODE__IRM_CREATE_IPCP: ret_msg.has_result = true; ret_msg.result = create_ipcp(msg->dst_name, msg->ipcp_type); break; case IRM_MSG_CODE__IPCP_CREATE_R: ret_msg.has_result = true; ret_msg.result = create_ipcp_r(msg->api); break; case IRM_MSG_CODE__IRM_DESTROY_IPCP: ret_msg.has_result = true; ret_msg.result = destroy_ipcp(msg->api); break; case IRM_MSG_CODE__IRM_BOOTSTRAP_IPCP: ret_msg.has_result = true; ret_msg.result = bootstrap_ipcp(msg->api, msg->conf); break; case IRM_MSG_CODE__IRM_ENROLL_IPCP: ret_msg.has_result = true; ret_msg.result = enroll_ipcp(msg->api, msg->dif_name[0]); break; case IRM_MSG_CODE__IRM_BIND_AP: ret_msg.has_result = true; ret_msg.result = bind_ap(msg->ap_name, msg->dst_name, msg->opts, msg->n_args, msg->args); break; case IRM_MSG_CODE__IRM_UNBIND_AP: ret_msg.has_result = true; ret_msg.result = unbind_ap(msg->ap_name, msg->dst_name); break; case IRM_MSG_CODE__IRM_API_ANNOUNCE: ret_msg.has_result = true; ret_msg.result = api_announce(msg->api, msg->ap_name); break; case IRM_MSG_CODE__IRM_BIND_API: ret_msg.has_result = true; ret_msg.result = bind_api(msg->api, msg->dst_name); break; case IRM_MSG_CODE__IRM_UNBIND_API: ret_msg.has_result = true; ret_msg.result = unbind_api(msg->api, msg->dst_name); break; case IRM_MSG_CODE__IRM_LIST_IPCPS: ret_msg.n_apis = list_ipcps(msg->dst_name, &apis); ret_msg.apis = apis; ret_msg.has_result = true; break; case IRM_MSG_CODE__IRM_REG: ret_msg.has_result = true; ret_msg.result = name_reg(msg->dst_name, msg->dif_name, msg->n_dif_name); break; case IRM_MSG_CODE__IRM_UNREG: ret_msg.has_result = true; ret_msg.result = name_unreg(msg->dst_name, msg->dif_name, msg->n_dif_name); break; case IRM_MSG_CODE__IRM_FLOW_ACCEPT: e = flow_accept(msg->api, &ret_msg.ae_name); if (e == NULL) { ret_msg.has_result = true; ret_msg.result = -1; break; } ret_msg.has_port_id = true; ret_msg.port_id = e->port_id; ret_msg.has_api = true; ret_msg.api = e->n_1_api; break; case IRM_MSG_CODE__IRM_FLOW_ALLOC_RESP: ret_msg.has_result = true; ret_msg.result = flow_alloc_resp(msg->api, msg->port_id, msg->response); break; case IRM_MSG_CODE__IRM_FLOW_ALLOC: e = flow_alloc(msg->api, msg->dst_name, msg->ae_name, NULL); if (e == NULL) { ret_msg.has_result = true; ret_msg.result = -1; break; } /* FIXME: badly timed dealloc may give SEGV */ ret_msg.has_port_id = true; ret_msg.port_id = e->port_id; ret_msg.has_api = true; ret_msg.api = e->n_1_api; break; case IRM_MSG_CODE__IRM_FLOW_ALLOC_RES: ret_msg.has_result = true; ret_msg.result = flow_alloc_res(msg->port_id); break; case IRM_MSG_CODE__IRM_FLOW_DEALLOC: ret_msg.has_result = true; ret_msg.result = flow_dealloc(msg->port_id); break; case IRM_MSG_CODE__IPCP_FLOW_REQ_ARR: e = flow_req_arr(msg->api, msg->dst_name, msg->ae_name); if (e == NULL) { ret_msg.has_result = true; ret_msg.result = -1; break; } /* FIXME: badly timed dealloc may give SEGV */ ret_msg.has_port_id = true; ret_msg.port_id = e->port_id; ret_msg.has_api = true; ret_msg.api = e->n_api; break; case IRM_MSG_CODE__IPCP_FLOW_ALLOC_REPLY: ret_msg.has_result = true; ret_msg.result = flow_alloc_reply(msg->port_id, msg->response); 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.len = irm_msg__get_packed_size(&ret_msg); if (buffer.len == 0) { LOG_ERR("Failed to calculate length of reply message."); if (apis != NULL) free(apis); close(cli_sockfd); continue; } buffer.data = malloc(buffer.len); if (buffer.data == NULL) { if (apis != NULL) free(apis); close(cli_sockfd); continue; } irm_msg__pack(&ret_msg, buffer.data); if (apis != NULL) free(apis); if (write(cli_sockfd, buffer.data, buffer.len) == -1) LOG_WARN("Failed to send reply message."); free(buffer.data); close(cli_sockfd); } return (void *) 0; } static int irm_create() { struct stat st = {0}; struct timeval timeout = {(IRMD_ACCEPT_TIMEOUT / 1000), (IRMD_ACCEPT_TIMEOUT % 1000) * 1000}; irmd = malloc(sizeof(*irmd)); if (irmd == NULL) return -ENOMEM; irmd->state = IRMD_NULL; if (pthread_rwlock_init(&irmd->state_lock, NULL)) { LOG_ERR("Failed to initialize rwlock."); free(irmd); return -1; } if (pthread_rwlock_init(&irmd->reg_lock, NULL)) { LOG_ERR("Failed to initialize rwlock."); free(irmd); return -1; } if (pthread_rwlock_init(&irmd->flows_lock, NULL)) { LOG_ERR("Failed to initialize rwlock."); free(irmd); return -1; } INIT_LIST_HEAD(&irmd->ipcps); INIT_LIST_HEAD(&irmd->api_table); INIT_LIST_HEAD(&irmd->apn_table); INIT_LIST_HEAD(&irmd->spawned_apis); INIT_LIST_HEAD(&irmd->registry); INIT_LIST_HEAD(&irmd->irm_flows); irmd->port_ids = bmp_create(IRMD_MAX_FLOWS, 0); if (irmd->port_ids == NULL) { irm_destroy(); return -ENOMEM; } irmd->threadpool = malloc(sizeof(pthread_t) * IRMD_THREADPOOL_SIZE); if (irmd->threadpool == NULL) { irm_destroy(); return -ENOMEM; } if (stat(SOCK_PATH, &st) == -1) { if (mkdir(SOCK_PATH, 0777)) { LOG_ERR("Failed to create sockets directory."); irm_destroy(); return -1; } } irmd->sockfd = server_socket_open(IRM_SOCK_PATH); if (irmd->sockfd < 0) { irm_destroy(); return -1; } if (setsockopt(irmd->sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, sizeof(timeout)) < 0) { LOG_ERR("Failed setting socket option."); irm_destroy(); return -1; } if (chmod(IRM_SOCK_PATH, 0666)) { LOG_ERR("Failed to chmod socket."); irm_destroy(); return -1; } if ((irmd->lf = lockfile_create()) == NULL) { if ((irmd->lf = lockfile_open()) == NULL) { LOG_ERR("Lockfile error."); irm_destroy(); return -1; } if (kill(lockfile_owner(irmd->lf), 0) < 0) { LOG_INFO("IRMd didn't properly shut down last time."); /* FIXME: do this for each QOS_CUBE in the system */ shm_rdrbuff_destroy(shm_rdrbuff_open(QOS_CUBE_BE)); LOG_INFO("Stale resources cleaned"); lockfile_destroy(irmd->lf); irmd->lf = lockfile_create(); } else { LOG_INFO("IRMd already running (%d), exiting.", lockfile_owner(irmd->lf)); lockfile_close(irmd->lf); free(irmd); return -1; } } if (irmd->lf == NULL) { irm_destroy(); return -1; } /* FIXME: create an rdrb for each QOS_CUBE in the system */ if ((irmd->rdrb = shm_rdrbuff_create(QOS_CUBE_BE)) == NULL) { irm_destroy(); return -1; } irmd->state = IRMD_RUNNING; LOG_INFO("Ouroboros IPC Resource Manager daemon started..."); return 0; } static void usage() { LOG_ERR("Usage: irmd \n\n" " [--stdout (Print to stdout instead of logs)]\n"); } int main(int argc, char ** argv) { struct sigaction sig_act; int t = 0; char * log_file = INSTALL_PREFIX LOG_DIR "irmd.log"; DIR * log_dir; struct dirent * ent; char * point; char * log_path; size_t len = 0; bool use_stdout = false; if (geteuid() != 0) { LOG_ERR("IPC Resource Manager must be run as root."); exit(EXIT_FAILURE); } argc--; argv++; while (argc > 0) { if (strcmp(*argv, "--stdout") == 0) { use_stdout = true; argc--; argv++; } else { usage(); exit(EXIT_FAILURE); } } if (!use_stdout && (log_dir = opendir(INSTALL_PREFIX LOG_DIR)) != NULL) { while ((ent = readdir(log_dir)) != NULL) { point = strrchr(ent->d_name,'.'); if (point == NULL || strcmp(point, ".log") != 0) continue; len += strlen(INSTALL_PREFIX); len += strlen(LOG_DIR); len += strlen(ent->d_name); log_path = malloc(len + 1); if (log_path == NULL) { LOG_ERR("Failed to malloc"); exit(EXIT_FAILURE); } strcpy(log_path, INSTALL_PREFIX); strcat(log_path, LOG_DIR); strcat(log_path, ent->d_name); unlink(log_path); free(log_path); len = 0; } closedir(log_dir); } if (!use_stdout && (set_logfile(log_file) < 0)) LOG_ERR("Cannot open %s, falling back to stdout for logs.", log_file); /* init sig_act */ memset(&sig_act, 0, sizeof sig_act); /* install signal traps */ sig_act.sa_sigaction = &irmd_sig_handler; sig_act.sa_flags = SA_SIGINFO; if (sigaction(SIGINT, &sig_act, NULL) < 0) exit(EXIT_FAILURE); if (sigaction(SIGTERM, &sig_act, NULL) < 0) exit(EXIT_FAILURE); if (sigaction(SIGHUP, &sig_act, NULL) < 0) exit(EXIT_FAILURE); if (sigaction(SIGPIPE, &sig_act, NULL) < 0) exit(EXIT_FAILURE); if (irm_create() < 0) { close_logfile(); exit(EXIT_FAILURE); } for (t = 0; t < IRMD_THREADPOOL_SIZE; ++t) pthread_create(&irmd->threadpool[t], NULL, mainloop, NULL); pthread_create(&irmd->irm_sanitize, NULL, irm_sanitize, NULL); pthread_create(&irmd->shm_sanitize, NULL, shm_rdrbuff_sanitize, irmd->rdrb); /* wait for (all of them) to return */ for (t = 0; t < IRMD_THREADPOOL_SIZE; ++t) pthread_join(irmd->threadpool[t], NULL); pthread_join(irmd->irm_sanitize, NULL); pthread_cancel(irmd->shm_sanitize); pthread_join(irmd->shm_sanitize, NULL); irm_destroy(); close_logfile(); LOG_INFO("Bye."); exit(EXIT_SUCCESS); }