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