ntsimulator/src/ntsimulator-manager/simulator-operations.c

   1 /*************************************************************************
   2 *
   3 * Copyright 2019 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 #include "simulator-operations.h"
  19 #include "sysrepo.h"
  20 #include "sysrepo/values.h"
  21 #include <string.h>
  22 #include <math.h>
  23 #include <linux/limits.h>
  24
  25 #include "utils.h"
  26
  27 #define LINE_BUFSIZE 128
  28
  29 static  CURL *curl; //share the same curl connection for communicating with the Docker Engine API
  30 static  CURL *curl_odl; //share the same curl connection for mounting servers in ODL
  31
  32 static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp)
  33 {
  34   size_t realsize = size * nmemb;
  35   struct MemoryStruct *mem = (struct MemoryStruct *)userp;
  36
  37   char *ptr = realloc(mem->memory, mem->size + realsize + 1);
  38   if(ptr == NULL) {
  39     /* out of memory! */
  40     printf("not enough memory (realloc returned NULL)\n");
  41     return 0;
  42   }
  43
  44   mem->memory = ptr;
  45   memcpy(&(mem->memory[mem->size]), contents, realsize);
  46   mem->size += realsize;
  47   mem->memory[mem->size] = 0;
  48
  49   return realsize;
  50 }
  51
  52 static void set_curl_common_info()
  53 {
  54         struct curl_slist *chunk = NULL;
  55         chunk = curl_slist_append(chunk, "Content-Type: application/json");
  56         chunk = curl_slist_append(chunk, "Accept: application/json");
  57
  58     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
  59
  60         curl_easy_setopt(curl, CURLOPT_UNIX_SOCKET_PATH, "/var/run/docker.sock");
  61
  62         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
  63     curl_easy_setopt(curl_odl, CURLOPT_CONNECTTIMEOUT, 2L); // seconds timeout for a connection
  64     curl_easy_setopt(curl_odl, CURLOPT_TIMEOUT, 5L); //seconds timeout for an operation
  65
  66     curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
  67 }
  68
  69 static void set_curl_common_info_odl()
  70 {
  71         struct curl_slist *chunk = NULL;
  72         chunk = curl_slist_append(chunk, "Content-Type: application/xml");
  73         chunk = curl_slist_append(chunk, "Accept: application/xml");
  74
  75     curl_easy_setopt(curl_odl, CURLOPT_HTTPHEADER, chunk);
  76
  77     curl_easy_setopt(curl_odl, CURLOPT_CONNECTTIMEOUT, 2L); // seconds timeout for a connection
  78     curl_easy_setopt(curl_odl, CURLOPT_TIMEOUT, 5L); //seconds timeout for an operation
  79
  80     curl_easy_setopt(curl_odl, CURLOPT_VERBOSE, 1L);
  81 }
  82
  83 static cJSON* get_docker_container_bindings(void)
  84 {
  85         struct MemoryStruct curl_response_mem;
  86
  87         curl_response_mem.memory = malloc(1);  /* will be grown as needed by the realloc above */
  88         curl_response_mem.size = 0;    /* no data at this point */
  89
  90         CURLcode res;
  91
  92         curl_easy_reset(curl);
  93         set_curl_common_info();
  94
  95         char url[200];
  96         sprintf(url, "http:/v%s/containers/%s/json", getenv("DOCKER_ENGINE_VERSION"), getenv("HOSTNAME"));
  97
  98         curl_easy_setopt(curl, CURLOPT_URL, url);
  99
 100     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "");
 101     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
 102
 103         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&curl_response_mem);
 104
 105         res = curl_easy_perform(curl);
 106
 107         if (res != CURLE_OK)
 108         {
 109                 return NULL;
 110         }
 111         else
 112         {
 113                 cJSON *json_response = cJSON_Parse(curl_response_mem.memory);
 114
 115                 printf("%lu bytes retrieved\n", (unsigned long)curl_response_mem.size);
 116
 117                 if (json_response == NULL)
 118                 {
 119                         printf("Could not parse JSON response for url=\"%s\"\n", url);
 120                         return NULL;
 121                 }
 122
 123                 cJSON *hostConfig = cJSON_GetObjectItemCaseSensitive(json_response, "HostConfig");
 124
 125                 if (hostConfig == NULL)
 126                 {
 127                         printf("Could not get HostConfig object\n");
 128                         return NULL;
 129                 }
 130
 131                 cJSON *binds = cJSON_GetObjectItemCaseSensitive(hostConfig, "Binds");
 132
 133                 if (binds == NULL)
 134                 {
 135                         printf("Could not get Binds object\n");
 136                         return NULL;
 137                 }
 138
 139                 cJSON *bindsCopy = cJSON_Duplicate(binds, 1);
 140
 141             cJSON_Delete(json_response);
 142
 143                 return bindsCopy;
 144         }
 145
 146         return NULL;
 147 }
 148
 149 static char* create_docker_container_curl(int base_netconf_port, cJSON* managerBinds)
 150 {
 151         if (managerBinds == NULL)
 152         {
 153                 printf("Could not retrieve JSON object: Binds\n");
 154                 return NULL;
 155         }
 156         cJSON *binds = cJSON_Duplicate(managerBinds, 1);
 157
 158         struct MemoryStruct curl_response_mem;
 159
 160         curl_response_mem.memory = malloc(1);  /* will be grown as needed by the realloc above */
 161         curl_response_mem.size = 0;    /* no data at this point */
 162
 163         CURLcode res;
 164
 165         curl_easy_reset(curl);
 166         set_curl_common_info();
 167
 168         char url[100];
 169         sprintf(url, "http:/v%s/containers/create", getenv("DOCKER_ENGINE_VERSION"));
 170
 171         // the docker image name to be used is defined in the Dockerfile of the NTS Manager,
 172         // under the MODELS_IMAGE env variable
 173         char models_var[50];
 174         sprintf(models_var, "%s", getenv("MODELS_IMAGE"));
 175
 176         curl_easy_setopt(curl, CURLOPT_URL, url);
 177
 178     cJSON *postDataJson = cJSON_CreateObject();
 179
 180     if (cJSON_AddStringToObject(postDataJson, "Image", models_var) == NULL)
 181         {
 182         printf("Could not create JSON object: Image\n");
 183                 return NULL;
 184         }
 185
 186     cJSON *hostConfig = cJSON_CreateObject();
 187     if (hostConfig == NULL)
 188         {
 189         printf("Could not create JSON object: HostConfig\n");
 190                 return NULL;
 191         }
 192
 193     cJSON_AddItemToObject(postDataJson, "HostConfig", hostConfig);
 194
 195     cJSON *portBindings = cJSON_CreateObject();
 196     if (portBindings == NULL)
 197         {
 198         printf("Could not create JSON object: PortBindings\n");
 199                 return NULL;
 200         }
 201
 202     cJSON_AddItemToObject(hostConfig, "PortBindings", portBindings);
 203
 204     for (int i = 0; i < NETCONF_CONNECTIONS_PER_DEVICE; ++i)
 205     {
 206         cJSON *port = cJSON_CreateArray();
 207                 if (port == NULL)
 208                 {
 209                 printf("Could not create JSON object: port\n");
 210                         return NULL;
 211                 }
 212
 213                 char dockerContainerPort[20];
 214                 sprintf(dockerContainerPort, "%d/tcp", 830 + i);
 215
 216             cJSON_AddItemToObject(portBindings, dockerContainerPort, port);
 217
 218             cJSON *hostPort = cJSON_CreateObject();
 219             if (hostPort == NULL)
 220                 {
 221                 printf("Could not create JSON object: HostPort\n");
 222                         return NULL;
 223                 }
 224
 225             char dockerHostPort[10];
 226             sprintf(dockerHostPort, "%d", base_netconf_port + i);
 227             if (cJSON_AddStringToObject(hostPort, "HostPort", dockerHostPort) == NULL)
 228             {
 229                 printf("Could not create JSON object: HostPortString\n");
 230                 return NULL;
 231             }
 232             if (cJSON_AddStringToObject(hostPort, "HostIp", getenv("NTS_IP")) == NULL)
 233             {
 234                 printf("Could not create JSON object: HostIpString\n");
 235                 return NULL;
 236             }
 237
 238             cJSON_AddItemToArray(port, hostPort);
 239     }
 240
 241     cJSON *labels = cJSON_CreateObject();
 242     if (labels == NULL)
 243         {
 244         printf("Could not create JSON object: Labels\n");
 245                 return NULL;
 246         }
 247
 248     cJSON_AddItemToObject(postDataJson, "Labels", labels);
 249
 250     if (cJSON_AddStringToObject(labels, "NTS", "") == NULL)
 251     {
 252         printf("Could not create JSON object: NTS\n");
 253         return NULL;
 254     }
 255
 256         if (cJSON_AddStringToObject(labels, "NTS_Manager", getenv("HOSTNAME")) == NULL)
 257     {
 258         printf("Could not create JSON object: NTS Manager\n");
 259         return NULL;
 260     }
 261
 262     cJSON *env_variables_array = cJSON_CreateArray();
 263     if (env_variables_array == NULL)
 264         {
 265         printf("Could not create JSON object: Env array\n");
 266                 return NULL;
 267         }
 268
 269     cJSON_AddItemToObject(postDataJson, "Env", env_variables_array);
 270
 271     char environment_var[50];
 272     sprintf(environment_var, "NTS_IP=%s", getenv("NTS_IP"));
 273
 274     cJSON *env_var_obj = cJSON_CreateString(environment_var);
 275     if (env_var_obj == NULL)
 276         {
 277         printf("Could not create JSON object: Env array object NTS_IP\n");
 278                 return NULL;
 279         }
 280     cJSON_AddItemToArray(env_variables_array, env_var_obj);
 281
 282     sprintf(environment_var, "NETCONF_BASE=%d", base_netconf_port);
 283     cJSON *env_var_obj_2 = cJSON_CreateString(environment_var);
 284     if (env_var_obj_2 == NULL)
 285         {
 286         printf("Could not create JSON object: Env array object NETCONF_BASE\n");
 287                 return NULL;
 288         }
 289     cJSON_AddItemToArray(env_variables_array, env_var_obj_2);
 290
 291         char scripts_dir[200];
 292         sprintf(scripts_dir, "SCRIPTS_DIR=%s", getenv("SCRIPTS_DIR"));
 293         cJSON *env_var_obj_3 = cJSON_CreateString(scripts_dir);
 294         if (env_var_obj_3 == NULL)
 295         {
 296                 printf("Could not create JSON object: Env array object SCRIPTS_DIR\n");
 297                 return NULL;
 298         }
 299         cJSON_AddItemToArray(env_variables_array, env_var_obj_3);
 300
 301     cJSON_AddItemToObject(hostConfig, "Binds", binds);
 302
 303     char *post_data_string = NULL;
 304
 305     post_data_string = cJSON_PrintUnformatted(postDataJson);
 306
 307     printf("Post data JSON:\n%s\n", post_data_string);
 308
 309     if (postDataJson != NULL)
 310     {
 311         cJSON_Delete(postDataJson);
 312     }
 313
 314     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post_data_string);
 315
 316         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&curl_response_mem);
 317
 318         res = curl_easy_perform(curl);
 319
 320         if (res != CURLE_OK)
 321         {
 322                 return NULL;
 323         }
 324         else
 325         {
 326                 cJSON *json_response = cJSON_Parse(curl_response_mem.memory);
 327                 const cJSON *container_id = NULL;
 328
 329                 printf("%lu bytes retrieved\n", (unsigned long)curl_response_mem.size);
 330
 331                 container_id = cJSON_GetObjectItemCaseSensitive(json_response, "Id");
 332
 333                 if (cJSON_IsString(container_id) && (container_id->valuestring != NULL))
 334                 {
 335                         printf("Container id: \"%s\"\n", container_id->valuestring);
 336
 337                         char container_id_short[13];
 338
 339                         memset(container_id_short, '\0', sizeof(container_id_short));
 340                         strncpy(container_id_short, container_id->valuestring, 12);
 341
 342                         printf("Container id short: \"%s\"\n", container_id_short);
 343
 344                     cJSON_Delete(json_response);
 345                         return strdup(container_id_short);
 346                 }
 347
 348             cJSON_Delete(json_response);
 349         }
 350
 351         return NULL;
 352 }
 353
 354 static int start_docker_container_curl(char *container_id)
 355 {
 356         struct MemoryStruct curl_response_mem;
 357
 358         curl_response_mem.memory = malloc(1);  /* will be grown as needed by the realloc above */
 359         curl_response_mem.size = 0;    /* no data at this point */
 360
 361         CURLcode res;
 362
 363         curl_easy_reset(curl);
 364         set_curl_common_info();
 365
 366         char url[100];
 367         sprintf(url, "http:/v%s/containers/%s/start", getenv("DOCKER_ENGINE_VERSION"), container_id);
 368
 369         curl_easy_setopt(curl, CURLOPT_URL, url);
 370
 371     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "");
 372
 373         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&curl_response_mem);
 374
 375         res = curl_easy_perform(curl);
 376
 377         if (res != CURLE_OK)
 378         {
 379                 return SR_ERR_OPERATION_FAILED;
 380         }
 381         else
 382         {
 383                 printf("Container %s started successfully!\n", container_id);
 384         }
 385
 386         return SR_ERR_OK;
 387 }
 388
 389 static int kill_and_remove_docker_container_curl(char *container_id)
 390 {
 391         struct MemoryStruct curl_response_mem;
 392
 393         curl_response_mem.memory = malloc(1);  /* will be grown as needed by the realloc above */
 394         curl_response_mem.size = 0;    /* no data at this point */
 395
 396         CURLcode res;
 397
 398         curl_easy_reset(curl);
 399         set_curl_common_info();
 400
 401         char url[100];
 402         sprintf(url, "http:/v%s/containers/%s?force=true", getenv("DOCKER_ENGINE_VERSION"), container_id);
 403
 404         curl_easy_setopt(curl, CURLOPT_URL, url);
 405
 406     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "");
 407     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
 408
 409         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&curl_response_mem);
 410
 411         res = curl_easy_perform(curl);
 412
 413         if (res != CURLE_OK)
 414         {
 415                 return SR_ERR_OPERATION_FAILED;
 416         }
 417         else
 418         {
 419                 printf("Container %s removed successfully!\n", container_id);
 420         }
 421
 422         return SR_ERR_OK;
 423 }
 424
 425 static int send_mount_device_instance_ssh(char *url, char *credentials, char *device_name, int device_port)
 426 {
 427         CURLcode res;
 428
 429         curl_easy_reset(curl_odl);
 430         set_curl_common_info_odl();
 431
 432         char url_for_curl[200];
 433         sprintf(url_for_curl, "%s%s_%d", url, device_name, device_port);
 434
 435         curl_easy_setopt(curl_odl, CURLOPT_URL, url_for_curl);
 436
 437         char post_data_xml[1500];
 438
 439         sprintf(post_data_xml,
 440                         "<node xmlns=\"urn:TBD:params:xml:ns:yang:network-topology\">"
 441                         "<node-id>%s_%d</node-id>"
 442                         "<host xmlns=\"urn:opendaylight:netconf-node-topology\">%s</host>"
 443                         "<port xmlns=\"urn:opendaylight:netconf-node-topology\">%d</port>"
 444                         "<username xmlns=\"urn:opendaylight:netconf-node-topology\">%s</username>"
 445                         "<password xmlns=\"urn:opendaylight:netconf-node-topology\">%s</password>"
 446                         "<tcp-only xmlns=\"urn:opendaylight:netconf-node-topology\">false</tcp-only>"
 447                         "<keepalive-delay xmlns=\"urn:opendaylight:netconf-node-topology\">120</keepalive-delay>"
 448                         "<reconnect-on-changed-schema xmlns=\"urn:opendaylight:netconf-node-topology\">false</reconnect-on-changed-schema>"
 449                         "<sleep-factor xmlns=\"urn:opendaylight:netconf-node-topology\">1.5</sleep-factor>"
 450                         "<connection-timeout-millis xmlns=\"urn:opendaylight:netconf-node-topology\">20000</connection-timeout-millis>"
 451                         "<max-connection-attempts xmlns=\"urn:opendaylight:netconf-node-topology\">100</max-connection-attempts>"
 452                         "<between-attempts-timeout-millis xmlns=\"urn:opendaylight:netconf-node-topology\">2000</between-attempts-timeout-millis>"
 453                         "</node>",
 454                         device_name, device_port, getenv("NTS_IP"), device_port, "netconf", "netconf");
 455
 456         printf("Post data:\n%s\n", post_data_xml);
 457
 458         curl_easy_setopt(curl_odl, CURLOPT_POSTFIELDS, post_data_xml);
 459     curl_easy_setopt(curl_odl, CURLOPT_CUSTOMREQUEST, "PUT");
 460     curl_easy_setopt(curl_odl, CURLOPT_USERPWD, credentials);
 461
 462         res = curl_easy_perform(curl_odl);
 463         if (res != CURLE_OK)
 464         {
 465                 printf("cURL failed to url=%s\n", url_for_curl);
 466         }
 467
 468         long http_response_code = 0;
 469         curl_easy_getinfo (curl_odl, CURLINFO_RESPONSE_CODE, &http_response_code);
 470         if (http_response_code >= 200 && http_response_code <= 226 && http_response_code != CURLE_ABORTED_BY_CALLBACK)
 471         {
 472                 printf("cURL succeeded to url=%s\n", url_for_curl);
 473         }
 474         else
 475         {
 476             printf("cURL to url=%s failed with code=%ld\n", url_for_curl, http_response_code);
 477                 return SR_ERR_OPERATION_FAILED;
 478         }
 479
 480         return SR_ERR_OK;
 481 }
 482
 483 static int send_mount_device_instance_tls(char *url, char *credentials, char *device_name, int device_port)
 484 {
 485         CURLcode res;
 486
 487         curl_easy_reset(curl_odl);
 488         set_curl_common_info_odl();
 489
 490         char url_for_curl[200];
 491         sprintf(url_for_curl, "%s%s_%d", url, device_name, device_port);
 492
 493         curl_easy_setopt(curl_odl, CURLOPT_URL, url_for_curl);
 494
 495         char post_data_xml[1500];
 496
 497         sprintf(post_data_xml,
 498                         "<node xmlns=\"urn:TBD:params:xml:ns:yang:network-topology\">"
 499                         "<protocol xmlns=\"urn:opendaylight:netconf-node-topology\">"
 500                         "<name>TLS</name>"
 501                         "</protocol>"
 502                         "<node-id>%s_%d</node-id>"
 503                         "<host xmlns=\"urn:opendaylight:netconf-node-topology\">%s</host>"
 504                         "<key-based xmlns=\"urn:opendaylight:netconf-node-topology\">"
 505                         "<username>%s</username>"
 506                         "<key-id>device-key</key-id>"
 507                         "</key-based>"
 508                         "<port xmlns=\"urn:opendaylight:netconf-node-topology\">%d</port>"
 509                         "<tcp-only xmlns=\"urn:opendaylight:netconf-node-topology\">false</tcp-only>"
 510                         "<keepalive-delay xmlns=\"urn:opendaylight:netconf-node-topology\">120</keepalive-delay>"
 511                         "<reconnect-on-changed-schema xmlns=\"urn:opendaylight:netconf-node-topology\">false</reconnect-on-changed-schema>"
 512                         "<sleep-factor xmlns=\"urn:opendaylight:netconf-node-topology\">1.5</sleep-factor>"
 513                         "<connection-timeout-millis xmlns=\"urn:opendaylight:netconf-node-topology\">20000</connection-timeout-millis>"
 514                         "<max-connection-attempts xmlns=\"urn:opendaylight:netconf-node-topology\">100</max-connection-attempts>"
 515                         "<between-attempts-timeout-millis xmlns=\"urn:opendaylight:netconf-node-topology\">2000</between-attempts-timeout-millis>"
 516                         "</node>",
 517                         device_name, device_port, getenv("NTS_IP"), "netconf", device_port);
 518
 519         printf("Post data:\n%s\n", post_data_xml);
 520
 521         curl_easy_setopt(curl_odl, CURLOPT_POSTFIELDS, post_data_xml);
 522     curl_easy_setopt(curl_odl, CURLOPT_CUSTOMREQUEST, "PUT");
 523     curl_easy_setopt(curl_odl, CURLOPT_USERPWD, credentials);
 524
 525         res = curl_easy_perform(curl_odl);
 526         if (res != CURLE_OK)
 527         {
 528                 printf("cURL failed to url=%s\n", url_for_curl);
 529         }
 530
 531         long http_response_code = 0;
 532         curl_easy_getinfo (curl_odl, CURLINFO_RESPONSE_CODE, &http_response_code);
 533         if (http_response_code >= 200 && http_response_code <= 226 && http_response_code != CURLE_ABORTED_BY_CALLBACK)
 534         {
 535                 printf("cURL succeeded to url=%s\n", url_for_curl);
 536         }
 537         else
 538         {
 539             printf("cURL to url=%s failed with code=%ld\n", url_for_curl, http_response_code);
 540                 return SR_ERR_OPERATION_FAILED;
 541         }
 542
 543         return SR_ERR_OK;
 544 }
 545
 546 static int send_unmount_device_instance(char *url, char *credentials, char *device_name, int device_port)
 547 {
 548         CURLcode res;
 549
 550         curl_easy_reset(curl_odl);
 551         set_curl_common_info_odl();
 552
 553         char url_for_curl[200];
 554         sprintf(url_for_curl, "%s%s_%d", url, device_name, device_port);
 555
 556         curl_easy_setopt(curl_odl, CURLOPT_URL, url_for_curl);
 557
 558         curl_easy_setopt(curl_odl, CURLOPT_POSTFIELDS, "");
 559         curl_easy_setopt(curl_odl, CURLOPT_CUSTOMREQUEST, "DELETE");
 560         curl_easy_setopt(curl_odl, CURLOPT_USERPWD, credentials);
 561
 562         res = curl_easy_perform(curl_odl);
 563         if (res != CURLE_OK)
 564         {
 565                 printf("cURL failed to url=%s\n", url_for_curl);
 566         }
 567
 568         long http_response_code = 0;
 569         curl_easy_getinfo (curl_odl, CURLINFO_RESPONSE_CODE, &http_response_code);
 570         if (http_response_code == 200 && http_response_code != CURLE_ABORTED_BY_CALLBACK)
 571         {
 572                 printf("cURL succeeded to url=%s\n", url_for_curl);
 573         }
 574         else
 575         {
 576                 printf("cURL to url=%s failed with code=%ld\n", url_for_curl, http_response_code);
 577                 return SR_ERR_OPERATION_FAILED;
 578         }
 579
 580
 581         return SR_ERR_OK;
 582 }
 583
 584
 585 static int send_mount_device(device_t *current_device, controller_t controller_details)
 586 {
 587         int rc = SR_ERR_OK;
 588         bool is_mounted = true;
 589
 590         //This is where we hardcoded: 7 devices will have SSH connections and 3 devices will have TLS connections
 591         for (int port = 0; port < NETCONF_CONNECTIONS_PER_DEVICE - 3; ++port)
 592         {
 593                 rc = send_mount_device_instance_ssh(controller_details.url, controller_details.credentials,
 594                                 current_device->device_id, current_device->netconf_port + port);
 595                 if (rc != SR_ERR_OK)
 596                 {
 597                         is_mounted = false;
 598                 }
 599         }
 600         for (int port = NETCONF_CONNECTIONS_PER_DEVICE - 3; port < NETCONF_CONNECTIONS_PER_DEVICE; ++port)
 601         {
 602                 rc = send_mount_device_instance_tls(controller_details.url, controller_details.credentials,
 603                                 current_device->device_id, current_device->netconf_port + port);
 604                 if (rc != SR_ERR_OK)
 605                 {
 606                         is_mounted = false;
 607                 }
 608         }
 609
 610         current_device->is_mounted = is_mounted;
 611
 612         return SR_ERR_OK;
 613 }
 614
 615 static int send_unmount_device(device_t *current_device, controller_t controller_details)
 616 {
 617         int rc = SR_ERR_OK;
 618
 619         for (int port = 0; port < NETCONF_CONNECTIONS_PER_DEVICE; ++port)
 620         {
 621                 rc = send_unmount_device_instance(controller_details.url, controller_details.credentials,
 622                                 current_device->device_id, current_device->netconf_port + port);
 623                 if (rc != SR_ERR_OK)
 624                 {
 625                         printf("Could not send unmount for ODL with url=\"%s\", for device=\"%s\" and port=%d\n",
 626                                         controller_details.url, current_device->device_id, current_device->netconf_port);
 627                 }
 628         }
 629         current_device->is_mounted = false;
 630
 631         return SR_ERR_OK;
 632 }
 633
 634 device_stack_t *new_device_stack(void)
 635 {
 636         device_stack_t *stack = malloc(sizeof(*stack));
 637
 638         if (stack) {
 639                 stack->head = NULL;
 640                 stack->stack_size = 0;
 641         }
 642         return stack;
 643 }
 644
 645 void push_device(device_stack_t *theStack, char *dev_id, int port)
 646 {
 647         device_t *new_dev = malloc(sizeof(*new_dev));
 648
 649         if (new_dev) {
 650                 new_dev->device_id = strdup(dev_id);
 651                 new_dev->netconf_port = port;
 652                 new_dev->is_mounted = false;
 653                 new_dev->operational_state = strdup("not-specified");
 654
 655                 new_dev->next = theStack->head;
 656
 657                 theStack->head = new_dev;
 658                 theStack->stack_size++;
 659         }
 660 }
 661
 662 void pop_device(device_stack_t *theStack)
 663 {
 664         if (theStack && theStack->head) {
 665                 device_t *temp = theStack->head;
 666                 theStack->head = theStack->head->next;
 667
 668                 free(temp->device_id);
 669                 free(temp->operational_state);
 670                 free(temp);
 671                 theStack->stack_size--;
 672         }
 673 }
 674
 675 int get_netconf_port_next(device_stack_t *theStack)
 676 {
 677         if (theStack && theStack->stack_size > 0) {
 678                 return theStack->head->netconf_port + NETCONF_CONNECTIONS_PER_DEVICE;
 679         }
 680
 681         return get_netconf_port_base();
 682 }
 683
 684 int get_netconf_port_base()
 685 {
 686         int netconf_port_base = 0, rc;
 687
 688         char *netconf_base_string = getenv("NETCONF_BASE");
 689
 690         if (netconf_base_string != NULL)
 691         {
 692                 rc = sscanf(netconf_base_string, "%d", &netconf_port_base);
 693                 if (rc != 1)
 694                 {
 695                         printf("Could not get the NETCONF_BASE port! Using the default 30.000...\n");
 696                         netconf_port_base = 30000;
 697                 }
 698         }
 699
 700         return netconf_port_base;
 701 }
 702
 703
 704 char *get_id_last_device(device_stack_t *theStack)
 705 {
 706         if (theStack && theStack->head) {
 707                 return theStack->head->device_id;
 708         }
 709         return NULL;
 710 }
 711
 712 int get_current_number_of_mounted_devices(device_stack_t *theStack)
 713 {
 714         int mounted_devices = 0;
 715
 716         if (theStack && theStack->head)
 717         {
 718                 device_t *current_device = theStack->head;
 719
 720                 while (current_device != NULL)
 721                 {
 722                         if (current_device->is_mounted)
 723                         {
 724                                 mounted_devices++;
 725                         }
 726                         current_device = current_device->next;
 727                 }
 728         }
 729
 730         return mounted_devices;
 731 }
 732
 733 int get_current_number_of_devices(device_stack_t *theStack)
 734 {
 735         struct MemoryStruct curl_response_mem;
 736
 737         curl_response_mem.memory = malloc(1);  /* will be grown as needed by the realloc above */
 738         curl_response_mem.size = 0;    /* no data at this point */
 739
 740         CURLcode res;
 741
 742         curl_easy_reset(curl);
 743         set_curl_common_info();
 744
 745         char url[100];
 746         sprintf(url, "http:/v%s/containers/json?all=true&filters={\"label\":[\"NTS\"],\"status\":[\"running\"]}",
 747                         getenv("DOCKER_ENGINE_VERSION"));
 748
 749         curl_easy_setopt(curl, CURLOPT_URL, url);
 750
 751         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "");
 752         curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
 753
 754         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&curl_response_mem);
 755
 756         res = curl_easy_perform(curl);
 757
 758         if (res != CURLE_OK)
 759         {
 760                 return SR_ERR_OPERATION_FAILED;
 761         }
 762         else
 763         {
 764                 cJSON *json_response = cJSON_Parse(curl_response_mem.memory);
 765
 766                 printf("%lu bytes retrieved\n", (unsigned long)curl_response_mem.size);
 767
 768                 if (json_response == NULL || !cJSON_IsArray(json_response))
 769                 {
 770                         printf("Could not parse JSON response for url=\"%s\"\n", url);
 771                         return SR_ERR_OPERATION_FAILED;
 772                 }
 773
 774                 int num_of_devices = cJSON_GetArraySize(json_response);
 775                 cJSON_Delete(json_response);
 776
 777                 return num_of_devices;
 778         }
 779
 780         return 0;
 781 }
 782
 783 static int set_operational_state_of_device(device_stack_t *theStack, char *device_id, char *operational_state)
 784 {
 785         if (theStack && theStack->head)
 786         {
 787                 device_t *current_device = theStack->head;
 788
 789                 while (current_device != NULL)
 790                 {
 791                         if (strcmp(current_device->device_id, device_id) == 0)
 792                         {
 793                                 free(current_device->operational_state);
 794                                 current_device->operational_state = strdup(operational_state);
 795
 796                                 return SR_ERR_OK;
 797                         }
 798
 799                         current_device = current_device->next;
 800                 }
 801         }
 802
 803         printf("Could not find device with uuid=\"%s\"\n", device_id);
 804         return SR_ERR_OPERATION_FAILED;
 805 }
 806
 807 char* get_docker_container_operational_state(device_stack_t *theStack, char *container_id)
 808 {
 809         if (theStack && theStack->head)
 810         {
 811                 device_t *current_device = theStack->head;
 812
 813                 while (current_device != NULL)
 814                 {
 815                         if (strcmp(current_device->device_id, container_id) == 0)
 816                         {
 817                                 return current_device->operational_state;
 818                         }
 819
 820                         current_device = current_device->next;
 821                 }
 822         }
 823
 824         return NULL;
 825 }
 826
 827 int start_device(device_stack_t *theStack)
 828 {
 829         int rc = SR_ERR_OK;
 830         static cJSON* managerBindings = NULL;
 831
 832         if (managerBindings == NULL)
 833         {
 834                 managerBindings = get_docker_container_bindings();
 835         }
 836
 837         int netconf_base = get_netconf_port_next(theStack);
 838
 839         char *dev_id = create_docker_container_curl(netconf_base, managerBindings);
 840
 841         push_device(theStack, dev_id, netconf_base);
 842
 843         rc = start_docker_container_curl(dev_id);
 844         if (rc != SR_ERR_OK)
 845         {
 846                 printf("Could not start device with device_id=\"%s\"\n", dev_id);
 847         }
 848
 849         if (dev_id) {
 850                 free(dev_id);
 851         }
 852
 853         return SR_ERR_OK;
 854 }
 855
 856 int _init_curl()
 857 {
 858         curl = curl_easy_init();
 859
 860         if (curl == NULL) {
 861                 printf("cURL initialization error! Aborting call!\n");
 862                 return SR_ERR_OPERATION_FAILED;
 863         }
 864
 865         return SR_ERR_OK;
 866 }
 867
 868 int cleanup_curl()
 869 {
 870         if (curl != NULL)
 871         {
 872                 curl_easy_cleanup(curl);
 873         }
 874
 875         return SR_ERR_OK;
 876 }
 877
 878 int _init_curl_odl()
 879 {
 880         curl_odl = curl_easy_init();
 881
 882         if (curl_odl == NULL) {
 883                 printf("cURL initialization error! Aborting call!\n");
 884                 return SR_ERR_OPERATION_FAILED;
 885         }
 886
 887         return SR_ERR_OK;
 888 }
 889
 890 int cleanup_curl_odl()
 891 {
 892         if (curl_odl != NULL)
 893         {
 894                 curl_easy_cleanup(curl_odl);
 895         }
 896
 897         return SR_ERR_OK;
 898 }
 899
 900 int stop_device(device_stack_t *theStack)
 901 {
 902         int rc = SR_ERR_OK;
 903         char *last_id = get_id_last_device(theStack);
 904
 905         rc = kill_and_remove_docker_container_curl(last_id);
 906         if (rc != SR_ERR_OK)
 907         {
 908                 printf("Could not kill and remove docker container with uuid=\"%s\"\n", last_id);
 909         }
 910
 911         pop_device(theStack);
 912
 913         return SR_ERR_OK;
 914 }
 915
 916 int mount_device(device_stack_t *theStack, controller_t controller_details)
 917 {
 918         int rc;
 919
 920         if (theStack && theStack->head)
 921         {
 922                 device_t *current_device = theStack->head;
 923                 while (current_device != NULL && current_device->is_mounted == true)
 924                 {
 925                         printf("Device \"%s\" is already mounted, skipping...\n", current_device->device_id);
 926                         current_device = current_device->next;
 927                 }
 928
 929                 if (current_device != NULL)
 930                 {
 931                         printf("Sending mount device for device \"%s\"...\n", current_device->device_id);
 932                         rc = send_mount_device(current_device, controller_details);
 933                         if (rc != SR_ERR_OK)
 934                         {
 935                                 return SR_ERR_OPERATION_FAILED;
 936                         }
 937                 }
 938         }
 939
 940         return SR_ERR_OK;
 941 }
 942
 943 int unmount_device(device_stack_t *theStack, controller_t controller_list)
 944 {
 945         int rc;
 946
 947         if (theStack && theStack->head)
 948         {
 949                 device_t *current_device = theStack->head;
 950                 while (current_device != NULL && current_device->is_mounted == false)
 951                 {
 952                         printf("Device \"%s\" is already unmounted, skipping...\n", current_device->device_id);
 953                         current_device = current_device->next;
 954                 }
 955
 956                 if (current_device != NULL)
 957                 {
 958                         printf("Sending unmount device for device \"%s\"...\n", current_device->device_id);
 959                         rc = send_unmount_device(current_device, controller_list);
 960                         if (rc != SR_ERR_OK)
 961                         {
 962                                 return SR_ERR_OPERATION_FAILED;
 963                         }
 964                 }
 965         }
 966
 967         return SR_ERR_OK;
 968 }
 969
 970 int get_docker_containers_operational_state_curl(device_stack_t *theStack)
 971 {
 972         int rc = SR_ERR_OK;
 973         struct MemoryStruct curl_response_mem;
 974
 975         curl_response_mem.memory = malloc(1);  /* will be grown as needed by the realloc above */
 976         curl_response_mem.size = 0;    /* no data at this point */
 977
 978         CURLcode res;
 979
 980         curl_easy_reset(curl);
 981         set_curl_common_info();
 982
 983         char url[100];
 984         sprintf(url, "http:/v%s/containers/json?all=true&filters={\"label\":[\"NTS\"]}", getenv("DOCKER_ENGINE_VERSION"));
 985
 986         curl_easy_setopt(curl, CURLOPT_URL, url);
 987
 988     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "");
 989     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
 990
 991         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&curl_response_mem);
 992
 993         res = curl_easy_perform(curl);
 994
 995         if (res != CURLE_OK)
 996         {
 997                 return SR_ERR_OPERATION_FAILED;
 998         }
 999         else
1000         {
1001                 cJSON *json_response = cJSON_Parse(curl_response_mem.memory);
1002                 const cJSON *container = NULL;
1003
1004                 printf("%lu bytes retrieved\n", (unsigned long)curl_response_mem.size);
1005
1006                 if (json_response == NULL || !cJSON_IsArray(json_response))
1007                 {
1008                         printf("Could not parse JSON response for url=\"%s\"\n", url);
1009                         return SR_ERR_OPERATION_FAILED;
1010                 }
1011
1012             cJSON_ArrayForEach(container, json_response)
1013             {
1014                 cJSON *container_id_long = cJSON_GetObjectItemCaseSensitive(container, "Id");
1015                 cJSON *state = cJSON_GetObjectItemCaseSensitive(container, "State");
1016
1017                         if (cJSON_IsString(container_id_long) && (container_id_long->valuestring != NULL))
1018                         {
1019                                 char container_id_short[13];
1020
1021                                 memset(container_id_short, '\0', sizeof(container_id_short));
1022                                 strncpy(container_id_short, container_id_long->valuestring, 12);
1023
1024                                 if (cJSON_IsString(state) && (state->valuestring != NULL))
1025                                 {
1026                                         rc = set_operational_state_of_device(theStack, container_id_short, state->valuestring);
1027                                         if (rc != SR_ERR_OK)
1028                                         {
1029                                                 printf("Could not set the operational state for the device with uuid=\"%s\"\n", container_id_short);
1030                                                 return SR_ERR_OPERATION_FAILED;
1031                                         }
1032                                 }
1033                         }
1034             }
1035
1036             cJSON_Delete(json_response);
1037         }
1038
1039         return SR_ERR_OK;
1040 }
1041
1042 char* get_docker_container_resource_stats(device_stack_t *theStack)
1043 {
1044         char line[LINE_BUFSIZE];
1045         int linenr;
1046         FILE *pipe;
1047
1048         /* Get a pipe where the output from the scripts comes in */
1049         char script[200];
1050         sprintf(script, "%s/docker_stats.sh", getenv("SCRIPTS_DIR"));
1051
1052         pipe = popen(script, "r");
1053         if (pipe == NULL) {  /* check for errors */
1054                 printf("Could not open script.\n");
1055                 return NULL;        /* return with exit code indicating error */
1056         }
1057
1058         /* Read script output from the pipe line by line */
1059         linenr = 1;
1060         while (fgets(line, LINE_BUFSIZE, pipe) != NULL) {
1061                 printf("Script output line %d: %s", linenr, line);
1062                 ++linenr;
1063
1064                 pclose(pipe); /* Close the pipe */
1065                 return strdup(line);
1066         }
1067
1068         /* Once here, out of the loop, the script has ended. */
1069         pclose(pipe); /* Close the pipe */
1070         return NULL;     /* return with exit code indicating success. */
1071 }
1072
1073 int notification_delay_period_changed(int period)
1074 {
1075         char *stringConfiguration = readConfigFileInString();
1076
1077         if (stringConfiguration == NULL)
1078         {
1079                 printf("Could not read configuration file!\n");
1080                 return SR_ERR_OPERATION_FAILED;
1081         }
1082
1083         cJSON *jsonConfig = cJSON_Parse(stringConfiguration);
1084         if (jsonConfig == NULL)
1085         {
1086                 free(stringConfiguration);
1087                 const char *error_ptr = cJSON_GetErrorPtr();
1088                 if (error_ptr != NULL)
1089                 {
1090                         fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr);
1091                 }
1092                 return SR_ERR_OPERATION_FAILED;
1093         }
1094         //we don't need the string anymore
1095         free(stringConfiguration);
1096         stringConfiguration = NULL;
1097
1098         cJSON *notifConfig = cJSON_GetObjectItemCaseSensitive(jsonConfig, "notification-config");
1099         if (!cJSON_IsObject(notifConfig))
1100         {
1101                 printf("Configuration JSON is not as expected: notification-config is not an object");
1102                 cJSON_Delete(jsonConfig);
1103                 return SR_ERR_OPERATION_FAILED;
1104         }
1105
1106         cJSON *faultNotifDelay = cJSON_GetObjectItemCaseSensitive(notifConfig, "fault-notification-delay-period");
1107         if (!cJSON_IsNumber(faultNotifDelay))
1108         {
1109                 printf("Configuration JSON is not as expected: fault-notification-delay-period is not an object");
1110                 cJSON_Delete(jsonConfig);
1111                 return SR_ERR_OPERATION_FAILED;
1112         }
1113
1114         //we set the value of the fault-notification-delay-period object
1115         cJSON_SetNumberValue(faultNotifDelay, period);
1116
1117         //writing the new JSON to the configuration file
1118         stringConfiguration = cJSON_Print(jsonConfig);
1119         writeConfigFile(stringConfiguration);
1120
1121         cJSON_Delete(jsonConfig);
1122
1123         return SR_ERR_OK;
1124 }
1125
1126 int ves_heartbeat_period_changed(int period)
1127 {
1128         char *stringConfiguration = readConfigFileInString();
1129
1130         if (stringConfiguration == NULL)
1131         {
1132                 printf("Could not read configuration file!\n");
1133                 return SR_ERR_OPERATION_FAILED;
1134         }
1135
1136         cJSON *jsonConfig = cJSON_Parse(stringConfiguration);
1137         if (jsonConfig == NULL)
1138         {
1139                 free(stringConfiguration);
1140                 const char *error_ptr = cJSON_GetErrorPtr();
1141                 if (error_ptr != NULL)
1142                 {
1143                         fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr);
1144                 }
1145                 return SR_ERR_OPERATION_FAILED;
1146         }
1147         //we don't need the string anymore
1148         free(stringConfiguration);
1149         stringConfiguration = NULL;
1150
1151         cJSON *notifConfig = cJSON_GetObjectItemCaseSensitive(jsonConfig, "notification-config");
1152         if (!cJSON_IsObject(notifConfig))
1153         {
1154                 printf("Configuration JSON is not as expected: notification-config is not an object");
1155                 cJSON_Delete(jsonConfig);
1156                 return SR_ERR_OPERATION_FAILED;
1157         }
1158
1159         cJSON *vesHeartbeatPeriod = cJSON_GetObjectItemCaseSensitive(notifConfig, "ves-heartbeat-period");
1160         if (!cJSON_IsNumber(vesHeartbeatPeriod))
1161         {
1162                 printf("Configuration JSON is not as expected: ves-heartbeat-period is not an object");
1163                 cJSON_Delete(jsonConfig);
1164                 return SR_ERR_OPERATION_FAILED;
1165         }
1166
1167         //we set the value of the fault-notification-delay-period object
1168         cJSON_SetNumberValue(vesHeartbeatPeriod, period);
1169
1170         //writing the new JSON to the configuration file
1171         stringConfiguration = cJSON_Print(jsonConfig);
1172         writeConfigFile(stringConfiguration);
1173
1174         cJSON_Delete(jsonConfig);
1175
1176         return SR_ERR_OK;
1177 }
1178
1179 static int add_keystore_entry_odl(char *url, char *credentials)
1180 {
1181         CURLcode res;
1182
1183         curl_easy_reset(curl_odl);
1184         set_curl_common_info_odl();
1185
1186         char url_for_curl[200];
1187         sprintf(url_for_curl, "%s", url);
1188
1189         curl_easy_setopt(curl_odl, CURLOPT_URL, url_for_curl);
1190
1191         char post_data_xml[2000];
1192
1193         sprintf(post_data_xml,
1194                         "<input xmlns=\"urn:opendaylight:netconf:keystore\">"
1195                         "<key-credential>"
1196                         "<key-id>device-key</key-id>"
1197                         "<private-key>MIIEpAIBAAKCAQEAueCQaNQWoNmFK6LKu1p8U8ZWdWg/PvDdLsJyzfzl/Qw4UA68"
1198                         "SfFNaY06zZl8QB9W02nr5kWeeMY0VA3adrPgOlvfx3oWlFbkETnMaN4OT3WTQ0Wt"
1199                         "6jAWZDzVfopwpJPAzRPxACDftIqFGagYcF32hZlVNqqnVdbXh0S0EViweqp/dbG4"
1200                         "VDUHSNVbglc+u4UbEzNIFXMdEFsJZpkynOmSiTsIATqIhb+2srkVgLwhfkC2qkuH"
1201                         "QwAHdubuB07ObM2z01UhyEdDvEYGHwtYAGDBL2TAcsI0oGeVkRyuOkV0QY0UN7UE"
1202                         "FI1yTYw+xZ42HgFx3uGwApCImxhbj69GBYWFqwIDAQABAoIBAQCZN9kR8DGu6V7y"
1203                         "t0Ax68asL8O5B/OKaHWKQ9LqpVrXmikZJOxkbzoGldow/CIFoU+q+Zbwu9aDa65a"
1204                         "0wiP7Hoa4Py3q5XNNUrOQDyU/OYC7cI0I83WS0lJ2zOJGYj8wKae5Z81IeQFKGHK"
1205                         "4lsy1OGPAvPRGh7RjUUgRavA2MCwe07rWRuDb/OJFe4Oh56UMEjwMiNBtMNtncog"
1206                         "j1vr/qgRJdf9tf0zlJmLvUJ9+HSFFV9I/97LJyFhb95gAfHkjdVroLVgT3Cho+4P"
1207                         "WtZaKCIGD0OwfOG2nLV4leXvRUk62/LMlB8NI9+JF7Xm+HCKbaWHNWC7mvWSLV58"
1208                         "Zl4AbUWRAoGBANyJ6SFHFRHSPDY026SsdMzXR0eUxBAK7G70oSBKKhY+O1j0ocLE"
1209                         "jI2krHJBhHbLlnvJVyMUaCUOTS5m0uDw9hgSsAqeSL3hL38kxVZw+KNG9Ouno1Fl"
1210                         "KnE/xXHlPQyeGs/P8nAMzHZxQtEsQdQayJEhK2XXHTsy7Q3MxDisfVJ1AoGBANfD"
1211                         "34gB+OMx6pwj7zk3qWbYXSX8xjCZMR0ciko+h4xeMP2N8B0oyoqC+v1ABMAtJ3wG"
1212                         "sGZd0hV9gwM7OUM3SEwkn6oeg1GemWLcn4rlSmTnZc4aeVwrEWlnSNFX3s4g9l4u"
1213                         "k8Ugu4MVJYqH8HuDQ5Ggl6/QAwPzMSEdCW0O+jOfAoGAIBRbegC5+t6m7Yegz4Ja"
1214                         "dxV1g98K6f58x+MDsQu4tYWV4mmrQgaPH2dtwizvlMwmdpkh+LNWNtWuumowkJHc"
1215                         "akIFo3XExQIFg6wYnGtQb4e5xrGa2xMpKlIJaXjb+YLiCYqJDG2ALFZrTrvuU2kV"
1216                         "9a5qfqTc1qigvNolTM0iaaUCgYApmrZWhnLUdEKV2wP813PNxfioI4afxlpHD8LG"
1217                         "sCn48gymR6E+Lihn7vuwq5B+8fYEH1ISWxLwW+RQUjIneNhy/jjfV8TgjyFqg7or"
1218                         "0Sy4KjpiNI6kLBXOakELRNNMkeSPopGR2E7v5rr3bGD9oAD+aqX1G7oJH/KgPPYd"
1219                         "Vl7+ZwKBgQDcHyWYrimjyUgKaQD2GmoO9wdcJYQ59ke9K+OuGlp4ti5arsi7N1tP"
1220                         "B4f09aeELM2ASIuk8Q/Mx0jQFnm8lzRFXdewgvdPoZW/7VufM9O7dGPOc41cm2Dh"
1221                         "yrTcXx/VmUBb+/fnXVEgCv7gylp/wtdTGHQBQJHR81jFBz0lnLj+gg==</private-key>"
1222                         "<passphrase></passphrase>"
1223                         "</key-credential>"
1224                         "</input>");
1225
1226         printf("Post data:\n%s\n", post_data_xml);
1227
1228         curl_easy_setopt(curl_odl, CURLOPT_POSTFIELDS, post_data_xml);
1229         curl_easy_setopt(curl_odl, CURLOPT_CUSTOMREQUEST, "POST");
1230         curl_easy_setopt(curl_odl, CURLOPT_USERPWD, credentials);
1231
1232         res = curl_easy_perform(curl_odl);
1233         if (res != CURLE_OK)
1234         {
1235                 printf("cURL failed to url=%s\n", url_for_curl);
1236         }
1237
1238         long http_response_code = 0;
1239         curl_easy_getinfo (curl_odl, CURLINFO_RESPONSE_CODE, &http_response_code);
1240         if (http_response_code >= 200 && http_response_code <= 226 && http_response_code != CURLE_ABORTED_BY_CALLBACK)
1241         {
1242                 printf("cURL succeeded to url=%s\n", url_for_curl);
1243         }
1244         else
1245         {
1246                 printf("cURL to url=%s failed with code=%ld\n", url_for_curl, http_response_code);
1247                 return SR_ERR_OPERATION_FAILED;
1248         }
1249
1250         return SR_ERR_OK;
1251 }
1252
1253 static int add_private_key_odl(char *url, char *credentials)
1254 {
1255         CURLcode res;
1256
1257         curl_easy_reset(curl_odl);
1258         set_curl_common_info_odl();
1259
1260         char url_for_curl[200];
1261         sprintf(url_for_curl, "%s", url);
1262
1263         curl_easy_setopt(curl_odl, CURLOPT_URL, url_for_curl);
1264
1265         char post_data_xml[4000];
1266
1267         sprintf(post_data_xml,
1268                         "<input xmlns=\"urn:opendaylight:netconf:keystore\">"
1269                         "<private-key>"
1270                         "<name>device-key</name>"
1271                         "<data>MIIEpAIBAAKCAQEAueCQaNQWoNmFK6LKu1p8U8ZWdWg/PvDdLsJyzfzl/Qw4UA68SfFNaY06zZl8QB9W02nr5kWeeMY0VA3adrPgOlvfx3oWlFbkETnMaN4OT3WTQ0Wt6jAWZDzVfopwpJPAzRPxACDftIqFGagYcF32hZlVNqqnVdbXh0S0EViweqp/dbG4VDUHSNVbglc+u4UbEzNIFXMdEFsJZpkynOmSiTsIATqIhb+2srkVgLwhfkC2qkuHQwAHdubuB07ObM2z01UhyEdDvEYGHwtYAGDBL2TAcsI0oGeVkRyuOkV0QY0UN7UEFI1yTYw+xZ42HgFx3uGwApCImxhbj69GBYWFqwIDAQABAoIBAQCZN9kR8DGu6V7yt0Ax68asL8O5B/OKaHWKQ9LqpVrXmikZJOxkbzoGldow/CIFoU+q+Zbwu9aDa65a0wiP7Hoa4Py3q5XNNUrOQDyU/OYC7cI0I83WS0lJ2zOJGYj8wKae5Z81IeQFKGHK4lsy1OGPAvPRGh7RjUUgRavA2MCwe07rWRuDb/OJFe4Oh56UMEjwMiNBtMNtncogj1vr/qgRJdf9tf0zlJmLvUJ9+HSFFV9I/97LJyFhb95gAfHkjdVroLVgT3Cho+4PWtZaKCIGD0OwfOG2nLV4leXvRUk62/LMlB8NI9+JF7Xm+HCKbaWHNWC7mvWSLV58Zl4AbUWRAoGBANyJ6SFHFRHSPDY026SsdMzXR0eUxBAK7G70oSBKKhY+O1j0ocLEjI2krHJBhHbLlnvJVyMUaCUOTS5m0uDw9hgSsAqeSL3hL38kxVZw+KNG9Ouno1FlKnE/xXHlPQyeGs/P8nAMzHZxQtEsQdQayJEhK2XXHTsy7Q3MxDisfVJ1AoGBANfD34gB+OMx6pwj7zk3qWbYXSX8xjCZMR0ciko+h4xeMP2N8B0oyoqC+v1ABMAtJ3wGsGZd0hV9gwM7OUM3SEwkn6oeg1GemWLcn4rlSmTnZc4aeVwrEWlnSNFX3s4g9l4uk8Ugu4MVJYqH8HuDQ5Ggl6/QAwPzMSEdCW0O+jOfAoGAIBRbegC5+t6m7Yegz4JadxV1g98K6f58x+MDsQu4tYWV4mmrQgaPH2dtwizvlMwmdpkh+LNWNtWuumowkJHcakIFo3XExQIFg6wYnGtQb4e5xrGa2xMpKlIJaXjb+YLiCYqJDG2ALFZrTrvuU2kV9a5qfqTc1qigvNolTM0iaaUCgYApmrZWhnLUdEKV2wP813PNxfioI4afxlpHD8LGsCn48gymR6E+Lihn7vuwq5B+8fYEH1ISWxLwW+RQUjIneNhy/jjfV8TgjyFqg7or0Sy4KjpiNI6kLBXOakELRNNMkeSPopGR2E7v5rr3bGD9oAD+aqX1G7oJH/KgPPYdVl7+ZwKBgQDcHyWYrimjyUgKaQD2GmoO9wdcJYQ59ke9K+OuGlp4ti5arsi7N1tPB4f09aeELM2ASIuk8Q/Mx0jQFnm8lzRFXdewgvdPoZW/7VufM9O7dGPOc41cm2DhyrTcXx/VmUBb+/fnXVEgCv7gylp/wtdTGHQBQJHR81jFBz0lnLj+gg==</data>"
1272                         "<certificate-chain>MIIECTCCAvGgAwIBAgIBBzANBgkqhkiG9w0BAQsFADCBjDELMAkGA1UEBhMCQ1oxFjAUBgNVBAgMDVNvdXRoIE1vcmF2aWExDTALBgNVBAcMBEJybm8xDzANBgNVBAoMBkNFU05FVDEMMAoGA1UECwwDVE1DMRMwEQYDVQQDDApleGFtcGxlIENBMSIwIAYJKoZIhvcNAQkBFhNleGFtcGxlY2FAbG9jYWxob3N0MB4XDTE1MDczMDA3MjcxOFoXDTM1MDcyNTA3MjcxOFowgYUxCzAJBgNVBAYTAkNaMRYwFAYDVQQIDA1Tb3V0aCBNb3JhdmlhMQ8wDQYDVQQKDAZDRVNORVQxDDAKBgNVBAsMA1RNQzEXMBUGA1UEAwwOZXhhbXBsZSBjbGllbnQxJjAkBgkqhkiG9w0BCQEWF2V4YW1wbGVjbGllbnRAbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAueCQaNQWoNmFK6LKu1p8U8ZWdWg/PvDdLsJyzfzl/Qw4UA68SfFNaY06zZl8QB9W02nr5kWeeMY0VA3adrPgOlvfx3oWlFbkETnMaN4OT3WTQ0Wt6jAWZDzVfopwpJPAzRPxACDftIqFGagYcF32hZlVNqqnVdbXh0S0EViweqp/dbG4VDUHSNVbglc+u4UbEzNIFXMdEFsJZpkynOmSiTsIATqIhb+2srkVgLwhfkC2qkuHQwAHdubuB07ObM2z01UhyEdDvEYGHwtYAGDBL2TAcsI0oGeVkRyuOkV0QY0UN7UEFI1yTYw+xZ42HgFx3uGwApCImxhbj69GBYWFqwIDAQABo3sweTAJBgNVHRMEAjAAMCwGCWCGSAGG+EIBDQQfFh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUXGpLeLnh2cSDARAVA7KrBxGYpo8wHwYDVR0jBBgwFoAUc1YQIqjZsHVwlea0AB4N+ilNI2gwDQYJKoZIhvcNAQELBQADggEBAJPV3RTXFRtNyOU4rjPpYeBAIAFp2aqGc4t2J1c7oPp/1n+lZvjnwtlJpZHxMM783e2ryDQ6dkvXDf8kpwKlg3U3mkJ3xKkDdWrM4QwghXdCN519aa9qmu0zdFL+jUAaWlQ5tsceOrvbusCcbMqiFGk/QfpHqPv52SVWbYyUx7IX7DE+UjgsLHycfV/tlcx4ZE6soTzl9VdgSL/zmzG3rjsr58J80rXckLgBhvijgBlIAJvWfC7D0vaouvBInSFXymdPVoUDZ30cdGLf+hI/i/TfsEMOinLrXVdkSGNo6FXAHKSvXeB9oFKSzhQ7OPyRyqvEPycUSw/qD6FVr80oDDc=</certificate-chain>"
1273                         "</private-key>"
1274                         "</input>");
1275
1276         printf("Post data:\n%s\n", post_data_xml);
1277
1278         curl_easy_setopt(curl_odl, CURLOPT_POSTFIELDS, post_data_xml);
1279         curl_easy_setopt(curl_odl, CURLOPT_CUSTOMREQUEST, "POST");
1280         curl_easy_setopt(curl_odl, CURLOPT_USERPWD, credentials);
1281
1282         res = curl_easy_perform(curl_odl);
1283         if (res != CURLE_OK)
1284         {
1285                 printf("cURL failed to url=%s\n", url_for_curl);
1286         }
1287
1288         long http_response_code = 0;
1289         curl_easy_getinfo (curl_odl, CURLINFO_RESPONSE_CODE, &http_response_code);
1290         if (http_response_code >= 200 && http_response_code <= 226 && http_response_code != CURLE_ABORTED_BY_CALLBACK)
1291         {
1292                 printf("cURL succeeded to url=%s\n", url_for_curl);
1293         }
1294         else
1295         {
1296                 printf("cURL to url=%s failed with code=%ld\n", url_for_curl, http_response_code);
1297                 return SR_ERR_OPERATION_FAILED;
1298         }
1299
1300         return SR_ERR_OK;
1301 }
1302
1303 static int add_trusted_ca_odl(char *url, char *credentials)
1304 {
1305         CURLcode res;
1306
1307         curl_easy_reset(curl_odl);
1308         set_curl_common_info_odl();
1309
1310         char url_for_curl[200];
1311         sprintf(url_for_curl, "%s", url);
1312
1313         curl_easy_setopt(curl_odl, CURLOPT_URL, url_for_curl);
1314
1315         char post_data_xml[2000];
1316
1317         sprintf(post_data_xml,
1318                         "<input xmlns=\"urn:opendaylight:netconf:keystore\">"
1319                         "<trusted-certificate>"
1320                         "<name>test_trusted_cert</name>"
1321                         "<certificate>MIID7TCCAtWgAwIBAgIJAMtE1NGAR5KoMA0GCSqGSIb3DQEBBQUAMIGMMQswCQYDVQQGEwJDWjEWMBQGA1UECAwNU291dGggTW9yYXZpYTENMAsGA1UEBwwEQnJubzEPMA0GA1UECgwGQ0VTTkVUMQwwCgYDVQQLDANUTUMxEzARBgNVBAMMCmV4YW1wbGUgQ0ExIjAgBgkqhkiG9w0BCQEWE2V4YW1wbGVjYUBsb2NhbGhvc3QwHhcNMTQwNzI0MTQxOTAyWhcNMjQwNzIxMTQxOTAyWjCBjDELMAkGA1UEBhMCQ1oxFjAUBgNVBAgMDVNvdXRoIE1vcmF2aWExDTALBgNVBAcMBEJybm8xDzANBgNVBAoMBkNFU05FVDEMMAoGA1UECwwDVE1DMRMwEQYDVQQDDApleGFtcGxlIENBMSIwIAYJKoZIhvcNAQkBFhNleGFtcGxlY2FAbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArD3TDHPAMT2Z84orK4lMlarbgooIUCcRZyLe+QM+8KY8Hn+mGaxPEOTSL3ywszqefB/Utm2hPKLHX684iRC14ID9WDGHxPjvoPArhgFhfV+qnPfxKTgxZC12uOj4u1V9y+SkTCocFbRfXVBGpojrBuDHXkDMDEWNvr8/52YCv7bGaiBwUHolcLCUbmtKILCG0RNJyTaJpXQdAeq5Z1SJotpbfYFFtAXB32hVoLug1dzl2tjG9sb1wq3QaDExcbC5w6P65qOkNoyym9ne6QlQagCqVDyFn3vcqkRaTjvZmxauCeUxXgJoXkyWcm0lM1KMHdoTArmchw2Dz0yHHSyDAQIDAQABo1AwTjAdBgNVHQ4EFgQUc1YQIqjZsHVwlea0AB4N+ilNI2gwHwYDVR0jBBgwFoAUc1YQIqjZsHVwlea0AB4N+ilNI2gwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAI/1KH60qnw9Xs2RGfi0/IKf5EynXt4bQX8EIyVKwSkYKe04zZxYfLIl/Q2HOPYoFmm3daj5ddr0ZS1i4p4fTUhstjsYWvXs3W/HhVmFUslakkn3PrswhP77fCk6eEJLxdfyJ1C7Uudq2m1isZbKih+XF0mG1LxJaDMocSz4eAya7M5brwjy8DoOmA1TnLQFCVcpn+sCr7VC4wE/JqxyVhBCk/MuGqqM3B1j90bGFZ112ZOecyE0EDSr6IbiRBtmeNbEwOFjKXhNLYdxpBZ9D8A/368OckZkCrVLGuJNxK9UwCVTe8IhotHUqU9EqFDmxdV8oIdU/OzUwwNPA/Bd/9g==</certificate>"
1322                         "</trusted-certificate>"
1323                         "</input>");
1324
1325         printf("Post data:\n%s\n", post_data_xml);
1326
1327         curl_easy_setopt(curl_odl, CURLOPT_POSTFIELDS, post_data_xml);
1328         curl_easy_setopt(curl_odl, CURLOPT_CUSTOMREQUEST, "POST");
1329         curl_easy_setopt(curl_odl, CURLOPT_USERPWD, credentials);
1330
1331         res = curl_easy_perform(curl_odl);
1332         if (res != CURLE_OK)
1333         {
1334                 printf("cURL failed to url=%s\n", url_for_curl);
1335         }
1336
1337         long http_response_code = 0;
1338         curl_easy_getinfo (curl_odl, CURLINFO_RESPONSE_CODE, &http_response_code);
1339         if (http_response_code >= 200 && http_response_code <= 226 && http_response_code != CURLE_ABORTED_BY_CALLBACK)
1340         {
1341                 printf("cURL succeeded to url=%s\n", url_for_curl);
1342         }
1343         else
1344         {
1345                 printf("cURL to url=%s failed with code=%ld\n", url_for_curl, http_response_code);
1346                 return SR_ERR_OPERATION_FAILED;
1347         }
1348
1349         return SR_ERR_OK;
1350 }
1351
1352 int add_key_pair_to_odl(controller_t *controller_list, int controller_list_size)
1353 {
1354         int rc = SR_ERR_OK;
1355
1356         rc = add_keystore_entry_odl(controller_list[0].url_for_keystore_add, controller_list[0].credentials);
1357         if (rc != SR_ERR_OK)
1358         {
1359                 printf("Failed to add keystore entry to ODL.\n");
1360         }
1361
1362         rc = add_private_key_odl(controller_list[0].url_for_private_key_add, controller_list[0].credentials);
1363         if (rc != SR_ERR_OK)
1364         {
1365                 printf("Failed to add private key entry to ODL.\n");
1366         }
1367
1368         rc = add_trusted_ca_odl(controller_list[0].url_for_trusted_ca_add, controller_list[0].credentials);
1369         if (rc != SR_ERR_OK)
1370         {
1371                 printf("Failed to add trusted CA entry to ODL.\n");
1372         }
1373
1374         return SR_ERR_OK;
1375 }
1376
1377 int ves_ip_changed(char *new_ip)
1378 {
1379         char *stringConfiguration = readConfigFileInString();
1380
1381         if (stringConfiguration == NULL)
1382         {
1383                 printf("Could not read configuration file!\n");
1384                 return SR_ERR_OPERATION_FAILED;
1385         }
1386
1387         cJSON *jsonConfig = cJSON_Parse(stringConfiguration);
1388         if (jsonConfig == NULL)
1389         {
1390                 free(stringConfiguration);
1391                 const char *error_ptr = cJSON_GetErrorPtr();
1392                 if (error_ptr != NULL)
1393                 {
1394                         fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr);
1395                 }
1396                 return SR_ERR_OPERATION_FAILED;
1397         }
1398         //we don't need the string anymore
1399         free(stringConfiguration);
1400         stringConfiguration = NULL;
1401
1402         cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details");
1403         if (!cJSON_IsObject(vesDetails))
1404         {
1405                 printf("Configuration JSON is not as expected: ves-endpoint-details is not an object");
1406                 cJSON_Delete(jsonConfig);
1407                 return SR_ERR_OPERATION_FAILED;
1408         }
1409
1410         cJSON *vesIp = cJSON_GetObjectItemCaseSensitive(vesDetails, "ves-endpoint-ip");
1411         if (!cJSON_IsString(vesIp))
1412         {
1413                 printf("Configuration JSON is not as expected: ves-endpoint-ip is not a string");
1414                 cJSON_Delete(jsonConfig);
1415                 return SR_ERR_OPERATION_FAILED;
1416         }
1417
1418         //we set the value of the fault-notification-delay-period object
1419         cJSON_ReplaceItemInObject(vesDetails, "ves-endpoint-ip", cJSON_CreateString(new_ip));
1420
1421         //writing the new JSON to the configuration file
1422         stringConfiguration = cJSON_Print(jsonConfig);
1423         writeConfigFile(stringConfiguration);
1424
1425         cJSON_Delete(jsonConfig);
1426
1427         return SR_ERR_OK;
1428 }
1429
1430 int ves_port_changed(int new_port)
1431 {
1432         char *stringConfiguration = readConfigFileInString();
1433
1434         if (stringConfiguration == NULL)
1435         {
1436                 printf("Could not read configuration file!\n");
1437                 return SR_ERR_OPERATION_FAILED;
1438         }
1439
1440         cJSON *jsonConfig = cJSON_Parse(stringConfiguration);
1441         if (jsonConfig == NULL)
1442         {
1443                 free(stringConfiguration);
1444                 const char *error_ptr = cJSON_GetErrorPtr();
1445                 if (error_ptr != NULL)
1446                 {
1447                         fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr);
1448                 }
1449                 return SR_ERR_OPERATION_FAILED;
1450         }
1451         //we don't need the string anymore
1452         free(stringConfiguration);
1453         stringConfiguration = NULL;
1454
1455         cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details");
1456         if (!cJSON_IsObject(vesDetails))
1457         {
1458                 printf("Configuration JSON is not as expected: ves-endpoint-details is not an object");
1459                 cJSON_Delete(jsonConfig);
1460                 return SR_ERR_OPERATION_FAILED;
1461         }
1462
1463         cJSON *vesPort = cJSON_GetObjectItemCaseSensitive(vesDetails, "ves-endpoint-port");
1464         if (!cJSON_IsNumber(vesPort))
1465         {
1466                 printf("Configuration JSON is not as expected: ves-endpoint-port is not a number.");
1467                 cJSON_Delete(jsonConfig);
1468                 return SR_ERR_OPERATION_FAILED;
1469         }
1470
1471         //we set the value of the fault-notification-delay-period object
1472         cJSON_SetNumberValue(vesPort, new_port);
1473
1474         //writing the new JSON to the configuration file
1475         stringConfiguration = cJSON_Print(jsonConfig);
1476         writeConfigFile(stringConfiguration);
1477
1478         cJSON_Delete(jsonConfig);
1479
1480         return SR_ERR_OK;
1481 }
1482
1483 int ves_registration_changed(cJSON_bool new_bool)
1484 {
1485         char *stringConfiguration = readConfigFileInString();
1486
1487         if (stringConfiguration == NULL)
1488         {
1489                 printf("Could not read configuration file!\n");
1490                 return SR_ERR_OPERATION_FAILED;
1491         }
1492
1493         cJSON *jsonConfig = cJSON_Parse(stringConfiguration);
1494         if (jsonConfig == NULL)
1495         {
1496                 free(stringConfiguration);
1497                 const char *error_ptr = cJSON_GetErrorPtr();
1498                 if (error_ptr != NULL)
1499                 {
1500                         fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr);
1501                 }
1502                 return SR_ERR_OPERATION_FAILED;
1503         }
1504         //we don't need the string anymore
1505         free(stringConfiguration);
1506         stringConfiguration = NULL;
1507
1508         cJSON *vesDetails = cJSON_GetObjectItemCaseSensitive(jsonConfig, "ves-endpoint-details");
1509         if (!cJSON_IsObject(vesDetails))
1510         {
1511                 printf("Configuration JSON is not as expected: ves-endpoint-details is not an object");
1512                 cJSON_Delete(jsonConfig);
1513                 return SR_ERR_OPERATION_FAILED;
1514         }
1515
1516         cJSON *vesRegistration = cJSON_GetObjectItemCaseSensitive(vesDetails, "ves-registration");
1517         if (!cJSON_IsBool(vesRegistration))
1518         {
1519                 printf("Configuration JSON is not as expected: ves-registration is not a bool.");
1520                 cJSON_Delete(jsonConfig);
1521                 return SR_ERR_OPERATION_FAILED;
1522         }
1523
1524         //we set the value of the ves-registration object
1525         cJSON_ReplaceItemInObject(vesDetails, "ves-registration", cJSON_CreateBool(new_bool));
1526
1527         //writing the new JSON to the configuration file
1528         stringConfiguration = cJSON_Print(jsonConfig);
1529         writeConfigFile(stringConfiguration);
1530
1531         cJSON_Delete(jsonConfig);
1532
1533         return SR_ERR_OK;
1534 }
1535
1536 int is_netconf_available_changed(cJSON_bool new_bool)
1537 {
1538         char *stringConfiguration = readConfigFileInString();
1539
1540         if (stringConfiguration == NULL)
1541         {
1542                 printf("Could not read configuration file!\n");
1543                 return SR_ERR_OPERATION_FAILED;
1544         }
1545
1546         cJSON *jsonConfig = cJSON_Parse(stringConfiguration);
1547         if (jsonConfig == NULL)
1548         {
1549                 free(stringConfiguration);
1550                 const char *error_ptr = cJSON_GetErrorPtr();
1551                 if (error_ptr != NULL)
1552                 {
1553                         fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr);
1554                 }
1555                 return SR_ERR_OPERATION_FAILED;
1556         }
1557         //we don't need the string anymore
1558         free(stringConfiguration);
1559         stringConfiguration = NULL;
1560
1561         cJSON *notifConfig = cJSON_GetObjectItemCaseSensitive(jsonConfig, "notification-config");
1562         if (!cJSON_IsObject(notifConfig))
1563         {
1564                 printf("Configuration JSON is not as expected: notification-config is not an object");
1565                 cJSON_Delete(jsonConfig);
1566                 return SR_ERR_OPERATION_FAILED;
1567         }
1568
1569         cJSON *isNetconfAvailable = cJSON_GetObjectItemCaseSensitive(notifConfig, "is-netconf-available");
1570         if (!cJSON_IsBool(isNetconfAvailable))
1571         {
1572                 printf("Configuration JSON is not as expected: is-netconf-available is not a bool.");
1573                 cJSON_Delete(jsonConfig);
1574                 return SR_ERR_OPERATION_FAILED;
1575         }
1576
1577         //we set the value of the ves-registration object
1578         cJSON_ReplaceItemInObject(notifConfig, "is-netconf-available", cJSON_CreateBool(new_bool));
1579
1580         //writing the new JSON to the configuration file
1581         stringConfiguration = cJSON_Print(jsonConfig);
1582         writeConfigFile(stringConfiguration);
1583
1584         cJSON_Delete(jsonConfig);
1585
1586         return SR_ERR_OK;
1587 }
1588
1589 int is_ves_available_changed(cJSON_bool new_bool)
1590 {
1591         char *stringConfiguration = readConfigFileInString();
1592
1593         if (stringConfiguration == NULL)
1594         {
1595                 printf("Could not read configuration file!\n");
1596                 return SR_ERR_OPERATION_FAILED;
1597         }
1598
1599         cJSON *jsonConfig = cJSON_Parse(stringConfiguration);
1600         if (jsonConfig == NULL)
1601         {
1602                 free(stringConfiguration);
1603                 const char *error_ptr = cJSON_GetErrorPtr();
1604                 if (error_ptr != NULL)
1605                 {
1606                         fprintf(stderr, "Could not parse JSON configuration! Error before: %s\n", error_ptr);
1607                 }
1608                 return SR_ERR_OPERATION_FAILED;
1609         }
1610         //we don't need the string anymore
1611         free(stringConfiguration);
1612         stringConfiguration = NULL;
1613
1614         cJSON *notifConfig = cJSON_GetObjectItemCaseSensitive(jsonConfig, "notification-config");
1615         if (!cJSON_IsObject(notifConfig))
1616         {
1617                 printf("Configuration JSON is not as expected: notification-config is not an object");
1618                 cJSON_Delete(jsonConfig);
1619                 return SR_ERR_OPERATION_FAILED;
1620         }
1621
1622         cJSON *isVesAvailable = cJSON_GetObjectItemCaseSensitive(notifConfig, "is-ves-available");
1623         if (!cJSON_IsBool(isVesAvailable))
1624         {
1625                 printf("Configuration JSON is not as expected: is-ves-available is not a bool.");
1626                 cJSON_Delete(jsonConfig);
1627                 return SR_ERR_OPERATION_FAILED;
1628         }
1629
1630         //we set the value of the ves-registration object
1631         cJSON_ReplaceItemInObject(notifConfig, "is-ves-available", cJSON_CreateBool(new_bool));
1632
1633         //writing the new JSON to the configuration file
1634         stringConfiguration = cJSON_Print(jsonConfig);
1635         writeConfigFile(stringConfiguration);
1636
1637         cJSON_Delete(jsonConfig);
1638
1639         return SR_ERR_OK;
1640 }