Bug fix.
[sim/o1-interface.git] / 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 }