ntsimulator/ntsim-ng/utils/nts_utils.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 "nts_utils.h"
  21 #include "utils/log_utils.h"
  22 #include "utils/sys_utils.h"
  23 #include "core/framework.h"
  24 #include "core/session.h"
  25 #include "core/xpath.h"
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <assert.h>
  29
  30
  31 cJSON* ves_create_common_event_header(const char *domain, const char *event_type, const char *hostname, int port, const char *priority, int seq_id) {
  32     assert(domain);
  33     assert(event_type);
  34     assert(hostname);
  35     assert(priority);
  36
  37     char *eventId = 0;
  38     long useconds = get_microseconds_since_epoch();
  39
  40     asprintf(&eventId, "%s-%d", event_type, seq_id);
  41     if(eventId == 0) {
  42         log_error("asprintf failed\n");
  43         return 0;
  44     }
  45
  46     cJSON *common_event_header = cJSON_CreateObject();
  47     if(common_event_header == 0) {
  48         log_error("could not create JSON object\n");
  49         free(eventId);
  50         return 0;
  51     }
  52
  53     if(cJSON_AddStringToObject(common_event_header, "domain", domain) == 0) {
  54         log_error("cJSON AddStringToObject error\n");
  55         free(eventId);
  56         cJSON_Delete(common_event_header);
  57         return 0;
  58     }
  59
  60     if(cJSON_AddStringToObject(common_event_header, "eventId", eventId) == 0) {
  61         log_error("cJSON AddStringToObject error\n");
  62         free(eventId);
  63         cJSON_Delete(common_event_header);
  64         return 0;
  65     }
  66
  67     free(eventId);
  68
  69     if(cJSON_AddStringToObject(common_event_header, "eventName", event_type) == 0) {
  70         log_error("cJSON AddStringToObject error\n");
  71         cJSON_Delete(common_event_header);
  72         return 0;
  73     }
  74
  75     if(cJSON_AddNumberToObject(common_event_header, "sequence", (double)(seq_id)) == 0) {
  76         log_error("cJSON AddNumberToObject error\n");
  77         cJSON_Delete(common_event_header);
  78         return 0;
  79     }
  80
  81     if(cJSON_AddStringToObject(common_event_header, "priority", priority) == 0) {
  82         log_error("cJSON AddStringToObject error\n");
  83         cJSON_Delete(common_event_header);
  84         return 0;
  85     }
  86
  87     if(cJSON_AddStringToObject(common_event_header, "reportingEntityId", "") == 0) {
  88         log_error("cJSON AddStringToObject error\n");
  89         cJSON_Delete(common_event_header);
  90         return 0;
  91     }
  92
  93     char source_name[512];
  94     if(port) {
  95         sprintf(source_name, "%s-%d", hostname, port);
  96     }
  97     else {
  98         sprintf(source_name, "%s", hostname);
  99     }
 100
 101     if(cJSON_AddStringToObject(common_event_header, "reportingEntityName", source_name) == 0) {
 102         log_error("cJSON AddStringToObject error\n");
 103         cJSON_Delete(common_event_header);
 104         return 0;
 105     }
 106
 107     if(cJSON_AddStringToObject(common_event_header, "sourceId", "") == 0) {
 108         log_error("cJSON AddStringToObject error\n");
 109         cJSON_Delete(common_event_header);
 110         return 0;
 111     }
 112
 113     if(cJSON_AddStringToObject(common_event_header, "sourceName", source_name) == 0) {
 114         log_error("cJSON AddStringToObject error\n");
 115         cJSON_Delete(common_event_header);
 116         return 0;
 117     }
 118
 119     if(cJSON_AddNumberToObject(common_event_header, "startEpochMicrosec", (double)(useconds)) == 0) {
 120         log_error("cJSON AddNumberToObject error\n");
 121         cJSON_Delete(common_event_header);
 122         return 0;
 123     }
 124
 125     if(cJSON_AddNumberToObject(common_event_header, "lastEpochMicrosec", (double)(useconds)) == 0) {
 126         log_error("cJSON AddNumberToObject error\n");
 127         cJSON_Delete(common_event_header);
 128         return 0;
 129     }
 130
 131     if(cJSON_AddStringToObject(common_event_header, "nfNamingCode", "sdn controller") == 0) {
 132         log_error("cJSON AddStringToObject error\n");
 133         cJSON_Delete(common_event_header);
 134         return 0;
 135     }
 136
 137     if(cJSON_AddStringToObject(common_event_header, "nfVendorName", "sdn") == 0) {
 138         log_error("cJSON AddStringToObject error\n");
 139         cJSON_Delete(common_event_header);
 140         return 0;
 141     }
 142
 143     if(cJSON_AddStringToObject(common_event_header, "timeZoneOffset", "+00:00") == 0) {
 144         log_error("cJSON AddStringToObject error\n");
 145         cJSON_Delete(common_event_header);
 146         return 0;
 147     }
 148
 149     if(cJSON_AddStringToObject(common_event_header, "version", "4.1") == 0) {
 150         log_error("cJSON AddStringToObject error\n");
 151         cJSON_Delete(common_event_header);
 152         return 0;
 153     }
 154
 155     if(cJSON_AddStringToObject(common_event_header, "vesEventListenerVersion", framework_environment.ves_endpoint.common_header_version) == 0) {
 156         log_error("cJSON AddStringToObject error\n");
 157         cJSON_Delete(common_event_header);
 158         return 0;
 159     }
 160
 161     return common_event_header;
 162 }
 163
 164 cJSON* ves_create_common_event_header_721(const char *domain, const char *event_type, const char *hostname, int port, const char *priority, int seq_id, const char *stnd_defined_namespace) {
 165     assert(domain);
 166     assert(event_type);
 167     assert(hostname);
 168     assert(priority);
 169
 170     char *eventId = 0;
 171     long useconds = get_microseconds_since_epoch();
 172
 173     asprintf(&eventId, "%s-%d", event_type, seq_id);
 174     if(eventId == 0) {
 175         log_error("asprintf failed\n");
 176         return 0;
 177     }
 178
 179     cJSON *common_event_header = cJSON_CreateObject();
 180     if(common_event_header == 0) {
 181         log_error("could not create JSON object\n");
 182         free(eventId);
 183         return 0;
 184     }
 185
 186     if(cJSON_AddStringToObject(common_event_header, "domain", domain) == 0) {
 187         log_error("cJSON AddStringToObject error\n");
 188         free(eventId);
 189         cJSON_Delete(common_event_header);
 190         return 0;
 191     }
 192
 193     if(cJSON_AddStringToObject(common_event_header, "eventId", eventId) == 0) {
 194         log_error("cJSON AddStringToObject error\n");
 195         free(eventId);
 196         cJSON_Delete(common_event_header);
 197         return 0;
 198     }
 199
 200     free(eventId);
 201
 202     char *eventName = 0;
 203     asprintf(&eventName, "ves-stndDefined-%s", event_type);
 204     if(eventId == 0) {
 205         log_error("asprintf failed\n");
 206         return 0;
 207     }
 208
 209     if(cJSON_AddStringToObject(common_event_header, "eventName", eventName) == 0) {
 210         log_error("cJSON AddStringToObject error\n");
 211         cJSON_Delete(common_event_header);
 212         free(eventName);
 213         return 0;
 214     }
 215     free(eventName);
 216
 217     if(cJSON_AddStringToObject(common_event_header, "eventType", event_type) == 0) {
 218         log_error("cJSON AddStringToObject error\n");
 219         cJSON_Delete(common_event_header);
 220         return 0;
 221     }
 222
 223     if(cJSON_AddNumberToObject(common_event_header, "sequence", (double)(seq_id)) == 0) {
 224         log_error("cJSON AddNumberToObject error\n");
 225         cJSON_Delete(common_event_header);
 226         return 0;
 227     }
 228
 229     if(cJSON_AddStringToObject(common_event_header, "priority", priority) == 0) {
 230         log_error("cJSON AddStringToObject error\n");
 231         cJSON_Delete(common_event_header);
 232         return 0;
 233     }
 234
 235     if(cJSON_AddStringToObject(common_event_header, "reportingEntityId", "") == 0) {
 236         log_error("cJSON AddStringToObject error\n");
 237         cJSON_Delete(common_event_header);
 238         return 0;
 239     }
 240
 241     char source_name[512];
 242     if(port) {
 243         sprintf(source_name, "%s-%d", hostname, port);
 244     }
 245     else {
 246         sprintf(source_name, "%s", hostname);
 247     }
 248
 249     if(cJSON_AddStringToObject(common_event_header, "reportingEntityName", source_name) == 0) {
 250         log_error("cJSON AddStringToObject error\n");
 251         cJSON_Delete(common_event_header);
 252         return 0;
 253     }
 254
 255     if(cJSON_AddStringToObject(common_event_header, "sourceId", "") == 0) {
 256         log_error("cJSON AddStringToObject error\n");
 257         cJSON_Delete(common_event_header);
 258         return 0;
 259     }
 260
 261     if(cJSON_AddStringToObject(common_event_header, "sourceName", source_name) == 0) {
 262         log_error("cJSON AddStringToObject error\n");
 263         cJSON_Delete(common_event_header);
 264         return 0;
 265     }
 266
 267     if(cJSON_AddNumberToObject(common_event_header, "startEpochMicrosec", (double)(useconds)) == 0) {
 268         log_error("cJSON AddNumberToObject error\n");
 269         cJSON_Delete(common_event_header);
 270         return 0;
 271     }
 272
 273     if(cJSON_AddNumberToObject(common_event_header, "lastEpochMicrosec", (double)(useconds)) == 0) {
 274         log_error("cJSON AddNumberToObject error\n");
 275         cJSON_Delete(common_event_header);
 276         return 0;
 277     }
 278
 279     if(cJSON_AddStringToObject(common_event_header, "nfNamingCode", "sdn controller") == 0) {
 280         log_error("cJSON AddStringToObject error\n");
 281         cJSON_Delete(common_event_header);
 282         return 0;
 283     }
 284
 285     if(cJSON_AddStringToObject(common_event_header, "nfVendorName", "sdn") == 0) {
 286         log_error("cJSON AddStringToObject error\n");
 287         cJSON_Delete(common_event_header);
 288         return 0;
 289     }
 290
 291     if(cJSON_AddStringToObject(common_event_header, "timeZoneOffset", "+00:00") == 0) {
 292         log_error("cJSON AddStringToObject error\n");
 293         cJSON_Delete(common_event_header);
 294         return 0;
 295     }
 296
 297     if(cJSON_AddStringToObject(common_event_header, "version", "4.1") == 0) {
 298         log_error("cJSON AddStringToObject error\n");
 299         cJSON_Delete(common_event_header);
 300         return 0;
 301     }
 302
 303     if(cJSON_AddStringToObject(common_event_header, "vesEventListenerVersion", "7.2.1") == 0) {
 304         log_error("cJSON AddStringToObject error\n");
 305         cJSON_Delete(common_event_header);
 306         return 0;
 307     }
 308
 309     if(cJSON_AddStringToObject(common_event_header, "stndDefinedNamespace", stnd_defined_namespace) == 0) {
 310         log_error("cJSON AddStringToObject error\n");
 311         cJSON_Delete(common_event_header);
 312         return 0;
 313     }
 314
 315     if(cJSON_AddStringToObject(common_event_header, "nfcNamingCode", "NFC") == 0) {
 316         log_error("cJSON AddStringToObject error\n");
 317         cJSON_Delete(common_event_header);
 318         return 0;
 319     }
 320
 321     return common_event_header;
 322 }
 323
 324
 325
 326 nts_mount_point_addressing_method_t nts_mount_point_addressing_method_get(sr_session_ctx_t *current_session) {
 327     assert_session();
 328
 329     nts_mount_point_addressing_method_t ret = UNKNOWN_MAPPING;
 330
 331     int rc;
 332     bool session_started = false;
 333     if(current_session == 0) {
 334         rc = sr_session_start(session_connection, SR_DS_RUNNING, &current_session);
 335         if(rc != SR_ERR_OK) {
 336             log_error("could not start sysrepo session\n");
 337             return ret;
 338         }
 339         session_started = true;
 340     }
 341
 342     sr_val_t *value = 0;
 343     rc = sr_get_item(current_session, NTS_NF_NETWORK_FUNCTION_MPAM_SCHEMA_XPATH, 0, &value);
 344     if(rc == SR_ERR_OK) {
 345         if(strcmp(value->data.enum_val, "host-mapping") == 0) {
 346             ret = HOST_MAPPING;
 347         }
 348         else {
 349             ret = DOCKER_MAPPING;
 350         }
 351         sr_free_val(value);
 352     }
 353
 354     if(session_started) {
 355         rc = sr_session_stop(current_session);
 356         if(rc != SR_ERR_OK) {
 357             log_error("could not stop sysrepo session\n");
 358             return ret;
 359         }
 360     }
 361
 362     return ret;
 363 }
 364
 365 // checkAS authentication via certificate not supported yet
 366 ves_details_t *ves_endpoint_details_get(sr_session_ctx_t *current_session, const char *custom_path) {
 367     assert_session();
 368
 369     int rc;
 370     bool session_started = false;
 371     if(current_session == 0) {
 372         rc = sr_session_start(session_connection, SR_DS_RUNNING, &current_session);
 373         if(rc != SR_ERR_OK) {
 374             log_error("could not start sysrepo session\n");
 375             return 0;
 376         }
 377         session_started = true;
 378     }
 379
 380     struct lyd_node *data = 0;
 381     char *xpath_to_get;
 382
 383     if(custom_path == 0) {
 384         if(framework_arguments.nts_mode == NTS_MODE_MANAGER) {
 385             xpath_to_get = NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH;
 386         }
 387         else {
 388             xpath_to_get = NTS_NF_VES_ENDPOINT_CONFIG_XPATH;
 389         }
 390     }
 391     else {
 392         xpath_to_get = (char *)custom_path;
 393     }
 394
 395     rc = sr_get_subtree(current_session, xpath_to_get, 0, &data);
 396     if(rc != SR_ERR_OK) {
 397         log_error("could not get value for xPath=%s from the running datastore\n", xpath_to_get);
 398         if(session_started) {
 399             sr_session_stop(current_session);
 400         }
 401         return 0;
 402     }
 403
 404     if(session_started) {
 405         rc = sr_session_stop(current_session);
 406         if(rc != SR_ERR_OK) {
 407             log_error("could not stop sysrepo session\n");
 408             lyd_free(data);
 409             return 0;
 410         }
 411     }
 412
 413     if(data->child == 0) {
 414         log_error("ves-endpoint probably not set yet\n", xpath_to_get);
 415         lyd_free(data);
 416         return 0;
 417     }
 418
 419     ves_details_t *ret = (ves_details_t *)malloc(sizeof(ves_details_t));
 420     if(!ret) {
 421         log_error("malloc failed\n");
 422         lyd_free(data);
 423         return 0;
 424     }
 425
 426     ret->protocol = 0;
 427     ret->ip = 0;
 428     ret->port = 0;
 429     ret->auth_method = 0;
 430     ret->username = 0;
 431     ret->password = 0;
 432
 433     struct lyd_node *chd = 0;
 434     LY_TREE_FOR(data->child, chd) {
 435         const char *val = ((const struct lyd_node_leaf_list *)chd)->value_str;
 436
 437         if(strcmp(chd->schema->name, "ves-endpoint-protocol") == 0) {
 438             ret->protocol = strdup(val);
 439         }
 440         else if(strcmp(chd->schema->name, "ves-endpoint-ip") == 0) {
 441             ret->ip = strdup(val);
 442         }
 443         else if(strcmp(chd->schema->name, "ves-endpoint-port") == 0) {
 444             ret->port = ((const struct lyd_node_leaf_list *)chd)->value.uint16;
 445         }
 446         else if(strcmp(chd->schema->name, "ves-endpoint-auth-method") == 0) {
 447             ret->auth_method = strdup(val);
 448         }
 449         else if(strcmp(chd->schema->name, "ves-endpoint-username") == 0) {
 450             ret->username = strdup(val);
 451         }
 452         else if(strcmp(chd->schema->name, "ves-endpoint-password") == 0) {
 453             ret->password = strdup(val);
 454         }
 455     }
 456     lyd_free(data);
 457
 458     if (strstr(ret->ip, ":")) {
 459         // IPv6 address
 460         asprintf(&ret->url, "%s://[%s]:%d/eventListener/v7", ret->protocol, ret->ip, ret->port);
 461     }
 462     else {
 463         if (framework_environment.ves_endpoint.port_absent == true) {
 464             // hostname addressing with port missing
 465             asprintf(&ret->url, "%s://%s/eventListener/v7", ret->protocol, ret->ip);
 466         }
 467         else {
 468             // normal addressing with IP and Port
 469             asprintf(&ret->url, "%s://%s:%d/eventListener/v7", ret->protocol, ret->ip, ret->port);
 470         }
 471
 472     }
 473
 474     if((ret->protocol == 0) || (ret->ip == 0) || (ret->auth_method == 0) || (ret->username == 0) || (ret->password == 0) || (ret->url == 0)) {
 475         free(ret->protocol);
 476         free(ret->ip);
 477         free(ret->auth_method);
 478         free(ret->username);
 479         free(ret->password);
 480         free(ret->url);
 481         free(ret);
 482         ret = 0;
 483     }
 484
 485     return ret;
 486 }
 487
 488 void ves_details_free(ves_details_t *instance) {
 489     assert(instance);
 490
 491     free(instance->protocol);
 492     free(instance->ip);
 493     free(instance->url);
 494     free(instance->auth_method);
 495     free(instance->username);
 496     free(instance->password);
 497     free(instance);
 498 }
 499
 500
 501 // checkAS authentication via certificate not supported yet
 502 controller_details_t *controller_details_get(sr_session_ctx_t *current_session) {
 503     assert_session();
 504
 505     int rc;
 506     bool session_started = false;
 507     if(current_session == 0) {
 508         rc = sr_session_start(session_connection, SR_DS_RUNNING, &current_session);
 509         if(rc != SR_ERR_OK) {
 510             log_error("could not start sysrepo session\n");
 511             return 0;
 512         }
 513         session_started = true;
 514     }
 515
 516     struct lyd_node *data = 0;
 517     char *xpath_to_get;
 518
 519     if(framework_arguments.nts_mode == NTS_MODE_MANAGER) {
 520         xpath_to_get = NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH;
 521     }
 522     else {
 523         xpath_to_get = NTS_NF_SDN_CONTROLLER_CONFIG_XPATH;
 524     }
 525
 526     rc = sr_get_subtree(current_session, xpath_to_get, 0, &data);
 527     if(rc != SR_ERR_OK) {
 528         log_error("could not get value for xPath=%s from the running datastore\n", xpath_to_get);
 529         if(session_started) {
 530             sr_session_stop(current_session);
 531         }
 532         return 0;
 533     }
 534
 535     if(session_started) {
 536         rc = sr_session_stop(current_session);
 537         if(rc != SR_ERR_OK) {
 538             log_error("could not stop sysrepo session\n");
 539             lyd_free(data);
 540             return 0;
 541         }
 542     }
 543
 544     if(data->child == 0) {
 545         log_error("sdn-controller probably not set yet\n");
 546         lyd_free(data);
 547         return 0;
 548     }
 549
 550     controller_details_t *ret = (controller_details_t *)malloc(sizeof(controller_details_t));
 551     if(!ret) {
 552         log_error("malloc failed\n");
 553         lyd_free(data);
 554         return 0;
 555     }
 556
 557     ret->protocol = 0;
 558     ret->ip = 0;
 559     ret->port = 0;
 560     ret->nc_callhome_ip = 0;
 561     ret->nc_callhome_port = 0;
 562     ret->auth_method = 0;
 563     ret->username = 0;
 564     ret->password = 0;
 565
 566     ret->auth_method = strdup("basic");
 567
 568     struct lyd_node *chd = 0;
 569     LY_TREE_FOR(data->child, chd) {
 570         const char *val = ((const struct lyd_node_leaf_list *)chd)->value_str;
 571
 572         if(strcmp(chd->schema->name, "controller-protocol") == 0) {
 573             ret->protocol = strdup(val);
 574         }
 575         else if(strcmp(chd->schema->name, "controller-ip") == 0) {
 576             ret->ip = strdup(val);
 577         }
 578         else if(strcmp(chd->schema->name, "controller-port") == 0) {
 579             ret->port = ((const struct lyd_node_leaf_list *)chd)->value.uint16;
 580         }
 581         else if(strcmp(chd->schema->name, "controller-netconf-call-home-ip") == 0) {
 582             ret->nc_callhome_ip = strdup(val);
 583         }
 584         else if(strcmp(chd->schema->name, "controller-netconf-call-home-port") == 0) {
 585             ret->nc_callhome_port = ((const struct lyd_node_leaf_list *)chd)->value.uint16;
 586         }
 587         else if(strcmp(chd->schema->name, "controller-username") == 0) {
 588             ret->username = strdup(val);
 589         }
 590         else if(strcmp(chd->schema->name, "controller-password") == 0) {
 591             ret->password = strdup(val);
 592         }
 593     }
 594     lyd_free(data);
 595
 596     if (strstr(ret->ip, ":")) {
 597         // IPv6 address
 598         asprintf(&ret->base_url, "%s://[%s]:%d", ret->protocol, ret->ip, ret->port);
 599     }
 600     else {
 601         if (framework_environment.sdn_controller.port_absent == true) {
 602             // hostname without port addressing
 603             asprintf(&ret->base_url, "%s://%s", ret->protocol, ret->ip);
 604         }
 605         else {
 606             // normal IP and Port addressing
 607             asprintf(&ret->base_url, "%s://%s:%d", ret->protocol, ret->ip, ret->port);
 608         }
 609     }
 610
 611     if((ret->protocol == 0) || (ret->ip == 0) || (ret->nc_callhome_ip == 0) || (ret->auth_method == 0) || (ret->username == 0) || (ret->password == 0) || (ret->base_url == 0)) {
 612         free(ret->protocol);
 613         free(ret->ip);
 614         free(ret->nc_callhome_ip);
 615         free(ret->auth_method);
 616         free(ret->username);
 617         free(ret->password);
 618         free(ret->base_url);
 619         free(ret);
 620         ret = 0;
 621     }
 622
 623     return ret;
 624 }
 625
 626 void controller_details_free(controller_details_t *instance) {
 627     assert(instance);
 628
 629     free(instance->protocol);
 630     free(instance->ip);
 631     free(instance->nc_callhome_ip);
 632     free(instance->base_url);
 633     free(instance->auth_method);
 634     free(instance->username);
 635     free(instance->password);
 636     free(instance);
 637 }
 638
 639 int nts_vercmp(const char *ver1, const char *ver2) {
 640     assert(ver1);
 641     assert(ver2);
 642
 643     int i = 0;
 644     int v1 = 0, v2 = 0, v3 = 0;
 645     while(ver1[i] && (ver1[i] != '.')) {
 646         v1 *= 10;
 647         v1 += ver1[i] - '0';
 648         i++;
 649     }
 650
 651     if(ver1[i]) {
 652         i++;
 653         while(ver1[i] && (ver1[i] != '.')) {
 654             v2 *= 10;
 655             v2 += ver1[i] - '0';
 656             i++;
 657         }
 658
 659         if(ver1[i]) {
 660             i++;
 661             while(ver1[i] && (ver1[i] != '.')) {
 662                 v3 *= 10;
 663                 v3 += ver1[i] - '0';
 664                 i++;
 665             }
 666         }
 667     }
 668
 669
 670     int V1 = 0, V2 = 0, V3 = 0;
 671     i = 0;
 672     while(ver2[i] && (ver2[i] != '.')) {
 673         V1 *= 10;
 674         V1 += ver2[i] - '0';
 675         i++;
 676     }
 677
 678     if(ver2[i]) {
 679         i++;
 680         while(ver2[i] && (ver2[i] != '.')) {
 681             V2 *= 10;
 682             V2 += ver2[i] - '0';
 683             i++;
 684         }
 685
 686         if(ver2[i]) {
 687             i++;
 688             while(ver2[i] && (ver2[i] != '.')) {
 689                 V3 *= 10;
 690                 V3 += ver2[i] - '0';
 691                 i++;
 692             }
 693         }
 694     }
 695
 696     if(v1 < V1) {
 697         return -1;
 698     }
 699     else if(v1 > V1) {
 700         return 1;
 701     }
 702
 703     if(v2 < V2) {
 704         return -1;
 705     }
 706     else if(v2 > V2) {
 707         return 1;
 708     }
 709
 710     if(v3 < V3) {
 711         return -1;
 712     }
 713     else if(v3 > V3) {
 714         return 1;
 715     }
 716
 717     return 0;
 718 }
 719
 720 int nts_utils_populate_info(sr_session_ctx_t *current_session, const char *function_type) {
 721     assert(current_session);
 722     assert(function_type);
 723
 724     bool manager = (strcmp(function_type, "NTS_FUNCTION_TYPE_MANAGER") == 0);
 725
 726     int rc;
 727     char int_to_str[30];
 728     //setup sdn-controller defaults
 729     if(strlen(framework_environment.sdn_controller.protocol)) {
 730         if(manager) {
 731             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-protocol", (const char*)framework_environment.sdn_controller.protocol, 0, 0);
 732         }
 733         else {
 734             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-protocol", (const char*)framework_environment.sdn_controller.protocol, 0, 0);
 735         }
 736         if(rc != SR_ERR_OK) {
 737             log_error("sr_set_item_str failed\n");
 738             return NTS_ERR_FAILED;
 739         }
 740     }
 741
 742     if(strlen(framework_environment.sdn_controller.ip)) {
 743         if(manager) {
 744             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-ip", (const char*)framework_environment.sdn_controller.ip, 0, 0);
 745         }
 746         else {
 747             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-ip", (const char*)framework_environment.sdn_controller.ip, 0, 0);
 748         }
 749         if(rc != SR_ERR_OK) {
 750             log_error("sr_set_item_str failed\n");
 751             return NTS_ERR_FAILED;
 752         }
 753     }
 754
 755     sprintf(int_to_str, "%d", framework_environment.sdn_controller.port);
 756     if(manager) {
 757         rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-port", (const char*)int_to_str, 0, 0);
 758     }
 759     else {
 760         rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-port", (const char*)int_to_str, 0, 0);
 761     }
 762     if(rc != SR_ERR_OK) {
 763         log_error("sr_set_item_str failed\n");
 764         return NTS_ERR_FAILED;
 765     }
 766
 767     if(strlen(framework_environment.sdn_controller.callhome_ip)) {
 768         if(manager) {
 769             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-netconf-call-home-ip", (const char*)framework_environment.sdn_controller.callhome_ip, 0, 0);
 770         }
 771         else {
 772             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-netconf-call-home-ip", (const char*)framework_environment.sdn_controller.callhome_ip, 0, 0);
 773         }
 774         if(rc != SR_ERR_OK) {
 775             log_error("sr_set_item_str failed\n");
 776             return NTS_ERR_FAILED;
 777         }
 778     }
 779
 780     sprintf(int_to_str, "%d", framework_environment.sdn_controller.callhome_port);
 781     if(manager) {
 782         rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-netconf-call-home-port", (const char*)int_to_str, 0, 0);
 783     }
 784     else {
 785         rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-netconf-call-home-port", (const char*)int_to_str, 0, 0);
 786     }
 787     if(rc != SR_ERR_OK) {
 788         log_error("sr_set_item_str failed\n");
 789         return NTS_ERR_FAILED;
 790     }
 791
 792     if(strlen(framework_environment.sdn_controller.username)) {
 793         if(manager) {
 794             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-username", (const char*)framework_environment.sdn_controller.username, 0, 0);
 795         }
 796         else {
 797             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-username", (const char*)framework_environment.sdn_controller.username, 0, 0);
 798         }
 799         if(rc != SR_ERR_OK) {
 800             log_error("sr_set_item_str failed\n");
 801             return NTS_ERR_FAILED;
 802         }
 803     }
 804
 805     if(strlen(framework_environment.sdn_controller.password)) {
 806         if(manager) {
 807             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-password", (const char*)framework_environment.sdn_controller.password, 0, 0);
 808         }
 809         else {
 810             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-password", (const char*)framework_environment.sdn_controller.password, 0, 0);
 811         }
 812         if(rc != SR_ERR_OK) {
 813             log_error("sr_set_item_str failed\n");
 814             return NTS_ERR_FAILED;
 815         }
 816     }
 817
 818     //setup ves-endpoint details
 819     if(strlen(framework_environment.ves_endpoint.protocol)) {
 820         if(manager) {
 821             rc = sr_set_item_str(current_session, NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-protocol", (const char*)framework_environment.ves_endpoint.protocol, 0, 0);
 822         }
 823         else {
 824             rc = sr_set_item_str(current_session, NTS_NF_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-protocol", (const char*)framework_environment.ves_endpoint.protocol, 0, 0);
 825         }
 826         if(rc != SR_ERR_OK) {
 827             log_error("sr_set_item_str failed\n");
 828             return NTS_ERR_FAILED;
 829         }
 830     }
 831
 832     if(strlen(framework_environment.ves_endpoint.ip)) {
 833         if(manager) {
 834             rc = sr_set_item_str(current_session, NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-ip", (const char*)framework_environment.ves_endpoint.ip, 0, 0);
 835         }
 836         else {
 837             rc = sr_set_item_str(current_session, NTS_NF_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-ip", (const char*)framework_environment.ves_endpoint.ip, 0, 0);
 838         }
 839         if(rc != SR_ERR_OK) {
 840             log_error("sr_set_item_str failed\n");
 841             return NTS_ERR_FAILED;
 842         }
 843     }
 844
 845     sprintf(int_to_str, "%d", framework_environment.ves_endpoint.port);
 846     if(manager) {
 847         rc = sr_set_item_str(current_session, NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-port", (const char*)int_to_str, 0, 0);
 848     }
 849     else {
 850         rc = sr_set_item_str(current_session, NTS_NF_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-port", (const char*)int_to_str, 0, 0);
 851     }
 852     if(rc != SR_ERR_OK) {
 853         log_error("sr_set_item_str failed\n");
 854         return NTS_ERR_FAILED;
 855     }
 856
 857     if(strlen(framework_environment.ves_endpoint.auth_method)) {
 858         if(manager) {
 859             rc = sr_set_item_str(current_session, NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-auth-method", (const char*)framework_environment.ves_endpoint.auth_method, 0, 0);
 860         }
 861         else {
 862             rc = sr_set_item_str(current_session, NTS_NF_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-auth-method", (const char*)framework_environment.ves_endpoint.auth_method, 0, 0);
 863         }
 864         if(rc != SR_ERR_OK) {
 865             log_error("sr_set_item_str failed\n");
 866             return NTS_ERR_FAILED;
 867         }
 868     }
 869
 870     if(strlen(framework_environment.ves_endpoint.username)) {
 871         if(manager) {
 872             rc = sr_set_item_str(current_session, NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-username", (const char*)framework_environment.ves_endpoint.username, 0, 0);
 873         }
 874         else {
 875             rc = sr_set_item_str(current_session, NTS_NF_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-username", (const char*)framework_environment.ves_endpoint.username, 0, 0);
 876         }
 877         if(rc != SR_ERR_OK) {
 878             log_error("sr_set_item_str failed\n");
 879             return NTS_ERR_FAILED;
 880         }
 881     }
 882
 883     if(strlen(framework_environment.ves_endpoint.password)) {
 884         if(manager) {
 885             rc = sr_set_item_str(current_session, NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-password", (const char*)framework_environment.ves_endpoint.password, 0, 0);
 886         }
 887         else {
 888             rc = sr_set_item_str(current_session, NTS_NF_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-password", (const char*)framework_environment.ves_endpoint.password, 0, 0);
 889         }
 890         if(rc != SR_ERR_OK) {
 891             log_error("sr_set_item_str failed\n");
 892             return NTS_ERR_FAILED;
 893         }
 894     }
 895
 896     if(strlen(framework_environment.ves_endpoint.certificate)) {
 897         if(manager) {
 898             rc = sr_set_item_str(current_session, NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-certificate", (const char*)framework_environment.ves_endpoint.certificate, 0, 0);
 899         }
 900         else {
 901             rc = sr_set_item_str(current_session, NTS_NF_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-certificate", (const char*)framework_environment.ves_endpoint.certificate, 0, 0);
 902         }
 903         if(rc != SR_ERR_OK) {
 904             log_error("sr_set_item_str failed\n");
 905             return NTS_ERR_FAILED;
 906         }
 907     }
 908
 909     if(manager == false) {
 910         //presence containers
 911         rc = sr_set_item_str(current_session, NTS_NF_FAULT_GENERATION_SCHEMA_XPATH, 0, 0, 0);
 912         if(rc != SR_ERR_OK) {
 913             log_error("sr_set_item_str failed\n");
 914             return NTS_ERR_FAILED;
 915         }
 916
 917         rc = sr_set_item_str(current_session, NTS_NF_NETCONF_SCHEMA_XPATH, 0, 0, 0);
 918         if(rc != SR_ERR_OK) {
 919             log_error("sr_set_item_str failed\n");
 920             return NTS_ERR_FAILED;
 921         }
 922
 923         rc = sr_set_item_str(current_session, NTS_NF_VES_SCHEMA_XPATH, 0, 0, 0);
 924         if(rc != SR_ERR_OK) {
 925             log_error("sr_set_item_str failed\n");
 926             return NTS_ERR_FAILED;
 927         }
 928     }
 929
 930     //also set the network-function module for easy identifying the function type
 931     rc = sr_set_item_str(current_session, NTS_NF_NETWORK_FUNCTION_FTYPE_SCHEMA_XPATH, function_type, 0, 0);
 932     if(rc != SR_ERR_OK) {
 933         log_error("sr_set_item_str failed\n");
 934         return NTS_ERR_FAILED;
 935     }
 936
 937     //mount-point-addressing-method
 938     rc = sr_set_item_str(current_session, NTS_NF_NETWORK_FUNCTION_MPAM_SCHEMA_XPATH, framework_environment.nts.nf_mount_point_addressing_method, 0, 0);
 939     if(rc != SR_ERR_OK) {
 940         log_error("sr_set_item_str failed\n");
 941         return NTS_ERR_FAILED;
 942     }
 943
 944     //apply all changes
 945     rc = sr_apply_changes(current_session, 0, 0);
 946     if(rc != SR_ERR_OK) {
 947         log_error("sr_apply_changes failed: %s\n", sr_strerror(rc));
 948         return NTS_ERR_FAILED;
 949     }
 950
 951     return NTS_ERR_OK;
 952 }