path: root/vnfs/VES5.0/evel/evel-library/code/evel_library/evel_event_mgr.c

/*************************************************************************//**
 *
 * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
 *
 * Unless otherwise specified, all software contained herein is
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and 
 * limitations under the License.
 * ECOMP is a trademark and service mark of AT&T Intellectual Property.
 ****************************************************************************/

/**************************************************************************//**
 * @file
 * Event Manager
 *
 * Simple event manager that is responsible for taking events (Heartbeats,
 * Faults and Measurements) from the ring-buffer and posting them to the API.
 *
 ****************************************************************************/

#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <pthread.h>

#include <curl/curl.h>

#include "evel.h"
#include "evel_internal.h"
#include "ring_buffer.h"
#include "evel_throttle.h"

/**************************************************************************//**
 * How long we're prepared to wait for the API service to respond in
 * seconds.
 *****************************************************************************/
static const int EVEL_API_TIMEOUT = 10;

/*****************************************************************************/
/* Prototypes of locally scoped functions.                                   */
/*****************************************************************************/
static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *userp);
static void * event_handler(void *arg);
static bool evel_handle_response_tokens(const MEMORY_CHUNK * const chunk,
                                        const jsmntok_t * const json_tokens,
                                        const int num_tokens,
                                        MEMORY_CHUNK * const post);
static bool evel_tokens_match_command_list(const MEMORY_CHUNK * const chunk,
                                           const jsmntok_t * const json_token,
                                           const int num_tokens);
static bool evel_token_equals_string(const MEMORY_CHUNK * const chunk,
                                     const jsmntok_t * const json_token,
                                     const char * check_string);
static void * event_multi_handler(void * arg __attribute__ ((unused)));

/**************************************************************************//**
 * Buffers for error strings from libcurl.
 *****************************************************************************/
static char curl_err_string[CURL_ERROR_SIZE] = "<NULL>";
static char curl_err_string2[CURL_ERROR_SIZE] = "<NULL>";

/**************************************************************************//**
 * Handle for the API into libcurl.
 *****************************************************************************/
static CURL * curl_handle = NULL;
static CURL * curl_handle2 = NULL;
static CURLM * multi_handle = NULL;
int curr_global_handles = 0;
int activmode = -1;

/**************************************************************************//**
 * Special headers that we send.
 *****************************************************************************/
static struct curl_slist * hdr_chunk = NULL;
static struct curl_slist * hdr_chunk2 = NULL;

/**************************************************************************//**
 * Message queue for sending events to the API.
 *****************************************************************************/
static ring_buffer event_buffer;

/**************************************************************************//**
 * Single pending priority post, which can be generated as a result of a
 * response to an event.  Currently only used to respond to a commandList.
 *****************************************************************************/
static MEMORY_CHUNK priority_post;

/**************************************************************************//**
 * The thread which is responsible for handling events off of the ring-buffer
 * and posting them to the Event Handler API.
 *****************************************************************************/
static pthread_t evt_handler_thread;

/**************************************************************************//**
 * Variable to convey to the event handler thread what the foreground wants it
 * to do.
 *****************************************************************************/
static EVT_HANDLER_STATE evt_handler_state = EVT_HANDLER_UNINITIALIZED;

/**************************************************************************//**
 * The configured API URL for event and throttling.
 *****************************************************************************/
static char * evel_event_api_url;
static char * evel_throt_api_url;
static char * evel_batch_api_url;

static char * evel_bevent_api_url;
static char * evel_bthrot_api_url;
static char * evel_bbatch_api_url;


/**************************************************************************//**
 * Initialize the event handler.
 *
 * Primarily responsible for getting CURL ready for use.
 *
 * @param[in] event_api_url
 *                      The URL where the Vendor Event Listener API is expected
 *                      to be.
 * @param[in] throt_api_url
 *                      The URL where the Throttling API is expected to be.
 * @param[in] source_ip  Source IP of VES Agent
 * @param[in] ring_buf_size     Initial size of ring buffer
 * @param[in] secure     Whether Using http or https
 * @param[in] cert_file_path  Path to Client Certificate file
 * @param[in] key_file_path   Path to Client key file
 * @param[in] ca_info         Path to CA info file
 * @param[in] ca_file_path    Path to CA file 
 * @param[in] verify_peer     Using peer verification or not 0 or 1
 * @param[in] verify_host     Using host verification or not 0 or 1
 * @param[in] username  The username for the Basic Authentication of requests.
 * @param[in] password  The password for the Basic Authentication of requests.
 * @param     verbosity 0 for normal operation, positive values for chattier
 *                        logs.
 *****************************************************************************/
EVEL_ERR_CODES event_handler_initialize(const char * const event_api_url,
                                        const char * const bakup_api_url,
                                        const char * const throt_api_url,
                                        const char * const source_ip,
                                        const char * const source_ip_bakup,
                                        int ring_buf_size,
                                        int secure,
                                        int activitymode,
                                        const char * const cert_file_path,
                                        const char * const key_file_path,
                                        const char * const ca_info,
                                        const char * const ca_file_path,
                                        long verify_peer,
                                        long verify_host,
                                        const char * const username,
                                        const char * const password,
                                        const char * const username2,
                                        const char * const password2,
                                        int verbosity)
{
  int rc = EVEL_SUCCESS;
  CURLcode curl_rc = CURLE_OK;
  char batch_api_url[EVEL_MAX_URL_LEN + 1] = {0};
  char local_address[64];

  EVEL_ENTER();

  /***************************************************************************/
  /* Check assumptions.                                                      */
  /***************************************************************************/
  assert(event_api_url != NULL);
  assert(throt_api_url != NULL);
  assert(username != NULL);
  assert(password != NULL);
  if( bakup_api_url != NULL )
  {
    assert(username2 != NULL);
    assert(password2 != NULL);
  }


  /***************************************************************************/
  /* Store the API URLs.                                                     */
  /***************************************************************************/
  evel_event_api_url = strdup(event_api_url);
  assert(evel_event_api_url != NULL);
  sprintf(batch_api_url,"%s/eventBatch",event_api_url);
  evel_batch_api_url = strdup(batch_api_url);
  assert(evel_batch_api_url != NULL);
  evel_throt_api_url = strdup(throt_api_url);
  assert(evel_throt_api_url != NULL);
  curr_global_handles = 1;

  if( bakup_api_url != NULL )
  {
    evel_bevent_api_url = strdup(bakup_api_url);
    assert(evel_bevent_api_url != NULL);
    sprintf(batch_api_url,"%s/eventBatch",event_api_url);
    evel_bbatch_api_url = strdup(batch_api_url);
    assert(evel_bbatch_api_url != NULL);
    evel_bthrot_api_url = strdup(throt_api_url);
    assert(evel_bthrot_api_url != NULL);
    curr_global_handles = 2;
  }


  curl_version_info_data *d = curl_version_info(CURLVERSION_NOW);
  /* compare with the 24 bit hex number in 8 bit fields */
  if(d->version_num >= 0x072100) {
     /* this is libcurl 7.33.0 or later */
     EVEL_INFO("7.33 or later Curl version %x.",d->version_num);
  }
  else {
     EVEL_INFO("Old Curl version.");
  }
  /***************************************************************************/
  /* Start the CURL library. Note that this initialization is not threadsafe */
  /* which imposes a constraint that the EVEL library is initialized before  */
  /* any threads are started.                                                */
  /***************************************************************************/
  curl_rc = curl_global_init(CURL_GLOBAL_SSL);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL. Error code=%d", curl_rc);
    goto exit_label;
  }

  /***************************************************************************/
  /* Get a curl handle which we'll use for all of our output.                */
  /***************************************************************************/
  curl_handle = curl_easy_init();
  if (curl_handle == NULL)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to get libCURL handle");
    goto exit_label;
  }

  if( bakup_api_url != NULL )
  {
     curl_handle2 = curl_easy_init();
     if (curl_handle2 == NULL)
     {
       rc = EVEL_CURL_LIBRARY_FAIL;
       log_error_state("Failed to get backup libCURL handle");
       goto exit_label;
     }
  }
  /***************************************************************************/
  /* Prime the library to give friendly error codes.                         */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_ERRORBUFFER,
                             curl_err_string);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL to provide friendly errors. "
                    "Error code=%d", curl_rc);
    goto exit_label;
  }

  if( bakup_api_url != NULL )
  {
    curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_ERRORBUFFER,
                             curl_err_string2);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL2 to provide friendly errors. "
                    "Error code=%d", curl_rc);
      goto exit_label;
    }
  }


  /***************************************************************************/
  /* If running in verbose mode generate more output.                        */
  /***************************************************************************/
  if (verbosity > 0)
  {
    curl_rc = curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, 1L);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL to be verbose. "
                      "Error code=%d", curl_rc);
      goto exit_label;
    }
  if( bakup_api_url != NULL )
  {
    curl_rc = curl_easy_setopt(curl_handle2, CURLOPT_VERBOSE, 1L);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL to be verbose. "
                      "Error code=%d", curl_rc);
      goto exit_label;
    }
   }

  }



  /***************************************************************************/
  /* Set the URL for the API.                                                */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_URL, event_api_url);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  EVEL_INFO("Initializing CURL to send events to: %s", event_api_url);

  if( bakup_api_url != NULL )
  {
    curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_URL,
                             bakup_api_url);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
      goto exit_label;
    }
  }


  /***************************************************************************/
  /* send all data to this function.                                         */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_WRITEFUNCTION,
                             evel_write_callback);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL with the write callback. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  if( bakup_api_url != NULL )
  {
    curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_WRITEFUNCTION,
                             evel_write_callback);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
      goto exit_label;
    }
  }



  /***************************************************************************/
  /* configure local ip address if provided */
  /* Default ip if NULL */
  /***************************************************************************/
  if( source_ip != NULL )
  {
    snprintf(local_address,sizeof(local_address),source_ip);
    if( local_address[0] != '\0' )
    {
      curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_INTERFACE,
                             local_address);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the local address. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
    }
  }
  if( source_ip_bakup != NULL )
  {
    snprintf(local_address,sizeof(local_address),source_ip_bakup);
    if( local_address[0] != '\0' )
    {
      curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_INTERFACE,
                             local_address);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize bakup libCURL with the local address. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
        goto exit_label;
      }
    }
  }

  /***************************************************************************/
  /* configure SSL options for HTTPS transfers */
  /***************************************************************************/
  if( secure )
  {
    if( cert_file_path != NULL )
    {
      curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_SSLCERT,
                             cert_file_path);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the client cert. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
  if( bakup_api_url != NULL )
  {
      curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_SSLCERT,
                             cert_file_path);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the client cert. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
  }
    }

    if( key_file_path != NULL )
    {
      curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_SSLKEY,
                             key_file_path);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the client key. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
  if( bakup_api_url != NULL )
  {
      curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_SSLKEY,
                             key_file_path);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the client key. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
  }
    }

    if( ca_info != NULL )
    {
      curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_CAINFO,
                             ca_info);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the CA cert file. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
  if( bakup_api_url != NULL )
  {
      curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_CAINFO,
                             ca_info);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the CA cert file. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
  }
    }

    if( ca_file_path != NULL )
    {
      curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_CAPATH,
                             ca_file_path);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the CA cert path. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
  if( bakup_api_url != NULL )
  {
      curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_CAPATH,
                             ca_file_path);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the CA cert path. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
  }
    }

      curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_SSL_VERIFYPEER,
                             verify_peer);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with SSL Server verification. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
      curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_SSL_VERIFYHOST,
                             verify_host);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with Client host verification. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }

     if( bakup_api_url != NULL )
     {
      curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_SSL_VERIFYPEER,
                             verify_peer);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with SSL Server verification. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
      curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_SSL_VERIFYHOST,
                             verify_host);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with Client host verification. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
        goto exit_label;
      }
     }
  }



  /***************************************************************************/
  /* some servers don't like requests that are made without a user-agent     */
  /* field, so we provide one.                                               */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_USERAGENT,
                             "libcurl-agent/1.0");
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL to upload. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  if( bakup_api_url != NULL )
  {
    curl_rc = curl_easy_setopt(curl_handle2,
                             CURLOPT_USERAGENT,
                             "libcurl-agent/1.0");
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
      goto exit_label;
    }
  }


  /***************************************************************************/
  /* Specify that we are going to POST data.                                 */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_POST, 1L);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL to upload. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  if( bakup_api_url != NULL )
  {
    curl_rc = curl_easy_setopt(curl_handle2,CURLOPT_POST, 1L);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
      goto exit_label;
    }
  }


  /***************************************************************************/
  /* we want to use our own read function.                                   */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_READFUNCTION, read_callback);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL to upload using read "
                    "function. Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  if( bakup_api_url != NULL )
  {
    curl_rc = curl_easy_setopt(curl_handle2,CURLOPT_READFUNCTION, read_callback);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
      goto exit_label;
    }
  }


  /***************************************************************************/
  /* All of our events are JSON encoded.  We also suppress the               */
  /* Expect: 100-continue   header that we would otherwise get since it      */
  /* confuses some servers.                                                  */
  /*                                                                         */
  /* @TODO: do AT&T want this behavior?                                      */
  /***************************************************************************/
  hdr_chunk = curl_slist_append(hdr_chunk, "Content-type: application/json");
  hdr_chunk = curl_slist_append(hdr_chunk, "Expect:");

  /***************************************************************************/
  /* set our custom set of headers.                                         */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, hdr_chunk);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL to use custom headers. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  if( bakup_api_url != NULL )
  {
    hdr_chunk2 = curl_slist_append(hdr_chunk2, "Content-type: application/json");
    hdr_chunk2 = curl_slist_append(hdr_chunk2, "Expect:");
    curl_rc = curl_easy_setopt(curl_handle2,CURLOPT_HTTPHEADER, hdr_chunk2);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
      goto exit_label;
    }
  }



  /***************************************************************************/
  /* Set the timeout for the operation.                                      */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_TIMEOUT,
                             EVEL_API_TIMEOUT);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL for API timeout. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  if( bakup_api_url != NULL )
  {
    curl_rc = curl_easy_setopt(curl_handle2,CURLOPT_TIMEOUT, EVEL_API_TIMEOUT);
    if (curl_rc != CURLE_OK)
    {
      rc = EVEL_CURL_LIBRARY_FAIL;
      log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
      goto exit_label;
    }
  }


  /***************************************************************************/
  /* Set that we want Basic authentication with username:password Base-64    */
  /* encoded for the operation.                                              */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL for Basic Authentication. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_USERNAME, username);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL with username. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_PASSWORD, password);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL with password. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }

  if( bakup_api_url != NULL )
  {
  curl_rc = curl_easy_setopt(curl_handle2, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL for Basic Authentication. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
    goto exit_label;
  }
  curl_rc = curl_easy_setopt(curl_handle2, CURLOPT_USERNAME, username2);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL with username. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
    goto exit_label;
  }
  curl_rc = curl_easy_setopt(curl_handle2, CURLOPT_PASSWORD, password2);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL with password. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
    goto exit_label;
  }

     multi_handle = curl_multi_init();;
     if (multi_handle == NULL)
     {
       rc = EVEL_CURL_LIBRARY_FAIL;
       log_error_state("Failed to get libCURL Multi handle");
       goto exit_label;
     }
     activmode = activitymode;

  }


  /***************************************************************************/
  /* Initialize a message ring-buffer to be used between the foreground and  */
  /* the thread which sends the messages.  This can't fail.                  */
  /***************************************************************************/
  if( ring_buf_size < EVEL_EVENT_BUFFER_DEPTH )
  {
    log_error_state("Warning: Failed to initialize Ring buffer size to %d. ",
                    ring_buf_size);
    goto exit_label;
  }
  ring_buffer_initialize(&event_buffer, EVEL_EVENT_BUFFER_DEPTH);

  /***************************************************************************/
  /* Initialize the priority post buffer to empty.                           */
  /***************************************************************************/
  priority_post.memory = NULL;

exit_label:
  EVEL_EXIT();

  return(rc);
}

/**************************************************************************//**
 * Run the event handler.
 *
 * Spawns the thread responsible for handling events and sending them to the
 * API.
 *
 *  @return Status code.
 *  @retval ::EVEL_SUCCESS if everything OK.
 *  @retval One of ::EVEL_ERR_CODES if there was a problem.
 *****************************************************************************/
EVEL_ERR_CODES event_handler_run()
{
  EVEL_ERR_CODES rc = EVEL_SUCCESS;
  int pthread_rc = 0;

  EVEL_ENTER();

  /***************************************************************************/
  /* Start the event handler thread.                                         */
  /***************************************************************************/
  evt_handler_state = EVT_HANDLER_INACTIVE;
  if( curr_global_handles <= 1 )
      pthread_rc = pthread_create(&evt_handler_thread, NULL, event_handler, NULL);
  else
      pthread_rc = pthread_create(&evt_handler_thread, NULL, event_multi_handler, NULL);

  if (pthread_rc != 0)
  {
    rc = EVEL_PTHREAD_LIBRARY_FAIL;
    log_error_state("Failed to start event handler thread. "
                    "Error code=%d", pthread_rc);
  }

  EVEL_EXIT()
  return rc;
}

/**************************************************************************//**
 * Terminate the event handler.
 *
 * Shuts down the event handler thread in as clean a way as possible. Sets the
 * global exit flag and then signals the thread to interrupt it since it's
 * most likely waiting on the ring-buffer.
 *
 * Having achieved an orderly shutdown of the event handler thread, clean up
 * the cURL library's resources cleanly.
 *
 *  @return Status code.
 *  @retval ::EVEL_SUCCESS if everything OK.
 *  @retval One of ::EVEL_ERR_CODES if there was a problem.
 *****************************************************************************/
EVEL_ERR_CODES event_handler_terminate()
{
  EVEL_ERR_CODES rc = EVEL_SUCCESS;

  EVEL_ENTER();
  EVENT_INTERNAL *event = NULL;

  /***************************************************************************/
  /* Make sure that we were initialized before trying to terminate the       */
  /* event handler thread.                                                   */
  /***************************************************************************/
  if (evt_handler_state != EVT_HANDLER_UNINITIALIZED)
  {
    /*************************************************************************/
    /* Make sure that the event handler knows it's time to die.              */
    /*************************************************************************/
    event = evel_new_internal_event(EVT_CMD_TERMINATE,"EVELinternal","EVELid");
    if (event == NULL)
    {
      /***********************************************************************/
      /* We failed to get an event, but we don't bail out - we will just     */
      /* clean up what we can and continue on our way, since we're exiting   */
      /* anyway.                                                             */
      /***********************************************************************/
      EVEL_ERROR("Failed to get internal event - perform dirty exit instead!");
    }
    else
    {
      /***********************************************************************/
      /* Post the event then wait for the Event Handler to exit.  Set the    */
      /* global command, too, in case the ring-buffer is full.               */
      /***********************************************************************/
      EVEL_DEBUG("Sending event to Event Hander to request it to exit.");
      evt_handler_state = EVT_HANDLER_REQUEST_TERMINATE;
      evel_post_event((EVENT_HEADER *) event);
      pthread_join(evt_handler_thread, NULL);
      EVEL_DEBUG("Event Handler thread has exited.");
    }
  }
  else
  {
    EVEL_DEBUG("Event handler was not initialized, so no need to kill it");
  }

  /***************************************************************************/
  /* Clean-up the cURL library.                                              */
  /***************************************************************************/
  if (multi_handle != NULL)
  {
     curl_multi_cleanup(multi_handle);
  }
  if (curl_handle != NULL)
  {
    curl_easy_cleanup(curl_handle);
    curl_handle = NULL;
  }
  if (curl_handle2 != NULL)
  {
    curl_easy_cleanup(curl_handle2);
    curl_handle2 = NULL;
  }
  if (hdr_chunk != NULL)
  {
    curl_slist_free_all(hdr_chunk);
    hdr_chunk = NULL;
  }
  if (hdr_chunk2 != NULL)
  {
    curl_slist_free_all(hdr_chunk2);
    hdr_chunk2 = NULL;
  }


  /***************************************************************************/
  /* Free off the stored API URL strings.                                    */
  /***************************************************************************/
  if (evel_event_api_url != NULL)
  {
    free(evel_event_api_url);
    evel_event_api_url = NULL;
  }
  if (evel_batch_api_url != NULL)
  {
    free(evel_batch_api_url);
    evel_batch_api_url = NULL;
  }
  if (evel_throt_api_url != NULL)
  {
    free(evel_throt_api_url);
    evel_throt_api_url = NULL;
  }

  EVEL_EXIT();
  return rc;
}

/**************************************************************************//**
 * Post an event.
 *
 * @note  So far as the caller is concerned, successfully posting the event
 * relinquishes all responsibility for the event - the library will take care
 * of freeing the event in due course.

 * @param event   The event to be posted.
 *
 * @returns Status code
 * @retval  EVEL_SUCCESS On success
 * @retval  "One of ::EVEL_ERR_CODES" On failure.
 *****************************************************************************/
EVEL_ERR_CODES evel_post_event(EVENT_HEADER * event)
{
  int rc = EVEL_SUCCESS;

  EVEL_ENTER();

  /***************************************************************************/
  /* Check preconditions.                                                    */
  /***************************************************************************/
  assert(event != NULL);

  /***************************************************************************/
  /* We need to make sure that we are either initializing or running         */
  /* normally before writing the event into the buffer so that we can        */
  /* guarantee that the ring-buffer empties  properly on exit.               */
  /***************************************************************************/
  if ((evt_handler_state == EVT_HANDLER_ACTIVE) ||
      (evt_handler_state == EVT_HANDLER_INACTIVE) ||
      (evt_handler_state == EVT_HANDLER_REQUEST_TERMINATE))
  {
    if (ring_buffer_write(&event_buffer, event) == 0)
    {
      log_error_state("Failed to write event to buffer - event dropped!");
      rc = EVEL_EVENT_BUFFER_FULL;
      evel_free_event(event);
    }
  }
  else
  {
    /*************************************************************************/
    /* System is not in active operation, so reject the event.               */
    /*************************************************************************/
    log_error_state("Event Handler system not active - event dropped!");
    rc = EVEL_EVENT_HANDLER_INACTIVE;
    evel_free_event(event);
  }

  EVEL_EXIT();
  return (rc);
}

/**************************************************************************//**
 * Post an event to the Vendor Event Listener API.
 *
 * @returns Status code
 * @retval  EVEL_SUCCESS On success
 * @retval  "One of ::EVEL_ERR_CODES" On failure.
 *****************************************************************************/
static EVEL_ERR_CODES evel_post_api(char * msg, size_t size)
{
  int rc = EVEL_SUCCESS;
  CURLcode curl_rc = CURLE_OK;
  MEMORY_CHUNK rx_chunk;
  MEMORY_CHUNK tx_chunk;
  int http_response_code = 0;

  EVEL_ENTER();

  /***************************************************************************/
  /* Create the memory chunk to be used for the response to the post.  The   */
  /* will be realloced.                                                      */
  /***************************************************************************/
  rx_chunk.memory = malloc(1);
  assert(rx_chunk.memory != NULL);
  rx_chunk.size = 0;

  /***************************************************************************/
  /* Create the memory chunk to be sent as the body of the post.             */
  /***************************************************************************/
  tx_chunk.memory = msg;
  tx_chunk.size = size;
  EVEL_DEBUG("Sending chunk of size %d", tx_chunk.size);

  /***************************************************************************/
  /* Point to the data to be received.                                       */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, &rx_chunk);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL to upload. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  EVEL_DEBUG("Initialized data to receive");

  /***************************************************************************/
  /* Pointer to pass to our read function                                    */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle, CURLOPT_READDATA, &tx_chunk);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to set upload data for libCURL to upload. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  EVEL_DEBUG("Initialized data to send");

  /***************************************************************************/
  /* Size of the data to transmit.                                           */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(curl_handle,
                             CURLOPT_POSTFIELDSIZE,
                             tx_chunk.size);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to set length of upload data for libCURL to "
                    "upload.  Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  EVEL_DEBUG("Initialized length of data to send");

  /***************************************************************************/
  /* Now run off and do what you've been told!                               */
  /***************************************************************************/
  curl_rc = curl_easy_perform(curl_handle);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to transfer an event to Vendor Event Listener! "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    EVEL_ERROR("Dropped event: %s", msg);
    goto exit_label;
  }

  /***************************************************************************/
  /* See what response we got - any 2XX response is good.                    */
  /***************************************************************************/
  curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &http_response_code);
  EVEL_DEBUG("HTTP response code: %d", http_response_code);
  if ((http_response_code / 100) == 2)
  {
    /*************************************************************************/
    /* If the server responded with data it may be interesting but not a     */
    /* problem.                                                              */
    /*************************************************************************/
    if ((rx_chunk.size > 0) && (rx_chunk.memory != NULL))
    {
      EVEL_DEBUG("Server returned data = %d (%s)",
                 rx_chunk.size,
                 rx_chunk.memory);

      /***********************************************************************/
      /* If this is a response to priority post, then we're not interested.  */
      /***********************************************************************/
      if (priority_post.memory != NULL)
      {
        EVEL_ERROR("Ignoring priority post response");
      }
      else
      {
        evel_handle_event_response(&rx_chunk, &priority_post);
      }
    }
  }
  else
  {
    EVEL_ERROR("Unexpected HTTP response code: %d with data size %d (%s)",
                http_response_code,
                rx_chunk.size,
                rx_chunk.size > 0 ? rx_chunk.memory : "NONE");
    EVEL_ERROR("Potentially dropped event: %s", msg);
  }

exit_label:
  free(rx_chunk.memory);
  EVEL_EXIT();
  return(rc);
}

/**************************************************************************//**
 * Callback function to provide data to send.
 *
 * Copy data into the supplied buffer, read_callback::ptr, checking size
 * limits.
 *
 * @returns   Number of bytes placed into read_callback::ptr. 0 for EOF.
 *****************************************************************************/
static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *userp)
{
  size_t rtn = 0;
  size_t bytes_to_write = 0;
  MEMORY_CHUNK *tx_chunk = (MEMORY_CHUNK *)userp;

  EVEL_ENTER();

  bytes_to_write = min(size*nmemb, tx_chunk->size);

  if (bytes_to_write > 0)
  {
    EVEL_DEBUG("Going to try to write %d bytes", bytes_to_write);
    strncpy((char *)ptr, tx_chunk->memory, bytes_to_write);
    tx_chunk->memory += bytes_to_write;
    tx_chunk->size -= bytes_to_write;
    rtn = bytes_to_write;
  }
  else
  {
    EVEL_DEBUG("Reached EOF");
  }

  EVEL_EXIT();
  return rtn;
}

/**************************************************************************//**
 * Callback function to provide returned data.
 *
 * Copy data into the supplied buffer, write_callback::ptr, checking size
 * limits.
 *
 * @returns   Number of bytes placed into write_callback::ptr. 0 for EOF.
 *****************************************************************************/
size_t evel_write_callback(void *contents,
                             size_t size,
                             size_t nmemb,
                             void *userp)
{
  size_t realsize = size * nmemb;
  MEMORY_CHUNK * rx_chunk = (MEMORY_CHUNK *)userp;

  EVEL_ENTER();

  EVEL_DEBUG("Called with %d chunks of %d size = %d", nmemb, size, realsize);
  EVEL_DEBUG("rx chunk size is %d", rx_chunk->size);

  rx_chunk->memory = realloc(rx_chunk->memory, rx_chunk->size + realsize + 1);
  if(rx_chunk->memory == NULL) {
    /* out of memory! */
    printf("not enough memory (realloc returned NULL)\n");
    return 0;
  }

  memcpy(&(rx_chunk->memory[rx_chunk->size]), contents, realsize);
  rx_chunk->size += realsize;
  rx_chunk->memory[rx_chunk->size] = 0;

  EVEL_DEBUG("Rx data: %s", rx_chunk->memory);
  EVEL_DEBUG("Returning: %d", realsize);

  EVEL_EXIT();
  return realsize;
}


/**************************************************************************//**
 * Post an event to the Vendor Event Listener API.
 *
 * @returns Status code
 * @retval  EVEL_SUCCESS On success
 * @retval  "One of ::EVEL_ERR_CODES" On failure.
 *****************************************************************************/
static EVEL_ERR_CODES evel_postmulti_message(char *msg, size_t size, int *still,
                CURL *handle, CURL *bhandle, int numhandles )
{
  int rc = EVEL_SUCCESS;
  CURLcode curl_rc = CURLE_OK;
  MEMORY_CHUNK rx_chunk[2];
  MEMORY_CHUNK tx_chunk[2];
  int http_response_code = 0, i;

  EVEL_ENTER();

  EVEL_INFO("Sending :%s: %d\n",msg, numhandles);

  /***************************************************************************/
  /* Create the memory chunk to be used for the response to the post.  The   */
  /* will be realloced.                                                      */
  /***************************************************************************/
for (i=0;i<numhandles;i++)
{
  rx_chunk[i].memory = malloc(1);
  assert(rx_chunk[i].memory != NULL);
  rx_chunk[i].size = 0;

  /***************************************************************************/
  /* Create the memory chunk to be sent as the body of the post.             */
  /***************************************************************************/
  tx_chunk[i].memory = msg;
  tx_chunk[i].size = size;
  EVEL_DEBUG("Sending chunk of size %d", tx_chunk[i].size);
}

  /***************************************************************************/
  /* Point to the data to be received.                                       */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(handle, CURLOPT_WRITEDATA, &rx_chunk[0]);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL rx to upload. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }

  /***************************************************************************/
  /* Pointer to pass to our read function                                    */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(handle, CURLOPT_READDATA, &tx_chunk[0]);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to set upload data for libCURL tx to upload. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }
  /***************************************************************************/
  /* Size of the data to transmit.                                           */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(handle,
                             CURLOPT_POSTFIELDSIZE,
                             tx_chunk[0].size);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to set length of upload data for libCURL to "
                    "upload.  Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }

if(numhandles == 2)
{

  /***************************************************************************/
  /* Point to the data to be received.                                       */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(bhandle, CURLOPT_WRITEDATA, &rx_chunk[1]);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to initialize libCURL2 rx to upload. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
    goto exit_label;
  }

  /***************************************************************************/
  /* Pointer to pass to our read function                                    */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(bhandle, CURLOPT_READDATA, &tx_chunk[1]);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to set upload data for libCURL2 tx to upload. "
                    "Error code=%d (%s)", curl_rc, curl_err_string2);
    goto exit_label;
  }
  /***************************************************************************/
  /* Size of the data to transmit.                                           */
  /***************************************************************************/
  curl_rc = curl_easy_setopt(bhandle,
                             CURLOPT_POSTFIELDSIZE,
                             tx_chunk[1].size);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to set length of upload data for libCURL2 to "
                    "upload.  Error code=%d (%s)", curl_rc, curl_err_string);
    goto exit_label;
  }

}

  /***************************************************************************/
  /* Now run off and do what you've been told!                               */
  /***************************************************************************/
  curl_rc = curl_multi_perform(multi_handle, still);
  if (curl_rc != CURLE_OK)
  {
    rc = EVEL_CURL_LIBRARY_FAIL;
    log_error_state("Failed to transfer an multi event to Vendor Event Listener! "
                    "Error code=%d (%s)", curl_rc, curl_multi_strerror(curl_rc
));
    EVEL_ERROR("Dropped event: %s", msg);
    goto exit_label;
  }

  /***************************************************************************/
  /* See what response we got - any 2XX response is good.                    */
  /***************************************************************************/

exit_label:
 for (i=0;i<numhandles;i++)
    free(rx_chunk[i].memory);
  EVEL_EXIT();

  return(rc);
}


/**************************************************************************//**
 * Event Multi Post Handler.
 *
 * Watch for messages coming on the internal queue and send them to the
 * listener.
 *
 * param[in]  jsonmsg  json message to be sent.
 * param[in]  size     size of json message
 * param[in]  currhandle Primary handle
 * param[in]  url1     pimary url
 * param[in]  bakkhandle  Backup handle
 * param[in]  url2     secondary url
 *****************************************************************************/
static int evel_post_multiapi(char *jsonmsg, size_t size,CURL *currhandle, char *url1,
                                   CURL *bakkhandle, char *url2)
{
      int rc = EVEL_SUCCESS;
      CURLcode curl_rc = 0;
      int nhandles = 1;
      int still_running,i;
      CURLMsg *msg; /* for picking up messages with the transfer status */ 
      int msgs_left; /* how many messages are left */

      /***************************************************************************/
      /* Set the URL for the API.                                                */
      /***************************************************************************/
      curl_rc = curl_easy_setopt(currhandle, CURLOPT_URL, url1);
      if (curl_rc != CURLE_OK )
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the multi API URL. "
                    "%s Error code=%d (%s)", url1, curl_rc, curl_err_string);
      }

      if( url2 != NULL && activmode == 1 )
      {
        curl_rc = curl_easy_setopt(bakkhandle, CURLOPT_URL, url2);
        if (curl_rc != CURLE_OK)
        {
           rc = EVEL_CURL_LIBRARY_FAIL;
           log_error_state("Failed to initialize libCURL with the API URL. "
                    "%s Error code=%d (%s)", url2, curl_rc, curl_err_string2);
        }
        nhandles = 2;
      }

      /* we start some action by calling perform right away */
      curl_multi_add_handle(multi_handle, currhandle);
      if(nhandles==2){
        curl_multi_add_handle(multi_handle, bakkhandle);
      }

      /* we start some action by calling perform right away */
      curl_multi_perform(multi_handle, &still_running);

  do {
    struct timeval timeout;
    int rc; /* select() return code */ 
    CURLMcode mc; /* curl_multi_fdset() return code */ 
 
    fd_set fdread;
    fd_set fdwrite;
    fd_set fdexcep;
    int maxfd = -1;
 
    long curl_timeo = -1;
 
    FD_ZERO(&fdread);
    FD_ZERO(&fdwrite);
    FD_ZERO(&fdexcep);
 
    /* set a suitable timeout to play around with */ 
    timeout.tv_sec = 1;
    timeout.tv_usec = 0;
 
    curl_multi_timeout(multi_handle, &curl_timeo);
    if(curl_timeo >= 0) {
      timeout.tv_sec = curl_timeo / 1000;
      if(timeout.tv_sec > 1)
        timeout.tv_sec = 1;
      else
        timeout.tv_usec = (curl_timeo % 1000) * 1000;
    }
 
    /* get file descriptors from the transfers */ 
    mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
 
    if(mc != CURLM_OK) {
      EVEL_ERROR("curl_multi_fdset() failed, code %d.\n", mc);
      break;
    }
 
    /* On success the value of maxfd is guaranteed to be >= -1. We call
       select(maxfd + 1, ...); specially in case of (maxfd == -1) there are
       no fds ready yet so we call select(0, ...) --or Sleep() on Windows--
       to sleep 100ms, which is the minimum suggested value in the
       curl_multi_fdset() doc. */ 
 
    if(maxfd == -1) {
#ifdef _WIN32
      Sleep(100);
      rc = 0;
#else
      /* Portable sleep for platforms other than Windows. */ 
      struct timeval wait = { 0, 300000 }; /* 250ms */ 
      rc = select(0, NULL, NULL, NULL, &wait);
#endif
    }
    else {
      /* Note that on some platforms 'timeout' may be modified by select().
         If you need access to the original value save a copy beforehand. */ 
      rc = select(maxfd + 1, &fdread, &fdwrite, &fdexcep, &timeout);
    }
 
    switch(rc) {
    case -1:
      /* select error */ 
      break;
    case 0: /* timeout */ 
    default: /* action */ 
      //curl_multi_perform(multi_handle, &still_running);
      evel_postmulti_message(jsonmsg, size, &still_running, currhandle, bakkhandle, nhandles);
    }
  } while(still_running);
 
  /* See how the transfers went */ 
  while((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
    if(msg->msg == CURLMSG_DONE) {
      int idx, found = 0;
      EVEL_DEBUG("Transfer status - %s\n", curl_multi_strerror(msg->data.result));

      /* Find out which handle this message is about */ 
      for(idx = 0; idx<nhandles; idx++) {
        if (msg->easy_handle == currhandle) break;
        else if(msg->easy_handle == bakkhandle) break;
      }
 
      switch(idx) {
      case 0:
        curl_rc = msg->data.result;
        break;
      case 1:
        curl_rc = msg->data.result;
        break;
      }
    }
  }

  /* we start some action by calling perform right away */
  curl_multi_remove_handle(multi_handle, currhandle);
  if(nhandles==2){
        curl_multi_remove_handle(multi_handle, bakkhandle);
  }

  EVEL_DEBUG("Transfer completed with status %s\n", curl_multi_strerror(curl_rc));
  if( curl_rc == 0 || curl_rc == 55 )
     return EVEL_SUCCESS;
  else
     return EVEL_CURL_LIBRARY_FAIL;

}
/**************************************************************************//**
 * Event Handler.
 *
 * Watch for messages coming on the internal queue and send them to the
 * listener.
 *
 * param[in]  arg  Argument - unused.
 *****************************************************************************/
static void * event_multi_handler(void * arg __attribute__ ((unused)))
{
  int old_type = 0;
  EVENT_HEADER * msg = NULL;
  EVENT_INTERNAL * internal_msg = NULL;
  int json_size = 0;
  char json_body[EVEL_MAX_JSON_BODY];
  int rc = EVEL_SUCCESS;
  CURLcode curl_rc;
  CURL *currhandler = NULL;
  CURL *bakhandler = NULL;
  char *send_url = NULL;
  char *send_url2 = NULL;

  EVEL_INFO("Event multi handler thread started");

  /***************************************************************************/
  /* Set this thread to be cancellable immediately.                          */
  /***************************************************************************/
  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old_type);

  /***************************************************************************/
  /* Set the handler as active, defending against weird situations like      */
  /* immediately shutting down after initializing the library so the         */
  /* handler never gets started up properly.                                 */
  /***************************************************************************/
  if (evt_handler_state == EVT_HANDLER_INACTIVE)
  {
    evt_handler_state = EVT_HANDLER_ACTIVE;
  }
  else
  {
    EVEL_ERROR("Event Handler State was not INACTIVE at start-up - "
               "Handler will exit immediately!");
  }

  currhandler = curl_handle;
  while (evt_handler_state == EVT_HANDLER_ACTIVE)
  {
    /*************************************************************************/
    /* Wait for a message to be received.                                    */
    /*************************************************************************/
    msg = ring_buffer_read(&event_buffer);

    /*************************************************************************/
    /* Internal events get special treatment while regular events get posted */
    /* to the far side.                                                      */
    /*************************************************************************/
    if (msg->event_domain == EVEL_DOMAIN_BATCH )
    {
      EVEL_DEBUG("Batch event received");

      /***********************************************************************/
      /* Encode the event in JSON.                                           */
      /***********************************************************************/
      json_size = evel_json_encode_batch_event(json_body, EVEL_MAX_JSON_BODY, msg);

      /***************************************************************************/
      /* Set the URL for the API.                                                */
      /***************************************************************************/
      if( currhandler == curl_handle){
         send_url = evel_batch_api_url;
         send_url2 = evel_bbatch_api_url;
         bakhandler = curl_handle2;
      } else if(currhandler == curl_handle2) {
         send_url = evel_bbatch_api_url;
         send_url2 = evel_batch_api_url;
         bakhandler = curl_handle;
      }

      /***********************************************************************/
      /* Send the JSON across the API.                                       */
      /***********************************************************************/
      EVEL_DEBUG("Sending Batch JSON of size %d is: %s", json_size, json_body);
      rc = evel_post_multiapi(json_body, json_size, currhandler, send_url, bakhandler, send_url2);
      if (rc != EVEL_SUCCESS)
      {
        EVEL_ERROR("Failed to transfer the data to %s. Error code=%d", send_url, rc);
        EVEL_INFO("Switched Collector ...");
        if( currhandler == curl_handle){
	  currhandler = curl_handle2;
          bakhandler = curl_handle;
        } else if(currhandler == curl_handle2) {
	  currhandler = curl_handle;
          bakhandler = curl_handle2;
        }
        rc = evel_post_multiapi(json_body, json_size, currhandler, send_url2, bakhandler,send_url);
        if (rc != EVEL_SUCCESS)
           EVEL_ERROR("Failed to transfer the data to failover %s. Error code=%d", send_url2, rc);
      }
    }
    else if (msg->event_domain != EVEL_DOMAIN_INTERNAL )
    {
      EVEL_DEBUG("External event received");

      /***********************************************************************/
      /* Encode the event in JSON.                                           */
      /***********************************************************************/
      json_size = evel_json_encode_event(json_body, EVEL_MAX_JSON_BODY, msg);

      /***************************************************************************/
      /* Set the URL for the API.                                                */
      /***************************************************************************/
      if( currhandler == curl_handle){
         send_url = evel_event_api_url;
         send_url2 = evel_bevent_api_url;
         bakhandler = curl_handle2;
      } else if(currhandler == curl_handle2) {
         send_url = evel_bevent_api_url;
         send_url2 = evel_event_api_url;
         bakhandler = curl_handle;
      }

      /***********************************************************************/
      /* Send the JSON across the API.                                       */
      /***********************************************************************/
      EVEL_DEBUG("Sending Batch JSON of size %d is: %s", json_size, json_body);
      rc = evel_post_multiapi(json_body, json_size, currhandler, send_url, bakhandler, send_url2);
      if (rc != EVEL_SUCCESS)
      {
        EVEL_ERROR("Failed to transfer the data to %s. Error code=%d", send_url, rc);
        EVEL_INFO("Switched Collector ...");
        if( currhandler == curl_handle){
          currhandler = curl_handle2;
          bakhandler = curl_handle;
        } else if(currhandler == curl_handle2) {
          currhandler = curl_handle;
          bakhandler = curl_handle2;
        }
        rc = evel_post_multiapi(json_body, json_size, currhandler, send_url2, bakhandler,send_url);
        if (rc != EVEL_SUCCESS)
           EVEL_ERROR("Failed to transfer the data to failover %s. Error code=%d", send_url2, rc);
      }

    }
    else
    {
      EVEL_DEBUG("Internal event received");
      internal_msg = (EVENT_INTERNAL *) msg;
      assert(internal_msg->command == EVT_CMD_TERMINATE);
      evt_handler_state = EVT_HANDLER_TERMINATING;
    }

    /*************************************************************************/
    /* We are responsible for freeing the memory.                            */
    /*************************************************************************/
    evel_free_event(msg);
    msg = NULL;

    /*************************************************************************/
    /* There may be a single priority post to be sent.                       */
    /*************************************************************************/
    if (priority_post.memory != NULL)
    {
      EVEL_DEBUG("Priority Post");

      /***********************************************************************/
      /* Set the URL for the throttling API.                                 */
      /***********************************************************************/
      curl_rc = curl_easy_setopt(curl_handle, CURLOPT_URL, evel_throt_api_url);
      if (curl_rc != CURLE_OK)
      {
        /*********************************************************************/
        /* This is only likely to happen with CURLE_OUT_OF_MEMORY, in which  */
        /* case we carry on regardless.                                      */
        /*********************************************************************/
        EVEL_ERROR("Failed to set throttling URL. Error code=%d", rc);
      }
      else
      {
        rc = evel_post_api(priority_post.memory, priority_post.size);
        if (rc != EVEL_SUCCESS)
        {
          EVEL_ERROR("Failed to transfer priority post. Error code=%d", rc);
        }
      }

      /***********************************************************************/
      /* Reinstate the URL for the event API.                                */
      /***********************************************************************/
      curl_rc = curl_easy_setopt(curl_handle, CURLOPT_URL, evel_event_api_url);
      if (curl_rc != CURLE_OK)
      {
        /*********************************************************************/
        /* This is only likely to happen with CURLE_OUT_OF_MEMORY, in which  */
        /* case we carry on regardless.                                      */
        /*********************************************************************/
        EVEL_ERROR("Failed to reinstate events URL. Error code=%d", rc);
      }

      /***********************************************************************/
      /* We are responsible for freeing the memory.                          */
      /***********************************************************************/
      free(priority_post.memory);
      priority_post.memory = NULL;
    }
  }

  /***************************************************************************/
  /* The event handler is now exiting. The ring-buffer could contain events  */
  /* which have not been processed, so deplete those.  Because we've been    */
  /* asked to exit we can be confident that the foreground will have stopped */
  /* sending events in so we know that this process will conclude!           */
  /***************************************************************************/
  evt_handler_state = EVT_HANDLER_TERMINATING;
  while (!ring_buffer_is_empty(&event_buffer))
  {
    EVEL_DEBUG("Reading event from buffer");
    msg = ring_buffer_read(&event_buffer);
    evel_free_event(msg);
  }
  evt_handler_state = EVT_HANDLER_TERMINATED;
  EVEL_INFO("Event handler thread stopped");

  return (NULL);
}


/**************************************************************************//**
 * Event Handler.
 *
 * Watch for messages coming on the internal queue and send them to the
 * listener.
 *
 * param[in]  arg  Argument - unused.
 *****************************************************************************/
static void * event_handler(void * arg __attribute__ ((unused)))
{
  int old_type = 0;
  EVENT_HEADER * msg = NULL;
  EVENT_INTERNAL * internal_msg = NULL;
  int json_size = 0;
  char json_body[EVEL_MAX_JSON_BODY];
  int rc = EVEL_SUCCESS;
  CURLcode curl_rc;

  EVEL_INFO("Event handler thread started");

  /***************************************************************************/
  /* Set this thread to be cancellable immediately.                          */
  /***************************************************************************/
  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old_type);

  /***************************************************************************/
  /* Set the handler as active, defending against weird situations like      */
  /* immediately shutting down after initializing the library so the         */
  /* handler never gets started up properly.                                 */
  /***************************************************************************/
  if (evt_handler_state == EVT_HANDLER_INACTIVE)
  {
    evt_handler_state = EVT_HANDLER_ACTIVE;
  }
  else
  {
    EVEL_ERROR("Event Handler State was not INACTIVE at start-up - "
               "Handler will exit immediately!");
  }

  while (evt_handler_state == EVT_HANDLER_ACTIVE)
  {
    /*************************************************************************/
    /* Wait for a message to be received.                                    */
    /*************************************************************************/
    EVEL_DEBUG("Event handler getting any messages");
    msg = ring_buffer_read(&event_buffer);

    /*************************************************************************/
    /* Internal events get special treatment while regular events get posted */
    /* to the far side.                                                      */
    /*************************************************************************/
    if (msg->event_domain == EVEL_DOMAIN_BATCH )
    {
      EVEL_DEBUG("Batch event received");

      /***********************************************************************/
      /* Encode the event in JSON.                                           */
      /***********************************************************************/
      json_size = evel_json_encode_batch_event(json_body, EVEL_MAX_JSON_BODY, msg);

      /***************************************************************************/
      /* Set the URL for the API.                                                */
      /***************************************************************************/
      curl_rc = curl_easy_setopt(curl_handle, CURLOPT_URL, evel_batch_api_url);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the Batch API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
      }

      /***********************************************************************/
      /* Send the JSON across the API.                                       */
      /***********************************************************************/
      EVEL_DEBUG("Sending Batch JSON of size %d is: %s", json_size, json_body);
      rc = evel_post_api(json_body, json_size);
      if (rc != EVEL_SUCCESS)
      {
        EVEL_ERROR("Failed to transfer the data %s. Error code=%d", evel_batch_api_url, rc);
      }
    }
    else if (msg->event_domain != EVEL_DOMAIN_INTERNAL )
    {
      EVEL_DEBUG("External event received");

      /***********************************************************************/
      /* Encode the event in JSON.                                           */
      /***********************************************************************/
      json_size = evel_json_encode_event(json_body, EVEL_MAX_JSON_BODY, msg);

      /***************************************************************************/
      /* Set the URL for the API.                                                */
      /***************************************************************************/
      curl_rc = curl_easy_setopt(curl_handle, CURLOPT_URL, evel_event_api_url);
      if (curl_rc != CURLE_OK)
      {
        rc = EVEL_CURL_LIBRARY_FAIL;
        log_error_state("Failed to initialize libCURL with the API URL. "
                    "Error code=%d (%s)", curl_rc, curl_err_string);
      }

      /***********************************************************************/
      /* Send the JSON across the API.                                       */
      /***********************************************************************/
      EVEL_DEBUG("Sending JSON of size %d is: %s", json_size, json_body);
      rc = evel_post_api(json_body, json_size);
      if (rc != EVEL_SUCCESS)
      {
        EVEL_ERROR("Failed to transfer the data %s. Error code=%d",evel_event_api_url, rc);
      }
    }
    else
    {
      EVEL_DEBUG("Internal event received");
      internal_msg = (EVENT_INTERNAL *) msg;
      assert(internal_msg->command == EVT_CMD_TERMINATE);
      evt_handler_state = EVT_HANDLER_TERMINATING;
    }

    /*************************************************************************/
    /* We are responsible for freeing the memory.                            */
    /*************************************************************************/
    evel_free_event(msg);
    msg = NULL;

    /*************************************************************************/
    /* There may be a single priority post to be sent.                       */
    /*************************************************************************/
    if (priority_post.memory != NULL)
    {
      EVEL_DEBUG("Priority Post");

      /***********************************************************************/
      /* Set the URL for the throttling API.                                 */
      /***********************************************************************/
      curl_rc = curl_easy_setopt(curl_handle, CURLOPT_URL, evel_throt_api_url);
      if (curl_rc != CURLE_OK)
      {
        /*********************************************************************/
        /* This is only likely to happen with CURLE_OUT_OF_MEMORY, in which  */
        /* case we carry on regardless.                                      */
        /*********************************************************************/
        EVEL_ERROR("Failed to set throttling URL. Error code=%d", rc);
      }
      else
      {
        rc = evel_post_api(priority_post.memory, priority_post.size);
        if (rc != EVEL_SUCCESS)
        {
          EVEL_ERROR("Failed to transfer priority post. Error code=%d", rc);
        }
      }

      /***********************************************************************/
      /* Reinstate the URL for the event API.                                */
      /***********************************************************************/
      curl_rc = curl_easy_setopt(curl_handle, CURLOPT_URL, evel_event_api_url);
      if (curl_rc != CURLE_OK)
      {
        /*********************************************************************/
        /* This is only likely to happen with CURLE_OUT_OF_MEMORY, in which  */
        /* case we carry on regardless.                                      */
        /*********************************************************************/
        EVEL_ERROR("Failed to reinstate events URL. Error code=%d", rc);
      }

      /***********************************************************************/
      /* We are responsible for freeing the memory.                          */
      /***********************************************************************/
      free(priority_post.memory);
      priority_post.memory = NULL;
    }
  }

  /***************************************************************************/
  /* The event handler is now exiting. The ring-buffer could contain events  */
  /* which have not been processed, so deplete those.  Because we've been    */
  /* asked to exit we can be confident that the foreground will have stopped */
  /* sending events in so we know that this process will conclude!           */
  /***************************************************************************/
  evt_handler_state = EVT_HANDLER_TERMINATING;
  while (!ring_buffer_is_empty(&event_buffer))
  {
    EVEL_DEBUG("Reading event from buffer");
    msg = ring_buffer_read(&event_buffer);
    evel_free_event(msg);
  }
  evt_handler_state = EVT_HANDLER_TERMINATED;
  EVEL_INFO("Event handler thread stopped");

  return (NULL);
}

/**************************************************************************//**
 * Handle a JSON response from the listener, contained in a ::MEMORY_CHUNK.
 *
 * Tokenize the response, and decode any tokens found.
 *
 * @param chunk         The memory chunk containing the response.
 * @param post          The memory chunk in which to place any resulting POST.
 *****************************************************************************/
void evel_handle_event_response(const MEMORY_CHUNK * const chunk,
                                MEMORY_CHUNK * const post)
{
  jsmn_parser json_parser;
  jsmntok_t json_tokens[EVEL_MAX_RESPONSE_TOKENS];
  int num_tokens = 0;

  EVEL_ENTER();

  /***************************************************************************/
  /* Check preconditions.                                                    */
  /***************************************************************************/
  assert(chunk != NULL);
  assert(priority_post.memory == NULL);

  EVEL_DEBUG("Response size = %d", chunk->size);
  EVEL_DEBUG("Response = %s", chunk->memory);

  /***************************************************************************/
  /* Initialize the parser and tokenize the response.                        */
  /***************************************************************************/
  jsmn_init(&json_parser);
  num_tokens = jsmn_parse(&json_parser,
                          chunk->memory,
                          chunk->size,
                          json_tokens,
                          EVEL_MAX_RESPONSE_TOKENS);

  if (num_tokens < 0)
  {
    EVEL_ERROR("Failed to parse JSON response.  "
               "Error code=%d", num_tokens);
  }
  else if (num_tokens == 0)
  {
    EVEL_DEBUG("No tokens found in JSON response");
  }
  else
  {
    //EVEL_DEBUG("Decode JSON response tokens");
    //if (!evel_handle_response_tokens(chunk, json_tokens, num_tokens, post))
    //{
    //  EVEL_ERROR("Failed to handle JSON response.");
    //}
  }

  EVEL_EXIT();
}

/**************************************************************************//**
 * Handle a JSON response from the listener, as a list of tokens from JSMN.
 *
 * @param chunk         Memory chunk containing the JSON buffer.
 * @param json_tokens   Array of tokens to handle.
 * @param num_tokens    The number of tokens to handle.
 * @param post          The memory chunk in which to place any resulting POST.
 * @return true if we handled the response, false otherwise.
 *****************************************************************************/
bool evel_handle_response_tokens(const MEMORY_CHUNK * const chunk,
                                 const jsmntok_t * const json_tokens,
                                 const int num_tokens,
                                 MEMORY_CHUNK * const post)
{
  bool json_ok = false;

  EVEL_ENTER();

  /***************************************************************************/
  /* Check preconditions.                                                    */
  /***************************************************************************/
  assert(chunk != NULL);
  assert(json_tokens != NULL);
  assert(num_tokens < EVEL_MAX_RESPONSE_TOKENS);

  /***************************************************************************/
  /* Peek at the tokens to decide what the response it, then call the        */
  /* appropriate handler to handle it.  There is only one handler at this    */
  /* point.                                                                  */
  /***************************************************************************/
  if (evel_tokens_match_command_list(chunk, json_tokens, num_tokens))
  {
    json_ok = evel_handle_command_list(chunk, json_tokens, num_tokens, post);
  }

  EVEL_EXIT();

  return json_ok;
}

/**************************************************************************//**
 * Determine whether a list of tokens looks like a "commandList" response.
 *
 * @param chunk         Memory chunk containing the JSON buffer.
 * @param json_tokens   Token to check.
 * @param num_tokens    The number of tokens to handle.
 * @return true if the tokens look like a "commandList" match, or false.
 *****************************************************************************/
bool evel_tokens_match_command_list(const MEMORY_CHUNK * const chunk,
                                    const jsmntok_t * const json_tokens,
                                    const int num_tokens)
{
  bool result = false;

  EVEL_ENTER();

  /***************************************************************************/
  /* Make some checks on the basic layout of the commandList.                */
  /***************************************************************************/
  if ((num_tokens > 3) &&
      (json_tokens[0].type == JSMN_OBJECT) &&
      (json_tokens[1].type == JSMN_STRING) &&
      (json_tokens[2].type == JSMN_ARRAY) &&
      (evel_token_equals_string(chunk, &json_tokens[1], "commandList")))
  {
    result = true;
  }

  EVEL_EXIT();

  return result;
}

/**************************************************************************//**
 * Check that a string token matches a given input string.
 *
 * @param chunk         Memory chunk containing the JSON buffer.
 * @param json_token    Token to check.
 * @param check_string  String to check it against.
 * @return true if the strings match, or false.
 *****************************************************************************/
bool evel_token_equals_string(const MEMORY_CHUNK * const chunk,
                              const jsmntok_t * json_token,
                              const char * check_string)
{
  bool result = false;

  EVEL_ENTER();

  const int token_length = json_token->end - json_token->start;
  const char * const token_string = chunk->memory + json_token->start;

  if (token_length == (int)strlen(check_string))
  {
    result = (strncmp(token_string, check_string, token_length) == 0);
  }

  EVEL_EXIT();

  return result;
}