X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=ntsimulator%2Fsrc%2Futils%2Futils.c;h=3da659986b2d8f460c652dc7f1f9db2c0397aa4a;hb=226e12e7c9b504dc32fcf71f97483bb97195643d;hp=af40454dbb406aeba121c0c3c23d9855014b97d8;hpb=0c00182421feb00a63a76555844dba5b72639b8e;p=sim%2Fo1-interface.git diff --git a/ntsimulator/src/utils/utils.c b/ntsimulator/src/utils/utils.c index af40454..3da6599 100644 --- a/ntsimulator/src/utils/utils.c +++ b/ntsimulator/src/utils/utils.c @@ -21,6 +21,7 @@ #include #include #include +#include void set_curl_common_info_ves(CURL *curl) { @@ -73,23 +74,31 @@ void generateRandomMacAddress(char *mac_address) return; } -long random_at_most(long max) { - unsigned long - // max <= RAND_MAX < ULONG_MAX, so this is okay. - num_bins = (unsigned long) max + 1, - num_rand = (unsigned long) RAND_MAX + 1, - bin_size = num_rand / num_bins, - defect = num_rand % num_bins; - - long x; - do { - x = random(); - } - // This is carefully written not to overflow - while (num_rand - defect <= (unsigned long)x); - - // Truncated division is intentional - return x/bin_size; +long random_at_most(long max) +{ + unsigned long + // max <= RAND_MAX < ULONG_MAX, so this is okay. + num_bins = (unsigned long) max + 1, + num_rand = (unsigned long) RAND_MAX + 1, + bin_size = num_rand / num_bins, + defect = num_rand % num_bins; + + unsigned int seed; + FILE* urandom = fopen("/dev/urandom", "r"); + fread(&seed, sizeof(int), 1, urandom); + fclose(urandom); + srandom(seed); + + long x; + do + { + x = random(); + } + // This is carefully written not to overflow + while (num_rand - defect <= (unsigned long)x); + + // Truncated division is intentional + return x/bin_size; } int getSecondsFromLastQuarterInterval(void) @@ -167,7 +176,6 @@ void getPreviousDayPmTimestamp(int number_of_intervals, char *date_and_time) long int getMicrosecondsSinceEpoch(void) { time_t t = time(NULL); - struct tm tm = *localtime(&t); struct timeval tv; long int useconds; @@ -185,24 +193,47 @@ void prepare_ves_message_curl(CURL *curl) char *ves_ip = getVesIpFromConfigJson(); int ves_port = getVesPortFromConfigJson(); + char *ves_auth_method = getVesAuthMethodFromConfigJson(); + if (strcmp(ves_auth_method, "basic-auth") == 0) + { + char *ves_username = getVesUsernameFromConfigJson(); + char *ves_password = getVesPasswordFromConfigJson(); + + char credentials[200]; + sprintf(credentials, "%s:%s", ves_username, ves_password); + + free(ves_username); + free(ves_password); - char url[100]; - sprintf(url, "http://%s:%d/eventListener/v7", ves_ip, ves_port); + curl_easy_setopt(curl, CURLOPT_USERPWD, credentials); + } + free(ves_auth_method); + + char url[300]; + sprintf(url, "https://%s:%d/eventListener/v7", ves_ip, ves_port); curl_easy_setopt(curl, CURLOPT_URL, url); - free(ves_ip); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); + curl_easy_setopt(curl, CURLOPT_PROXY_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_PROXY_SSL_VERIFYHOST, 0L); -// curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY); + free(ves_ip); return; } +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ cJSON* vesCreateCommonEventHeader(char *domain, char *event_type, char *source_name, int seq_id) { char dateAndTime[50]; getCurrentDateAndTime(dateAndTime); - long int useconds = getMicrosecondsSinceEpoch; + long useconds = getMicrosecondsSinceEpoch(); cJSON *commonEventHeader = cJSON_CreateObject(); if (commonEventHeader == NULL) @@ -214,6 +245,7 @@ cJSON* vesCreateCommonEventHeader(char *domain, char *event_type, char *source_n if (cJSON_AddStringToObject(commonEventHeader, "domain", domain) == NULL) { printf("Could not create JSON object: domain\n"); + cJSON_Delete(commonEventHeader); return NULL; } @@ -223,6 +255,7 @@ cJSON* vesCreateCommonEventHeader(char *domain, char *event_type, char *source_n if (cJSON_AddStringToObject(commonEventHeader, "eventId", eventId) == NULL) { printf("Could not create JSON object: eventId\n"); + cJSON_Delete(commonEventHeader); return NULL; } @@ -232,96 +265,116 @@ cJSON* vesCreateCommonEventHeader(char *domain, char *event_type, char *source_n if (cJSON_AddStringToObject(commonEventHeader, "eventName", event_name) == NULL) { printf("Could not create JSON object: eventName\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "eventType", event_type) == NULL) { printf("Could not create JSON object: eventType\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddNumberToObject(commonEventHeader, "sequence", (double)(seq_id)) == NULL) { printf("Could not create JSON object: sequence\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "priority", "Low") == NULL) { printf("Could not create JSON object: priority\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "reportingEntityId", "") == NULL) { printf("Could not create JSON object: reportingEntityId\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "reportingEntityName", source_name) == NULL) { printf("Could not create JSON object: reportingEntityName\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "sourceId", "") == NULL) { printf("Could not create JSON object: sourceId\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "sourceName", source_name) == NULL) { printf("Could not create JSON object: sourceName\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddNumberToObject(commonEventHeader, "startEpochMicrosec", (double)(useconds)) == NULL) { printf("Could not create JSON object: startEpochMicrosec\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddNumberToObject(commonEventHeader, "lastEpochMicrosec", (double)(useconds)) == NULL) { printf("Could not create JSON object: lastEpochMicrosec\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "nfNamingCode", "sdn controller") == NULL) { printf("Could not create JSON object: nfNamingCode\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "nfVendorName", "sdn") == NULL) { printf("Could not create JSON object: nfVendorName\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "timeZoneOffset", "+00:00") == NULL) { printf("Could not create JSON object: timeZoneOffset\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "version", "4.0.1") == NULL) { printf("Could not create JSON object: version\n"); + cJSON_Delete(commonEventHeader); return NULL; } if (cJSON_AddStringToObject(commonEventHeader, "vesEventListenerVersion", "7.0.1") == NULL) { printf("Could not create JSON object: vesEventListenerVersion\n"); + cJSON_Delete(commonEventHeader); return NULL; } return commonEventHeader; } +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ cJSON* vesCreateHeartbeatFields(int heartbeat_interval) { char dateAndTime[50]; @@ -337,12 +390,14 @@ cJSON* vesCreateHeartbeatFields(int heartbeat_interval) if (cJSON_AddStringToObject(heartbeatFields, "heartbeatFieldsVersion", "3.0") == NULL) { printf("Could not create JSON object: heartbeatFieldsVersion\n"); + cJSON_Delete(heartbeatFields); return NULL; } if (cJSON_AddNumberToObject(heartbeatFields, "heartbeatInterval", (double)(heartbeat_interval)) == NULL) { printf("Could not create JSON object: heartbeatInterval\n"); + cJSON_Delete(heartbeatFields); return NULL; } @@ -350,6 +405,7 @@ cJSON* vesCreateHeartbeatFields(int heartbeat_interval) if (additionalFields == NULL) { printf("Could not create JSON object: additionalFields\n"); + cJSON_Delete(heartbeatFields); return NULL; } cJSON_AddItemToObject(heartbeatFields, "additionalFields", additionalFields); @@ -357,18 +413,43 @@ cJSON* vesCreateHeartbeatFields(int heartbeat_interval) if (cJSON_AddStringToObject(additionalFields, "eventTime", dateAndTime) == NULL) { printf("Could not create JSON object: eventTime\n"); + cJSON_Delete(heartbeatFields); return NULL; } return heartbeatFields; } +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ char* readConfigFileInString(void) { char * buffer = 0; long length; char config_file[200]; - sprintf(config_file, "%s/configuration.json", getenv("SCRIPTS_DIR")); + + //sprintf(config_file, "%s/configuration.json", getenv("SCRIPTS_DIR")); + + // --> recommended fix, Karl Koch, Deutsche Telekom AG, 22. 5. 2020. + // Path to config_file contains NULL when env variable is unset. + char *scripts_dir = getenv("SCRIPTS_DIR"); + char *scripts_dir_default = "/opt/dev/ntsimulator/scripts"; + + if(NULL != scripts_dir) + { + sprintf(config_file, "%s/configuration.json", scripts_dir); + } + else + { + sprintf(config_file, "%s/configuration.json", scripts_dir_default); + printf("warning: opening config file in default path: <%s>\n", + config_file); + } + // end of fix <-- + FILE * f = fopen (config_file, "rb"); if (f) @@ -395,10 +476,27 @@ char* readConfigFileInString(void) void writeConfigFile(char *config) { - char * buffer = 0; - long length; char config_file[200]; - sprintf(config_file, "%s/configuration.json", getenv("SCRIPTS_DIR")); + + //sprintf(config_file, "%s/configuration.json", getenv("SCRIPTS_DIR")); + + // --> recommended fix, Karl Koch, Deutsche Telekom AG, 22. 5. 2020. + // Path to config_file contains NULL when env variable is unset. + char *scripts_dir = getenv("SCRIPTS_DIR"); + char *scripts_dir_default = "/opt/dev/ntsimulator/scripts"; + + if(NULL != scripts_dir) + { + sprintf(config_file, "%s/configuration.json", scripts_dir); + } + else + { + sprintf(config_file, "%s/configuration.json", scripts_dir_default); + printf("warning: opening config file in default path: <%s>\n", + config_file); + } + // end of fix <-- + FILE * f = fopen (config_file, "w"); if (f) @@ -412,10 +510,9 @@ void writeConfigFile(char *config) } } -int getFaultNotificationDelayPeriodFromConfigJson(void) +int getFaultNotificationDelayPeriodFromConfigJson(int *period_array, int *count) { char *stringConfig = readConfigFileInString(); - int notificationDelay = 0; if (stringConfig == NULL) { @@ -436,28 +533,45 @@ int getFaultNotificationDelayPeriodFromConfigJson(void) } //we don't need the string anymore free(stringConfig); + stringConfig = NULL; cJSON *notifConfig = cJSON_GetObjectItemCaseSensitive(jsonConfig, "notification-config"); if (!cJSON_IsObject(notifConfig)) { printf("Configuration JSON is not as expected: notification-config is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } cJSON *faultNotifDelay = cJSON_GetObjectItemCaseSensitive(notifConfig, "fault-notification-delay-period"); - if (!cJSON_IsNumber(faultNotifDelay)) + if (!cJSON_IsArray(faultNotifDelay)) { - printf("Configuration JSON is not as expected: fault-notification-delay-period is not a number"); - free(jsonConfig); + printf("Configuration JSON is not as expected: fault-notification-delay-period is not an array."); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } - notificationDelay = (int)(faultNotifDelay->valuedouble); + cJSON *iterator = NULL; + *count = 0; + int i = 0; - free(jsonConfig); + cJSON_ArrayForEach(iterator, faultNotifDelay) + { + if (cJSON_IsNumber(iterator)) + { + period_array[i++] = iterator->valueint; + } + else + { + printf("Invalid number in array!"); + } + } - return notificationDelay; + *count = i; + + cJSON_Delete(jsonConfig); + + return SR_ERR_OK; } int getVesHeartbeatPeriodFromConfigJson(void) @@ -484,12 +598,13 @@ int getVesHeartbeatPeriodFromConfigJson(void) } //we don't need the string anymore free(stringConfig); + stringConfig = NULL; cJSON *notifConfig = cJSON_GetObjectItemCaseSensitive(jsonConfig, "notification-config"); if (!cJSON_IsObject(notifConfig)) { printf("Configuration JSON is not as expected: notification-config is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } @@ -497,13 +612,13 @@ int getVesHeartbeatPeriodFromConfigJson(void) if (!cJSON_IsNumber(vesHeartbeatPeriod)) { printf("Configuration JSON is not as expected: ves-heartbeat-period is not a number"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } vesHeartbeat = (int)(vesHeartbeatPeriod->valuedouble); - free(jsonConfig); + cJSON_Delete(jsonConfig); return vesHeartbeat; } @@ -533,30 +648,31 @@ char* getVesAuthMethodFromConfigJson(void) { fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr); } - return SR_ERR_OPERATION_FAILED; + return NULL; } //we don't need the string anymore free(stringConfig); + stringConfig = NULL; cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details"); if (!cJSON_IsObject(vesDetails)) { printf("Configuration JSON is not as expected: ves-endpoint-details is not an object"); - free(jsonConfig); - return SR_ERR_OPERATION_FAILED; + cJSON_Delete(jsonConfig); + return NULL; } cJSON *vesAuthMethod = cJSON_GetObjectItemCaseSensitive(vesDetails, "ves-endpoint-auth-method"); if (!cJSON_IsString(vesAuthMethod)) { printf("Configuration JSON is not as expected: ves-endpoint-auth-method is not an object"); - free(jsonConfig); - return SR_ERR_OPERATION_FAILED; + cJSON_Delete(jsonConfig); + return NULL; } char *auth_method_string = strdup(cJSON_GetStringValue(vesAuthMethod)); - free(jsonConfig); + cJSON_Delete(jsonConfig); return auth_method_string; } @@ -568,49 +684,156 @@ char* getVesAuthMethodFromConfigJson(void) */ char* getVesIpFromConfigJson(void) { - char *stringConfig = readConfigFileInString(); - - if (stringConfig == NULL) - { - printf("Could not read JSON configuration file in string."); - return 0; - } - - cJSON *jsonConfig = cJSON_Parse(stringConfig); - if (jsonConfig == NULL) - { - free(stringConfig); - const char *error_ptr = cJSON_GetErrorPtr(); - if (error_ptr != NULL) - { - fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr); - } - return SR_ERR_OPERATION_FAILED; - } - //we don't need the string anymore - free(stringConfig); - - cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details"); - if (!cJSON_IsObject(vesDetails)) - { - printf("Configuration JSON is not as expected: ves-endpoint-details is not an object"); - free(jsonConfig); - return SR_ERR_OPERATION_FAILED; - } - - cJSON *vesIp = cJSON_GetObjectItemCaseSensitive(vesDetails, "ves-endpoint-ip"); - if (!cJSON_IsString(vesIp)) - { - printf("Configuration JSON is not as expected: ves-endpoint-ip is not an object"); - free(jsonConfig); - return SR_ERR_OPERATION_FAILED; - } - - char *ves_ip = strdup(cJSON_GetStringValue(vesIp)); + char *stringConfig = readConfigFileInString(); + + if (stringConfig == NULL) + { + printf("Could not read JSON configuration file in string."); + return 0; + } + + cJSON *jsonConfig = cJSON_Parse(stringConfig); + if (jsonConfig == NULL) + { + free(stringConfig); + const char *error_ptr = cJSON_GetErrorPtr(); + if (error_ptr != NULL) + { + fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr); + } + return NULL; + } + //we don't need the string anymore + free(stringConfig); + stringConfig = NULL; + + cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details"); + if (!cJSON_IsObject(vesDetails)) + { + printf("Configuration JSON is not as expected: ves-endpoint-details is not an object"); + cJSON_Delete(jsonConfig); + return NULL; + } + + cJSON *vesIp = cJSON_GetObjectItemCaseSensitive(vesDetails, "ves-endpoint-ip"); + if (!cJSON_IsString(vesIp)) + { + printf("Configuration JSON is not as expected: ves-endpoint-ip is not an object"); + cJSON_Delete(jsonConfig); + return NULL; + } + + char *ves_ip = strdup(cJSON_GetStringValue(vesIp)); + + cJSON_Delete(jsonConfig); + + return ves_ip; +} - free(jsonConfig); +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ +char* getVesUsernameFromConfigJson(void) +{ + char *stringConfig = readConfigFileInString(); + + if (stringConfig == NULL) + { + printf("Could not read JSON configuration file in string."); + return 0; + } + + cJSON *jsonConfig = cJSON_Parse(stringConfig); + if (jsonConfig == NULL) + { + free(stringConfig); + const char *error_ptr = cJSON_GetErrorPtr(); + if (error_ptr != NULL) + { + fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr); + } + return NULL; + } + //we don't need the string anymore + free(stringConfig); + stringConfig = NULL; + + cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details"); + if (!cJSON_IsObject(vesDetails)) + { + printf("Configuration JSON is not as expected: ves-endpoint-details is not an object"); + cJSON_Delete(jsonConfig); + return NULL; + } + + cJSON *vesUsername = cJSON_GetObjectItemCaseSensitive(vesDetails, "ves-endpoint-username"); + if (!cJSON_IsString(vesUsername)) + { + printf("Configuration JSON is not as expected: ves-endpoint-username is not an object"); + cJSON_Delete(jsonConfig); + return NULL; + } + + char *ves_username = strdup(cJSON_GetStringValue(vesUsername)); + + cJSON_Delete(jsonConfig); + + return ves_username; +} - return ves_ip; +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ +char* getVesPasswordFromConfigJson(void) +{ + char *stringConfig = readConfigFileInString(); + + if (stringConfig == NULL) + { + printf("Could not read JSON configuration file in string."); + return 0; + } + + cJSON *jsonConfig = cJSON_Parse(stringConfig); + if (jsonConfig == NULL) + { + free(stringConfig); + const char *error_ptr = cJSON_GetErrorPtr(); + if (error_ptr != NULL) + { + fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr); + } + return NULL; + } + //we don't need the string anymore + free(stringConfig); + stringConfig = NULL; + + cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details"); + if (!cJSON_IsObject(vesDetails)) + { + printf("Configuration JSON is not as expected: ves-endpoint-details is not an object"); + cJSON_Delete(jsonConfig); + return NULL; + } + + cJSON *vesPassword = cJSON_GetObjectItemCaseSensitive(vesDetails, "ves-endpoint-password"); + if (!cJSON_IsString(vesPassword)) + { + printf("Configuration JSON is not as expected: ves-endpoint-password is not an object"); + cJSON_Delete(jsonConfig); + return NULL; + } + + char *ves_password = strdup(cJSON_GetStringValue(vesPassword)); + + cJSON_Delete(jsonConfig); + + return ves_password; } int getVesPortFromConfigJson(void) @@ -636,12 +859,13 @@ int getVesPortFromConfigJson(void) } //we don't need the string anymore free(stringConfig); + stringConfig = NULL; cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details"); if (!cJSON_IsObject(vesDetails)) { printf("Configuration JSON is not as expected: ves-endpoint-details is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } @@ -649,13 +873,13 @@ int getVesPortFromConfigJson(void) if (!cJSON_IsNumber(vesPort)) { printf("Configuration JSON is not as expected: ves-endpoint-port is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } int port = (int)(vesPort->valuedouble); - free(jsonConfig); + cJSON_Delete(jsonConfig); return port; } @@ -683,12 +907,13 @@ int getVesRegistrationFromConfigJson(void) } //we don't need the string anymore free(stringConfig); + stringConfig = NULL; cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details"); if (!cJSON_IsObject(vesDetails)) { printf("Configuration JSON is not as expected: ves-endpoint-details is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } @@ -696,17 +921,22 @@ int getVesRegistrationFromConfigJson(void) if (!cJSON_IsBool(vesReg)) { printf("Configuration JSON is not as expected: ves-registration is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } int is_ves_reg = (cJSON_IsTrue(vesReg)) ? TRUE : FALSE; - free(jsonConfig); + cJSON_Delete(jsonConfig); return is_ves_reg; } +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) { cJSON *pnfRegistrationFields = cJSON_CreateObject(); @@ -719,12 +949,14 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(pnfRegistrationFields, "pnfRegistrationFieldsVersion", "2.0") == NULL) { printf("Could not create JSON object: pnfRegistrationFieldsVersion\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(pnfRegistrationFields, "lastServiceDate", "2019-08-16") == NULL) { printf("Could not create JSON object: lastServiceDate\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } @@ -734,63 +966,73 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(pnfRegistrationFields, "macAddress", mac_addr) == NULL) { printf("Could not create JSON object: macAddress\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(pnfRegistrationFields, "manufactureDate", "2019-08-16") == NULL) { printf("Could not create JSON object: manufactureDate\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(pnfRegistrationFields, "modelNumber", "Simulated Device Melacon") == NULL) { printf("Could not create JSON object: manufactureDate\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } - if (cJSON_AddStringToObject(pnfRegistrationFields, "oamV4IpAddress", getenv("NTS_IP")) == NULL) + if (cJSON_AddStringToObject(pnfRegistrationFields, "oamV4IpAddress", getenv("EXTERNAL_NTS_IP")) == NULL) { printf("Could not create JSON object: oamV4IpAddress\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(pnfRegistrationFields, "oamV6IpAddress", "0:0:0:0:0:ffff:a0a:011") == NULL) { printf("Could not create JSON object: oamV6IpAddress\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } char serial_number[100]; - sprintf(serial_number, "%s-%s-%d-Simulated Device Melacon", getenv("HOSTNAME"), getenv("NTS_IP"), port); + sprintf(serial_number, "%s-%s-%d-Simulated Device Melacon", getenv("HOSTNAME"), getenv("EXTERNAL_NTS_IP"), port); if (cJSON_AddStringToObject(pnfRegistrationFields, "serialNumber", serial_number) == NULL) { printf("Could not create JSON object: serialNumber\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(pnfRegistrationFields, "softwareVersion", "2.3.5") == NULL) { printf("Could not create JSON object: softwareVersion\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(pnfRegistrationFields, "unitFamily", "Simulated Device") == NULL) { printf("Could not create JSON object: unitFamily\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(pnfRegistrationFields, "unitType", "O-RAN-sim") == NULL) { printf("Could not create JSON object: unitType\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(pnfRegistrationFields, "vendorName", "Melacon") == NULL) { printf("Could not create JSON object: vendorName\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } @@ -798,6 +1040,7 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (additionalFields == NULL) { printf("Could not create JSON object: additionalFields\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } cJSON_AddItemToObject(pnfRegistrationFields, "additionalFields", additionalFields); @@ -808,6 +1051,7 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(additionalFields, "oamPort", portString) == NULL) { printf("Could not create JSON object: oamPort\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } @@ -817,6 +1061,7 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(additionalFields, "protocol", "TLS") == NULL) { printf("Could not create JSON object: protocol\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } @@ -824,12 +1069,14 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(additionalFields, "username", "netconf") == NULL) { printf("Could not create JSON object: username\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(additionalFields, "keyId", "device-key") == NULL) { printf("Could not create JSON object: keyId\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } } @@ -839,6 +1086,7 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(additionalFields, "protocol", "SSH") == NULL) { printf("Could not create JSON object: protocol\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } @@ -846,6 +1094,7 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(additionalFields, "username", "netconf") == NULL) { printf("Could not create JSON object: username\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } @@ -853,6 +1102,7 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(additionalFields, "password", "netconf") == NULL) { printf("Could not create JSON object: password\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } } @@ -860,42 +1110,49 @@ cJSON* vesCreatePnfRegistrationFields(int port, bool is_tls) if (cJSON_AddStringToObject(additionalFields, "reconnectOnChangedSchema", "false") == NULL) { printf("Could not create JSON object: reconnectOnChangedSchema\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(additionalFields, "sleep-factor", "1.5") == NULL) { printf("Could not create JSON object: sleep-factor\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(additionalFields, "tcpOnly", "false") == NULL) { printf("Could not create JSON object: tcpOnly\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(additionalFields, "connectionTimeout", "20000") == NULL) { printf("Could not create JSON object: connectionTimeout\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(additionalFields, "maxConnectionAttempts", "100") == NULL) { printf("Could not create JSON object: maxConnectionAttempts\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(additionalFields, "betweenAttemptsTimeout", "2000") == NULL) { printf("Could not create JSON object: betweenAttemptsTimeout\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } if (cJSON_AddStringToObject(additionalFields, "keepaliveDelay", "120") == NULL) { printf("Could not create JSON object: keepaliveDelay\n"); + cJSON_Delete(pnfRegistrationFields); return NULL; } @@ -925,12 +1182,13 @@ int getNetconfAvailableFromConfigJson(void) } //we don't need the string anymore free(stringConfig); + stringConfig = NULL; cJSON *notifDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "notification-config"); if (!cJSON_IsObject(notifDetails)) { printf("Configuration JSON is not as expected: notification-config is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } @@ -938,13 +1196,13 @@ int getNetconfAvailableFromConfigJson(void) if (!cJSON_IsBool(isNetconfAvailable)) { printf("Configuration JSON is not as expected: is-netconf-available is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } int is_netconf_available = (cJSON_IsTrue(isNetconfAvailable)) ? TRUE : FALSE; - free(jsonConfig); + cJSON_Delete(jsonConfig); return is_netconf_available; } @@ -972,12 +1230,13 @@ int getVesAvailableFromConfigJson(void) } //we don't need the string anymore free(stringConfig); + stringConfig = NULL; cJSON *notifDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "notification-config"); if (!cJSON_IsObject(notifDetails)) { printf("Configuration JSON is not as expected: notification-config is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } @@ -985,17 +1244,22 @@ int getVesAvailableFromConfigJson(void) if (!cJSON_IsBool(isVesAvailable)) { printf("Configuration JSON is not as expected: is-ves-available is not an object"); - free(jsonConfig); + cJSON_Delete(jsonConfig); return SR_ERR_OPERATION_FAILED; } int is_netconf_available = (cJSON_IsTrue(isVesAvailable)) ? TRUE : FALSE; - free(jsonConfig); + cJSON_Delete(jsonConfig); return is_netconf_available; } +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ cJSON* vesCreateFaultFields(char *alarm_condition, char *alarm_object, char *severity, char *date_time, char *specific_problem) { cJSON *faultFields = cJSON_CreateObject(); @@ -1008,42 +1272,49 @@ cJSON* vesCreateFaultFields(char *alarm_condition, char *alarm_object, char *sev if (cJSON_AddStringToObject(faultFields, "faultFieldsVersion", "4.0") == NULL) { printf("Could not create JSON object: faultFieldsVersion\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(faultFields, "alarmCondition", alarm_condition) == NULL) { printf("Could not create JSON object: alarmCondition\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(faultFields, "alarmInterfaceA", alarm_object) == NULL) { printf("Could not create JSON object: alarmInterfaceA\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(faultFields, "eventSourceType", "O_RAN_COMPONENT") == NULL) { printf("Could not create JSON object: eventSourceType\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(faultFields, "specificProblem", specific_problem) == NULL) { printf("Could not create JSON object: specificProblem\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(faultFields, "eventSeverity", severity) == NULL) { printf("Could not create JSON object: eventSeverity\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(faultFields, "vfStatus", "Active") == NULL) { printf("Could not create JSON object: vfStatus\n"); + cJSON_Delete(faultFields); return NULL; } @@ -1051,6 +1322,7 @@ cJSON* vesCreateFaultFields(char *alarm_condition, char *alarm_object, char *sev if (alarmAdditionalInformation == NULL) { printf("Could not create JSON object: alarmAdditionalInformation\n"); + cJSON_Delete(faultFields); return NULL; } cJSON_AddItemToObject(faultFields, "alarmAdditionalInformation", alarmAdditionalInformation); @@ -1058,26 +1330,1060 @@ cJSON* vesCreateFaultFields(char *alarm_condition, char *alarm_object, char *sev if (cJSON_AddStringToObject(alarmAdditionalInformation, "eventTime", date_time) == NULL) { printf("Could not create JSON object: eventTime\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(alarmAdditionalInformation, "equipType", "O-RAN-sim") == NULL) { printf("Could not create JSON object: equipType\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(alarmAdditionalInformation, "vendor", "Melacon") == NULL) { printf("Could not create JSON object: vendor\n"); + cJSON_Delete(faultFields); return NULL; } if (cJSON_AddStringToObject(alarmAdditionalInformation, "model", "Simulated Device") == NULL) { printf("Could not create JSON object: model\n"); + cJSON_Delete(faultFields); return NULL; } return faultFields; } + +static cJSON* createSeverityCounters(counterAlarms count) +{ + cJSON *severityCounters = cJSON_CreateObject(); + if (severityCounters == NULL) + { + printf("Could not create JSON object: severityCounters\n"); + return NULL; + } + + if (cJSON_AddNumberToObject(severityCounters, "severity-normal", count.normal) == NULL) + { + printf("Could not create JSON object: severity-normal\n"); + return NULL; + } + + if (cJSON_AddNumberToObject(severityCounters, "severity-warning", count.warning) == NULL) + { + printf("Could not create JSON object: severity-warning\n"); + return NULL; + } + + if (cJSON_AddNumberToObject(severityCounters, "severity-minor", count.minor) == NULL) + { + printf("Could not create JSON object: severity-minor\n"); + return NULL; + } + + if (cJSON_AddNumberToObject(severityCounters, "severity-major", count.major) == NULL) + { + printf("Could not create JSON object: severity-major\n"); + return NULL; + } + + if (cJSON_AddNumberToObject(severityCounters, "severity-critical", count.critical) == NULL) + { + printf("Could not create JSON object: severity-critical\n"); + return NULL; + } + + return severityCounters; +} + +void writeStatusFile(char *status) +{ + char status_file[200]; + sprintf(status_file, "%s/status.json", getenv("SCRIPTS_DIR")); + FILE * f = fopen (status_file, "w"); + + if (f) + { + fputs(status, f); + fclose(f); + } + else + { + printf("Could not write status file!\n"); + } +} + +int writeSkeletonStatusFile() +{ + cJSON *statusObject = cJSON_CreateObject(); + if (statusObject == NULL) + { + printf("Could not create JSON object: statusObject\n"); + return SR_ERR_OPERATION_FAILED; + } + + // counterAlarms counter = { + // .normal = 0, + // .warning = 0, + // .minor = 0, + // .major = 0, + // .critical = 0 + // }; + + // cJSON *totalVesNotifications = createSeverityCounters(counter); + // if (totalVesNotifications == NULL) + // { + // printf("Could not create JSON object: totalVesNotifications\n"); + // cJSON_Delete(statusObject); + // return SR_ERR_OPERATION_FAILED; + // } + // cJSON_AddItemToObject(statusObject, "total-ves-notifications-sent", totalVesNotifications); + + // cJSON *totalNetconfNotifications = createSeverityCounters(counter); + // if (totalNetconfNotifications == NULL) + // { + // printf("Could not create JSON object: totalNetconfNotifications\n"); + // cJSON_Delete(statusObject); + // return SR_ERR_OPERATION_FAILED; + // } + // cJSON_AddItemToObject(statusObject, "total-netconf-notifications-sent", totalNetconfNotifications); + + cJSON *deviceList = cJSON_CreateArray(); + if (deviceList == NULL) + { + printf("Could not create JSON object: deviceList\n"); + cJSON_Delete(statusObject); + return SR_ERR_OPERATION_FAILED; + } + cJSON_AddItemToObject(statusObject, "device-list", deviceList); + + char *status_string = NULL; + + status_string = cJSON_PrintUnformatted(statusObject); + + writeStatusFile(status_string); + + if (status_string != NULL) + { + free(status_string); + status_string = NULL; + } + + if (statusObject != NULL) + { + cJSON_Delete(statusObject); + } + + return SR_ERR_OK; +} + +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ +char* readStatusFileInString(void) +{ + char * buffer = 0; + long length; + char config_file[200]; + sprintf(config_file, "%s/status.json", getenv("SCRIPTS_DIR")); + FILE * f = fopen (config_file, "rb"); + + if (f) + { + fseek (f, 0, SEEK_END); + length = ftell (f); + fseek (f, 0, SEEK_SET); + buffer = malloc (length + 1); + if (buffer) + { + fread (buffer, 1, length, f); + } + fclose (f); + buffer[length] = '\0'; + } + + if (buffer) + { + return buffer; + } + + return NULL; +} + +/* + * Dynamically allocated memory; + * Caller needs to free the memory after it uses the value. + * +*/ +cJSON* getDeviceListFromStatusFile(void) +{ + char *stringStatus = readStatusFileInString(); + + if (stringStatus == NULL) + { + printf("Could not read status file!\n"); + return NULL; + } + + cJSON *jsonStatus = cJSON_Parse(stringStatus); + if (jsonStatus == NULL) + { + free(stringStatus); + const char *error_ptr = cJSON_GetErrorPtr(); + if (error_ptr != NULL) + { + fprintf(stderr, "Could not parse JSON status! Error before: %s\n", error_ptr); + } + return NULL; + } + //we don't need the string anymore + free(stringStatus); + stringStatus = NULL; + + return jsonStatus; +} + +cJSON* createDeviceListEntry(counterAlarms ves_counter, counterAlarms netconf_counter) +{ + cJSON *deviceListEntry = cJSON_CreateObject(); + if (deviceListEntry == NULL) + { + printf("Could not create JSON object: deviceListEntry\n"); + return NULL; + } + + char hostname[100]; + sprintf(hostname, "%s", getenv("HOSTNAME")); + + if (cJSON_AddStringToObject(deviceListEntry, "device-name", hostname) == NULL) + { + printf("Could not create JSON object: device-name\n"); + cJSON_Delete(deviceListEntry); + return NULL; + } + + cJSON *vesNotificationsSent = createSeverityCounters(ves_counter); + if (vesNotificationsSent == NULL) + { + printf("Could not create JSON object: vesNotificationsSent\n"); + cJSON_Delete(deviceListEntry); + return NULL; + } + cJSON_AddItemToObject(deviceListEntry, "ves-notifications-sent", vesNotificationsSent); + + cJSON *netconfNotificationsSent = createSeverityCounters(netconf_counter); + if (netconfNotificationsSent == NULL) + { + printf("Could not create JSON object: netconfNotificationsSent\n"); + cJSON_Delete(deviceListEntry); + return NULL; + } + cJSON_AddItemToObject(deviceListEntry, "netconf-notifications-sent", netconfNotificationsSent); + + return deviceListEntry; +} + +static void modifySeverityCounters(cJSON **severityCounters, counterAlarms count) +{ + cJSON *severity= cJSON_GetObjectItemCaseSensitive(*severityCounters, "severity-normal"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-normal is not an number"); + return; + } + //we set the value of the severity-normal object + cJSON_SetNumberValue(severity, count.normal); + + severity= cJSON_GetObjectItemCaseSensitive(*severityCounters, "severity-warning"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-warning is not an number"); + return; + } + //we set the value of the severity-warning object + cJSON_SetNumberValue(severity, count.warning); + + severity= cJSON_GetObjectItemCaseSensitive(*severityCounters, "severity-minor"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-minor is not an number"); + return; + } + //we set the value of the severity-minor object + cJSON_SetNumberValue(severity, count.minor); + + severity= cJSON_GetObjectItemCaseSensitive(*severityCounters, "severity-major"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-major is not an number"); + return; + } + //we set the value of the severity-major object + cJSON_SetNumberValue(severity, count.major); + + severity= cJSON_GetObjectItemCaseSensitive(*severityCounters, "severity-critical"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-critical is not an number"); + return; + } + //we set the value of the severity-critical object + cJSON_SetNumberValue(severity, count.critical); + + return; +} + +static void modifyDeviceListEntry(cJSON **deviceListEntry, counterAlarms ves_counter, counterAlarms netconf_counter) +{ + cJSON *vesNotificationsSent= cJSON_GetObjectItemCaseSensitive(*deviceListEntry, "ves-notifications-sent"); + if (!cJSON_IsObject(vesNotificationsSent)) + { + printf("Status JSON is not as expected: ves-notifications-sent is not a object"); + return; + } + + modifySeverityCounters(&vesNotificationsSent, ves_counter); + + cJSON *netconfNotificationsSent= cJSON_GetObjectItemCaseSensitive(*deviceListEntry, "netconf-notifications-sent"); + if (!cJSON_IsObject(netconfNotificationsSent)) + { + printf("Status JSON is not as expected: netconf-notifications-sent is not a object"); + return; + } + + modifySeverityCounters(&netconfNotificationsSent, netconf_counter); +} + +int writeStatusNotificationCounters(counterAlarms ves_counter, counterAlarms netconf_counter) +{ + cJSON *jsonStatus = getDeviceListFromStatusFile(); + + cJSON *deviceList = cJSON_GetObjectItemCaseSensitive(jsonStatus, "device-list"); + if (!cJSON_IsArray(deviceList)) + { + printf("Status JSON is not as expected: device-list is not an object"); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + + int array_size = cJSON_GetArraySize(deviceList); + + int found = 0; + for (int i=0; inormal = ves_counter->warning = \ + ves_counter->minor = ves_counter->major = \ + ves_counter->critical = 0; + netconf_counter->normal = netconf_counter->warning = \ + netconf_counter->minor = netconf_counter->major = \ + netconf_counter->critical = 0; + + cJSON *jsonStatus = getDeviceListFromStatusFile(); + + cJSON *deviceList = cJSON_GetObjectItemCaseSensitive(jsonStatus, "device-list"); + if (!cJSON_IsArray(deviceList)) + { + printf("Status JSON is not as expected: device-list is not an object"); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + + int array_size = cJSON_GetArraySize(deviceList); + + for (int i=0; ivaluedouble); + ves_counter->normal += counter; + + severity = cJSON_GetObjectItemCaseSensitive(vesNotifications, "severity-warning"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-warning is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + ves_counter->warning += counter; + + severity = cJSON_GetObjectItemCaseSensitive(vesNotifications, "severity-minor"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-minor is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + ves_counter->minor += counter; + + severity = cJSON_GetObjectItemCaseSensitive(vesNotifications, "severity-major"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-major is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + ves_counter->major += counter; + + severity = cJSON_GetObjectItemCaseSensitive(vesNotifications, "severity-critical"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-critical is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + ves_counter->critical += counter; + + cJSON *netconfNotifications = cJSON_GetObjectItemCaseSensitive(deviceListEntry, "netconf-notifications-sent"); + if (!cJSON_IsObject(netconfNotifications)) + { + printf("Status JSON is not as expected: netconf-notifications-sent is not an object."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-normal"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-normal is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + + counter = (int)(severity->valuedouble); + netconf_counter->normal += (counter * NETCONF_CONNECTIONS_PER_DEVICE); + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-warning"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-warning is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + netconf_counter->warning += (counter * NETCONF_CONNECTIONS_PER_DEVICE); + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-minor"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-minor is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + netconf_counter->minor += (counter * NETCONF_CONNECTIONS_PER_DEVICE); + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-major"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-major is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + netconf_counter->major += (counter * NETCONF_CONNECTIONS_PER_DEVICE); + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-critical"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-critical is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + netconf_counter->critical += (counter * NETCONF_CONNECTIONS_PER_DEVICE); + } + + cJSON_Delete(jsonStatus); + + return SR_ERR_OK; +} + +int getDeviceCounters(char *containerId, counterAlarms *ves_counter, counterAlarms *netconf_counter) +{ + cJSON *jsonStatus = getDeviceListFromStatusFile(); + + cJSON *deviceList = cJSON_GetObjectItemCaseSensitive(jsonStatus, "device-list"); + if (!cJSON_IsArray(deviceList)) + { + printf("Status JSON is not as expected: device-list is not an object"); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + + int array_size = cJSON_GetArraySize(deviceList); + + ves_counter->critical = ves_counter->major = ves_counter->minor = ves_counter->warning = ves_counter->normal = 0; + netconf_counter->critical = netconf_counter->major = netconf_counter->minor = netconf_counter->warning = netconf_counter->normal = 0; + + for (int i=0; ivaluedouble); + ves_counter->normal = counter; + + severity = cJSON_GetObjectItemCaseSensitive(vesNotifications, "severity-warning"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-warning is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + ves_counter->warning = counter; + + severity = cJSON_GetObjectItemCaseSensitive(vesNotifications, "severity-minor"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-minor is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + ves_counter->minor = counter; + + severity = cJSON_GetObjectItemCaseSensitive(vesNotifications, "severity-major"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-major is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + ves_counter->major = counter; + + severity = cJSON_GetObjectItemCaseSensitive(vesNotifications, "severity-critical"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-critical is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + ves_counter->critical = counter; + + cJSON *netconfNotifications = cJSON_GetObjectItemCaseSensitive(deviceListEntry, "netconf-notifications-sent"); + if (!cJSON_IsObject(netconfNotifications)) + { + printf("Status JSON is not as expected: netconf-notifications-sent is not an object."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-normal"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-normal is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + + counter = (int)(severity->valuedouble); + netconf_counter->normal = (counter * NETCONF_CONNECTIONS_PER_DEVICE); + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-warning"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-warning is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + netconf_counter->warning = (counter * NETCONF_CONNECTIONS_PER_DEVICE); + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-minor"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-minor is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + netconf_counter->minor = (counter * NETCONF_CONNECTIONS_PER_DEVICE); + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-major"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-major is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + netconf_counter->major = (counter * NETCONF_CONNECTIONS_PER_DEVICE); + + severity = cJSON_GetObjectItemCaseSensitive(netconfNotifications, "severity-critical"); + if (!cJSON_IsNumber(severity)) + { + printf("Status JSON is not as expected: severity-critical is not a string."); + cJSON_Delete(jsonStatus); + return SR_ERR_OPERATION_FAILED; + } + counter = (int)(severity->valuedouble); + netconf_counter->critical = (counter * NETCONF_CONNECTIONS_PER_DEVICE); + } + + cJSON_Delete(jsonStatus); + + return SR_ERR_OK; +} + +int writeSkeletonConfigFile() +{ + cJSON *configObject = cJSON_CreateObject(); + if (configObject == NULL) + { + printf("Could not create JSON object: configObject\n"); + return SR_ERR_OPERATION_FAILED; + } + + cJSON *notificationConfig = cJSON_CreateObject(); + if (notificationConfig == NULL) + { + printf("Could not create JSON object: notificationConfig\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + cJSON_AddItemToObject(configObject, "notification-config", notificationConfig); + + if (cJSON_AddNumberToObject(notificationConfig, "ves-heartbeat-period", 0) == NULL) + { + printf("Could not create JSON object: ves-heartbeat-period\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddTrueToObject(notificationConfig, "is-netconf-available") == NULL) + { + printf("Could not create JSON object: is-netconf-available\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddTrueToObject(notificationConfig, "is-ves-available") == NULL) + { + printf("Could not create JSON object: is-ves-available\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + cJSON *faultNotificationDelayPeriod = cJSON_CreateArray(); + if (faultNotificationDelayPeriod == NULL) + { + printf("Could not create JSON object: faultNotificationDelayPeriod\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + cJSON_AddItemToObject(notificationConfig, "fault-notification-delay-period", faultNotificationDelayPeriod); + + cJSON *arrayItem = cJSON_CreateNumber(0); + if (arrayItem == NULL) + { + printf("Could not create JSON object: arrayItem\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + cJSON_AddItemToArray(faultNotificationDelayPeriod, arrayItem); + + cJSON *vesEndPointDetails = cJSON_CreateObject(); + if (vesEndPointDetails == NULL) + { + printf("Could not create JSON object: vesEndPointDetails\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + cJSON_AddItemToObject(configObject, "ves-endpoint-details", vesEndPointDetails); + + if (cJSON_AddStringToObject(vesEndPointDetails, "ves-endpoint-ip", "172.17.0.1") == NULL) + { + printf("Could not create JSON object: ves-endpoint-ip\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddNumberToObject(vesEndPointDetails, "ves-endpoint-port", 30007) == NULL) + { + printf("Could not create JSON object: ves-endpoint-port\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddStringToObject(vesEndPointDetails, "ves-endpoint-auth-method", "no-auth") == NULL) + { + printf("Could not create JSON object: ves-endpoint-auth-method\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddStringToObject(vesEndPointDetails, "ves-endpoint-username", "") == NULL) + { + printf("Could not create JSON object: ves-endpoint-username\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddStringToObject(vesEndPointDetails, "ves-endpoint-password", "") == NULL) + { + printf("Could not create JSON object: ves-endpoint-password\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddStringToObject(vesEndPointDetails, "ves-endpoint-certificate", "") == NULL) + { + printf("Could not create JSON object: ves-endpoint-certificate\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddFalseToObject(vesEndPointDetails, "ves-registration") == NULL) + { + printf("Could not create JSON object: ves-registration\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + cJSON *controllerDetails = cJSON_CreateObject(); + if (controllerDetails == NULL) + { + printf("Could not create JSON object: controllerDetails\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + cJSON_AddItemToObject(configObject, "controller-details", controllerDetails); + + if (cJSON_AddStringToObject(controllerDetails, "controller-ip", "172.17.0.1") == NULL) + { + printf("Could not create JSON object: controller-ip\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddNumberToObject(controllerDetails, "controller-port", 8181) == NULL) + { + printf("Could not create JSON object: controller-port\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddNumberToObject(controllerDetails, "netconf-call-home-port", 6666) == NULL) + { + printf("Could not create JSON object: netconf-call-home-port\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddStringToObject(controllerDetails, "controller-username", "admin") == NULL) + { + printf("Could not create JSON object: controller-username\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddStringToObject(controllerDetails, "controller-password", "admin") == NULL) + { + printf("Could not create JSON object: controller-password\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddNumberToObject(configObject, "ssh-connections", 1) == NULL) + { + printf("Could not create JSON object: ssh-connections\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddNumberToObject(configObject, "tls-connections", 0) == NULL) + { + printf("Could not create JSON object: tls-connections\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + if (cJSON_AddFalseToObject(configObject, "netconf-call-home") == NULL) + { + printf("Could not create JSON object: netconf-call-home\n"); + cJSON_Delete(configObject); + return SR_ERR_OPERATION_FAILED; + } + + char *config_string = NULL; + + config_string = cJSON_PrintUnformatted(configObject); + + writeConfigFile(config_string); + + if (config_string != NULL) + { + free(config_string); + config_string = NULL; + } + + if (configObject != NULL) + { + cJSON_Delete(configObject); + } + + return SR_ERR_OK; +} + +int getIntFromString(char *string, int def_value) +{ + int rc, value = def_value; + if (string != NULL) + { + rc = sscanf(string, "%d", &value); + if (rc != 1) + { + printf("Could not get the %s! Using the default 0...\n", string); + value = def_value; + } + } + return value; +} + +int getSshConnectionsFromConfigJson(void) +{ + char *stringConfig = readConfigFileInString(); + + if (stringConfig == NULL) + { + printf("Could not read JSON configuration file in string."); + return 0; + } + + cJSON *jsonConfig = cJSON_Parse(stringConfig); + if (jsonConfig == NULL) + { + free(stringConfig); + const char *error_ptr = cJSON_GetErrorPtr(); + if (error_ptr != NULL) + { + fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr); + } + return SR_ERR_OPERATION_FAILED; + } + //we don't need the string anymore + free(stringConfig); + stringConfig = NULL; + + cJSON *sshConnections = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ssh-connections"); + if (!cJSON_IsNumber(sshConnections)) + { + printf("Configuration JSON is not as expected: ssh-connections is not an object"); + cJSON_Delete(jsonConfig); + return SR_ERR_OPERATION_FAILED; + } + + int num_of_ssh = (int)(sshConnections->valuedouble); + + cJSON_Delete(jsonConfig); + + return num_of_ssh; +} + +int getTlsConnectionsFromConfigJson(void) +{ + char *stringConfig = readConfigFileInString(); + + if (stringConfig == NULL) + { + printf("Could not read JSON configuration file in string."); + return 0; + } + + cJSON *jsonConfig = cJSON_Parse(stringConfig); + if (jsonConfig == NULL) + { + free(stringConfig); + const char *error_ptr = cJSON_GetErrorPtr(); + if (error_ptr != NULL) + { + fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr); + } + return SR_ERR_OPERATION_FAILED; + } + //we don't need the string anymore + free(stringConfig); + stringConfig = NULL; + + cJSON *tlsConnections = cJSON_GetObjectItemCaseSensitive(jsonConfig, "tls-connections"); + if (!cJSON_IsNumber(tlsConnections)) + { + printf("Configuration JSON is not as expected: ssh-connections is not an object"); + cJSON_Delete(jsonConfig); + return SR_ERR_OPERATION_FAILED; + } + + int num_of_tls = (int)(tlsConnections->valuedouble); + + cJSON_Delete(jsonConfig); + + return num_of_tls; +}