ntsimulator/ntsim-ng/core/framework.c

   1 /*************************************************************************
   2 *
   3 * Copyright 2020 highstreet technologies GmbH and others
   4 *
   5 * Licensed under the Apache License, Version 2.0 (the "License");
   6 * you may not use this file except in compliance with the License.
   7 * You may obtain a copy of the License at
   8 *
   9 *     http://www.apache.org/licenses/LICENSE-2.0
  10 *
  11 * Unless required by applicable law or agreed to in writing, software
  12 * distributed under the License is distributed on an "AS IS" BASIS,
  13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 * See the License for the specific language governing permissions and
  15 * limitations under the License.
  16 ***************************************************************************/
  17
  18 #define _GNU_SOURCE
  19
  20 #include "framework.h"
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <unistd.h>
  25 #include <limits.h>
  26 #include <assert.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <cjson/cJSON.h>
  30
  31 #include "utils/sys_utils.h"
  32 #include "utils/log_utils.h"
  33 #include "utils/rand_utils.h"
  34
  35 framework_arguments_t framework_arguments;
  36 framework_environment_t framework_environment;
  37 framework_config_t framework_config;
  38
  39 const char *argp_program_version = 0;    //is set later
  40 const char *argp_program_bug_address = "<alexandru.stancu@highstreet-technologies.com> / <adrian.lita@highstreet-technologies.com>";
  41 static char doc[] = "ntsim - new generation";
  42
  43 static struct argp_option options[] = {
  44     { "container-init", 'i', 0, 0, "Runs initialization tasks for the Docker container that's being built. Do not run manually." },
  45     { "supervisor", 's', 0, 0, "Run as supervisor; manager/network-function is chosen via config.json"},
  46     { "manager", 'm', 0, 0, "Run the daemon as manager." },
  47     { "network-function", 'f', 0, 0, "Run the daemon as network function." },
  48     { "generate", 'g', 0, 0, "Generate population data without commiting." },
  49     { "test-mode", 't', 0, 0, "Test mode." },
  50
  51     // tools
  52     { "ls", '1', 0, 0, "Print all available root paths." },
  53     { "schema", '2', "XPATH", 0, "Print schema for XPATH." },
  54
  55     { "fixed-rand", 'r', "SEED", 0, "Initialize RAND seed to a fixed value (for debugging purposes)." },
  56     { "verbose", 'v', "LEVEL", 0, "Verbosity level for printing to stdout (logs will still save everything). LEVEL is: 0=errors only, 1=requested info(default), 2=info" },
  57     { "workspace", 'w', "PATH", 0, "Initialize workspace to a different one than the current working directory." },
  58     { 0 }
  59 };
  60
  61 volatile sig_atomic_t framework_sigint;
  62
  63 static int framework_env_init(void);
  64 static int framework_config_init(void);
  65
  66 static void framework_signal_handler(int signo);
  67 static error_t parse_opt(int key, char *arg, struct argp_state *state);
  68
  69 int framework_init(int argc, char **argv) {
  70     //environment vars
  71     framework_environment.nts.version = getenv(ENV_VAR_NTS_BUILD_VERSION) ? strdup(getenv(ENV_VAR_NTS_BUILD_VERSION)) : strdup("N/A");
  72     framework_environment.nts.build_time = getenv(ENV_VAR_NTS_BUILD_TIME) ? strdup(getenv(ENV_VAR_NTS_BUILD_TIME)) : strdup("N/A");
  73
  74     //set argp_version
  75     char *version = 0;
  76     asprintf(&version, "ntsim-ng v%s build %s", framework_environment.nts.version, framework_environment.nts.build_time);
  77     argp_program_version = version;
  78
  79     //initialize app arguments
  80     framework_arguments.nts_mode = NTS_MODE_DEFAULT;
  81
  82     framework_arguments.argc = argc;
  83     framework_arguments.argv = argv;
  84
  85     framework_arguments.no_rand = false;
  86     framework_arguments.fixed_seed = 0;
  87     framework_arguments.verbosity_level = 1;
  88
  89     framework_arguments.print_root_paths = false;
  90     framework_arguments.print_structure_xpath = 0;
  91
  92     //parse provided command line arguments
  93     struct argp argp = { options, parse_opt, 0, doc, 0, 0, 0 };
  94     argp_parse(&argp, argc, argv, 0, 0, &framework_arguments);
  95
  96     //manage signals
  97     framework_sigint = 0;
  98     signal(SIGINT, framework_signal_handler);
  99     signal(SIGTERM, framework_signal_handler);
 100     signal(SIGQUIT, framework_signal_handler);
 101
 102     //disable buffering for stdout
 103     setbuf(stdout, NULL);
 104
 105     //init logging subsystem
 106     char *log_file = 0;
 107     char *stderr_file = 0;
 108
 109     if(!dir_exists("log")) {
 110         mkdir("log", 0777);
 111     }
 112
 113     switch(framework_arguments.nts_mode) {
 114         case NTS_MODE_CONTAINER_INIT:
 115             log_file = "log/log-install.txt";
 116             stderr_file = "log/stderr-install.txt";
 117             break;
 118
 119         case NTS_MODE_SUPERVISOR:
 120             log_file = "log/log-supervisor.txt";
 121             stderr_file = "log/stderr-supervisor.txt";
 122             break;
 123
 124         case NTS_MODE_GENERATE_DATA:
 125             log_file = "log/log-generate.txt";
 126             stderr_file = "log/stderr-generate.txt";
 127             break;
 128
 129         default:
 130             log_file = "log/log.txt";
 131             stderr_file = "log/stderr.txt";
 132             break;
 133     }
 134
 135     log_init(log_file);
 136     log_redirect_stderr(stderr_file);
 137
 138     char cwd[PATH_MAX];
 139     getcwd(cwd, sizeof(cwd));
 140     log_add_verbose(2, "[framework] current working dir is: %s\n", cwd);
 141
 142     //init rand generator if needed
 143     if(framework_arguments.no_rand == false) {
 144         rand_init();
 145     }
 146     else {
 147         rand_init_fixed(framework_arguments.fixed_seed);
 148     }
 149
 150     log_add_verbose(2, "[framework] app was called: ");
 151     for(int i = 0; i < argc; i++) {
 152         log_add(2, "%s ", argv[i]);
 153     }
 154     log_add(2, "\n");
 155
 156     if(framework_env_init() != NTS_ERR_OK) {
 157         log_error("[framework] framework_env_init() failed\n");
 158         return NTS_ERR_FAILED;
 159     }
 160
 161     if(framework_config_init() != NTS_ERR_OK) {
 162         log_error("[framework] framework_config_init() failed\n");
 163         return NTS_ERR_FAILED;
 164     }
 165
 166     log_add_verbose(2, "[framework] init complete\n");
 167     return NTS_ERR_OK;
 168 }
 169
 170 static int framework_env_init(void) {
 171     log_add_verbose(2, "[framework-env] started\n");
 172
 173     /*
 174     The following env vars are taken care of by framework_init()
 175         framework_environment.nts.version
 176         framework_environment.nts.build_time
 177     */
 178
 179     framework_environment.nts.manual = getenv(ENV_VAR_NTS_MANUAL) ? true : false;
 180     framework_environment.nts.function_type = getenv(ENV_VAR_NTS_FUNCTION_TYPE) ? strdup(getenv(ENV_VAR_NTS_FUNCTION_TYPE)) : strdup("");
 181     framework_environment.nts.nf_standalone_start_features = getenv(ENV_VAR_NTS_NF_STANDALONE_START_FEATURES) ? strdup(getenv(ENV_VAR_NTS_NF_STANDALONE_START_FEATURES)) : strdup("");
 182
 183     framework_environment.settings.docker_engine_version = getenv(ENV_VAR_DOCKER_ENGINE_VERSION) ? strdup(getenv(ENV_VAR_DOCKER_ENGINE_VERSION)) : strdup("1.40");
 184     framework_environment.settings.hostname = getenv(ENV_VAR_HOSTNAME) ? strdup(getenv(ENV_VAR_HOSTNAME)) : strdup("localhost");
 185
 186     bool ip_ok = get_local_ips("eth0", &framework_environment.settings.ip_v4, &framework_environment.settings.ip_v6);
 187     if(!ip_ok) {
 188         log_error("[framework-env] could not get local IP addresses\n");
 189     }
 190
 191     char *ipv6_env_var = getenv(ENV_VAR_IPV6ENABLED);
 192     if(ipv6_env_var == 0) {
 193         log_error("[framework-env] could not get the IPv6 Enabled env variable\n");
 194     }
 195     framework_environment.settings.ip_v6_enabled = (strcmp(ipv6_env_var, "true") == 0) ? true : false;
 196     framework_environment.settings.ssh_connections = get_int_from_string_with_default(getenv(ENV_VAR_SSH_CONNECTIONS), 1);
 197     framework_environment.settings.tls_connections = get_int_from_string_with_default(getenv(ENV_VAR_TLS_CONNECTIONS), 0);
 198     framework_environment.settings.ftp_connections = 1;
 199     framework_environment.settings.sftp_connections = 1;
 200
 201     //build version and build time are set in the begining of the function
 202     framework_environment.host.ip = getenv(ENV_VAR_HOST_IP) ? strdup(getenv(ENV_VAR_HOST_IP)) : strdup("127.0.0.1");
 203     framework_environment.host.base_port = get_int_from_string_with_default(getenv(ENV_VAR_HOST_BASE_PORT), 1000);
 204     framework_environment.host.ssh_base_port = get_int_from_string_with_default(getenv(ENV_VAR_HOST_NETCONF_SSH_BASE_PORT), 0);
 205     framework_environment.host.tls_base_port = get_int_from_string_with_default(getenv(ENV_VAR_HOST_NETCONF_TLS_BASE_PORT), 0);
 206     framework_environment.host.ftp_base_port = get_int_from_string_with_default(getenv(ENV_VAR_HOST_TRANSFER_FTP_BASE_PORT), 0);
 207     framework_environment.host.sftp_base_port = get_int_from_string_with_default(getenv(ENV_VAR_HOST_TRANSFER_SFTP_BASE_PORT), 0);
 208
 209     framework_environment.sdn_controller.protocol = getenv(ENV_VAR_SDN_CONTROLLER_IP) ? strdup(getenv(ENV_VAR_SDN_CONTROLLER_PROTOCOL)) : strdup("https");
 210     framework_environment.sdn_controller.ip = getenv(ENV_VAR_SDN_CONTROLLER_IP) ? strdup(getenv(ENV_VAR_SDN_CONTROLLER_IP)) : strdup("127.0.0.1");
 211     framework_environment.sdn_controller.port = get_int_from_string_with_default(getenv(ENV_VAR_SDN_CONTROLLER_PORT), 8181);
 212     framework_environment.sdn_controller.callhome_port = get_int_from_string_with_default(getenv(ENV_VAR_SDN_CONTROLLER_CALLHOME_PORT), 6666);
 213     framework_environment.sdn_controller.username = getenv(ENV_VAR_SDN_CONTROLLER_USERNAME) ? strdup(getenv(ENV_VAR_SDN_CONTROLLER_USERNAME)) : strdup("admin");
 214     framework_environment.sdn_controller.password = getenv(ENV_VAR_SDN_CONTROLLER_PASSWORD) ? strdup(getenv(ENV_VAR_SDN_CONTROLLER_PASSWORD)) : strdup("admin");
 215
 216     framework_environment.ves_endpoint.common_header_version = getenv(ENV_VAR_VES_COMMON_HEADER_VERSION) ? strdup(getenv(ENV_VAR_VES_COMMON_HEADER_VERSION)) : strdup("7.2");
 217     framework_environment.ves_endpoint.protocol = getenv(ENV_VAR_VES_ENDPOINT_PROTOCOL) ? strdup(getenv(ENV_VAR_VES_ENDPOINT_PROTOCOL)) : strdup("https");
 218     framework_environment.ves_endpoint.ip = getenv(ENV_VAR_VES_ENDPOINT_IP) ? strdup(getenv(ENV_VAR_VES_ENDPOINT_IP)) : strdup("127.0.0.1");
 219     framework_environment.ves_endpoint.port = get_int_from_string_with_default(getenv(ENV_VAR_VES_ENDPOINT_PORT), 1234);
 220     framework_environment.ves_endpoint.auth_method = getenv(ENV_VAR_VES_ENDPOINT_AUTH_METHOD) ? strdup(getenv(ENV_VAR_VES_ENDPOINT_AUTH_METHOD)) : strdup("no-auth");
 221     framework_environment.ves_endpoint.username = getenv(ENV_VAR_VES_ENDPOINT_USERNAME) ? strdup(getenv(ENV_VAR_VES_ENDPOINT_USERNAME)) : strdup("admin");
 222     framework_environment.ves_endpoint.password = getenv(ENV_VAR_VES_ENDPOINT_PASSWORD) ? strdup(getenv(ENV_VAR_VES_ENDPOINT_PASSWORD)) : strdup("admin");
 223     framework_environment.ves_endpoint.certificate = getenv(ENV_VAR_VES_ENDPOINT_CERTIFICATE) ? strdup(getenv(ENV_VAR_VES_ENDPOINT_CERTIFICATE)) : strdup("");
 224
 225     log_add_verbose(2, "[framework-env] nts.manual = %d\n", framework_environment.nts.manual);
 226     log_add_verbose(2, "[framework-env] nts.version = %s\n", framework_environment.nts.version);
 227     log_add_verbose(2, "[framework-env] nts.build_time = %s\n", framework_environment.nts.build_time);
 228     log_add_verbose(2, "[framework-env] nts.function_type = %s\n", framework_environment.nts.function_type);
 229     log_add_verbose(2, "[framework-env] nts.nf_standalone_start_features = %s\n", framework_environment.nts.nf_standalone_start_features);
 230
 231     log_add_verbose(2, "[framework-env] settings.docker_engine_version = %s\n", framework_environment.settings.docker_engine_version);
 232     log_add_verbose(2, "[framework-env] settings.hostname = %s\n", framework_environment.settings.hostname);
 233     log_add_verbose(2, "[framework-env] settings.ip_v4 = %s\n", framework_environment.settings.ip_v4);
 234     log_add_verbose(2, "[framework-env] settings.ip_v6 = %s\n", framework_environment.settings.ip_v6);
 235     log_add_verbose(2, "[framework-env] settings.ip_v6_enabled = %s\n", framework_environment.settings.ip_v6_enabled ? "true" : "false");
 236     log_add_verbose(2, "[framework-env] settings.ssh_connections = %d\n", framework_environment.settings.ssh_connections);
 237     log_add_verbose(2, "[framework-env] settings.tls_connections = %d\n", framework_environment.settings.tls_connections);
 238     log_add_verbose(2, "[framework-env] settings.ftp_connections = %d\n", framework_environment.settings.ftp_connections);
 239     log_add_verbose(2, "[framework-env] settings.sftp_connections = %d\n", framework_environment.settings.sftp_connections);
 240
 241     //check ports
 242     if(framework_environment.host.base_port < 1000) {
 243         log_add_verbose(2, "[framework-env] host.base_port < 1000 -> disabling\n");
 244         framework_environment.host.base_port = 0;
 245     }
 246
 247     if(framework_environment.host.ssh_base_port < 1000) {
 248         log_add_verbose(2, "[framework-env] host.ssh_base_port < 1000 -> using base_port\n");
 249         framework_environment.host.ssh_base_port = framework_environment.host.base_port;
 250     }
 251
 252     if(framework_environment.host.tls_base_port < 1000) {
 253         log_add_verbose(2, "[framework-env] host.tls_base_port < 1000 -> using base_port\n");
 254         framework_environment.host.tls_base_port = framework_environment.host.base_port;
 255     }
 256
 257     if(framework_environment.host.ftp_base_port < 1000) {
 258         log_add_verbose(2, "[framework-env] host.ftp_base_port < 1000 -> using base_port\n");
 259         framework_environment.host.ftp_base_port = framework_environment.host.base_port;
 260     }
 261
 262     if(framework_environment.host.sftp_base_port < 1000) {
 263         log_add_verbose(2, "[framework-env] host.sftp_base_port < 1000 -> using base_port\n");
 264         framework_environment.host.sftp_base_port = framework_environment.host.base_port;
 265     }
 266
 267     if(framework_environment.host.base_port == 0) {
 268         if(framework_environment.host.ssh_base_port == 0) {
 269             log_error("[framework-env] host.ssh_base_port unknown\n");
 270             return NTS_ERR_FAILED;
 271         }
 272
 273         if(framework_environment.host.tls_base_port == 0) {
 274             log_error("[framework-env] host.tls_base_port unknown\n");
 275             return NTS_ERR_FAILED;
 276         }
 277
 278         if(framework_environment.host.ftp_base_port == 0) {
 279             log_error("[framework-env] host.ftp_base_port unknown\n");
 280             return NTS_ERR_FAILED;
 281         }
 282
 283         if(framework_environment.host.sftp_base_port == 0) {
 284             log_error("[framework-env] host.sftp_base_port unknown\n");
 285             return NTS_ERR_FAILED;
 286         }
 287     }
 288
 289     log_add_verbose(2, "[framework-env] host.ip = %s\n", framework_environment.host.ip);
 290     if(framework_environment.settings.ip_v6_enabled) {
 291         if(strstr(framework_environment.host.ip, ".")) {
 292             log_error("[framework-env] host.ip is an invalid IP v6\n");
 293         }
 294     }
 295     else {
 296         if(strstr(framework_environment.host.ip, ":")) {
 297             log_error("[framework-env] host.ip is an invalid IP v4\n");
 298         }
 299     }
 300
 301     log_add_verbose(2, "[framework-env] host.base_port = %d\n", framework_environment.host.base_port);
 302     log_add_verbose(2, "[framework-env] host.ssh_base_port = %d\n", framework_environment.host.ssh_base_port);
 303     log_add_verbose(2, "[framework-env] host.tls_base_port = %d\n", framework_environment.host.tls_base_port);
 304     log_add_verbose(2, "[framework-env] host.ftp_base_port = %d\n", framework_environment.host.ftp_base_port);
 305     log_add_verbose(2, "[framework-env] host.sftp_base_port = %d\n", framework_environment.host.sftp_base_port);
 306
 307     log_add_verbose(2, "[framework-env] sdn_controller.protocol = %s\n", framework_environment.sdn_controller.protocol);
 308     log_add_verbose(2, "[framework-env] sdn_controller.ip = %s\n", framework_environment.sdn_controller.ip);
 309     log_add_verbose(2, "[framework-env] sdn_controller.port = %d\n", framework_environment.sdn_controller.port);
 310     log_add_verbose(2, "[framework-env] sdn_controller.callhome_port = %d\n", framework_environment.sdn_controller.callhome_port);
 311     log_add_verbose(2, "[framework-env] sdn_controller.username = %s\n", framework_environment.sdn_controller.username);
 312     log_add_verbose(2, "[framework-env] sdn_controller.password = %s\n", framework_environment.sdn_controller.password);
 313
 314     log_add_verbose(2, "[framework-env] ves_endpoint.common_header_version = %s\n", framework_environment.ves_endpoint.common_header_version);
 315     log_add_verbose(2, "[framework-env] ves_endpoint.protocol = %s\n", framework_environment.ves_endpoint.protocol);
 316     log_add_verbose(2, "[framework-env] ves_endpoint.ip = %s\n", framework_environment.ves_endpoint.ip);
 317     log_add_verbose(2, "[framework-env] ves_endpoint.port = %d\n", framework_environment.ves_endpoint.port);
 318     log_add_verbose(2, "[framework-env] ves_endpoint.auth_method = %s\n", framework_environment.ves_endpoint.auth_method);
 319     log_add_verbose(2, "[framework-env] ves_endpoint.username = %s\n", framework_environment.ves_endpoint.username);
 320     log_add_verbose(2, "[framework-env] ves_endpoint.password = %s\n", framework_environment.ves_endpoint.password);
 321     log_add_verbose(2, "[framework-env] ves_endpoint.certificate = %s\n", framework_environment.ves_endpoint.certificate);
 322
 323     log_add_verbose(2, "[framework-env] finished\n");
 324     return NTS_ERR_OK;
 325 }
 326
 327 static int framework_config_init(void) {
 328     log_add_verbose(2, "[framework-config] started\n");
 329
 330     //init app config
 331     framework_config.docker.excluded_modules = 0;
 332     framework_config.docker.excluded_modules_count = 0;
 333     framework_config.docker.excluded_features = 0;
 334     framework_config.docker.excluded_features_count = 0;
 335
 336     framework_config.supervisor.rules_count = 0;
 337     framework_config.supervisor.rules = 0;
 338
 339     framework_config.datastore_generate.debug_max_string_size = 0;
 340     framework_config.datastore_generate.excluded_modules = 0;
 341     framework_config.datastore_generate.excluded_modules_count = 0;
 342     framework_config.datastore_generate.default_list_instances = 1;
 343     framework_config.datastore_generate.custom_list_instances_count = 0;
 344     framework_config.datastore_generate.custom_list_instances = 0;
 345     framework_config.datastore_generate.restrict_schema_count = 0;
 346     framework_config.datastore_generate.restrict_schema = 0;
 347
 348     framework_config.datastore_populate.random_generation_enabled = 1;
 349     framework_config.datastore_populate.preg_operational_count = 0;
 350     framework_config.datastore_populate.preg_operational = 0;
 351     framework_config.datastore_populate.preg_running_count = 0;
 352     framework_config.datastore_populate.preg_running = 0;
 353
 354     //config init
 355     if(!dir_exists("config")) {
 356         log_add_verbose(2, "[framework-config] config/ folder wasn't found; created.\n");
 357         mkdir("config", 0777);
 358     }
 359
 360     if(!file_exists("config/config.json")) {
 361         log_add_verbose(2, "[framework-config] config.json file missing; created.\n");
 362         file_touch("config/config.json", "{}");
 363     }
 364
 365     log_add_verbose(2, "[framework-config] parsing config.json\n");
 366     char *config_contents = file_read_content("config/config.json");
 367     cJSON *json = cJSON_Parse(config_contents);
 368     free(config_contents);
 369     if(!json) {
 370         log_error("[framework-config] config.json error: %s\n", cJSON_GetErrorPtr());
 371     }
 372     else {
 373         cJSON *main_node;
 374         cJSON *node;
 375
 376         if(framework_arguments.nts_mode == NTS_MODE_CONTAINER_INIT) {
 377             main_node = cJSON_GetObjectItem(json, "container-rules");
 378             if(main_node) {
 379                 node = cJSON_GetObjectItem(main_node, "excluded-modules");
 380                 if(node) {
 381                     if(cJSON_IsArray(node)) {
 382                         cJSON *element;
 383                         cJSON_ArrayForEach(element, node) {
 384                             if(cJSON_IsString(element)) {
 385                                 log_add_verbose(2, "[framework-config] adding container-rules/exclude-modules: %s\n", element->valuestring);
 386                                 framework_config.docker.excluded_modules = (char **)realloc(framework_config.docker.excluded_modules, sizeof(char*) * (framework_config.docker.excluded_modules_count + 1));
 387                                 if(!framework_config.docker.excluded_modules) {
 388                                     log_error("[framework-config] bad realloc\n");
 389                                 }
 390                                 framework_config.docker.excluded_modules[framework_config.docker.excluded_modules_count] = (char *)malloc(sizeof(char) * (strlen(element->valuestring) + 1));
 391                                 if(!framework_config.docker.excluded_modules[framework_config.docker.excluded_modules_count]) {
 392                                     log_error("[framework-config] bad malloc\n");
 393                                 }
 394                                 strcpy(framework_config.docker.excluded_modules[framework_config.docker.excluded_modules_count], element->valuestring);
 395                                 framework_config.docker.excluded_modules_count++;
 396                             }
 397                         }
 398                     }
 399                 }
 400
 401                 node = cJSON_GetObjectItem(main_node, "excluded-features");
 402                 if(node) {
 403                     if(cJSON_IsArray(node)) {
 404                         cJSON *element;
 405                         cJSON_ArrayForEach(element, node) {
 406                             if(cJSON_IsString(element)) {
 407                                 log_add_verbose(2, "[framework-config] adding container-rules/excluded-features: %s\n", element->valuestring);
 408                                 framework_config.docker.excluded_features = (char **)realloc(framework_config.docker.excluded_features, sizeof(char*) * (framework_config.docker.excluded_features_count + 1));
 409                                 if(!framework_config.docker.excluded_features) {
 410                                     log_error("[framework-config] bad realloc\n");
 411                                 }
 412                                 framework_config.docker.excluded_features[framework_config.docker.excluded_features_count] = (char *)malloc(sizeof(char) * (strlen(element->valuestring) + 1));
 413                                 if(!framework_config.docker.excluded_features[framework_config.docker.excluded_features_count]) {
 414                                     log_error("[framework-config] bad malloc\n");
 415                                 }
 416                                 strcpy(framework_config.docker.excluded_features[framework_config.docker.excluded_features_count], element->valuestring);
 417                                 framework_config.docker.excluded_features_count++;
 418                             }
 419                         }
 420                     }
 421                 }
 422             }
 423         }
 424         else if(framework_arguments.nts_mode == NTS_MODE_SUPERVISOR) {
 425             main_node = cJSON_GetObjectItem(json, "supervisor-rules");
 426             if(main_node) {
 427                 cJSON *app;
 428                 cJSON_ArrayForEach(app, main_node) {
 429                     if(cJSON_IsObject(app)) {
 430                         cJSON *object = cJSON_GetObjectItem(app, "path");
 431                         if(object) {
 432                             framework_config.supervisor.rules = (supervisor_rules_t *)realloc(framework_config.supervisor.rules, sizeof(supervisor_rules_t) * (framework_config.supervisor.rules_count + 1));
 433                             if(!framework_config.supervisor.rules) {
 434                                 log_error("[framework-config] bad realloc\n");
 435                             }
 436
 437                             char *path = strdup(object->valuestring);
 438                             bool autorestart = false;
 439                             bool nomanual = false;
 440                             char *stdout_path = 0;
 441                             char *stderr_path = 0;
 442
 443                             int args_count = 0;
 444                             char **args = 0;
 445                             cJSON *args_json = cJSON_GetObjectItem(app, "args");
 446                             if(args_json) {
 447                                 args_count = cJSON_GetArraySize(args_json);
 448                                 if(args_count) {
 449                                     args = malloc(sizeof(char *) * args_count);
 450                                     int i = 0;
 451                                     cJSON *arg;
 452                                     cJSON_ArrayForEach(arg, args_json) {
 453                                         args[i] = strdup(arg->valuestring);
 454                                         i++;
 455                                     }
 456                                 }
 457                             }
 458
 459                             object = cJSON_GetObjectItem(app, "autorestart");
 460                             if(object) {
 461                                 autorestart = object->valueint;
 462                             }
 463
 464                             object = cJSON_GetObjectItem(app, "nomanual");
 465                             if(object) {
 466                                 nomanual = object->valueint;
 467                             }
 468
 469                             object = cJSON_GetObjectItem(app, "stdout");
 470                             if(object) {
 471                                 stdout_path = strdup(object->valuestring);
 472                             }
 473
 474                             object = cJSON_GetObjectItem(app, "stderr");
 475                             if(object) {
 476                                 stderr_path = strdup(object->valuestring);
 477                             }
 478
 479                             framework_config.supervisor.rules[framework_config.supervisor.rules_count].name = strdup(app->string);
 480                             framework_config.supervisor.rules[framework_config.supervisor.rules_count].path = path;
 481                             framework_config.supervisor.rules[framework_config.supervisor.rules_count].args = args;
 482                             framework_config.supervisor.rules[framework_config.supervisor.rules_count].args_count = args_count;
 483                             framework_config.supervisor.rules[framework_config.supervisor.rules_count].autorestart = autorestart;
 484                             framework_config.supervisor.rules[framework_config.supervisor.rules_count].nomanual = nomanual;
 485                             framework_config.supervisor.rules[framework_config.supervisor.rules_count].stdout_path = stdout_path;
 486                             framework_config.supervisor.rules[framework_config.supervisor.rules_count].stderr_path = stderr_path;
 487
 488                             log_add_verbose(2, "[framework-config] adding supervisor command: %s with autorestart: %d\n", path, autorestart);
 489                             framework_config.supervisor.rules_count++;
 490                         }
 491                     }
 492                 }
 493             }
 494         }
 495         else {
 496             main_node = cJSON_GetObjectItem(json, "datastore-random-generation-rules");
 497             if(main_node) {
 498                 node = cJSON_GetObjectItem(main_node, "excluded-modules");
 499                 if(node) {
 500                     if(cJSON_IsArray(node)) {
 501                         cJSON *element;
 502                         cJSON_ArrayForEach(element, node) {
 503                             if(cJSON_IsString(element)) {
 504                                 log_add_verbose(2, "[framework-config] adding datastore-random-generation-rules/excluded-modules: %s\n", element->valuestring);
 505                                 framework_config.datastore_generate.excluded_modules = (char **)realloc(framework_config.datastore_generate.excluded_modules, sizeof(char*) * (framework_config.datastore_generate.excluded_modules_count + 1));
 506                                 if(!framework_config.datastore_generate.excluded_modules) {
 507                                     log_error("[framework-config] bad realloc\n");
 508                                 }
 509                                 framework_config.datastore_generate.excluded_modules[framework_config.datastore_generate.excluded_modules_count] = (char *)malloc(sizeof(char) * (strlen(element->valuestring) + 1));
 510                                 if(!framework_config.datastore_generate.excluded_modules[framework_config.datastore_generate.excluded_modules_count]) {
 511                                     log_error("[framework-config] bad malloc\n");
 512                                 }
 513                                 strcpy(framework_config.datastore_generate.excluded_modules[framework_config.datastore_generate.excluded_modules_count], element->valuestring);
 514                                 framework_config.datastore_generate.excluded_modules_count++;
 515                             }
 516                         }
 517                     }
 518                 }
 519
 520                 node = cJSON_GetObjectItem(main_node, "debug-max-string-size");
 521                 if(node) {
 522                     framework_config.datastore_generate.debug_max_string_size = node->valueint;
 523                     log_add_verbose(2, "[framework-config] setting datastore-random-generation-rules/debug-max-string-size: %d\n", framework_config.datastore_generate.debug_max_string_size);
 524                 }
 525
 526                 node = cJSON_GetObjectItem(main_node, "default-list-instances");
 527                 if(node) {
 528                     if(cJSON_IsNumber(node)) {
 529                         framework_config.datastore_generate.default_list_instances = node->valueint;
 530                         log_add_verbose(2, "[framework-config] setting datastore-random-generation-rules/default-list-instances: %d\n", framework_config.datastore_generate.default_list_instances);
 531                     }
 532                 }
 533
 534                 node = cJSON_GetObjectItem(main_node, "custom-list-instances");
 535                 if(node) {
 536                     if(cJSON_IsArray(node)) {
 537                         cJSON *element;
 538                         cJSON_ArrayForEach(element, node) {
 539                             if(cJSON_IsObject(element)) {
 540                                 cJSON *object;
 541                                 cJSON_ArrayForEach(object, element) {
 542                                     char *path = object->string;
 543                                     int count = object->valueint;
 544                                     log_add_verbose(2, "[framework-config] adding datastore-random-generation-rules/custom-list-instances %s - %d\n", path, count);
 545                                     framework_config.datastore_generate.custom_list_instances = (custom_list_instances_t *)realloc(framework_config.datastore_generate.custom_list_instances, sizeof(custom_list_instances_t) * (framework_config.datastore_generate.custom_list_instances_count + 1));
 546                                     if(!framework_config.datastore_generate.custom_list_instances) {
 547                                         log_error("[framework-config] bad realloc\n");
 548                                     }
 549
 550                                     framework_config.datastore_generate.custom_list_instances[framework_config.datastore_generate.custom_list_instances_count].path = (char *)malloc(sizeof(char) * (strlen(path) + 1));
 551                                     if(!framework_config.datastore_generate.custom_list_instances[framework_config.datastore_generate.custom_list_instances_count].path) {
 552                                         log_error("[framework-config] bad malloc\n");
 553                                     }
 554                                     strcpy(framework_config.datastore_generate.custom_list_instances[framework_config.datastore_generate.custom_list_instances_count].path, path);
 555                                     framework_config.datastore_generate.custom_list_instances[framework_config.datastore_generate.custom_list_instances_count].count = count;
 556                                     framework_config.datastore_generate.custom_list_instances_count++;
 557                                 }
 558                             }
 559                         }
 560                     }
 561                 }
 562
 563                 node = cJSON_GetObjectItem(main_node, "restrict-schema");
 564                 if(node) {
 565                     if(cJSON_IsArray(node)) {
 566                         cJSON *element;
 567                         cJSON_ArrayForEach(element, node) {
 568                             if(cJSON_IsObject(element)) {
 569                                 cJSON *object;
 570                                 cJSON_ArrayForEach(object, element) {
 571                                     char *path = object->string;
 572
 573                                     log_add_verbose(2, "[framework-config] adding datastore-random-generation-rules/restrict-schema: %s with values:", path);
 574                                     framework_config.datastore_generate.restrict_schema = (restrict_schema_t *)realloc(framework_config.datastore_generate.restrict_schema, sizeof(restrict_schema_t) * (framework_config.datastore_generate.restrict_schema_count + 1));
 575                                     if(!framework_config.datastore_generate.restrict_schema) {
 576                                         log_error("[framework-config] bad realloc\n");
 577                                     }
 578
 579                                     framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].path = (char *)malloc(sizeof(char) * (strlen(path) + 1));
 580                                     if(!framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].path) {
 581                                         log_error("[framework-config] bad malloc\n");
 582                                     }
 583                                     strcpy(framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].path, path);
 584
 585
 586                                     framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values_count = 0;
 587                                     framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values = 0;
 588                                     framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].index = 0;
 589                                     cJSON *value;
 590                                     cJSON_ArrayForEach(value, object) {
 591                                         if(cJSON_IsString(value)) {
 592                                             framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values = (char **)realloc(framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values, sizeof(char*) * (framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values_count + 1));
 593                                             if(!framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values) {
 594                                                 log_error("[framework-config] bad realloc\n");
 595                                             }
 596                                             framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values[framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values_count] = (char *)malloc(sizeof(char) * (strlen(value->valuestring) + 1));
 597                                             if(!framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values[framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values_count]) {
 598                                                 log_error("[framework-config] bad malloc\n");
 599                                             }
 600                                             strcpy(framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values[framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values_count], value->valuestring);
 601                                             framework_config.datastore_generate.restrict_schema[framework_config.datastore_generate.restrict_schema_count].values_count++;
 602
 603                                             log_add(2, " %s", value->valuestring);
 604                                         }
 605                                     }
 606                                     log_add(2, "\n");
 607
 608                                     framework_config.datastore_generate.restrict_schema_count++;
 609                                 }
 610                             }
 611                         }
 612                     }
 613                 }
 614             }
 615
 616             main_node = cJSON_GetObjectItem(json, "datastore-populate-rules");
 617             if(main_node) {
 618                 node = cJSON_GetObjectItem(main_node, "random-generation-enabled");
 619                 if(node) {
 620                     framework_config.datastore_populate.random_generation_enabled = node->valueint;
 621                     log_add_verbose(2, "[framework-config] setting datastore-populate-rules/random-generation-enabled: %d\n", framework_config.datastore_populate.random_generation_enabled);
 622                 }
 623                 else {
 624                     log_add_verbose(2, "[framework-config] setting datastore-populate-rules/random-generation-enabled: %d [default value]\n", framework_config.datastore_populate.random_generation_enabled);
 625                 }
 626
 627                 node = cJSON_GetObjectItem(main_node, "pre-generated-operational-data");
 628                 if(node) {
 629                     if(cJSON_IsArray(node)) {
 630                         cJSON *element;
 631                         cJSON_ArrayForEach(element, node) {
 632                             if(cJSON_IsString(element)) {
 633                                 log_add_verbose(2, "[framework-config] adding datastore-populate-rules/pre-generated-operational-data: %s\n", element->valuestring);
 634                                 framework_config.datastore_populate.preg_operational = (char **)realloc(framework_config.datastore_populate.preg_operational, sizeof(char*) * (framework_config.datastore_populate.preg_operational_count + 1));
 635                                 if(!framework_config.datastore_populate.preg_operational) {
 636                                     log_error("[framework-config] bad realloc\n");
 637                                 }
 638                                 framework_config.datastore_populate.preg_operational[framework_config.datastore_populate.preg_operational_count] = (char *)malloc(sizeof(char) * (strlen(element->valuestring) + 1));
 639                                 if(!framework_config.datastore_populate.preg_operational[framework_config.datastore_populate.preg_operational_count]) {
 640                                     log_error("[framework-config] bad malloc\n");
 641                                 }
 642                                 strcpy(framework_config.datastore_populate.preg_operational[framework_config.datastore_populate.preg_operational_count], element->valuestring);
 643                                 framework_config.datastore_populate.preg_operational_count++;
 644                             }
 645                         }
 646                     }
 647                 }
 648
 649                 node = cJSON_GetObjectItem(main_node, "pre-generated-running-data");
 650                 if(node) {
 651                     if(cJSON_IsArray(node)) {
 652                         cJSON *element;
 653                         cJSON_ArrayForEach(element, node) {
 654                             if(cJSON_IsString(element)) {
 655                                 log_add_verbose(2, "[framework-config] adding datastore-populate-rules/pre-generated-running-data: %s\n", element->valuestring);
 656                                 framework_config.datastore_populate.preg_running = (char **)realloc(framework_config.datastore_populate.preg_running, sizeof(char*) * (framework_config.datastore_populate.preg_running_count + 1));
 657                                 if(!framework_config.datastore_populate.preg_running) {
 658                                     log_error("[framework-config] bad realloc\n");
 659                                 }
 660                                 framework_config.datastore_populate.preg_running[framework_config.datastore_populate.preg_running_count] = (char *)malloc(sizeof(char) * (strlen(element->valuestring) + 1));
 661                                 if(!framework_config.datastore_populate.preg_running[framework_config.datastore_populate.preg_running_count]) {
 662                                     log_error("[framework-config] bad malloc\n");
 663                                 }
 664                                 strcpy(framework_config.datastore_populate.preg_running[framework_config.datastore_populate.preg_running_count], element->valuestring);
 665                                 framework_config.datastore_populate.preg_running_count++;
 666                             }
 667                         }
 668                     }
 669                 }
 670
 671             }
 672         }
 673
 674         cJSON_Delete(json);
 675
 676     }
 677     log_add_verbose(2, "[framework-config] finished parsing config.json\n");
 678
 679     return NTS_ERR_OK;
 680 }
 681
 682 void framework_free(void) {
 683     log_add_verbose(2, "[framework-config] framework_free()... ");
 684
 685     signal(SIGINT, 0);
 686     signal(SIGTERM, 0);
 687     signal(SIGQUIT, 0);
 688
 689     free((char *)argp_program_version);
 690     argp_program_version = 0;
 691
 692     free(framework_environment.nts.version);
 693     free(framework_environment.nts.build_time);
 694     free(framework_environment.nts.function_type);
 695     free(framework_environment.nts.nf_standalone_start_features);
 696     free(framework_environment.settings.ip_v4);
 697     free(framework_environment.settings.ip_v6);
 698     free(framework_environment.settings.docker_engine_version);
 699     free(framework_environment.settings.hostname);
 700     free(framework_environment.host.ip);
 701     free(framework_environment.sdn_controller.protocol);
 702     free(framework_environment.sdn_controller.ip);
 703     free(framework_environment.sdn_controller.username);
 704     free(framework_environment.sdn_controller.password);
 705     free(framework_environment.ves_endpoint.common_header_version);
 706     free(framework_environment.ves_endpoint.protocol);
 707     free(framework_environment.ves_endpoint.ip);
 708     free(framework_environment.ves_endpoint.auth_method);
 709     free(framework_environment.ves_endpoint.username);
 710     free(framework_environment.ves_endpoint.password);
 711     free(framework_environment.ves_endpoint.certificate);
 712
 713     free(framework_arguments.print_structure_xpath);
 714     framework_arguments.print_structure_xpath = 0;
 715
 716     for(int i = 0; i < framework_config.supervisor.rules_count; i++) {
 717         free(framework_config.supervisor.rules[i].name);
 718         free(framework_config.supervisor.rules[i].path);
 719         for(int j = 0; j < framework_config.supervisor.rules[i].args_count; j++) {
 720             free(framework_config.supervisor.rules[i].args[j]);
 721         }
 722         free(framework_config.supervisor.rules[i].args);
 723         free(framework_config.supervisor.rules[i].stdout_path);
 724         free(framework_config.supervisor.rules[i].stderr_path);
 725     }
 726
 727     free(framework_config.supervisor.rules);
 728
 729     for(int i = 0; i < framework_config.docker.excluded_modules_count; i++) {
 730         free(framework_config.docker.excluded_modules[i]);
 731     }
 732     free(framework_config.docker.excluded_modules);
 733
 734     for(int i = 0; i < framework_config.docker.excluded_features_count; i++) {
 735         free(framework_config.docker.excluded_features[i]);
 736     }
 737     free(framework_config.docker.excluded_features);
 738
 739     for(int i = 0; i < framework_config.datastore_generate.excluded_modules_count; i++) {
 740         free(framework_config.datastore_generate.excluded_modules[i]);
 741     }
 742     free(framework_config.datastore_generate.excluded_modules);
 743
 744
 745     for(int i = 0; i < framework_config.datastore_generate.custom_list_instances_count; i++) {
 746         free(framework_config.datastore_generate.custom_list_instances[i].path);
 747
 748     }
 749     free(framework_config.datastore_generate.custom_list_instances);
 750
 751     for(int i = 0; i < framework_config.datastore_generate.restrict_schema_count; i++) {
 752         free(framework_config.datastore_generate.restrict_schema[i].path);
 753         for(int j = 0; j < framework_config.datastore_generate.restrict_schema[i].values_count; j++) {
 754             free(framework_config.datastore_generate.restrict_schema[i].values[j]);
 755         }
 756         free(framework_config.datastore_generate.restrict_schema[i].values);
 757     }
 758     free(framework_config.datastore_generate.restrict_schema);
 759
 760     for(int i = 0; i < framework_config.datastore_populate.preg_operational_count; i++) {
 761         free(framework_config.datastore_populate.preg_operational[i]);
 762     }
 763     free(framework_config.datastore_populate.preg_operational);
 764
 765     for(int i = 0; i < framework_config.datastore_populate.preg_running_count; i++) {
 766         free(framework_config.datastore_populate.preg_running[i]);
 767     }
 768     free(framework_config.datastore_populate.preg_running);
 769
 770
 771     log_add(2, "done\n");
 772     log_close();
 773 }
 774
 775 static void framework_signal_handler(int signo) {
 776     framework_sigint = 1;
 777 }
 778
 779 static error_t parse_opt(int key, char *arg, struct argp_state *state) {
 780     framework_arguments_t *iter_arguments = state->input;
 781     switch (key) {
 782         case 'i':
 783             iter_arguments->nts_mode = NTS_MODE_CONTAINER_INIT;
 784             break;
 785
 786         case 's':
 787             iter_arguments->nts_mode = NTS_MODE_SUPERVISOR;
 788             break;
 789
 790         case 'm':
 791             iter_arguments->nts_mode = NTS_MODE_MANAGER;
 792             break;
 793
 794         case 'f':
 795             iter_arguments->nts_mode = NTS_MODE_NETWORK_FUNCTION;
 796             break;
 797
 798         case 'g':
 799             iter_arguments->nts_mode = NTS_MODE_GENERATE_DATA;
 800             break;
 801
 802         case 't':
 803             iter_arguments->nts_mode = NTS_MODE_TEST;
 804             break;
 805
 806         case 'r':
 807             iter_arguments->no_rand = true;
 808             framework_arguments.fixed_seed = 0;
 809             int i = 0;
 810             while(arg[i]) {
 811                 framework_arguments.fixed_seed *= 10;
 812                 framework_arguments.fixed_seed += arg[i] - '0';
 813                 i++;
 814             }
 815             break;
 816
 817         case 'v':
 818             iter_arguments->verbosity_level = arg[0] - '0';
 819             break;
 820
 821         case 'w':
 822             chdir(arg);
 823             break;
 824
 825         case '1':
 826             iter_arguments->print_root_paths = true;
 827             break;
 828
 829         case '2':
 830             iter_arguments->print_structure_xpath = (char *)malloc(sizeof(char) * (strlen(arg) + 1));
 831             if(!iter_arguments->print_structure_xpath) {
 832                 log_error("[framework-arg] bad malloc\n");
 833                 return 1;
 834             }
 835             strcpy(iter_arguments->print_structure_xpath, arg);
 836             if(arg[strlen(arg) - 1] == '/') {
 837                 iter_arguments->print_structure_xpath[strlen(arg) - 1] = 0;
 838             }
 839             break;
 840
 841         case ARGP_KEY_ARG:
 842             if (state->arg_num >= 2) {
 843                 argp_usage(state);
 844             }
 845             break;
 846
 847         case ARGP_KEY_END:
 848
 849             break;
 850
 851         default:
 852             return ARGP_ERR_UNKNOWN;
 853     }
 854
 855     return 0;
 856 }