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 nts_mount_point_addressing_method_t nts_mount_point_addressing_method_get(sr_session_ctx_t *current_session) {
 165     assert_session();
 166
 167     nts_mount_point_addressing_method_t ret = UNKNOWN_MAPPING;
 168
 169     int rc;
 170     bool session_started = false;
 171     if(current_session == 0) {
 172         rc = sr_session_start(session_connection, SR_DS_RUNNING, &current_session);
 173         if(rc != SR_ERR_OK) {
 174             log_error("could not start sysrepo session\n");
 175             return ret;
 176         }
 177         session_started = true;
 178     }
 179
 180     sr_val_t *value = 0;
 181     rc = sr_get_item(current_session, NTS_NF_NETWORK_FUNCTION_MPAM_SCHEMA_XPATH, 0, &value);
 182     if(rc == SR_ERR_OK) {
 183         if(strcmp(value->data.enum_val, "host-mapping") == 0) {
 184             ret = HOST_MAPPING;
 185         }
 186         else {
 187             ret = DOCKER_MAPPING;
 188         }
 189         sr_free_val(value);
 190     }
 191
 192     if(session_started) {
 193         rc = sr_session_stop(current_session);
 194         if(rc != SR_ERR_OK) {
 195             log_error("could not stop sysrepo session\n");
 196             return ret;
 197         }
 198     }
 199
 200     return ret;
 201 }
 202
 203 // checkAS authentication via certificate not supported yet
 204 ves_details_t *ves_endpoint_details_get(sr_session_ctx_t *current_session, const char *custom_path) {
 205     assert_session();
 206
 207     int rc;
 208     bool session_started = false;
 209     if(current_session == 0) {
 210         rc = sr_session_start(session_connection, SR_DS_RUNNING, &current_session);
 211         if(rc != SR_ERR_OK) {
 212             log_error("could not start sysrepo session\n");
 213             return 0;
 214         }
 215         session_started = true;
 216     }
 217
 218     struct lyd_node *data = 0;
 219     char *xpath_to_get;
 220
 221     if(custom_path == 0) {
 222         if(framework_arguments.nts_mode == NTS_MODE_MANAGER) {
 223             xpath_to_get = NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH;
 224         }
 225         else {
 226             xpath_to_get = NTS_NF_VES_ENDPOINT_CONFIG_XPATH;
 227         }
 228     }
 229     else {
 230         xpath_to_get = (char *)custom_path;
 231     }
 232
 233     rc = sr_get_subtree(current_session, xpath_to_get, 0, &data);
 234     if(rc != SR_ERR_OK) {
 235         log_error("could not get value for xPath=%s from the running datastore\n", xpath_to_get);
 236         if(session_started) {
 237             sr_session_stop(current_session);
 238         }
 239         return 0;
 240     }
 241
 242     if(session_started) {
 243         rc = sr_session_stop(current_session);
 244         if(rc != SR_ERR_OK) {
 245             log_error("could not stop sysrepo session\n");
 246             lyd_free(data);
 247             return 0;
 248         }
 249     }
 250
 251     if(data->child == 0) {
 252         log_error("ves-endpoint probably not set yet\n", xpath_to_get);
 253         lyd_free(data);
 254         return 0;
 255     }
 256
 257     ves_details_t *ret = (ves_details_t *)malloc(sizeof(ves_details_t));
 258     if(!ret) {
 259         log_error("malloc failed\n");
 260         lyd_free(data);
 261         return 0;
 262     }
 263
 264     ret->protocol = 0;
 265     ret->ip = 0;
 266     ret->port = 0;
 267     ret->auth_method = 0;
 268     ret->username = 0;
 269     ret->password = 0;
 270
 271     struct lyd_node *chd = 0;
 272     LY_TREE_FOR(data->child, chd) {
 273         const char *val = ((const struct lyd_node_leaf_list *)chd)->value_str;
 274
 275         if(strcmp(chd->schema->name, "ves-endpoint-protocol") == 0) {
 276             ret->protocol = strdup(val);
 277         }
 278         else if(strcmp(chd->schema->name, "ves-endpoint-ip") == 0) {
 279             ret->ip = strdup(val);
 280         }
 281         else if(strcmp(chd->schema->name, "ves-endpoint-port") == 0) {
 282             ret->port = ((const struct lyd_node_leaf_list *)chd)->value.uint16;
 283         }
 284         else if(strcmp(chd->schema->name, "ves-endpoint-auth-method") == 0) {
 285             ret->auth_method = strdup(val);
 286         }
 287         else if(strcmp(chd->schema->name, "ves-endpoint-username") == 0) {
 288             ret->username = strdup(val);
 289         }
 290         else if(strcmp(chd->schema->name, "ves-endpoint-password") == 0) {
 291             ret->password = strdup(val);
 292         }
 293     }
 294     lyd_free(data);
 295
 296     if (strstr(ret->ip, ":")) {
 297         // IPv6 address
 298         asprintf(&ret->url, "%s://[%s]:%d/eventListener/v7", ret->protocol, ret->ip, ret->port);
 299     }
 300     else {
 301         if (framework_environment.ves_endpoint.port_absent == true) {
 302             // hostname addressing with port missing
 303             asprintf(&ret->url, "%s://%s/eventListener/v7", ret->protocol, ret->ip);
 304         }
 305         else {
 306             // normal addressing with IP and Port
 307             asprintf(&ret->url, "%s://%s:%d/eventListener/v7", ret->protocol, ret->ip, ret->port);
 308         }
 309
 310     }
 311
 312     if((ret->protocol == 0) || (ret->ip == 0) || (ret->auth_method == 0) || (ret->username == 0) || (ret->password == 0) || (ret->url == 0)) {
 313         free(ret->protocol);
 314         free(ret->ip);
 315         free(ret->auth_method);
 316         free(ret->username);
 317         free(ret->password);
 318         free(ret->url);
 319         free(ret);
 320         ret = 0;
 321     }
 322
 323     return ret;
 324 }
 325
 326 void ves_details_free(ves_details_t *instance) {
 327     assert(instance);
 328
 329     free(instance->protocol);
 330     free(instance->ip);
 331     free(instance->url);
 332     free(instance->auth_method);
 333     free(instance->username);
 334     free(instance->password);
 335     free(instance);
 336 }
 337
 338
 339 // checkAS authentication via certificate not supported yet
 340 controller_details_t *controller_details_get(sr_session_ctx_t *current_session) {
 341     assert_session();
 342
 343     int rc;
 344     bool session_started = false;
 345     if(current_session == 0) {
 346         rc = sr_session_start(session_connection, SR_DS_RUNNING, &current_session);
 347         if(rc != SR_ERR_OK) {
 348             log_error("could not start sysrepo session\n");
 349             return 0;
 350         }
 351         session_started = true;
 352     }
 353
 354     struct lyd_node *data = 0;
 355     char *xpath_to_get;
 356
 357     if(framework_arguments.nts_mode == NTS_MODE_MANAGER) {
 358         xpath_to_get = NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH;
 359     }
 360     else {
 361         xpath_to_get = NTS_NF_SDN_CONTROLLER_CONFIG_XPATH;
 362     }
 363
 364     rc = sr_get_subtree(current_session, xpath_to_get, 0, &data);
 365     if(rc != SR_ERR_OK) {
 366         log_error("could not get value for xPath=%s from the running datastore\n", xpath_to_get);
 367         if(session_started) {
 368             sr_session_stop(current_session);
 369         }
 370         return 0;
 371     }
 372
 373     if(session_started) {
 374         rc = sr_session_stop(current_session);
 375         if(rc != SR_ERR_OK) {
 376             log_error("could not stop sysrepo session\n");
 377             lyd_free(data);
 378             return 0;
 379         }
 380     }
 381
 382     if(data->child == 0) {
 383         log_error("sdn-controller probably not set yet\n");
 384         lyd_free(data);
 385         return 0;
 386     }
 387
 388     controller_details_t *ret = (controller_details_t *)malloc(sizeof(controller_details_t));
 389     if(!ret) {
 390         log_error("malloc failed\n");
 391         lyd_free(data);
 392         return 0;
 393     }
 394
 395     ret->protocol = 0;
 396     ret->ip = 0;
 397     ret->port = 0;
 398     ret->nc_callhome_ip = 0;
 399     ret->nc_callhome_port = 0;
 400     ret->auth_method = 0;
 401     ret->username = 0;
 402     ret->password = 0;
 403
 404     ret->auth_method = strdup("basic");
 405
 406     struct lyd_node *chd = 0;
 407     LY_TREE_FOR(data->child, chd) {
 408         const char *val = ((const struct lyd_node_leaf_list *)chd)->value_str;
 409
 410         if(strcmp(chd->schema->name, "controller-protocol") == 0) {
 411             ret->protocol = strdup(val);
 412         }
 413         else if(strcmp(chd->schema->name, "controller-ip") == 0) {
 414             ret->ip = strdup(val);
 415         }
 416         else if(strcmp(chd->schema->name, "controller-port") == 0) {
 417             ret->port = ((const struct lyd_node_leaf_list *)chd)->value.uint16;
 418         }
 419         else if(strcmp(chd->schema->name, "controller-netconf-call-home-ip") == 0) {
 420             ret->nc_callhome_ip = strdup(val);
 421         }
 422         else if(strcmp(chd->schema->name, "controller-netconf-call-home-port") == 0) {
 423             ret->nc_callhome_port = ((const struct lyd_node_leaf_list *)chd)->value.uint16;
 424         }
 425         else if(strcmp(chd->schema->name, "controller-username") == 0) {
 426             ret->username = strdup(val);
 427         }
 428         else if(strcmp(chd->schema->name, "controller-password") == 0) {
 429             ret->password = strdup(val);
 430         }
 431     }
 432     lyd_free(data);
 433
 434     if (strstr(ret->ip, ":")) {
 435         // IPv6 address
 436         asprintf(&ret->base_url, "%s://[%s]:%d", ret->protocol, ret->ip, ret->port);
 437     }
 438     else {
 439         if (framework_environment.sdn_controller.port_absent == true) {
 440             // hostname without port addressing
 441             asprintf(&ret->base_url, "%s://%s", ret->protocol, ret->ip);
 442         }
 443         else {
 444             // normal IP and Port addressing
 445             asprintf(&ret->base_url, "%s://%s:%d", ret->protocol, ret->ip, ret->port);
 446         }
 447     }
 448
 449     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)) {
 450         free(ret->protocol);
 451         free(ret->ip);
 452         free(ret->nc_callhome_ip);
 453         free(ret->auth_method);
 454         free(ret->username);
 455         free(ret->password);
 456         free(ret->base_url);
 457         free(ret);
 458         ret = 0;
 459     }
 460
 461     return ret;
 462 }
 463
 464 void controller_details_free(controller_details_t *instance) {
 465     assert(instance);
 466
 467     free(instance->protocol);
 468     free(instance->ip);
 469     free(instance->nc_callhome_ip);
 470     free(instance->base_url);
 471     free(instance->auth_method);
 472     free(instance->username);
 473     free(instance->password);
 474     free(instance);
 475 }
 476
 477 int nts_vercmp(const char *ver1, const char *ver2) {
 478     assert(ver1);
 479     assert(ver2);
 480
 481     int i = 0;
 482     int v1 = 0, v2 = 0, v3 = 0;
 483     while(ver1[i] && (ver1[i] != '.')) {
 484         v1 *= 10;
 485         v1 += ver1[i] - '0';
 486         i++;
 487     }
 488
 489     if(ver1[i]) {
 490         i++;
 491         while(ver1[i] && (ver1[i] != '.')) {
 492             v2 *= 10;
 493             v2 += ver1[i] - '0';
 494             i++;
 495         }
 496
 497         if(ver1[i]) {
 498             i++;
 499             while(ver1[i] && (ver1[i] != '.')) {
 500                 v3 *= 10;
 501                 v3 += ver1[i] - '0';
 502                 i++;
 503             }
 504         }
 505     }
 506
 507
 508     int V1 = 0, V2 = 0, V3 = 0;
 509     i = 0;
 510     while(ver2[i] && (ver2[i] != '.')) {
 511         V1 *= 10;
 512         V1 += ver2[i] - '0';
 513         i++;
 514     }
 515
 516     if(ver2[i]) {
 517         i++;
 518         while(ver2[i] && (ver2[i] != '.')) {
 519             V2 *= 10;
 520             V2 += ver2[i] - '0';
 521             i++;
 522         }
 523
 524         if(ver2[i]) {
 525             i++;
 526             while(ver2[i] && (ver2[i] != '.')) {
 527                 V3 *= 10;
 528                 V3 += ver2[i] - '0';
 529                 i++;
 530             }
 531         }
 532     }
 533
 534     if(v1 < V1) {
 535         return -1;
 536     }
 537     else if(v1 > V1) {
 538         return 1;
 539     }
 540
 541     if(v2 < V2) {
 542         return -1;
 543     }
 544     else if(v2 > V2) {
 545         return 1;
 546     }
 547
 548     if(v3 < V3) {
 549         return -1;
 550     }
 551     else if(v3 > V3) {
 552         return 1;
 553     }
 554
 555     return 0;
 556 }
 557
 558 int nts_utils_populate_info(sr_session_ctx_t *current_session, const char *function_type) {
 559     assert(current_session);
 560     assert(function_type);
 561
 562     bool manager = (strcmp(function_type, "NTS_FUNCTION_TYPE_MANAGER") == 0);
 563
 564     int rc;
 565     char int_to_str[30];
 566     //setup sdn-controller defaults
 567     if(strlen(framework_environment.sdn_controller.protocol)) {
 568         if(manager) {
 569             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-protocol", (const char*)framework_environment.sdn_controller.protocol, 0, 0);
 570         }
 571         else {
 572             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-protocol", (const char*)framework_environment.sdn_controller.protocol, 0, 0);
 573         }
 574         if(rc != SR_ERR_OK) {
 575             log_error("sr_set_item_str failed\n");
 576             return NTS_ERR_FAILED;
 577         }
 578     }
 579
 580     if(strlen(framework_environment.sdn_controller.ip)) {
 581         if(manager) {
 582             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-ip", (const char*)framework_environment.sdn_controller.ip, 0, 0);
 583         }
 584         else {
 585             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-ip", (const char*)framework_environment.sdn_controller.ip, 0, 0);
 586         }
 587         if(rc != SR_ERR_OK) {
 588             log_error("sr_set_item_str failed\n");
 589             return NTS_ERR_FAILED;
 590         }
 591     }
 592
 593     sprintf(int_to_str, "%d", framework_environment.sdn_controller.port);
 594     if(manager) {
 595         rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-port", (const char*)int_to_str, 0, 0);
 596     }
 597     else {
 598         rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-port", (const char*)int_to_str, 0, 0);
 599     }
 600     if(rc != SR_ERR_OK) {
 601         log_error("sr_set_item_str failed\n");
 602         return NTS_ERR_FAILED;
 603     }
 604
 605     if(strlen(framework_environment.sdn_controller.callhome_ip)) {
 606         if(manager) {
 607             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);
 608         }
 609         else {
 610             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);
 611         }
 612         if(rc != SR_ERR_OK) {
 613             log_error("sr_set_item_str failed\n");
 614             return NTS_ERR_FAILED;
 615         }
 616     }
 617
 618     sprintf(int_to_str, "%d", framework_environment.sdn_controller.callhome_port);
 619     if(manager) {
 620         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);
 621     }
 622     else {
 623         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);
 624     }
 625     if(rc != SR_ERR_OK) {
 626         log_error("sr_set_item_str failed\n");
 627         return NTS_ERR_FAILED;
 628     }
 629
 630     if(strlen(framework_environment.sdn_controller.username)) {
 631         if(manager) {
 632             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-username", (const char*)framework_environment.sdn_controller.username, 0, 0);
 633         }
 634         else {
 635             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-username", (const char*)framework_environment.sdn_controller.username, 0, 0);
 636         }
 637         if(rc != SR_ERR_OK) {
 638             log_error("sr_set_item_str failed\n");
 639             return NTS_ERR_FAILED;
 640         }
 641     }
 642
 643     if(strlen(framework_environment.sdn_controller.password)) {
 644         if(manager) {
 645             rc = sr_set_item_str(current_session, NTS_MANAGER_SDN_CONTROLLER_CONFIG_XPATH"/controller-password", (const char*)framework_environment.sdn_controller.password, 0, 0);
 646         }
 647         else {
 648             rc = sr_set_item_str(current_session, NTS_NF_SDN_CONTROLLER_CONFIG_XPATH"/controller-password", (const char*)framework_environment.sdn_controller.password, 0, 0);
 649         }
 650         if(rc != SR_ERR_OK) {
 651             log_error("sr_set_item_str failed\n");
 652             return NTS_ERR_FAILED;
 653         }
 654     }
 655
 656     //setup ves-endpoint details
 657     if(strlen(framework_environment.ves_endpoint.protocol)) {
 658         if(manager) {
 659             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);
 660         }
 661         else {
 662             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);
 663         }
 664         if(rc != SR_ERR_OK) {
 665             log_error("sr_set_item_str failed\n");
 666             return NTS_ERR_FAILED;
 667         }
 668     }
 669
 670     if(strlen(framework_environment.ves_endpoint.ip)) {
 671         if(manager) {
 672             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);
 673         }
 674         else {
 675             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);
 676         }
 677         if(rc != SR_ERR_OK) {
 678             log_error("sr_set_item_str failed\n");
 679             return NTS_ERR_FAILED;
 680         }
 681     }
 682
 683     sprintf(int_to_str, "%d", framework_environment.ves_endpoint.port);
 684     if(manager) {
 685         rc = sr_set_item_str(current_session, NTS_MANAGER_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-port", (const char*)int_to_str, 0, 0);
 686     }
 687     else {
 688         rc = sr_set_item_str(current_session, NTS_NF_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-port", (const char*)int_to_str, 0, 0);
 689     }
 690     if(rc != SR_ERR_OK) {
 691         log_error("sr_set_item_str failed\n");
 692         return NTS_ERR_FAILED;
 693     }
 694
 695     if(strlen(framework_environment.ves_endpoint.auth_method)) {
 696         if(manager) {
 697             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);
 698         }
 699         else {
 700             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);
 701         }
 702         if(rc != SR_ERR_OK) {
 703             log_error("sr_set_item_str failed\n");
 704             return NTS_ERR_FAILED;
 705         }
 706     }
 707
 708     if(strlen(framework_environment.ves_endpoint.username)) {
 709         if(manager) {
 710             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);
 711         }
 712         else {
 713             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);
 714         }
 715         if(rc != SR_ERR_OK) {
 716             log_error("sr_set_item_str failed\n");
 717             return NTS_ERR_FAILED;
 718         }
 719     }
 720
 721     if(strlen(framework_environment.ves_endpoint.password)) {
 722         if(manager) {
 723             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);
 724         }
 725         else {
 726             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);
 727         }
 728         if(rc != SR_ERR_OK) {
 729             log_error("sr_set_item_str failed\n");
 730             return NTS_ERR_FAILED;
 731         }
 732     }
 733
 734     if(strlen(framework_environment.ves_endpoint.certificate)) {
 735         if(manager) {
 736             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);
 737         }
 738         else {
 739             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);
 740         }
 741         if(rc != SR_ERR_OK) {
 742             log_error("sr_set_item_str failed\n");
 743             return NTS_ERR_FAILED;
 744         }
 745     }
 746
 747     if(manager == false) {
 748         //presence containers
 749         rc = sr_set_item_str(current_session, NTS_NF_FAULT_GENERATION_SCHEMA_XPATH, 0, 0, 0);
 750         if(rc != SR_ERR_OK) {
 751             log_error("sr_set_item_str failed\n");
 752             return NTS_ERR_FAILED;
 753         }
 754
 755         rc = sr_set_item_str(current_session, NTS_NF_NETCONF_SCHEMA_XPATH, 0, 0, 0);
 756         if(rc != SR_ERR_OK) {
 757             log_error("sr_set_item_str failed\n");
 758             return NTS_ERR_FAILED;
 759         }
 760
 761         rc = sr_set_item_str(current_session, NTS_NF_VES_SCHEMA_XPATH, 0, 0, 0);
 762         if(rc != SR_ERR_OK) {
 763             log_error("sr_set_item_str failed\n");
 764             return NTS_ERR_FAILED;
 765         }
 766     }
 767
 768     //also set the network-function module for easy identifying the function type
 769     rc = sr_set_item_str(current_session, NTS_NF_NETWORK_FUNCTION_FTYPE_SCHEMA_XPATH, function_type, 0, 0);
 770     if(rc != SR_ERR_OK) {
 771         log_error("sr_set_item_str failed\n");
 772         return NTS_ERR_FAILED;
 773     }
 774
 775     //mount-point-addressing-method
 776     rc = sr_set_item_str(current_session, NTS_NF_NETWORK_FUNCTION_MPAM_SCHEMA_XPATH, framework_environment.nts.nf_mount_point_addressing_method, 0, 0);
 777     if(rc != SR_ERR_OK) {
 778         log_error("sr_set_item_str failed\n");
 779         return NTS_ERR_FAILED;
 780     }
 781
 782     //apply all changes
 783     rc = sr_apply_changes(current_session, 0, 0);
 784     if(rc != SR_ERR_OK) {
 785         log_error("sr_apply_changes failed: %s\n", sr_strerror(rc));
 786         return NTS_ERR_FAILED;
 787     }
 788
 789     return NTS_ERR_OK;
 790 }