Merge pull request #289 from bill1600/camera

fix mutex error in service alive
2026-01-27 18:20:04 +00:00 · 2019-03-17 19:30:34 -07:00 · 2019-03-17 16:57:20 -07:00 · 2019-03-05 15:50:51 -08:00 · 2019-03-04 15:48:41 -08:00 · 2019-03-04 15:28:00 -08:00
43 changed files with 1541 additions and 452 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -26,7 +26,7 @@ install:
 script:
    - mkdir build
    - cd build
-    - cmake .. -DINTEGRATION_TESTING:BOOL=false -DDISABLE_VALGRIND:BOOL=true -DENABLE_SESHAT:BOOL=true -DFEATURE_DNS_QUERY:BOOL=true
+    - cmake .. -DINTEGRATION_TESTING:BOOL=false -DDISABLE_VALGRIND:BOOL=false -DENABLE_SESHAT:BOOL=true -DFEATURE_DNS_QUERY:BOOL=true
    - make
    - export ARGS="-V"
    - make test
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).

 ## [Unreleased]
+- Security: Added support to use auth token during initial connect to cloud
+
+## [1.0.2] - 2019-02-08
 - Refactored connection.c and updated corresponding unit tests
 - Additional `/cloud-status` and `/cloud-disconnect` fields.
 - Switched from nanomsg (Release 1.1.2) to NNG (Release v1.0.1)
@@ -17,6 +20,19 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - added NULL check for device mac id in upstream retrieve message handling
 - backoff retry to include find_servers in loop (connection.c)
 - backoff max is max count not max delay
+- used mutex protection to make client list and nn_sends thread safe
+- put mutex lock into get_global_node
+- change svc alive from a thread to a function called every 30 sec from main
+- shut down tasks properly
+- fix memory leaks
+- Fixed memory leak in upstream event message flow
+- Fixed crash in CRUD request processing
+- Fixed issue on RETRIEVE respone processing
+- Enabled valgrind
+- Fixed main loop to keep calling svc_alive_task during a cloud disconnect and retry
+- change svc alive back to a separate thread.  Shut it down with pthread_cond_timedwait
+- Refactored Upsteam RETRIEVE flow
+- Fix re-registration to call nn_shutdown and nn_close, so we don't lose a socket.

 ## [1.0.1] - 2018-07-18
 ### Added
@@ -49,6 +65,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Initial creation

 [Unreleased]: https://github.com/Comcast/parodus/compare/1.0.1...HEAD
+[1.0.2]: https://github.com/Comcast/parodus/compare/1.0.1...1.0.2
 [1.0.1]: https://github.com/Comcast/parodus/compare/1.0.0...1.0.1
 [1.0.0]: https://github.com/Comcast/parodus/compare/79fa7438de2b14ae64f869d52f5c127497bf9c3f...1.0.0

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,6 +34,7 @@ include_directories(${INCLUDE_DIR}
                    ${INCLUDE_DIR}/cjson
                    ${INCLUDE_DIR}/nopoll
                    ${INCLUDE_DIR}/msgpack
+	            ${INCLUDE_DIR}/curl
                    ${INCLUDE_DIR}/trower-base64
                    ${INCLUDE_DIR}/wrp-c                   
                    ${INCLUDE_DIR}/libparodus
@@ -134,6 +135,18 @@ add_library(libmsgpack STATIC SHARED IMPORTED)
 add_dependencies(libmsgpack msgpack)


+# curl external dependency
+#-------------------------------------------------------------------------------
+ExternalProject_Add(curl
+    PREFIX ${CMAKE_CURRENT_BINARY_DIR}/_prefix/curl
+    GIT_REPOSITORY https://github.com/curl/curl.git
+    GIT_TAG "curl-7_63_0"
+    CMAKE_ARGS += -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -DBUILD_TESTING=OFF
+)
+add_library(libcurl STATIC SHARED IMPORTED)
+add_dependencies(libcurl curl)
+
+
 # cimplog external dependency
 #-------------------------------------------------------------------------------
 ExternalProject_Add(cimplog
@@ -191,7 +204,8 @@ endif (ENABLE_SESHAT)
 ExternalProject_Add(cjwt
    PREFIX ${CMAKE_CURRENT_BINARY_DIR}/_prefix/cjwt
    GIT_REPOSITORY https://github.com/Comcast/cjwt.git
-    GIT_TAG "1.0.1"
+    GIT_TAG "1b023c41bb2d6dbbf493c202ed81f06c84d5b51b"
+    #GIT_TAG "1.0.1"
    CMAKE_ARGS += -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -DBUILD_TESTING=OFF
 )
 add_library(libcjwt STATIC SHARED IMPORTED)
--- a/README.md
+++ b/README.md
@@ -55,9 +55,9 @@ make test

 - /force-ipv6 -Forcefully connect parodus to ipv6 address (optional argument)

- /token-read-script -Script to get auth token for establishing secure connection (absolute path where that script is present) -optional argument
+- /client-cert-path -MTLS client cert location to request auth token for establishing secure connection [absolute path where client cert is present] (optional argument)

- /token-acquisition-script -Script to create new auth token for establishing secure connection (absolute path where that script is present) -optional argument 
+- /token-server-url -complete server url with API path to request new auth token for establishing secure connection (optional argument)

 - /crud-config-file -Config json file to store objects during create, retrieve, update and delete (CRUD) operations -optional argument 

@@ -82,17 +82,17 @@ make test
 ```
 # Seshat & FEATURE_DNS_QUERY Enabled

-./parodus --hw-model=TGXXX --hw-serial-number=E8GBUEXXXXXXXXX --hw-manufacturer=ARRIS --hw-mac=14cfexxxxxxx --hw-last-reboot-reason=unknown --fw-name=TG1682_DEV_master_20170512115046sdy --boot-time=1494590301 --webpa-ping-timeout=180 --webpa-interface-used=eth0 --webpa-url=somebody.net:8080 --webpa-backoff-max=9 --parodus-local-url=tcp://127.0.0.1:6666 --partner-id=comcast --ssl-cert-path=/etc/ssl/certs/ca-certificates.crt --acquire-jwt=1 --dns-txt-url=somebody.net --jwt-public-key-file=webpa-rs256.pem --jwt-algo=RS256 --seshat-url=tcp://127.0.0.1:7777 --token-read-script=/usr/ccsp/parodus/parodus_token1.sh --token-acquisition-script=/usr/ccsp/parodus/parodus_token2.sh --force-ipv4 --crud-config-file=/tmp/parodus_cfg.json
+./parodus --hw-model=TGXXX --hw-serial-number=E8GBUEXXXXXXXXX --hw-manufacturer=ARRIS --hw-mac=14cfexxxxxxx --hw-last-reboot-reason=unknown --fw-name=TG1682_DEV_master_20170512115046sdy --boot-time=1494590301 --webpa-ping-timeout=180 --webpa-interface-used=eth0 --webpa-url=https://somebody.net:8080 --webpa-backoff-max=9 --parodus-local-url=tcp://127.0.0.1:6666 --partner-id=comcast --ssl-cert-path=/etc/ssl/certs/ca-certificates.crt --acquire-jwt=1 --dns-txt-url=somebody.net --jwt-public-key-file=webpa-rs256.pem --jwt-algo=RS256 --seshat-url=tcp://127.0.0.1:7777 --client-cert-path=/tmp/clientcert.mch --token-server-url=https://somebody.net:8080/token --force-ipv4 --crud-config-file=/tmp/parodus_cfg.json


 # Seshat is not enabled

-./parodus --hw-model=TGXXX --hw-serial-number=E8GBUEXXXXXXXXX --hw-manufacturer=ARRIS --hw-mac=14cfexxxxxxx --hw-last-reboot-reason=unknown --fw-name=TG1682_DEV_master_20170512115046sdy --boot-time=1494590301 --webpa-ping-timeout=180 --webpa-interface-used=eth0 --webpa-url=somebody.net:8080 --webpa-backoff-max=9 --parodus-local-url=tcp://127.0.0.1:6666 --partner-id=comcast --ssl-cert-path=/etc/ssl/certs/ca-certificates.crt --acquire-jwt=1 --dns-txt-url=somebody.net --jwt-public-key-file=webpa-rs256.pem --jwt-algo=RS256 --token-read-script=/usr/ccsp/parodus/parodus_token1.sh --token-acquisition-script=/usr/ccsp/parodus/parodus_token2.sh --force-ipv4 --crud-config-file=/tmp/parodus_cfg.json
+./parodus --hw-model=TGXXX --hw-serial-number=E8GBUEXXXXXXXXX --hw-manufacturer=ARRIS --hw-mac=14cfexxxxxxx --hw-last-reboot-reason=unknown --fw-name=TG1682_DEV_master_20170512115046sdy --boot-time=1494590301 --webpa-ping-timeout=180 --webpa-interface-used=eth0 --webpa-url=https://somebody.net:8080 --webpa-backoff-max=9 --parodus-local-url=tcp://127.0.0.1:6666 --partner-id=comcast --ssl-cert-path=/etc/ssl/certs/ca-certificates.crt --acquire-jwt=1 --dns-txt-url=somebody.net --jwt-public-key-file=webpa-rs256.pem --jwt-algo=RS256 --client-cert-path=/tmp/clientcert.mch --token-server-url=https://somebody.net:8080/token --force-ipv4 --crud-config-file=/tmp/parodus_cfg.json


 # When both Seshat & FEATURE_DNS_QUERY not Enabled

-./parodus --hw-model=TGXXX --hw-serial-number=E8GBUEXXXXXXXXX --hw-manufacturer=ARRIS --hw-mac=14cfexxxxxxx --hw-last-reboot-reason=unknown --fw-name=TG1682_DEV_master_20170512115046sdy --boot-time=1494590301 --webpa-ping-timeout=180 --webpa-interface-used=eth0 --webpa-url=somebody.net:8080 --webpa-backoff-max=9 --parodus-local-url=tcp://127.0.0.1:6666 --partner-id=comcast --ssl-cert-path=/etc/ssl/certs/ca-certificates.crt --token-read-script=/usr/ccsp/parodus/parodus_token1.sh --token-acquisition-script=/usr/ccsp/parodus/parodus_token2.sh --force-ipv4 --crud-config-file=/tmp/parodus_cfg.json
+./parodus --hw-model=TGXXX --hw-serial-number=E8GBUEXXXXXXXXX --hw-manufacturer=ARRIS --hw-mac=14cfexxxxxxx --hw-last-reboot-reason=unknown --fw-name=TG1682_DEV_master_20170512115046sdy --boot-time=1494590301 --webpa-ping-timeout=180 --webpa-interface-used=eth0 --webpa-url=https://somebody.net:8080 --webpa-backoff-max=9 --parodus-local-url=tcp://127.0.0.1:6666 --partner-id=comcast --ssl-cert-path=/etc/ssl/certs/ca-certificates.crt --client-cert-path=/tmp/clientcert.mch --token-server-url=https://somebody.net:8080/token --force-ipv4 --crud-config-file=/tmp/parodus_cfg.json

 ```

--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -15,7 +15,7 @@ set(SOURCES main.c mutex.c networking.c nopoll_helpers.c heartBeat.c nopoll_hand
    ParodusInternal.c string_helpers.c time.c config.c conn_interface.c
    connection.c spin_thread.c client_list.c service_alive.c
    upstream.c downstream.c thread_tasks.c partners_check.c token.c 
-	crud_interface.c crud_tasks.c crud_internal.c close_retry.c)
+	crud_interface.c crud_tasks.c crud_internal.c close_retry.c auth_token.c)

 if (ENABLE_SESHAT)
 set(SOURCES ${SOURCES} seshat_interface.c)
@@ -30,6 +30,7 @@ target_link_libraries (parodus
    ${CMAKE_THREAD_LIBS_INIT}
    -lwrp-c
    -lmsgpackc
+    -lcurl
    -ltrower-base64
    -lnopoll
    -luuid
--- a/src/ParodusInternal.h
+++ b/src/ParodusInternal.h
@@ -50,7 +50,8 @@
 /*                                   Macros                                   */
 /*----------------------------------------------------------------------------*/
 #define UNUSED(x) (void )(x)
-#define NANOMSG_SOCKET_TIMEOUT_MSEC                      2000
+#define NANO_SOCKET_SEND_TIMEOUT_MS                     2000
+#define NANO_SOCKET_RCV_TIMEOUT_MS			500

 #ifndef TEST
 #define FOREVER()   1
@@ -133,6 +134,7 @@ typedef struct {
 /*----------------------------------------------------------------------------*/
 /*                            File Scoped Variables                           */
 /*----------------------------------------------------------------------------*/
+extern bool g_shutdown;
 extern ParodusMsg *ParodusMsgQ;
 int numLoops;
 /*----------------------------------------------------------------------------*/
--- a/src/auth_token.c
+++ b/src/auth_token.c
@@ -0,0 +1,319 @@
+/**
+ * Copyright 2015 Comcast Cable Communications Management, LLC
+ *
+ * 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.
+ *
+ */
+/**
+ * @file auth_token.c
+ *
+ * @description This file is to fetch authorization token during parodus cloud connection.
+ *
+ */
+
+#include <stdio.h>
+#include <fcntl.h> 
+#include "config.h"
+#include "auth_token.h"
+#include "ParodusInternal.h"
+#include <cjwt/cjwt.h>
+#include <stdlib.h>
+#include <curl/curl.h>
+#include <uuid/uuid.h>
+
+#define MAX_BUF_SIZE	        128
+#define CURL_TIMEOUT_SEC	25L
+#define MAX_CURL_RETRY_COUNT 	3
+/*----------------------------------------------------------------------------*/
+/*                            File Scoped Variables                           */
+/*----------------------------------------------------------------------------*/
+void createCurlheader(char *mac_header, char *serial_header, char *uuid_header, char *transaction_uuid, struct curl_slist *list, struct curl_slist **header_list);
+/*----------------------------------------------------------------------------*/
+/*                             External Functions                             */
+/*----------------------------------------------------------------------------*/
+/*
+* @brief Initialize curl object with required options. create newToken using libcurl.
+* @param[out] newToken auth token string obtained from JWT curl response
+* @param[in] len total token size
+* @param[in] r_count Number of curl retries on ipv4 and ipv6 mode during failure
+* @return returns 0 if success, otherwise failed to fetch auth token and will be retried.
+*/
+
+int requestNewAuthToken(char *newToken, size_t len, int r_count)
+{
+	CURL *curl;
+	CURLcode res;
+	CURLcode time_res;
+	struct curl_slist *list = NULL;
+	struct curl_slist *headers_list = NULL;
+
+	char *mac_header = NULL;
+	char *serial_header = NULL;
+	char *uuid_header = NULL;
+	char *transaction_uuid = NULL;
+	double total;
+	long response_code;
+
+	struct token_data data;
+	data.size = 0;
+
+	curl = curl_easy_init();
+	if(curl)
+	{
+		//this memory will be dynamically grown by write call back fn as required
+		data.data = (char *) malloc(sizeof(char) * 1);
+		if(NULL == data.data)
+		{
+			ParodusError("Failed to allocate memory.\n");
+			return -1;
+		}
+		data.data[0] = '\0';
+
+		createCurlheader(mac_header, serial_header, uuid_header, transaction_uuid, list, &headers_list);
+
+		curl_easy_setopt(curl, CURLOPT_URL, get_parodus_cfg()->token_server_url);
+		curl_easy_setopt(curl, CURLOPT_TIMEOUT, CURL_TIMEOUT_SEC);
+
+		if(get_parodus_cfg()->webpa_interface_used !=NULL && strlen(get_parodus_cfg()->webpa_interface_used) >0)
+		{
+			curl_easy_setopt(curl, CURLOPT_INTERFACE, get_parodus_cfg()->webpa_interface_used);
+		}
+		/* set callback for writing received data */
+		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback_fn);
+		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
+
+		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers_list);
+
+		/* setting curl resolve option as default mode.
+		If any failure, retry with v4 first and then v6 mode. */
+
+		if(r_count == 1)
+		{
+			ParodusInfo("curl Ip resolve option set as V4 mode\n");
+			curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+		}
+		else if(r_count == 2)
+		{
+			ParodusInfo("curl Ip resolve option set as V6 mode\n");
+			curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
+		}
+		else
+		{
+			ParodusInfo("curl Ip resolve option set as default mode\n");
+			curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER);
+		}
+
+		/* set the cert for client authentication */
+		curl_easy_setopt(curl, CURLOPT_SSLCERT, get_parodus_cfg()->client_cert_path);
+
+		curl_easy_setopt(curl, CURLOPT_CAINFO, get_parodus_cfg()->cert_path);
+
+		/* disconnect if it is failed to validate server's cert */
+		curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
+
+		/* Perform the request, res will get the return code */
+		res = curl_easy_perform(curl);
+
+		curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+		ParodusInfo("themis curl response %d http_code %d\n", res, response_code);
+
+		time_res = curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME, &total);
+		if(time_res == 0)
+		{
+			ParodusInfo("curl response Time: %.1f seconds\n", total);
+		}
+		curl_slist_free_all(headers_list);
+		if(res != 0)
+		{
+			ParodusError("curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
+			curl_easy_cleanup(curl);
+			if(data.data)
+			{
+				free(data.data);
+				data.data = NULL;
+			}
+			return -1;
+		}
+		else
+		{
+			if(response_code == 200)
+			{
+				ParodusInfo("cURL success\n");
+				strncpy(newToken, data.data, len);
+			}
+		}
+		if(data.data)
+		{
+			free(data.data);
+			data.data = NULL;
+		}
+		curl_easy_cleanup(curl);
+	}
+	else
+	{
+		ParodusError("curl init failure\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+* @brief Fetches authorization token and update to parodus config.
+  This will do curl retry in case of any failure till it reaches max curl retry count.
+ * @param[in] cfg Global parodus config structure to update webpa_auth_token
+*/
+
+void getAuthToken(ParodusCfg *cfg)
+{
+	int status = -1;
+	int retry_count = 0;
+
+	if( cfg->hw_mac != NULL && strlen(cfg->hw_mac) !=0 )
+	{
+		if( cfg->client_cert_path !=NULL && strlen(cfg->client_cert_path) !=0 )
+		{
+			while(1)
+			{
+				//Fetch new auth token using libcurl
+				status = requestNewAuthToken(cfg->webpa_auth_token, sizeof(cfg->webpa_auth_token), retry_count);
+				if(status == 0)
+				{
+					ParodusInfo("cfg->webpa_auth_token created successfully\n");
+					break;
+				}
+				else
+				{
+					ParodusError("Failed to create new token\n");
+					retry_count++;
+					ParodusError("Curl execution is failed, retry attempt: %d\n", retry_count);
+				}
+
+				if(retry_count == MAX_CURL_RETRY_COUNT)
+				{
+					ParodusError("Curl retry is reached to max %d attempts, proceeding without token\n", retry_count);
+					break;
+				}
+			}
+		}
+		else
+		{
+			ParodusError("client_cert_path is NULL, failed to fetch auth token\n");
+		}
+	}
+	else
+	{
+		ParodusError("hw_mac is NULL, failed to fetch auth token\n");
+	}
+}
+
+/* @brief callback function for writing libcurl received data
+ * @param[in] buffer curl delivered data which need to be saved.
+ * @param[in] size size is always 1
+ * @param[in] nmemb size of delivered data
+ * @param[out] data curl response data saved.
+*/
+size_t write_callback_fn(void *buffer, size_t size, size_t nmemb, struct token_data *data)
+{
+    size_t index = data->size;
+    size_t n = (size * nmemb);
+    char* tmp;
+
+    data->size += (size * nmemb);
+
+    tmp = realloc(data->data, data->size + 1); /* +1 for '\0' */
+
+    if(tmp) {
+        data->data = tmp;
+    } else {
+        if(data->data) {
+            free(data->data);
+        }
+        ParodusError("Failed to allocate memory for data\n");
+        return 0;
+    }
+
+    memcpy((data->data + index), buffer, n);
+    data->data[data->size] = '\0';
+
+    return size * nmemb;
+}
+
+/* @brief function to generate random uuid.
+*/
+char* generate_trans_uuid()
+{
+	char *transID = NULL;
+	uuid_t transaction_Id;
+	char *trans_id = NULL;
+	trans_id = (char *)malloc(37);
+	uuid_generate_random(transaction_Id);
+	uuid_unparse(transaction_Id, trans_id);
+
+	if(trans_id !=NULL)
+	{
+		transID = trans_id;
+	}
+	return transID;
+}
+
+/* @brief function to create curl header contains mac, serial number and uuid.
+ * @param[in] mac_header mac address header key value pair
+ * @param[in] serial_header serial number key value pair
+ * @param[in] uuid_header transaction uuid key value pair
+ * @param[in] list temp curl header list
+ * @param[out] header_list output curl header list
+*/
+void createCurlheader(char *mac_header, char *serial_header, char *uuid_header, char *transaction_uuid, struct curl_slist *list, struct curl_slist **header_list)
+{
+	mac_header = (char *) malloc(sizeof(char)*MAX_BUF_SIZE);
+	if(mac_header !=NULL)
+	{
+		snprintf(mac_header, MAX_BUF_SIZE, "X-Midt-Mac-Address: %s", get_parodus_cfg()->hw_mac);
+		ParodusPrint("mac_header formed %s\n", mac_header);
+		list = curl_slist_append(list, mac_header);
+		free(mac_header);
+		mac_header = NULL;
+	}
+
+	serial_header = (char *) malloc(sizeof(char)*MAX_BUF_SIZE);
+	if(serial_header !=NULL)
+	{
+		snprintf(serial_header, MAX_BUF_SIZE, "X-Midt-Serial-Number: %s", get_parodus_cfg()->hw_serial_number);
+		ParodusPrint("serial_header formed %s\n", serial_header);
+		list = curl_slist_append(list, serial_header);
+		free(serial_header);
+		serial_header = NULL;
+	}
+
+	transaction_uuid = generate_trans_uuid();
+	if(transaction_uuid !=NULL)
+	{
+		uuid_header = (char *) malloc(sizeof(char)*MAX_BUF_SIZE);
+		if(uuid_header !=NULL)
+		{
+			snprintf(uuid_header, MAX_BUF_SIZE, "X-Midt-Uuid: %s", transaction_uuid);
+			ParodusInfo("uuid_header formed %s\n", uuid_header);
+			list = curl_slist_append(list, uuid_header);
+			free(transaction_uuid);
+			transaction_uuid = NULL;
+			free(uuid_header);
+			uuid_header = NULL;
+		}
+	}
+	else
+	{
+		ParodusError("Failed to generate transaction_uuid\n");
+	}
+	*header_list = list;
+}
--- a/src/auth_token.h
+++ b/src/auth_token.h
@@ -0,0 +1,57 @@
+/**
+ * Copyright 2015 Comcast Cable Communications Management, LLC
+ *
+ * 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.
+ *
+ */
+/**
+ * @file auth_token.h
+ *
+ * @description This file is to fetch authorization token during parodus cloud connection.
+ *
+ */
+ 
+#ifndef _AUTH_TOKEN_H_ 
+#define _AUTH_TOKEN_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*----------------------------------------------------------------------------*/
+/*                                   Macros                                   */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+/*                               Data Structures                              */
+/*----------------------------------------------------------------------------*/
+
+struct token_data {
+    size_t size;
+    char* data;
+};
+
+/*----------------------------------------------------------------------------*/
+/*                             Function Prototypes                            */
+/*----------------------------------------------------------------------------*/
+
+int requestNewAuthToken(char *newToken, size_t len, int r_count);
+void getAuthToken(ParodusCfg *cfg);
+size_t write_callback_fn(void *buffer, size_t size, size_t nmemb, struct token_data *data);
+char* generate_trans_uuid();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/src/client_list.c
+++ b/src/client_list.c
@@ -30,6 +30,7 @@
 /*----------------------------------------------------------------------------*/
 static int numOfClients = 0;
 static reg_list_item_t * g_head = NULL;
+pthread_mutex_t client_mut=PTHREAD_MUTEX_INITIALIZER;

 /*----------------------------------------------------------------------------*/
 /*                             External functions                             */
@@ -37,9 +38,16 @@ static reg_list_item_t * g_head = NULL;

 reg_list_item_t * get_global_node(void)
 {
+    pthread_mutex_lock (&client_mut);
    return g_head;
 }

+void release_global_node (void)
+{
+    pthread_mutex_unlock (&client_mut);
+}
+
+
 int get_numOfClients()
 {
    return numOfClients;
@@ -52,11 +60,12 @@ int addToList( wrp_msg_t **msg)
    int rc = -1;
    int sock;
    int retStatus = -1;
+
    sock = nn_socket( AF_SP, NN_PUSH );
    ParodusPrint("sock created for adding entries to list: %d\n", sock);
    if(sock >= 0)
    {
-            int t = NANOMSG_SOCKET_TIMEOUT_MSEC;
+            int t = NANO_SOCKET_SEND_TIMEOUT_MS;
            rc = nn_setsockopt(sock, NN_SOL_SOCKET, NN_SNDTIMEO, &t, sizeof(t));
            if(rc < 0)
            {
@@ -214,7 +223,7 @@ int deleteFromList(char* service_name)
 			curr_node = NULL;
 			ParodusInfo("Deleted successfully and returning..\n");
 			numOfClients =numOfClients - 1;
-			ParodusPrint("numOfClients after delte is %d\n", numOfClients);
+			ParodusPrint("numOfClients after delete is %d\n", numOfClients);
 			return 0;
 		}
 		
@@ -225,6 +234,22 @@ int deleteFromList(char* service_name)
 	return -1;
 }

+void deleteAllClients (void)
+{
+  reg_list_item_t *next_node = NULL;
+
+  while (NULL != g_head)
+  {
+    next_node = g_head->next;
+    free (g_head);
+    g_head = next_node;
+  }
+  if (numOfClients > 0) {
+    ParodusInfo ("Deleted %d clients\n", numOfClients);
+    numOfClients = 0;
+  }
+}
+
 /*
 *@dest : Client destination to send message
 *@Msg:	Msg to send it to client (No free done here), user responsibilites to free the msg
@@ -243,6 +268,7 @@ int sendMsgtoRegisteredClients(char *dest,const char **Msg,size_t msgSize)
 		if( strcmp(dest, temp->service_name) == 0)
 		{
 			bytes = nn_send(temp->sock, *Msg, msgSize, 0);
+			release_global_node ();
 			ParodusInfo("sent downstream message to reg_client '%s'\n", temp->url);
 			ParodusPrint("downstream bytes sent:%d\n", bytes);
 			return 1;
@@ -250,5 +276,6 @@ int sendMsgtoRegisteredClients(char *dest,const char **Msg,size_t msgSize)
 		ParodusPrint("checking the next item in the list\n");
 		temp= temp->next;
 	}
+	release_global_node ();
 	return 0;
 }
--- a/src/client_list.h
+++ b/src/client_list.h
@@ -50,9 +50,11 @@ int sendAuthStatus(reg_list_item_t *new_node);

 int deleteFromList(char* service_name);
 int get_numOfClients();
+void deleteAllClients (void);
 int sendMsgtoRegisteredClients(char *dest,const char **Msg,size_t msgSize);

 reg_list_item_t * get_global_node(void);
+void release_global_node (void);

 #ifdef __cplusplus
 }
--- a/src/config.c
+++ b/src/config.c
@@ -26,8 +26,9 @@
 #include "config.h"
 #include "ParodusInternal.h"
 #include <cjwt/cjwt.h>
-
-#define MAX_BUF_SIZE	128
+#include <stdlib.h>
+#include <curl/curl.h>
+#include <uuid/uuid.h>

 /*----------------------------------------------------------------------------*/
 /*                            File Scoped Variables                           */
@@ -36,7 +37,6 @@
 static ParodusCfg parodusCfg;
 static unsigned int rsa_algorithms = 
 	(1<<alg_rs256) | (1<<alg_rs384) | (1<<alg_rs512);
-
 /*----------------------------------------------------------------------------*/
 /*                             External Functions                             */
 /*----------------------------------------------------------------------------*/
@@ -141,31 +141,6 @@ void read_key_from_file (const char *fname, char *buf, size_t buflen)
  ParodusInfo ("%d bytes read\n", nbytes);
 }

-void execute_token_script(char *token, char *name, size_t len, char *mac, char *serNum)
-{
-    FILE* out = NULL, *file = NULL;
-    char command[MAX_BUF_SIZE] = {'\0'};
-    if(strlen(name)>0)
-    {
-        file = fopen(name, "r");
-        if(file)
-        {
-            snprintf(command,sizeof(command),"%s %s %s",name,serNum,mac);
-            out = popen(command, "r");
-            if(out)
-            {
-                fgets(token, len, out);
-                pclose(out);
-            }
-            fclose(file);
-        }
-        else
-        {
-            ParodusError ("File %s open error\n", name);
-        }
-    }
-}
-
 // strips ':' characters
 // verifies that there exactly 12 characters
 int parse_mac_address (char *target, const char *arg)
@@ -386,9 +361,9 @@ int parseCommandLine(int argc,char **argv,ParodusCfg * cfg)
        {"ssl-cert-path",           required_argument, 0, 'c'},
        {"force-ipv4",              no_argument,       0, '4'},
        {"force-ipv6",              no_argument,       0, '6'},
-        {"token-read-script",       required_argument, 0, 'T'},
        {"boot-time-retry-wait",    required_argument, 0, 'w'},
-	{"token-acquisition-script",     required_argument, 0, 'J'},
+	{"client-cert-path",        required_argument, 0, 'P'},
+	{"token-server-url",        required_argument, 0, 'U'},
 	{"crud-config-file",        required_argument, 0, 'C'},
        {0, 0, 0, 0}
    };
@@ -405,6 +380,8 @@ int parseCommandLine(int argc,char **argv,ParodusCfg * cfg)
 	cfg->jwt_algo = 0;
 	parStrncpy (cfg->jwt_key, "", sizeof(cfg->jwt_key));
 	cfg->crud_config_file = NULL;
+	cfg->client_cert_path = NULL;
+	cfg->token_server_url = NULL;
 	cfg->cloud_status = NULL;
 	cfg->cloud_disconnect = NULL;
 	optind = 1;  /* We need this if parseCommandLine is called again */
@@ -546,14 +523,6 @@ int parseCommandLine(int argc,char **argv,ParodusCfg * cfg)
          cfg->flags |= FLAGS_IPV6_ONLY;
          break;

-        case 'J':
-          parStrncpy(cfg->token_acquisition_script, optarg,sizeof(cfg->token_acquisition_script));
-          break;
-        
-        case 'T':
-          parStrncpy(cfg->token_read_script, optarg,sizeof(cfg->token_read_script));
-          break;
-
        case 'w':
          cfg->boot_retry_wait = parse_num_arg (optarg, "boot-time-retry-wait");
          ParodusInfo("boot_retry_wait is %d\n",cfg->boot_retry_wait);
@@ -564,6 +533,16 @@ int parseCommandLine(int argc,char **argv,ParodusCfg * cfg)
 		  ParodusInfo("crud_config_file is %s\n", cfg->crud_config_file);
 		  break;

+		case 'P':
+		cfg->client_cert_path = strdup(optarg);
+		ParodusInfo("client_cert_path is %s\n", cfg->client_cert_path);
+		break;
+
+		case 'U':
+		cfg->token_server_url = strdup(optarg);
+		ParodusInfo("token_server_url is %s\n", cfg->token_server_url);
+		break;
+
        case '?':
          /* getopt_long already printed an error message. */
          break;
@@ -606,63 +585,6 @@ int parseCommandLine(int argc,char **argv,ParodusCfg * cfg)
    return 0;
 }

-/*
-* call parodus create/acquisition script to create new auth token, if success then calls 
-* execute_token_script func with args as parodus read script.
-*/
-
-void createNewAuthToken(char *newToken, size_t len)
-{
-	//Call create script
-	char output[12] = {'\0'};
-	execute_token_script(output,get_parodus_cfg()->token_acquisition_script,sizeof(output),get_parodus_cfg()->hw_mac,get_parodus_cfg()->hw_serial_number);
-  	if (strlen(output)>0  && strcmp(output,"SUCCESS")==0)
-	{
-		//Call read script 
-		execute_token_script(newToken,get_parodus_cfg()->token_read_script,len,get_parodus_cfg()->hw_mac,get_parodus_cfg()->hw_serial_number);
-	}	
-	else 
-	{
-		ParodusError("Failed to create new token\n");
-	}
-}
-
-/*
-* Fetches authorization token from the output of read script. If read script returns "ERROR"
-* it will call createNewAuthToken to create and read new token 
-*/
-
-void getAuthToken(ParodusCfg *cfg)
-{
-	//local var to update cfg->webpa_auth_token only in success case
-	char output[4069] = {'\0'} ;
-	
-	if( strlen(cfg->token_read_script) !=0 && strlen(cfg->token_acquisition_script) !=0)
-    	{
-		execute_token_script(output,cfg->token_read_script,sizeof(output),cfg->hw_mac,cfg->hw_serial_number);
-		
-	    	if ((strlen(output) == 0))
-	    	{
-			ParodusError("Unable to get auth token\n");
-		}
-		else if(strcmp(output,"ERROR")==0)
-		{
-			ParodusInfo("Failed to read token from %s. Proceeding to create new token.\n",cfg->token_read_script);
-			//Call create/acquisition script
-			createNewAuthToken(cfg->webpa_auth_token, sizeof(cfg->webpa_auth_token));	
-		}
-		else
-		{
-			ParodusInfo("update cfg->webpa_auth_token in success case\n");
-			parStrncpy(cfg->webpa_auth_token, output, sizeof(cfg->webpa_auth_token));
-		}
-	}
-	else
-	{
-        	ParodusInfo("Both read and write file are NULL \n");
-	}
-}
-
 void setDefaultValuesToCfg(ParodusCfg *cfg)
 {
    if(cfg == NULL)
@@ -694,6 +616,8 @@ void setDefaultValuesToCfg(ParodusCfg *cfg)
    parStrncpy(cfg->webpa_uuid, "1234567-345456546",sizeof(cfg->webpa_uuid));
    ParodusPrint("cfg->webpa_uuid is :%s\n", cfg->webpa_uuid);
    cfg->crud_config_file = NULL;
+    cfg->client_cert_path = NULL;
+    cfg->token_server_url = NULL;
 	
 	cfg->cloud_status = CLOUD_STATUS_OFFLINE;
 	ParodusInfo("Default cloud_status is %s\n", cfg->cloud_status);
@@ -834,24 +758,6 @@ void loadParodusCfg(ParodusCfg * config,ParodusCfg *cfg)
        ParodusPrint("cert_path is NULL. set to empty\n");
    }

-    if(strlen(config->token_acquisition_script )!=0)
-    {
-          parStrncpy(cfg->token_acquisition_script, config->token_acquisition_script,sizeof(cfg->token_acquisition_script));
-    }
-    else
-    {
-          ParodusPrint("token_acquisition_script is NULL. read from tmp file\n");
-    }
-        
-    if(strlen(config->token_read_script )!=0)
-    {
-          parStrncpy(cfg->token_read_script, config->token_read_script,sizeof(cfg->token_read_script));
-    }
-    else
-    {
-          ParodusPrint("token_read_script is NULL. read from tmp file\n");
-    }
-
    cfg->boot_time = config->boot_time;
    cfg->webpa_ping_timeout = config->webpa_ping_timeout;
    cfg->webpa_backoff_max = config->webpa_backoff_max;
@@ -869,6 +775,24 @@ void loadParodusCfg(ParodusCfg * config,ParodusCfg *cfg)
    {
        ParodusPrint("crud_config_file is NULL. set to empty\n");
    }
+
+    if(config->client_cert_path != NULL)
+    {
+        cfg->client_cert_path = strdup(config->client_cert_path);
+    }
+    else
+    {
+        ParodusPrint("client_cert_path is NULL. set to empty\n");
+    }
+
+    if(config->token_server_url != NULL)
+    {
+        cfg->token_server_url = strdup(config->token_server_url);
+    }
+    else
+    {
+        ParodusPrint("token_server_url is NULL. set to empty\n");
+    }
 }


--- a/src/config.h
+++ b/src/config.h
@@ -42,7 +42,7 @@ extern "C" {
 #define BOOT_TIME               "boot-time"
 #define LAST_RECONNECT_REASON   "webpa-last-reconnect-reason"
 #define WEBPA_PROTOCOL          "webpa-protocol"
-#define WEBPA_INTERFACE         "webpa-inteface-used"
+#define WEBPA_INTERFACE         "webpa-interface-used"
 #define WEBPA_UUID              "webpa-uuid"
 #define WEBPA_URL               "webpa-url"
 #define WEBPA_PING_TIMEOUT      "webpa-ping-timeout"
@@ -99,6 +99,8 @@ typedef struct
    char webpa_auth_token[4096];
    char token_acquisition_script[64];
    char token_read_script[64];
+    char *client_cert_path;
+    char *token_server_url;
 	char *crud_config_file;
 	char *cloud_status;
 	char *cloud_disconnect;
@@ -114,7 +116,6 @@ typedef struct
 /*----------------------------------------------------------------------------*/

 void loadParodusCfg(ParodusCfg * config,ParodusCfg *cfg);
-void createNewAuthToken(char *newToken, size_t len);

 /**
 * parse command line arguments and create config structure
@@ -128,7 +129,6 @@ void createNewAuthToken(char *newToken, size_t len);
 int parseCommandLine(int argc,char **argv,ParodusCfg * cfg);

 void setDefaultValuesToCfg(ParodusCfg *cfg); 
-void getAuthToken(ParodusCfg *cfg);
 // Accessor for the global config structure.
 ParodusCfg *get_parodus_cfg(void);
 void set_parodus_cfg(ParodusCfg *);
@@ -149,7 +149,6 @@ void reset_cloud_disconnect_reason(ParodusCfg *cfg);
 */ 
 int parse_webpa_url (const char *full_url, 
 	char **server_addr, unsigned int *port);
-
 #ifdef __cplusplus
 }
 #endif
--- a/src/conn_interface.c
+++ b/src/conn_interface.c
@@ -36,6 +36,7 @@
 #include "crud_interface.h"
 #include "heartBeat.h"
 #include "close_retry.h"
+#include <curl/curl.h>
 #ifdef FEATURE_DNS_QUERY
 #include <ucresolv_log.h>
 #endif
@@ -52,12 +53,18 @@
 /*                            File Scoped Variables                           */
 /*----------------------------------------------------------------------------*/
 bool g_shutdown  = false;
+pthread_t upstream_tid;
+pthread_t upstream_msg_tid;
+pthread_t downstream_tid;
+pthread_t svc_alive_tid;
+pthread_t crud_tid;

 /*----------------------------------------------------------------------------*/
 /*                             Function Prototypes                            */
 /*----------------------------------------------------------------------------*/
 void timespec_diff(struct timespec *start, struct timespec *stop,
                   struct timespec *result);
+
 /*----------------------------------------------------------------------------*/
 /*                             External Functions                             */
 /*----------------------------------------------------------------------------*/
@@ -69,6 +76,7 @@ void createSocketConnection(void (* initKeypress)())
    bool seshat_registered = false;
    unsigned int webpa_ping_timeout_ms = 1000 * get_parodus_cfg()->webpa_ping_timeout;
    unsigned int heartBeatTimer = 0;
+    struct timespec start_svc_alive_timer;
    
    //loadParodusCfg(tmpCfg,get_parodus_cfg());
 #ifdef FEATURE_DNS_QUERY
@@ -94,12 +102,12 @@ void createSocketConnection(void (* initKeypress)())
    packMetaData();
    
    UpStreamMsgQ = NULL;
-    StartThread(handle_upstream);
-    StartThread(processUpstreamMessage);
+    StartThread(handle_upstream, &upstream_tid);
+    StartThread(processUpstreamMessage, &upstream_msg_tid);
    ParodusMsgQ = NULL;
-    StartThread(messageHandlerTask);
-    StartThread(serviceAliveTask);
-	StartThread(CRUDHandlerTask);
+    StartThread(messageHandlerTask, &downstream_tid);
+    StartThread(serviceAliveTask, &svc_alive_tid);
+    StartThread(CRUDHandlerTask, &crud_tid);

    if (NULL != initKeypress) 
    {
@@ -108,6 +116,8 @@ void createSocketConnection(void (* initKeypress)())

    seshat_registered = __registerWithSeshat();
    
+    clock_gettime(CLOCK_REALTIME, &start_svc_alive_timer);
+
    do
    {
        struct timespec start, stop, diff;
@@ -158,22 +168,45 @@ void createSocketConnection(void (* initKeypress)())
            ParodusInfo("cloud_status set as %s after connection close\n", get_parodus_cfg()->cloud_status);
            if(get_parodus_cfg()->cloud_disconnect !=NULL)
            {
-				ParodusPrint("get_parodus_cfg()->cloud_disconnect is %s\n", get_parodus_cfg()->cloud_disconnect);
-				set_cloud_disconnect_time(CLOUD_RECONNECT_TIME);
-				ParodusInfo("Waiting for %d minutes for reconnecting .. \n", get_cloud_disconnect_time());
+                ParodusPrint("get_parodus_cfg()->cloud_disconnect is %s\n", get_parodus_cfg()->cloud_disconnect);
+		set_cloud_disconnect_time(CLOUD_RECONNECT_TIME);
+		ParodusInfo("Waiting for %d minutes for reconnecting .. \n", get_cloud_disconnect_time());

-				sleep( get_cloud_disconnect_time() * 60 );
-				ParodusInfo("cloud-disconnect reason reset after %d minutes\n", get_cloud_disconnect_time());
-				free(get_parodus_cfg()->cloud_disconnect);
-				reset_cloud_disconnect_reason(get_parodus_cfg());
+		sleep (get_cloud_disconnect_time() * 60);
+		ParodusInfo("cloud-disconnect reason reset after %d minutes\n", get_cloud_disconnect_time());
+		free(get_parodus_cfg()->cloud_disconnect);
+		reset_cloud_disconnect_reason(get_parodus_cfg());
            }
            createNopollConnection(ctx);
        }
       } while(!get_close_retry() && !g_shutdown);

+    pthread_mutex_lock (get_global_svc_mut());
+    pthread_cond_signal (get_global_svc_con());
+    pthread_mutex_unlock (get_global_svc_mut());
+    pthread_mutex_lock (get_global_crud_mut());
+    pthread_cond_signal (get_global_crud_con());
+    pthread_mutex_unlock (get_global_crud_mut());
+    pthread_mutex_lock (&g_mutex);
+    pthread_cond_signal (&g_cond);
+    pthread_mutex_unlock (&g_mutex);
+    pthread_mutex_lock (get_global_nano_mut ());
+    pthread_cond_signal (get_global_nano_con());
+    pthread_mutex_unlock (get_global_nano_mut());
+
+    ParodusInfo ("joining threads\n");
+    JoinThread (svc_alive_tid);
+    JoinThread (upstream_tid);
+    JoinThread (downstream_tid);
+    JoinThread (upstream_msg_tid);
+    JoinThread (crud_tid);
+
+    deleteAllClients ();
+
    close_and_unref_connection(get_global_conn());
    nopoll_ctx_unref(ctx);
    nopoll_cleanup_library();
+    curl_global_cleanup();
 }

 void shutdownSocketConnection(void) {
--- a/src/connection.c
+++ b/src/connection.c
@@ -25,6 +25,7 @@
 #include "time.h"
 #include "token.h"
 #include "config.h"
+#include "auth_token.h"
 #include "nopoll_helpers.h"
 #include "mutex.h"
 #include "spin_thread.h"
@@ -46,6 +47,7 @@ static char *reconnect_reason = "webpa_process_starts";
 static int cloud_disconnect_max_time = 5;
 static noPollConn *g_conn = NULL;
 static bool LastReasonStatus = false;
+static int init = 1;
 static noPollConnOpts * createConnOpts (char * extra_headers, bool secure);
 static char* build_extra_headers( const char *auth, const char *device_id,
                                  const char *user_agent, const char *convey );
@@ -296,10 +298,9 @@ void set_current_server (create_connection_ctx_t *ctx)

 void set_extra_headers (create_connection_ctx_t *ctx, int reauthorize)
 {
-  if (reauthorize && (strlen(get_parodus_cfg()->token_acquisition_script) >0))
+  if (reauthorize && (get_parodus_cfg()->client_cert_path !=NULL && strlen(get_parodus_cfg()->client_cert_path) >0))
  {
-    createNewAuthToken(get_parodus_cfg()->webpa_auth_token,
-      sizeof(get_parodus_cfg()->webpa_auth_token));
+    getAuthToken(get_parodus_cfg());
  }
  
  ctx->extra_headers = build_extra_hdrs (&ctx->header_info);
@@ -384,7 +385,7 @@ int nopoll_connect (create_connection_ctx_t *ctx, int is_ipv6)
           NULL, default_url,NULL,NULL);
      }      
   }
-   if (NULL == connection) {
+   if ((NULL == connection) && (!is_ipv6)) {
     if((checkHostIp(server->server_addr) == -2)) {
       if (check_timer_expired (&ctx->connect_timer, 15*60*1000)) {
  	 ParodusError("WebPA unable to connect due to DNS resolving to 10.0.0.1 for over 15 minutes; crashing service.\n");
@@ -406,6 +407,8 @@ int nopoll_connect (create_connection_ctx_t *ctx, int is_ipv6)
 #define WAIT_ACTION_RETRY	1	// if wait_status is 307, 302, 303 or 403
 #define WAIT_FAIL 	2

+#define FREE_NON_NULL_PTR(ptr) if (NULL != ptr) free(ptr)
+
 int wait_connection_ready (create_connection_ctx_t *ctx)
 {
  int wait_status;
@@ -413,7 +416,10 @@ int wait_connection_ready (create_connection_ctx_t *ctx)

  if(nopoll_conn_wait_for_status_until_connection_ready(get_global_conn(), 10, 
 	&wait_status, &redirectURL)) 
+  { 
+     FREE_NON_NULL_PTR (redirectURL);
     return WAIT_SUCCESS;
+  }
  if(wait_status == 307 || wait_status == 302 || wait_status == 303)    // only when there is a http redirect
  {
 	char *redirect_ptr = redirectURL;
@@ -431,9 +437,7 @@ int wait_connection_ready (create_connection_ctx_t *ctx)
 	set_current_server (ctx); // set current server to redirect server
 	return WAIT_ACTION_RETRY;
  }
-  if (NULL != redirectURL) {
-    free (redirectURL);
-  }
+  FREE_NON_NULL_PTR (redirectURL);
  if(wait_status == 403) 
  {
 	ParodusError("Received Unauthorized response with status: %d\n", wait_status);
@@ -556,7 +560,7 @@ int createNopollConnection(noPollCtx *ctx)
        set_server_list_null (&conn_ctx.server_list);
        init_backoff_timer (&backoff_timer, max_retry_count);
  
-	while (true)
+	while (!g_shutdown)
 	{
 	  query_dns_status = find_servers (&conn_ctx.server_list);
 	  if (query_dns_status == FIND_INVALID_DEFAULT)
@@ -579,9 +583,10 @@ int createNopollConnection(noPollCtx *ctx)
 	get_parodus_cfg()->cloud_status = CLOUD_STATUS_ONLINE;
 	ParodusInfo("cloud_status set as %s after successful connection\n", get_parodus_cfg()->cloud_status);

-	if(get_parodus_cfg()->boot_time != 0) {
+	if((get_parodus_cfg()->boot_time != 0) && init) {
 		getCurrentTime(connectTimePtr);
 		ParodusInfo("connect_time-diff-boot_time=%d\n", connectTimePtr->tv_sec - get_parodus_cfg()->boot_time);
+		init = 0; //set init to 0 so that this is logged only during process start up and not during reconnect
 	}

 	free_extra_headers (&conn_ctx);
--- a/src/crud_interface.c
+++ b/src/crud_interface.c
@@ -44,6 +44,16 @@ CrudMsg *crudMsgQ = NULL;
 /*                             External functions                             */
 /*----------------------------------------------------------------------------*/

+pthread_cond_t *get_global_crud_con(void)
+{
+    return &crud_con;
+}
+
+pthread_mutex_t *get_global_crud_mut(void)
+{
+    return &crud_mut;
+}
+
 void addCRUDmsgToQueue(wrp_msg_t *crudMsg)
 {
 	CrudMsg * crudMessage;
@@ -122,6 +132,10 @@ void *CRUDHandlerTask()
 		}
 		else
 		{
+			if (g_shutdown) {
+			  pthread_mutex_unlock (&crud_mut);
+			  break;
+			}
 			pthread_cond_wait(&crud_con, &crud_mut);
 			pthread_mutex_unlock (&crud_mut);
 		}
--- a/src/crud_interface.h
+++ b/src/crud_interface.h
@@ -24,6 +24,8 @@
 #ifndef _CRUD_INTERFACE_H_
 #define _CRUD_INTERFACE_H_

+#include <pthread.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -43,6 +45,8 @@ typedef struct CrudMsg__
 /*----------------------------------------------------------------------------*/

 void addCRUDresponseToUpstreamQ(void *response_bytes, ssize_t response_size);
+pthread_cond_t *get_global_crud_con(void);
+pthread_mutex_t *get_global_crud_mut(void);

 #ifdef __cplusplus
 }
--- a/src/downstream.c
+++ b/src/downstream.c
@@ -27,7 +27,10 @@
 #include "partners_check.h"
 #include "ParodusInternal.h"
 #include "crud_interface.h"
-
+/*----------------------------------------------------------------------------*/
+/*                             Function Prototypes                            */
+/*----------------------------------------------------------------------------*/
+static void createNewMsgForCRUD(wrp_msg_t *message, wrp_msg_t **crudMessage );
 /*----------------------------------------------------------------------------*/
 /*                             External Functions                             */
 /*----------------------------------------------------------------------------*/
@@ -42,6 +45,7 @@ void listenerOnMessage(void * msg, size_t msgSize)
 {
    int rv =0;
    wrp_msg_t *message;
+    wrp_msg_t *crudMessage= NULL;
    char* destVal = NULL;
    char dest[32] = {'\0'};
    int msgType;
@@ -75,7 +79,6 @@ void listenerOnMessage(void * msg, size_t msgSize)
                case WRP_MSG_TYPE__AUTH:
                {
                    ParodusInfo("Authorization Status received with Status code :%d\n", message->u.auth.status);
-		    wrp_free_struct(message);
                    break;
                }

@@ -120,7 +123,8 @@ void listenerOnMessage(void * msg, size_t msgSize)
                            ((WRP_MSG_TYPE__EVENT == msgType) ? "NA" : message->u.crud.transaction_uuid)));
                        
                        free(destVal);
-						temp = get_global_node();
+
+                        temp = get_global_node();
                        //Checking for individual clients & Sending to each client

                        while (NULL != temp)
@@ -139,10 +143,11 @@ void listenerOnMessage(void * msg, size_t msgSize)
                            ParodusPrint("checking the next item in the list\n");
                            temp= temp->next;
                        }
+                        release_global_node ();

-						/* check Downstream dest for CRUD requests */
-						if(destFlag ==0 && strcmp("parodus", dest)==0)
-						{
+			/* check Downstream dest for CRUD requests */
+			if(destFlag ==0 && strcmp("parodus", dest)==0)
+			{
 							ParodusPrint("Received CRUD request : dest : %s\n", dest);
 							if ((message->u.crud.source == NULL) || (message->u.crud.transaction_uuid == NULL))
 							{
@@ -154,11 +159,12 @@ void listenerOnMessage(void * msg, size_t msgSize)
 							}
 							else
 							{
-								addCRUDmsgToQueue(message);
+							    createNewMsgForCRUD(message, &crudMessage);
+							    addCRUDmsgToQueue(crudMessage);
 							}
 							destFlag =1;
-						}
-						//if any unknown dest received sending error response to server
+			}
+			//if any unknown dest received sending error response to server
                        if(destFlag ==0)
                        {
                            ParodusError("Unknown dest:%s\n", dest);
@@ -184,14 +190,14 @@ void listenerOnMessage(void * msg, size_t msgSize)
                        else
                        {
                            resp_msg ->u.crud.source = message->u.crud.dest;
-							if(message->u.crud.source !=NULL)
-							{
-								resp_msg ->u.crud.dest = message->u.crud.source;
-							}
-							else
-							{
-								resp_msg ->u.crud.dest = "unknown";
-							}
+				if(message->u.crud.source !=NULL)
+				{
+					resp_msg ->u.crud.dest = message->u.crud.source;
+				}
+				else
+				{
+					resp_msg ->u.crud.dest = "unknown";
+				}
                            resp_msg ->u.crud.transaction_uuid = message->u.crud.transaction_uuid;
                            resp_msg ->u.crud.path =             message->u.crud.path;
                        }
@@ -225,8 +231,6 @@ void listenerOnMessage(void * msg, size_t msgSize)
                            resp_bytes = NULL;
                        }
                        free(resp_msg);
-                        ParodusPrint("free for downstream decoded msg\n");
-                        wrp_free_struct(message);
                    }
                    break;
                }
@@ -235,9 +239,11 @@ void listenerOnMessage(void * msg, size_t msgSize)
                case WRP_MSG_TYPE__SVC_ALIVE:
                case WRP_MSG_TYPE__UNKNOWN:
                default:
-                        wrp_free_struct(message);
                    break;
            }
+            ParodusPrint("free for downstream decoded msg\n");
+            wrp_free_struct(message);
+            message = NULL;
        }
        else
        {
@@ -245,3 +251,116 @@ void listenerOnMessage(void * msg, size_t msgSize)
        }
    }
 }
+/*----------------------------------------------------------------------------*/
+/*                             Internal Functions                             */
+/*----------------------------------------------------------------------------*/
+/**
+ * @brief createNewMsgForCRUD function to create new message for processing CRUD requests
+ *
+ * @param[in] message The message received from server
+ * @param[out] crudMessage New message for processing CRUD requests
+ */
+static void createNewMsgForCRUD(wrp_msg_t *message, wrp_msg_t **crudMessage )
+{
+    wrp_msg_t *msg;
+    msg = ( wrp_msg_t * ) malloc( sizeof( wrp_msg_t ) );
+    size_t i;
+    if(msg != NULL)
+    {
+        memset( msg, 0, sizeof( wrp_msg_t ) );
+        msg->msg_type = message->msg_type;
+        if(message->u.crud.source != NULL)
+        {
+            ParodusPrint("message->u.crud.source = %s\n",message->u.crud.source);
+            msg->u.crud.source = strdup(message->u.crud.source);
+        }
+
+        if(message->u.crud.dest!= NULL)
+        {
+            ParodusPrint("message->u.crud.dest = %s\n",message->u.crud.dest);
+            msg->u.crud.dest = strdup(message->u.crud.dest);
+        }
+
+        if(message->u.crud.transaction_uuid != NULL)
+        {
+            ParodusPrint("message->u.crud.transaction_uuid = %s\n",message->u.crud.transaction_uuid);
+            msg->u.crud.transaction_uuid = strdup(message->u.crud.transaction_uuid);
+        }
+
+        if(message->u.crud.partner_ids!= NULL && message->u.crud.partner_ids->count >0)
+        {
+            msg->u.crud.partner_ids = ( partners_t * ) malloc( sizeof( partners_t ) +
+                                                              sizeof( char * ) * message->u.crud.partner_ids->count );
+            if(msg->u.crud.partner_ids != NULL)
+            {
+                msg->u.crud.partner_ids->count = message->u.crud.partner_ids->count;
+                for(i = 0; i<message->u.crud.partner_ids->count; i++)
+                {
+                    ParodusPrint("message->u.crud.partner_ids->partner_ids[%d] = %s\n",i,message->u.crud.partner_ids->partner_ids[i]);
+                    msg->u.crud.partner_ids->partner_ids[i] = strdup(message->u.crud.partner_ids->partner_ids[i]);
+                }
+            }
+        }
+
+        if(message->u.crud.headers!= NULL && message->u.crud.headers->count >0)
+        {
+            msg->u.crud.headers = ( headers_t * ) malloc( sizeof( headers_t ) +
+                                                                sizeof( char * ) * message->u.crud.headers->count );
+            if(msg->u.crud.headers != NULL)
+            {
+                msg->u.crud.headers->count = message->u.crud.headers->count;
+                for(i = 0; i<message->u.crud.headers->count; i++)
+                {
+                    ParodusPrint("message->u.crud.headers->headers[%d] = %s\n",i,message->u.crud.headers->headers[i]);
+                    msg->u.crud.headers->headers[i] = strdup(message->u.crud.headers->headers[i]);
+                }
+            }
+        }
+
+        if(message->u.crud.metadata != NULL && message->u.crud.metadata->count > 0)
+        {
+            msg->u.crud.metadata = (data_t *) malloc( sizeof( data_t ) );
+            if(msg->u.crud.metadata != NULL)
+            {
+                memset( msg->u.crud.metadata, 0, sizeof( data_t ) );
+                msg->u.crud.metadata->count = message->u.crud.metadata->count;
+                msg->u.crud.metadata->data_items = ( struct data* )malloc( sizeof( struct data ) * ( message->u.crud.metadata->count ) );
+                for(i=0; i<message->u.crud.metadata->count; i++)
+                {
+                    if(message->u.crud.metadata->data_items[i].name != NULL)
+                    {
+                        ParodusPrint("message->u.crud.metadata->data_items[%d].name : %s\n",i,message->u.crud.metadata->data_items[i].name);
+                        msg->u.crud.metadata->data_items[i].name = strdup(message->u.crud.metadata->data_items[i].name);
+                    }
+                    if(message->u.crud.metadata->data_items[i].value != NULL)
+                    {
+                        ParodusPrint("message->u.crud.metadata->data_items[%d].value : %s\n",i,message->u.crud.metadata->data_items[i].value);
+                        msg->u.crud.metadata->data_items[i].value = strdup(message->u.crud.metadata->data_items[i].value);
+                    }
+                }
+            }
+        }
+        msg->u.crud.include_spans = message->u.crud.include_spans;
+        if(message->u.crud.content_type != NULL)
+        {
+            ParodusPrint("message->u.crud.content_type : %s\n",message->u.crud.content_type);
+            msg->u.crud.content_type = strdup(message->u.crud.content_type);
+        }
+        msg->u.crud.spans.spans = NULL;   /* not supported */
+        msg->u.crud.spans.count = 0;     /* not supported */
+        msg->u.crud.status = message->u.crud.status;
+        msg->u.crud.rdr = message->u.crud.rdr;
+        if(message->u.crud.payload != NULL)
+        {
+            ParodusPrint("message->u.crud.payload = %s\n", (char *)message->u.crud.payload);
+            msg->u.crud.payload = strdup((char *)message->u.crud.payload);
+        }
+        msg->u.crud.payload_size = message->u.crud.payload_size;
+        if(message->u.crud.path != NULL)
+        {
+            ParodusPrint("message->u.crud.path = %s\n", message->u.crud.path);
+            msg->u.crud.path = strdup(message->u.crud.path);
+        }
+        *crudMessage = msg;
+    }
+}
--- a/src/main.c
+++ b/src/main.c
@@ -18,8 +18,10 @@
 #include <string.h>
 #include "stdlib.h"
 #include "config.h"
+#include "auth_token.h"
 #include "conn_interface.h"
 #include "parodus_log.h"
+#include <curl/curl.h>
 #ifdef INCLUDE_BREAKPAD
 #include "breakpad_wrapper.h"
 #else
@@ -80,6 +82,7 @@ int main( int argc, char **argv)
    if (0 != parseCommandLine(argc,argv,cfg)) {
 		abort();
 	}
+    curl_global_init(CURL_GLOBAL_DEFAULT);
    getAuthToken(cfg);
     
    createSocketConnection( NULL);
--- a/src/service_alive.c
+++ b/src/service_alive.c
@@ -31,9 +31,41 @@
 /*----------------------------------------------------------------------------*/
 #define KEEPALIVE_INTERVAL_SEC                         	30

+pthread_mutex_t svc_mut=PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t svc_con=PTHREAD_COND_INITIALIZER;
+
+/*----------------------------------------------------------------------------*/
+/*                             Utiliy Functions                               */
+/*----------------------------------------------------------------------------*/
+static int wait__ (unsigned int secs)
+{
+  int shutdown_flag;
+  struct timespec svc_alive_timer;
+
+  clock_gettime(CLOCK_REALTIME, &svc_alive_timer);
+  svc_alive_timer.tv_sec += secs;
+  pthread_mutex_lock(&svc_mut);
+  pthread_cond_timedwait (&svc_con, &svc_mut, &svc_alive_timer);
+  shutdown_flag = g_shutdown;
+  pthread_mutex_unlock (&svc_mut);
+  return shutdown_flag;
+}
+
 /*----------------------------------------------------------------------------*/
 /*                             External Functions                             */
 /*----------------------------------------------------------------------------*/
+
+pthread_cond_t *get_global_svc_con(void)
+{
+    return &svc_con;
+}
+
+pthread_mutex_t *get_global_svc_mut(void)
+{
+    return &svc_mut;
+}
+
+
 /*
 * @brief To handle registered services to indicate that the service is still alive.
 */
@@ -58,10 +90,10 @@ void *serviceAliveTask()
 	        while(1)
 	        {
 		        ParodusPrint("serviceAliveTask: numOfClients registered is %d\n", get_numOfClients());
+		        temp = get_global_node();
 		        if(get_numOfClients() > 0)
 		        {
 			        //sending svc msg to all the clients every 30s
-			        temp = get_global_node();
 			        size = (size_t) nbytes;
 			        while(NULL != temp)
 			        {
@@ -82,8 +114,9 @@ void *serviceAliveTask()
 				        byte = 0;
 				        if(ret == 0)
 				        {
-					        ParodusPrint("Deletion from list is success, doing resync with head\n");
+						release_global_node ();
 					        temp= get_global_node();
+					        ParodusInfo("Deletion from list is success, doing resync with head\n");
 					        ret = -1;
 				        }
 				        else
@@ -91,15 +124,20 @@ void *serviceAliveTask()
 					        temp= temp->next;
 				        }
 			        }
+				release_global_node ();
 		         	ParodusPrint("Waiting for 30s to send keep alive msg \n");
-		         	sleep(KEEPALIVE_INTERVAL_SEC);
+		         	if (wait__ (KEEPALIVE_INTERVAL_SEC))
+				  break;
 	            	}
 	            	else
 	            	{
+				release_global_node ();
 	            		ParodusInfo("No clients are registered, waiting ..\n");
-	            		sleep(50);
+	            		if (wait__ (50))
+				  break;
 	            	}
 	        }
+		free (svc_bytes);
 	}
 	return 0;
 }
--- a/src/service_alive.h
+++ b/src/service_alive.h
@@ -24,6 +24,8 @@
 #ifndef _SERVICE_ALIVE_H_
 #define _SERVICE_ALIVE_H_

+#include <pthread.h>
+
 /*----------------------------------------------------------------------------*/
 /*                             Function Prototypes                            */
 /*----------------------------------------------------------------------------*/
@@ -33,7 +35,8 @@ extern "C" {
 #endif
  
 void *serviceAliveTask();
-
+pthread_cond_t *get_global_svc_con(void);
+pthread_mutex_t *get_global_svc_mut(void);

 #ifdef __cplusplus
 }
--- a/src/spin_thread.c
+++ b/src/spin_thread.c
@@ -23,7 +23,6 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <pthread.h>

 #include "spin_thread.h"
 #include "parodus_log.h"
@@ -31,12 +30,12 @@
 /*----------------------------------------------------------------------------*/
 /*                             External Functions                             */
 /*----------------------------------------------------------------------------*/
-void StartThread(void *(*start_routine) (void *))
+void StartThread(void *(*start_routine) (void *), pthread_t *threadId)
 {
    int err = 0;
-	pthread_t threadId;
+	pthread_t __threadId;

-	err = pthread_create(&threadId, NULL, start_routine, NULL);
+	err = pthread_create(&__threadId, NULL, start_routine, NULL);
 	if (err != 0) 
 	{
 		ParodusError("Error creating thread :[%s]\n", strerror(err));
@@ -44,8 +43,13 @@ void StartThread(void *(*start_routine) (void *))
 	}
 	else
 	{
-		ParodusPrint("Thread created Successfully %lu\n", (unsigned long) threadId);
+		*threadId = __threadId;
+		ParodusPrint("Thread created Successfully %lu\n", (unsigned long) __threadId);
 	}    
 }

-         
+
+void JoinThread (pthread_t threadId)
+{
+  pthread_join (threadId, NULL);
+}
--- a/src/spin_thread.h
+++ b/src/spin_thread.h
@@ -24,6 +24,8 @@
 #ifndef _SPIN_THREAD_H_
 #define _SPIN_THREAD_H_

+#include <pthread.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -32,8 +34,8 @@ extern "C" {
 /*                             Function Prototypes                            */
 /*----------------------------------------------------------------------------*/

-void StartThread(void *(*start_routine) (void *));
-
+void StartThread(void *(*start_routine) (void *), pthread_t *threadId);
+void JoinThread (pthread_t threadId);

 #ifdef __cplusplus
 }
--- a/src/thread_tasks.c
+++ b/src/thread_tasks.c
@@ -43,6 +43,10 @@ void *messageHandlerTask()
        }
        else
        {
+            if (g_shutdown) {
+                pthread_mutex_unlock (&g_mutex);
+                break;
+            }
            ParodusPrint("Before pthread cond wait in consumer thread\n");
            pthread_cond_wait(&g_cond, &g_mutex);
            pthread_mutex_unlock (&g_mutex);
--- a/src/token.c
+++ b/src/token.c
@@ -527,7 +527,9 @@ int allow_insecure_conn(char **server_addr, unsigned int *port)
 	}

 	if (insecure >= 0) {
-		ParodusInfo ("JWT claims: %s\n", cJSON_Print (jwt->private_claims));
+		char *claim_str = cJSON_Print (jwt->private_claims);
+		ParodusInfo ("JWT claims: %s\n", claim_str);
+		free (claim_str);
 	}
 	cjwt_destroy(&jwt);
 	
--- a/src/upstream.c
+++ b/src/upstream.c
@@ -34,7 +34,7 @@
 /*                                   Macros                                   */
 /*----------------------------------------------------------------------------*/
 #define METADATA_COUNT 					12
-#define CLOUD_STATUS_FORMAT				"parodus/cloud-status"
+#define PARODUS_SERVICE_NAME			"parodus"
 /*----------------------------------------------------------------------------*/
 /*                            File Scoped Variables                           */
 /*----------------------------------------------------------------------------*/
@@ -129,6 +129,12 @@ void *handle_upstream()
    sock = nn_socket( AF_SP, NN_PULL );
    if(sock >= 0)
    {
+        int t = NANO_SOCKET_RCV_TIMEOUT_MS;
+        int rc = nn_setsockopt(sock, NN_SOL_SOCKET, NN_RCVTIMEO, &t, sizeof(t));
+        if (rc < 0)
+        {
+            ParodusError ("Unable to set socket receive timeout (errno=%d, %s)\n",errno, strerror(errno));
+        }
        ParodusPrint("Nanomsg bind with get_parodus_cfg()->local_url  %s\n", get_parodus_cfg()->local_url);
        bind = nn_bind(sock, get_parodus_cfg()->local_url);
        if(bind < 0)
@@ -137,11 +143,18 @@ void *handle_upstream()
        }
        else
        {
+            ParodusInfo("nanomsg server gone into the listening mode...\n");
            while( FOREVER() ) 
            {
                buf = NULL;
-                ParodusInfo("nanomsg server gone into the listening mode...\n");
                bytes = nn_recv (sock, &buf, NN_MSG, 0);
+                if (g_shutdown)
+                  break;
+                if (bytes < 0) {
+                  if ((errno != EAGAIN) && (errno != ETIMEDOUT))
+                    ParodusInfo ("Error (%d) receiving message from nanomsg client\n", errno);
+                  continue;
+                }
                ParodusInfo ("Upstream message received from nanomsg client\n");
                message = (UpStreamMsg *)malloc(sizeof(UpStreamMsg));

@@ -197,11 +210,10 @@ void *processUpstreamMessage()
    reg_list_item_t *temp = NULL;
    int matchFlag = 0;
    int status = -1;
-    char *serviceName = NULL;
-    char *macId = NULL;
-    char *destService, *destApplication =NULL;
-    char *sourceService, *sourceApplication =NULL;
-    int sendStatus =-1;
+	char *device_id = NULL;
+	size_t device_id_len = 0;
+	size_t parodus_len;
+	int ret = -1;

    while(FOREVER())
    {
@@ -226,11 +238,11 @@ void *processUpstreamMessage()
                {
                    ParodusInfo("\n Nanomsg client Registration for Upstream\n");
                    //Extract serviceName and url & store it in a linked list for reg_clients
+                    temp = get_global_node();
                    if(get_numOfClients() !=0)
                    {
                        matchFlag = 0;
                        ParodusPrint("matchFlag reset to %d\n", matchFlag);
-                        temp = get_global_node();
                        while(temp!=NULL)
                        {
                            if(strcmp(temp->service_name, msg->u.reg.service_name)==0)
@@ -239,17 +251,19 @@ void *processUpstreamMessage()
                                parStrncpy(temp->url,msg->u.reg.url, sizeof(temp->url));
                                if(nn_shutdown(temp->sock, 0) < 0)
                                {
-                                    ParodusError ("Failed to shutdown\n");
+                                    ParodusError ("nn_shutdown socket=%d err=%d\n", 
+					temp->sock, errno);
                                }
+				nn_close (temp->sock);

                                temp->sock = nn_socket(AF_SP,NN_PUSH );
                                if(temp->sock >= 0)
                                {					
-                                    int t = NANOMSG_SOCKET_TIMEOUT_MSEC;
+                                    int t = NANO_SOCKET_SEND_TIMEOUT_MS;
                                    rc = nn_setsockopt(temp->sock, NN_SOL_SOCKET, NN_SNDTIMEO, &t, sizeof(t));
                                    if(rc < 0)
                                    {
-                                        ParodusError ("Unable to set socket timeout (errno=%d, %s)\n",errno, strerror(errno));
+                                        ParodusError ("Unable to set socket send timeout (errno=%d, %s)\n",errno, strerror(errno));
                                    }
                                    rc = nn_connect(temp->sock, msg->u.reg.url); 
                                    if(rc < 0)
@@ -258,7 +272,7 @@ void *processUpstreamMessage()
                                    }
                                    else
                                    {
-                                        ParodusInfo("Client registered before. Sending acknowledgement \n"); 
+                                        ParodusInfo("Client registered before. Sending ack on socket %d\n", temp->sock); 
                                        status =sendAuthStatus(temp);

                                        if(status == 0)
@@ -289,11 +303,13 @@ void *processUpstreamMessage()
                            ParodusPrint("sent auth status to reg client\n");
                        }
                    }
+                    release_global_node ();
                }
                else if(msgType == WRP_MSG_TYPE__EVENT)
                {
                    ParodusInfo(" Received upstream event data: dest '%s'\n", msg->u.event.dest);
                    partners_t *partnersList = NULL;
+                    int j = 0;

                    int ret = validate_partner_id(msg, &partnersList);
                    if(ret == 1)
@@ -322,6 +338,18 @@ void *processUpstreamMessage()
                    {
                        sendUpstreamMsgToServer(&message->msg, message->len);
                    }
+                    if(partnersList != NULL)
+                    {
+                        for(j=0; j<(int)partnersList->count; j++)
+                        {
+                            if(NULL != partnersList->partner_ids[j])
+                            {
+                                free(partnersList->partner_ids[j]);
+                            }
+                        }
+                        free(partnersList);
+                    }
+                    partnersList = NULL;
                }
                else
                {
@@ -334,87 +362,46 @@ void *processUpstreamMessage()
 					else
 					{
 						ParodusInfo(" Received upstream data with MsgType: %d dest: '%s' transaction_uuid: %s status: %d\n",msgType, msg->u.crud.dest, msg->u.crud.transaction_uuid, msg->u.crud.status );
-						if(WRP_MSG_TYPE__RETREIVE == msgType && msg->u.crud.dest !=NULL && msg->u.crud.source != NULL)
+						if(WRP_MSG_TYPE__RETREIVE == msgType)
 						{
-                                                        macId = wrp_get_msg_element(WRP_ID_ELEMENT__ID, msg, DEST);
-							destService = wrp_get_msg_element(WRP_ID_ELEMENT__SERVICE, msg, DEST);
-							destApplication = wrp_get_msg_element(WRP_ID_ELEMENT__APPLICATION, msg, DEST);
-							sourceService = wrp_get_msg_element(WRP_ID_ELEMENT__SERVICE, msg, SOURCE);
-							sourceApplication = wrp_get_msg_element(WRP_ID_ELEMENT__APPLICATION, msg, SOURCE);
-							/*  Handle cloud-status retrieve request here
-								Expecting dest format as mac:xxxxxxxxxxxx/parodus/cloud-status
-								Parse dest field and check destService is "parodus" and destApplication is "cloud-status"
-							*/
-							if(macId != NULL)
-						    	{
-								if(destService != NULL && destApplication != NULL && strcmp(destService,"parodus")== 0 && strcmp(destApplication,"cloud-status")== 0)
+								ret = getDeviceId(&device_id, &device_id_len);
+								if(ret == 0)
 								{
-									retrieve_msg = ( wrp_msg_t *)malloc( sizeof( wrp_msg_t ) );
-									memset(retrieve_msg, 0, sizeof(wrp_msg_t));
-									retrieve_msg->msg_type = msg->msg_type;
-									retrieve_msg->u.crud.transaction_uuid = strdup(msg->u.crud.transaction_uuid);
-									retrieve_msg->u.crud.source = strdup(msg->u.crud.source);
-									retrieve_msg->u.crud.dest = strdup(msg->u.crud.dest);
-									addCRUDmsgToQueue(retrieve_msg);
-								}
-								else if(sourceService != NULL && sourceApplication != NULL && strcmp(sourceService,"parodus")== 0 && strcmp(sourceApplication,"cloud-status")== 0 && strncmp(msg->u.crud.dest,"mac:", 4)==0)
-								{
-									/*  Handle cloud-status retrieve response here to send it to registered client
-										Expecting src format as mac:xxxxxxxxxxxx/parodus/cloud-status and dest as mac:
-										Parse src field and check sourceService is "parodus" and sourceApplication is "cloud-status"
-									*/
-									serviceName = wrp_get_msg_element(WRP_ID_ELEMENT__SERVICE, msg, DEST);
-									if ( serviceName != NULL)
+									ParodusPrint("device_id %s device_id_len %lu\n", device_id, device_id_len);
+									/* Match dest based on device_id. Check dest start with: "mac:112233445xxx" ? */
+									if( 0 == strncasecmp(device_id, msg->u.crud.dest, device_id_len-1) )
 									{
-										//Send Client cloud-status response back to registered client
-										ParodusInfo("Sending cloud-status response to %s client\n",serviceName);
-										sendStatus=sendMsgtoRegisteredClients(serviceName,(const char **)&message->msg,message->len);
-										if(sendStatus ==1)
+										 /* For this device. */
+										parodus_len = strlen( PARODUS_SERVICE_NAME );
+										if( 0 == strncmp(PARODUS_SERVICE_NAME, &msg->u.crud.dest[device_id_len], parodus_len-1) ) 
 										{
-											ParodusInfo("Send upstreamMsg successfully to registered client %s\n", serviceName);
+											/* For Parodus CRUD queue. */
+											ParodusInfo("Create RetrieveMsg and add to parodus CRUD queue\n");
+											createUpstreamRetrieveMsg(msg, &retrieve_msg);
+											addCRUDmsgToQueue(retrieve_msg);
 										}
 										else
 										{
-											ParodusError("Failed to send upstreamMsg to registered client %s\n", serviceName);
+											/* For nanomsg clients. */
+											getServiceNameAndSendResponse(msg, &message->msg, message->len);
 										}
-										free(serviceName);
-										serviceName = NULL;
 									}
 									else
 									{
-										ParodusError("serviceName is NULL,not sending cloud-status response to client\n");
+										/* Not for this device. Send upstream */
+										ParodusInfo("sendUpstreamMsgToServer \n");
+										sendUpstreamMsgToServer(&message->msg, message->len);
+									}
+									if(device_id != NULL)
+									{
+										free(device_id);
+										device_id = NULL;
 									}
 								}
 								else
 								{
-									ParodusInfo("sendUpstreamMsgToServer \n");
-									sendUpstreamMsgToServer(&message->msg, message->len);
+									ParodusError("Failed to get device_id\n");
 								}
-							}
-							else
-							{
-								ParodusError("MAC is null, not handling retrieve wrp message \n");
-							}
-							if(sourceService !=NULL)
-							{
-								free(sourceService);
-								sourceService = NULL;
-							}
-							if(sourceApplication !=NULL)
-							{
-								free(sourceApplication);
-								sourceApplication = NULL;
-							}
-							if(destService !=NULL)
-							{
-								free(destService);
-								destService = NULL;
-							}
-							if(destApplication !=NULL)
-							{
-								free(destApplication);
-								destApplication = NULL;
-							}
 						}
 						else
 						{
@@ -450,6 +437,10 @@ void *processUpstreamMessage()
        }
        else
        {
+            if (g_shutdown) {
+                pthread_mutex_unlock (&nano_mut);
+                break;
+            }
            ParodusPrint("Before pthread cond wait in consumer thread\n");   
            pthread_cond_wait(&nano_con, &nano_mut);
            pthread_mutex_unlock (&nano_mut);
@@ -459,6 +450,107 @@ void *processUpstreamMessage()
    return NULL;
 }

+/**
+ * @brief getDeviceId function to create deviceId in the format "mac:112233445xxx"
+ *
+ * @param[out] device_id in the format "mac:112233445xxx"
+ * @param[out] total size of device_id
+ */
+int getDeviceId(char **device_id, size_t *device_id_len)
+{
+	char *deviceID = NULL;
+	size_t len;
+
+	if((get_parodus_cfg()->hw_mac !=NULL) && (strlen(get_parodus_cfg()->hw_mac)!=0))
+	{
+		len = strlen(get_parodus_cfg()->hw_mac) + 5;
+
+		deviceID = (char *) malloc(sizeof(char)*64);
+		if(deviceID != NULL)
+		{
+			snprintf(deviceID, len, "mac:%s", get_parodus_cfg()->hw_mac);
+			*device_id = deviceID;
+			*device_id_len = len;
+		}
+		else
+		{
+			ParodusError("device_id allocation failed\n");
+			return -1;
+		}
+	}
+	else
+	{
+		ParodusError("device mac is NULL\n");
+		return -1;
+	}
+	return 0;
+}
+
+
+/**
+ * @brief createUpstreamRetrieveMsg function to create new message for processing Retrieve requests
+ *
+ * @param[in] message The upstream message received from cloud or internal clients
+ * @param[out] retrieve_msg New message for processing Retrieve requests
+ */
+void createUpstreamRetrieveMsg(wrp_msg_t *message, wrp_msg_t **retrieve_msg)
+{
+	wrp_msg_t *msg;
+	msg = ( wrp_msg_t * ) malloc( sizeof( wrp_msg_t ) );
+	if(msg != NULL)
+    {
+		memset(msg, 0, sizeof(wrp_msg_t));
+
+		msg->msg_type = message->msg_type;
+		if(message->u.crud.transaction_uuid != NULL)
+		{
+			msg->u.crud.transaction_uuid = strdup(message->u.crud.transaction_uuid);
+		}
+		if(message->u.crud.source !=NULL)
+		{
+			msg->u.crud.source = strdup(message->u.crud.source);
+		}
+		if(message->u.crud.dest != NULL)
+		{
+			msg->u.crud.dest = strdup(message->u.crud.dest);
+		}
+		*retrieve_msg = msg;
+	}
+}
+
+/**
+ * @brief getServiceNameAndSendResponse function to fetch client service name and to send msg to it.
+ *
+ * @param[in] msg The decoded message to fetch client service name from its dest field
+ * @param[in] msg_bytes The encoded upstream msg to be sent to client
+ * @param[in] msg_size Total size of the msg to send to client
+ */
+void getServiceNameAndSendResponse(wrp_msg_t *msg, void **msg_bytes, size_t msg_size)
+{
+	char *serviceName = NULL;
+	int sendStatus =-1;
+
+	serviceName = wrp_get_msg_element(WRP_ID_ELEMENT__SERVICE, msg, DEST);
+	if ( serviceName != NULL)
+	{
+		sendStatus=sendMsgtoRegisteredClients(serviceName,(const char **)msg_bytes, msg_size);
+		if(sendStatus ==1)
+		{
+			ParodusInfo("Send upstreamMsg successfully to registered client %s\n", serviceName);
+		}
+		else
+		{
+			ParodusError("Failed to send upstreamMsg to registered client %s\n", serviceName);
+		}
+		free(serviceName);
+		serviceName = NULL;
+	}
+	else
+	{
+		ParodusError("serviceName is NULL,not sending retrieve response to client\n");
+	}
+}
+
 void sendUpstreamMsgToServer(void **resp_bytes, size_t resp_size)
 {
 	void *appendData;
--- a/src/upstream.h
+++ b/src/upstream.h
@@ -47,8 +47,10 @@ typedef struct UpStreamMsg__
 void packMetaData();
 void *handle_upstream();
 void *processUpstreamMessage();
-
+int getDeviceId(char **device_id, size_t *device_id_len);
 void sendUpstreamMsgToServer(void **resp_bytes, size_t resp_size);
+void getServiceNameAndSendResponse(wrp_msg_t *msg, void **msg_bytes, size_t msg_size);
+void createUpstreamRetrieveMsg(wrp_msg_t *message, wrp_msg_t **retrieve_msg);
 void set_global_UpStreamMsgQ(UpStreamMsg * UpStreamQ);
 UpStreamMsg * get_global_UpStreamMsgQ(void);
 pthread_cond_t *get_global_nano_con(void);
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -120,10 +120,10 @@ target_link_libraries (test_nopoll_handlers_fragment -lnopoll -lcunit -lcimplog
 add_test(NAME test_connection COMMAND ${MEMORY_CHECK} ./test_connection)
 set (CONN_SRC ../src/connection.c 
  ../src/string_helpers.c ../src/mutex.c ../src/time.c 
-  ../src/config.c ../src/spin_thread.c  ../src/heartBeat.c ../src/close_retry.c)
+  ../src/config.c ../src/auth_token.c ../src/spin_thread.c  ../src/heartBeat.c ../src/close_retry.c)
 #set(CONN_SRC ../src/connection.c ${PARODUS_COMMON_SRC})
 add_executable(test_connection test_connection.c ${CONN_SRC})
-target_link_libraries (test_connection ${PARODUS_COMMON_LIBS} -lcmocka)
+target_link_libraries (test_connection ${PARODUS_COMMON_LIBS} -lcmocka -lcurl -luuid)

 #-------------------------------------------------------------------------------
 #   test_connection - function createNopollConnection
@@ -141,7 +141,7 @@ target_link_libraries (test_connection ${PARODUS_COMMON_LIBS} -lcmocka)
 add_test(NAME test_client_list COMMAND ${MEMORY_CHECK} ./test_client_list)
 #add_executable(test_client_list test_client_list.c ../src/client_list.c ../src/service_alive.c ../src/upstream.c ../src/networking.c ../src/nopoll_helpers.c ../src/downstream.c ../src/connection.c ../src/nopoll_handlers.c ../src/ParodusInternal.c ../src/thread_tasks.c ../src/conn_interface.c ../src/partners_check.c ${PARODUS_COMMON_SRC})
 #target_link_libraries (test_client_list ${PARODUS_COMMON_LIBS})
-set(CLIST_SRC test_client_list.c ../src/client_list.c 
+set(CLIST_SRC test_client_list.c ../src/client_list.c ../src/auth_token.c
 ../src/service_alive.c ../src/upstream.c ../src/networking.c ../src/nopoll_helpers.c 
 ../src/downstream.c ../src/connection.c ../src/nopoll_handlers.c ../src/heartBeat.c ../src/close_retry.c
 ../src/ParodusInternal.c ../src/thread_tasks.c ../src/conn_interface.c 
@@ -155,7 +155,7 @@ endif (ENABLE_SESHAT)
 
 add_executable(test_client_list ${CLIST_SRC})
 #target_link_libraries (test_client_list ${PARODUS_CONN_LIBS} ${PARODUS_COMMON_LIBS})
-target_link_libraries (test_client_list ${PARODUS_COMMON_LIBS})
+target_link_libraries (test_client_list ${PARODUS_COMMON_LIBS} -lcurl -luuid)

 #-------------------------------------------------------------------------------
 #   test_service_alive
@@ -163,7 +163,7 @@ target_link_libraries (test_client_list ${PARODUS_COMMON_LIBS})
 add_test(NAME test_service_alive COMMAND ${MEMORY_CHECK} ./test_service_alive)
 #add_executable(test_service_alive test_service_alive.c ../src/client_list.c ../src/service_alive.c ../src/upstream.c ../src/networking.c ../src/nopoll_helpers.c ../src/nopoll_handlers.c ../src/config.c ../src/connection.c ../src/ParodusInternal.c ../src/downstream.c ../src/thread_tasks.c ../src/conn_interface.c ../src/partners_check.c ${PARODUS_COMMON_SRC})
 #target_link_libraries (test_service_alive ${PARODUS_COMMON_LIBS})
-set(SVA_SRC test_service_alive.c ../src/client_list.c ../src/service_alive.c ../src/upstream.c ../src/networking.c ../src/nopoll_helpers.c ../src/nopoll_handlers.c ../src/config.c ../src/connection.c ../src/ParodusInternal.c ../src/downstream.c ../src/thread_tasks.c ../src/conn_interface.c ../src/partners_check.c ../src/heartBeat.c ../src/close_retry.c ${PARODUS_COMMON_SRC})
+set(SVA_SRC test_service_alive.c ../src/client_list.c ../src/service_alive.c ../src/auth_token.c ../src/upstream.c ../src/networking.c ../src/nopoll_helpers.c ../src/nopoll_handlers.c ../src/config.c ../src/connection.c ../src/ParodusInternal.c ../src/downstream.c ../src/thread_tasks.c ../src/conn_interface.c ../src/partners_check.c ../src/heartBeat.c ../src/close_retry.c ${PARODUS_COMMON_SRC})
 if (ENABLE_SESHAT)
 set(SVA_SRC ${SVA_SRC} ../src/seshat_interface.c)
 else()
@@ -172,18 +172,27 @@ endif (ENABLE_SESHAT)

 add_executable(test_service_alive ${SVA_SRC})
 #target_link_libraries (test_service_alive ${PARODUS_CONN_LIBS} ${PARODUS_COMMON_LIBS})
-target_link_libraries (test_service_alive ${PARODUS_COMMON_LIBS})
+target_link_libraries (test_service_alive ${PARODUS_COMMON_LIBS} -lcurl -luuid)

 #-------------------------------------------------------------------------------
 #   test_config
 #-------------------------------------------------------------------------------
 add_test(NAME test_config COMMAND ${MEMORY_CHECK} ./test_config)
-add_executable(test_config test_config.c ../src/config.c ../src/string_helpers.c)
+add_executable(test_config test_config.c ../src/config.c ../src/auth_token.c ../src/string_helpers.c)
 target_link_libraries (test_config -lcmocka
 -Wl,--no-as-needed -lcimplog
- -lcjson -lcjwt -ltrower-base64 -lssl -lcrypto -lrt -lm
+ -lcjson -lcjwt -ltrower-base64 -lssl -lcrypto -lrt -lm -lcurl -luuid
 )

+#-------------------------------------------------------------------------------
+#   test_auth_token
+#-------------------------------------------------------------------------------
+add_test(NAME test_auth_token COMMAND ${MEMORY_CHECK} ./test_auth_token)
+add_executable(test_auth_token test_auth_token.c ../src/config.c ../src/auth_token.c ../src/string_helpers.c)
+target_link_libraries (test_auth_token -lcmocka
+ -Wl,--no-as-needed -lcimplog
+ -lcjson -lcjwt -ltrower-base64 -lssl -lcrypto -lrt -lm -lcurl -luuid
+)
 #-------------------------------------------------------------------------------
 #   test_crud_interface
 #-------------------------------------------------------------------------------
@@ -203,7 +212,7 @@ target_link_libraries (test_crud_tasks -lcmocka ${PARODUS_COMMON_LIBS} )
 #-------------------------------------------------------------------------------
 add_test(NAME test_crud_internal COMMAND ${MEMORY_CHECK} ./test_crud_internal)
 add_executable(test_crud_internal test_crud_internal.c ../src/config.c ../src/close_retry.c ../src/string_helpers.c ../src/crud_internal.c )
-target_link_libraries (test_crud_internal -lcmocka ${PARODUS_COMMON_LIBS} )
+target_link_libraries (test_crud_internal -lcmocka ${PARODUS_COMMON_LIBS} -lcurl -luuid)

 #-------------------------------------------------------------------------------
 #   test_upstream
@@ -259,14 +268,14 @@ else()
 set(CONIFC_SRC ${CONIFC_SRC} ../src/seshat_interface_stub.c)
 endif (ENABLE_SESHAT)
 add_executable(test_conn_interface ${CONIFC_SRC})
-target_link_libraries (test_conn_interface -lcmocka ${PARODUS_COMMON_LIBS} )
+target_link_libraries (test_conn_interface -lcmocka ${PARODUS_COMMON_LIBS} -lcurl -luuid )

 #-------------------------------------------------------------------------------
 #   test_ParodusInternal
 #-------------------------------------------------------------------------------
 add_test(NAME test_ParodusInternal COMMAND ${MEMORY_CHECK} ./test_ParodusInternal)
 add_executable(test_ParodusInternal test_ParodusInternal.c ../src/ParodusInternal.c ../src/config.c ../src/string_helpers.c)
-target_link_libraries (test_ParodusInternal -lcmocka ${PARODUS_COMMON_LIBS} )
+target_link_libraries (test_ParodusInternal -lcmocka ${PARODUS_COMMON_LIBS} -lcurl -luuid)

 #-------------------------------------------------------------------------------
 #   test_partners_check
@@ -285,7 +294,7 @@ set(TOKEN_SRC ../src/conn_interface.c ../src/config.c
 ../src/nopoll_handlers.c ../src/nopoll_helpers.c
 ../src/partners_check.c ../src/ParodusInternal.c
 ../src/upstream.c ../src/downstream.c 
- ../src/networking.c
+ ../src/networking.c ../src/auth_token.c
 ../src/thread_tasks.c ../src/time.c
 ../src/string_helpers.c ../src/mutex.c 
 ../src/token.c ../src/heartBeat.c
@@ -306,7 +315,7 @@ endif (FEATURE_DNS_QUERY)

 add_executable(test_token ${TOKEN_SRC} ) 
 #target_link_libraries (test_token ${PARODUS_COMMON_LIBS} ${PARODUS_JWT_LIBS} -lcmocka )
-target_link_libraries (test_token ${PARODUS_COMMON_LIBS} -lcmocka )
+target_link_libraries (test_token ${PARODUS_COMMON_LIBS} -lcmocka -lcurl -luuid)

 #-------------------------------------------------------------------------------
 #   test_seshat_interface - registerWithSeshat
--- a/tests/test_auth_token.c
+++ b/tests/test_auth_token.c
@@ -0,0 +1,299 @@
+/**
+ *  Copyright 2010-2016 Comcast Cable Communications Management, LLC
+ *
+ *  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.
+ */
+#include <assert.h>
+#include <errno.h>
+#include <pthread.h>
+#include <malloc.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <cmocka.h>
+
+#include <CUnit/Basic.h>
+
+#include "../src/config.h"
+#include "../src/auth_token.h"
+#include "../src/ParodusInternal.h"
+
+extern int requestNewAuthToken(char *newToken, size_t len, int r_count);
+
+/*----------------------------------------------------------------------------*/
+/*                                   Mocks                                    */
+/*----------------------------------------------------------------------------*/
+typedef void CURL;
+
+typedef enum {
+  CURLINFO_RESPONSE_CODE    = 2,
+  CURLINFO_TOTAL_TIME
+} CURLINFO;
+
+int curl_easy_perform(CURL *curl)
+{
+	UNUSED(curl);
+	function_called();
+	return (int) mock();
+}
+
+int curl_easy_getinfo(CURL *curl, CURLINFO CURLINFO_RESPONSE_CODE, long response_code)
+{
+	UNUSED(curl);
+	UNUSED(CURLINFO_RESPONSE_CODE);
+	UNUSED(response_code);
+	function_called();
+	return (int) mock();
+}
+/*----------------------------------------------------------------------------*/
+/*                                   Tests                                    */
+/*----------------------------------------------------------------------------*/
+void getAuthToken_Null()
+{
+	ParodusCfg cfg;
+	memset(&cfg,0,sizeof(cfg));
+	parStrncpy(cfg.hw_mac , "123567892366", sizeof(cfg.hw_mac));
+	cfg.client_cert_path = NULL;
+	getAuthToken(&cfg);
+	set_parodus_cfg(&cfg);
+	assert( cfg.client_cert_path == NULL);
+}
+
+void getAuthToken_MacNull()
+{
+    ParodusCfg cfg;
+    memset(&cfg,0,sizeof(cfg));
+    cfg.client_cert_path = NULL;
+    getAuthToken(&cfg);
+    set_parodus_cfg(&cfg);
+    assert( cfg.client_cert_path == NULL);
+}
+
+void test_requestNewAuthToken_init_fail ()
+{
+	char token[32];
+	ParodusCfg cfg;
+	int output = -1;
+	memset(&cfg,0,sizeof(cfg));
+
+	cfg.token_server_url = strdup("https://dev.comcast.net/token");
+	parStrncpy(cfg.cert_path , "/etc/ssl/certs/ca-certificates.crt", sizeof(cfg.cert_path));
+	parStrncpy(cfg.hw_serial_number, "Fer23u948590", sizeof(cfg.hw_serial_number));
+	parStrncpy(cfg.hw_mac , "123567892366", sizeof(cfg.hw_mac));
+
+	set_parodus_cfg(&cfg);
+
+	will_return (curl_easy_perform, -1);
+	expect_function_calls (curl_easy_perform, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_getinfo, -1);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	requestNewAuthToken (token, sizeof(token), 2);
+	assert_int_equal (output, -1);
+	free(cfg.token_server_url);
+}
+
+
+void test_requestNewAuthToken_failure ()
+{
+	char token[32];
+	ParodusCfg cfg;
+	int output = -1;
+	memset(&cfg,0,sizeof(cfg));
+
+	cfg.token_server_url = strdup("https://dev.comcast.net/token");
+	parStrncpy(cfg.cert_path , "/etc/ssl/certs/ca-certificates.crt", sizeof(cfg.cert_path));
+	parStrncpy(cfg.hw_serial_number, "Fer23u948590", sizeof(cfg.hw_serial_number));
+	parStrncpy(cfg.hw_mac , "123567892366", sizeof(cfg.hw_mac));
+	set_parodus_cfg(&cfg);
+
+	will_return (curl_easy_perform, -1);
+	expect_function_calls (curl_easy_perform, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_getinfo, -1);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	requestNewAuthToken (token, sizeof(token), 2);
+	assert_int_equal (output, -1);
+	free(cfg.token_server_url);
+}
+
+
+void test_requestNewAuthToken ()
+{
+  char token[1024];
+  ParodusCfg cfg;
+  int output = -1;
+  memset(&cfg,0,sizeof(cfg));
+
+  cfg.token_server_url = strdup("https://dev.comcast.net/token");
+  parStrncpy(cfg.cert_path , "/etc/ssl/certs/ca-certificates.crt", sizeof(cfg.cert_path));
+  parStrncpy(cfg.webpa_interface_used , "eth0", sizeof(cfg.webpa_interface_used));
+  parStrncpy(cfg.hw_serial_number, "Fer23u948590", sizeof(cfg.hw_serial_number));
+  parStrncpy(cfg.hw_mac , "123567892366", sizeof(cfg.hw_mac));
+  set_parodus_cfg(&cfg);
+
+  will_return (curl_easy_perform, 0);
+  expect_function_calls (curl_easy_perform, 1);
+  will_return (curl_easy_getinfo, 0);
+  expect_function_calls (curl_easy_getinfo, 1);
+
+  will_return (curl_easy_getinfo, 0);
+  expect_function_calls (curl_easy_getinfo, 1);
+
+  output = requestNewAuthToken (token, sizeof(token), 1);
+  assert_int_equal (output, 0);
+  free(cfg.token_server_url);
+}
+
+void test_getAuthToken ()
+{
+	ParodusCfg cfg;
+	memset(&cfg,0,sizeof(cfg));
+
+	cfg.token_server_url = strdup("https://dev.comcast.net/token");
+	cfg.client_cert_path = strdup("testcert");
+	parStrncpy(cfg.cert_path , "/etc/ssl/certs/ca-certificates.crt", sizeof(cfg.cert_path));
+	parStrncpy(cfg.webpa_interface_used , "eth0", sizeof(cfg.webpa_interface_used));
+	parStrncpy(cfg.hw_serial_number, "Fer23u948590", sizeof(cfg.hw_serial_number));
+	parStrncpy(cfg.hw_mac , "123567892366", sizeof(cfg.hw_mac));
+	set_parodus_cfg(&cfg);
+
+	/* To test curl failure case and retry on v4 mode */
+	will_return (curl_easy_perform, -1);
+	expect_function_calls (curl_easy_perform, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	/* To test curl failure case and retry on v6 mode */
+	will_return (curl_easy_perform, -1);
+	expect_function_calls (curl_easy_perform, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	/* To test curl success case */
+	will_return (curl_easy_perform, 0);
+	expect_function_calls (curl_easy_perform, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	getAuthToken(&cfg);
+
+	free(cfg.client_cert_path);
+	free(cfg.token_server_url);
+}
+
+void test_getAuthTokenFailure ()
+{
+	ParodusCfg cfg;
+	memset(&cfg,0,sizeof(cfg));
+
+	cfg.token_server_url = strdup("https://dev.comcast.net/token");
+	cfg.client_cert_path = strdup("testcert");
+	parStrncpy(cfg.cert_path , "/etc/ssl/certs/ca-certificates.crt", sizeof(cfg.cert_path));
+	parStrncpy(cfg.webpa_interface_used , "eth0", sizeof(cfg.webpa_interface_used));
+	parStrncpy(cfg.hw_serial_number, "Fer23u948590", sizeof(cfg.hw_serial_number));
+	parStrncpy(cfg.hw_mac , "123567892366", sizeof(cfg.hw_mac));
+	set_parodus_cfg(&cfg);
+	will_return (curl_easy_perform, -1);
+	expect_function_calls (curl_easy_perform, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_perform, -1);
+	expect_function_calls (curl_easy_perform, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_perform, -1);
+	expect_function_calls (curl_easy_perform, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	will_return (curl_easy_getinfo, 0);
+	expect_function_calls (curl_easy_getinfo, 1);
+
+	getAuthToken(&cfg);
+
+	assert_string_equal( cfg.webpa_auth_token, "");
+
+	free(cfg.client_cert_path);
+	free(cfg.token_server_url);
+}
+
+void test_write_callback_fn ()
+{
+	void *buffer;
+	size_t size = 1;
+	size_t nmemb =8;
+	int out_len=0;
+	struct token_data data;
+	data.size = 0;
+	buffer = strdup("response");
+
+	data.data = (char *) malloc(sizeof(char) * 5);
+	data.data[0] = '\0';
+
+	out_len = write_callback_fn(buffer, size, nmemb, &data);
+	assert_string_equal(data.data, buffer);
+	assert_int_equal( out_len, strlen(buffer));
+	free(data.data);
+}
+
+/*----------------------------------------------------------------------------*/
+/*                             External Functions                             */
+/*----------------------------------------------------------------------------*/
+
+int main(void)
+{
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(test_requestNewAuthToken),
+	cmocka_unit_test(test_requestNewAuthToken_init_fail),
+	cmocka_unit_test(test_requestNewAuthToken_failure),
+	cmocka_unit_test(getAuthToken_Null),
+	cmocka_unit_test(getAuthToken_MacNull),
+	cmocka_unit_test(test_getAuthToken),
+	cmocka_unit_test(test_getAuthTokenFailure),
+	cmocka_unit_test(test_write_callback_fn),
+    };
+
+    return cmocka_run_group_tests(tests, NULL, NULL);
+}
--- a/tests/test_client_list.c
+++ b/tests/test_client_list.c
@@ -26,6 +26,9 @@
 #define TEST_CLIENT1_URL "tcp://127.0.0.1:6677"
 #define TEST_CLIENT2_URL "tcp://127.0.0.1:6655"

+pthread_t test_tid;
+pthread_t test_tid2;
+
 static void *client_rcv_task();
 static void *client2_rcv_task();

@@ -58,7 +61,7 @@ void test_client_addtolist()
 	ParodusPrint("decoded service_name:%s\n", message->u.reg.service_name);
 	ParodusPrint("decoded dest:%s\n", message->u.reg.url);
 	
-	StartThread(client_rcv_task);
+	StartThread(client_rcv_task, &test_tid);
 	
 	status = addToList(&message);
 	ParodusPrint("addToList status is %d\n", status);
@@ -73,7 +76,7 @@ void test_client_addtolist()
 		CU_ASSERT_STRING_EQUAL( temp->service_name, message->u.reg.service_name );
 		CU_ASSERT_STRING_EQUAL( temp->url, message->u.reg.url );
 	}
-
+	release_global_node ();
 	wrp_free_struct(message);
 	free(bytes);
 	ParodusInfo("test_client_addtolist done..\n");	
@@ -189,7 +192,7 @@ void test_addtolist_multiple_clients()
 	ParodusPrint("decoded service_name:%s\n", message->u.reg.service_name);
 	ParodusPrint("decoded dest:%s\n", message->u.reg.url);
 	
-	StartThread(client2_rcv_task);
+	StartThread(client2_rcv_task, &test_tid2);
 	
 	status = addToList(&message);
 	ParodusPrint("addToList status is %d\n", status);
@@ -206,7 +209,7 @@ void test_addtolist_multiple_clients()
 		CU_ASSERT_STRING_EQUAL( temp->url, message->u.reg.url );
 		
 	}
-
+	release_global_node ();
 	wrp_free_struct(message);
 	free(bytes);
 	ParodusInfo("test_addtolist_multiple_clients done..\n");	
--- a/tests/test_config.c
+++ b/tests/test_config.c
@@ -25,6 +25,7 @@
 #include <CUnit/Basic.h>

 #include "../src/config.h"
+#include "../src/auth_token.h"
 #include "../src/ParodusInternal.h"

 extern int parse_mac_address (char *target, const char *arg);
@@ -37,8 +38,6 @@ extern int parse_webpa_url (const char *full_url,
 	char **server_addr, unsigned int *port);
 extern unsigned int get_algo_mask (const char *algo_str);
 extern unsigned int parse_num_arg (const char *arg, const char *arg_name);
-extern void execute_token_script(char *token, char *name, size_t len, char *mac, char *serNum);
-extern void createNewAuthToken(char *newToken, size_t len);

 /*----------------------------------------------------------------------------*/
 /*                                   Mocks                                    */
@@ -53,6 +52,7 @@ void create_token_script(char *fname)
    sprintf(command, "chmod +x %s",fname);
    system(command);
 }
+
 /*----------------------------------------------------------------------------*/
 /*                                   Tests                                    */
 /*----------------------------------------------------------------------------*/
@@ -184,9 +184,10 @@ void test_parseCommandLine()
 #endif
 		"--force-ipv4",
 		"--force-ipv6",
-		"--token-read-script=/tmp/token.sh",
-		"--token-acquisition-script=/tmp/token.sh",
+		"--boot-time-retry-wait=10",
 		"--ssl-cert-path=/etc/ssl/certs/ca-certificates.crt",
+		"--client-cert-path=testcert",
+		"--token-server-url=https://dev.comcast.net/token",
 #ifdef FEATURE_DNS_QUERY
 		"--acquire-jwt=1",
 		"--dns-txt-url=mydns.mycom.net",
@@ -214,6 +215,7 @@ void test_parseCommandLine()
    assert_string_equal( parodusCfg.hw_last_reboot_reason, "unknown");	
    assert_string_equal( parodusCfg.fw_name, "TG1682_DEV_master_2016000000sdy");	
    assert_int_equal( (int) parodusCfg.webpa_ping_timeout,180);	
+    assert_int_equal( (int) parodusCfg.boot_retry_wait,10);
    assert_string_equal( parodusCfg.webpa_interface_used, "br0");	
    assert_string_equal( parodusCfg.webpa_url, "http://127.0.0.1");
    assert_int_equal( (int) parodusCfg.webpa_backoff_max,0);
@@ -224,18 +226,20 @@ void test_parseCommandLine()
    assert_string_equal(  parodusCfg.seshat_url, "ipc://127.0.0.1:7777");
 #endif
    assert_int_equal( (int) parodusCfg.flags, FLAGS_IPV6_ONLY|FLAGS_IPV4_ONLY);
-    sprintf(expectedToken,"secure-token-%s-%s",parodusCfg.hw_serial_number,parodusCfg.hw_mac);
-    getAuthToken(&parodusCfg);
-    set_parodus_cfg(&parodusCfg);
    
+    set_parodus_cfg(&parodusCfg);
+    getAuthToken(&parodusCfg);
    assert_string_equal(  get_parodus_cfg()->webpa_auth_token,expectedToken);
    assert_string_equal(  parodusCfg.cert_path,"/etc/ssl/certs/ca-certificates.crt");
+	assert_string_equal(  parodusCfg.client_cert_path,"testcert");
+	assert_string_equal(  parodusCfg.token_server_url,"https://dev.comcast.net/token");
 #ifdef FEATURE_DNS_QUERY
 	assert_int_equal( (int) parodusCfg.acquire_jwt, 1);
    assert_string_equal(parodusCfg.dns_txt_url, "mydns.mycom.net");
    assert_int_equal( (int) parodusCfg.jwt_algo, 1024);
 	assert_string_equal ( get_parodus_cfg()->jwt_key, jwt_key);
 #endif
+	assert_int_equal( (int) parodusCfg.boot_retry_wait, 10);
 	assert_string_equal(parodusCfg.crud_config_file, "parodus_cfg.json");
 }

@@ -317,13 +321,13 @@ void test_loadParodusCfg()
    Cfg->jwt_algo = 1025;
    parStrncpy(Cfg->jwt_key, "AGdyuwyhwl2ow2ydsoioiygkshwdthuwd",sizeof(Cfg->jwt_key));
 #endif
-    parStrncpy(Cfg->token_acquisition_script , "/tmp/token.sh", sizeof(Cfg->token_acquisition_script));
-    parStrncpy(Cfg->token_read_script , "/tmp/token.sh", sizeof(Cfg->token_read_script));
    parStrncpy(Cfg->cert_path, "/etc/ssl.crt",sizeof(Cfg->cert_path));
 #ifdef ENABLE_SESHAT
    parStrncpy(Cfg->seshat_url, "ipc://tmp/seshat_service.url", sizeof(Cfg->seshat_url));
 #endif
 	Cfg->crud_config_file = strdup("parodus_cfg.json");
+	Cfg->client_cert_path = strdup("testcert");
+	Cfg->token_server_url = strdup("https://dev.comcast.net/token");
    memset(&tmpcfg,0,sizeof(ParodusCfg));
    loadParodusCfg(Cfg,&tmpcfg);

@@ -334,14 +338,14 @@ void test_loadParodusCfg()
    assert_string_equal( tmpcfg.local_url, "tcp://10.0.0.1:6000");
    assert_string_equal( tmpcfg.partner_id, "shaw");
    assert_string_equal( tmpcfg.webpa_protocol, protocol);
+	assert_string_equal(tmpcfg.client_cert_path, "testcert");
+	assert_string_equal(tmpcfg.token_server_url, "https://dev.comcast.net/token");
 #ifdef FEATURE_DNS_QUERY
 	assert_int_equal( (int) tmpcfg.acquire_jwt, 1);
    assert_string_equal(tmpcfg.dns_txt_url, "mydns");
    assert_int_equal( (int) tmpcfg.jwt_algo, 1025);
    assert_string_equal(tmpcfg.jwt_key, "AGdyuwyhwl2ow2ydsoioiygkshwdthuwd");
 #endif
-    assert_string_equal(  tmpcfg.token_acquisition_script,"/tmp/token.sh");
-    assert_string_equal(  tmpcfg.token_read_script,"/tmp/token.sh");
    assert_string_equal(tmpcfg.cert_path, "/etc/ssl.crt");
 #ifdef ENABLE_SESHAT
    assert_string_equal(tmpcfg.seshat_url, "ipc://tmp/seshat_service.url");
@@ -553,47 +557,6 @@ void test_get_algo_mask ()
 #endif	
 }

-void test_execute_token_script()
-{
-  char *cmd1 = "../../tests/return_ser_mac.bsh";
-  char *cmd2 = "nosuch";
-  char token[32];
-  
-  memset (token, '\0', sizeof(token));
-  execute_token_script (token, cmd1, sizeof(token), "mac123", "ser456");
-  assert_string_equal (token, "SER_MAC ser456 mac123");
-  
-  memset (token, '\0', sizeof(token));
-  execute_token_script (token, cmd2, sizeof(token), "mac123", "ser456");
-  assert_string_equal (token, "");
-}
-
-void test_new_auth_token ()
-{
-  char token[64];
-  ParodusCfg cfg;
-  memset(&cfg,0,sizeof(cfg));
-
-  parStrncpy (cfg.token_acquisition_script, "../../tests/return_success.bsh",
-	sizeof(cfg.token_acquisition_script));
-  parStrncpy (cfg.token_read_script, "../../tests/return_ser_mac.bsh",
-	sizeof(cfg.token_read_script));
-  parStrncpy(cfg.hw_serial_number, "Fer23u948590", sizeof(cfg.hw_serial_number));
-  parStrncpy(cfg.hw_mac , "123567892366", sizeof(cfg.hw_mac));
-	
-  set_parodus_cfg(&cfg);
-  createNewAuthToken (token, sizeof(token));
-  assert_string_equal (token, "SER_MAC Fer23u948590 123567892366");
-  
-  memset (token, 0, sizeof(token));
-  parStrncpy (cfg.token_acquisition_script, "../../tests/return_failure.bsh",
-	sizeof(cfg.token_acquisition_script));
-  set_parodus_cfg(&cfg);
-  createNewAuthToken (token, sizeof(token));
-  assert_string_equal (token, "");  
-	
-}
-
 /*----------------------------------------------------------------------------*/
 /*                             External Functions                             */
 /*----------------------------------------------------------------------------*/
@@ -618,8 +581,6 @@ int main(void)
        //cmocka_unit_test(test_parodusGitVersion),
        cmocka_unit_test(test_setDefaultValuesToCfg),
        cmocka_unit_test(err_setDefaultValuesToCfg),
-        cmocka_unit_test(test_execute_token_script),
-        cmocka_unit_test(test_new_auth_token)
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
--- a/tests/test_conn_interface.c
+++ b/tests/test_conn_interface.c
@@ -35,8 +35,12 @@
 /*----------------------------------------------------------------------------*/
 UpStreamMsg *UpStreamMsgQ;
 ParodusMsg *ParodusMsgQ;
-pthread_mutex_t nano_mut;
-pthread_cond_t nano_con;
+pthread_mutex_t g_mutex=PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t g_cond=PTHREAD_COND_INITIALIZER;
+pthread_mutex_t nano_mut=PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t nano_con=PTHREAD_COND_INITIALIZER;
+pthread_mutex_t svc_mut=PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t svc_con=PTHREAD_COND_INITIALIZER;

 
 /*----------------------------------------------------------------------------*/
@@ -103,9 +107,9 @@ void *messageHandlerTask()
    return NULL;
 }

-void *serviceAliveTask()
+int serviceAliveTask()
 {
-    return NULL;
+    return 0;
 }

 int nopoll_loop_wait(noPollCtx * ctx,long timeout)
@@ -156,12 +160,18 @@ void set_global_conn(noPollConn *conn)
    function_called();
 }

-void StartThread(void *(*start_routine) (void *))
+void StartThread(void *(*start_routine) (void *), pthread_t *threadId)
 {
    UNUSED(start_routine);
+    UNUSED(threadId);
    function_called(); 
 }

+void JoinThread (pthread_t threadId)
+{
+    UNUSED(threadId);
+}
+
 noPollCtx* nopoll_ctx_new(void)
 {
    function_called();
@@ -192,6 +202,16 @@ pthread_mutex_t *get_global_nano_mut(void)
    return &nano_mut;
 }

+pthread_cond_t *get_global_svc_con(void)
+{
+    return &svc_con;
+}
+
+pthread_mutex_t *get_global_svc_mut(void)
+{
+    return &svc_mut;
+}
+
 /*
 * Mock func to calculate time diff between start and stop time
 * This timespec_diff retuns 1 sec as diff time
@@ -205,6 +225,10 @@ void timespec_diff(struct timespec *start, struct timespec *stop,
   diff->tv_nsec = 1000;
 }

+void deleteAllClients (void)
+{
+}
+
 /*----------------------------------------------------------------------------*/
 /*                                   Tests                                    */
 /*----------------------------------------------------------------------------*/
--- a/tests/test_connection.c
+++ b/tests/test_connection.c
@@ -63,6 +63,7 @@ bool LastReasonStatus;
 pthread_mutex_t close_mut;

 // Mock values
+bool g_shutdown = false;
 char *mock_server_addr;
 unsigned int mock_port;
 int mock_wait_status;
@@ -380,7 +381,6 @@ void test_set_extra_headers ()
  create_connection_ctx_t ctx;
  ParodusCfg cfg;
  const char *expected_extra_headers =
-      "\r\nAuthorization: Bearer SER_MAC Fer23u948590 123567892366"
      "\r\nX-WebPA-Device-Name: mac:123567892366"
      "\r\nX-WebPA-Device-Protocols: wrp-0.11,getset-0.1"
      "\r\nUser-Agent: WebPA-1.6 (2.364s2; TG1682/ARRISGroup,Inc.;)"
@@ -389,15 +389,13 @@ void test_set_extra_headers ()
  memset(&cfg,0,sizeof(cfg));
  memset (&ctx, 0, sizeof(ctx));

-  parStrncpy (cfg.token_acquisition_script, "../../tests/return_success.bsh",
-	sizeof(cfg.token_acquisition_script));    
-  parStrncpy (cfg.token_read_script, "../../tests/return_ser_mac.bsh",
-	sizeof(cfg.token_read_script));
+  cfg.client_cert_path = strdup("testcert");
  parStrncpy(cfg.hw_serial_number, "Fer23u948590", sizeof(cfg.hw_serial_number));
  parStrncpy(cfg.hw_mac , "123567892366", sizeof(cfg.hw_mac));
  parStrncpy(cfg.hw_model, "TG1682", sizeof(cfg.hw_model));
  parStrncpy(cfg.hw_manufacturer , "ARRISGroup,Inc.", sizeof(cfg.hw_manufacturer));
  parStrncpy(cfg.fw_name , "2.364s2", sizeof(cfg.fw_name));
+  parStrncpy(cfg.cert_path , "/etc/ssl/certs/ca-certificates.crt", sizeof(cfg.cert_path));
  parStrncpy(cfg.webpa_protocol , "WebPA-1.6", sizeof(cfg.webpa_protocol));
 	
  set_parodus_cfg(&cfg);
@@ -409,9 +407,9 @@ void test_set_extra_headers ()
  assert_string_equal (ctx.header_info.conveyHeader, "WebPA-1.6 (TG1682)");
  set_extra_headers (&ctx, true);
  
-  assert_string_equal (get_parodus_cfg()->webpa_auth_token, 
-    "SER_MAC Fer23u948590 123567892366");
  assert_string_equal (ctx.extra_headers, expected_extra_headers);
+  if(cfg.client_cert_path !=NULL) {
+  free(cfg.client_cert_path); }
  free (ctx.extra_headers);
  free_header_info (&ctx.header_info);
 	
@@ -515,34 +513,58 @@ void test_nopoll_connect ()
  test_server.allow_insecure = 1;
  will_return (nopoll_conn_new_opts, NULL);
  expect_function_call (nopoll_conn_new_opts);
-  will_return (checkHostIp, 0);
-  expect_function_call (checkHostIp);
+  //will_return (checkHostIp, 0);
+  //expect_function_call (checkHostIp);
  assert_int_equal (nopoll_connect (&ctx, true), 0);
  assert_ptr_equal(NULL, get_global_conn());
  
  test_server.allow_insecure = 0;
  will_return (nopoll_conn_tls_new6, NULL);
  expect_function_call (nopoll_conn_tls_new6);
+  //will_return (checkHostIp, 0);
+  //expect_function_call (checkHostIp);
+  assert_int_equal (nopoll_connect (&ctx, true), 0);
+  assert_ptr_equal(NULL, get_global_conn());
+
+  will_return (nopoll_conn_tls_new, NULL);
+  expect_function_call (nopoll_conn_tls_new);
  will_return (checkHostIp, 0);
  expect_function_call (checkHostIp);
-  assert_int_equal (nopoll_connect (&ctx, true), 0);
+  assert_int_equal (nopoll_connect (&ctx, false), 0);
  assert_ptr_equal(NULL, get_global_conn());

  will_return (nopoll_conn_tls_new6, NULL);
  expect_function_call (nopoll_conn_tls_new6);
+  //will_return (checkHostIp, -2);
+  //expect_function_call (checkHostIp);
+  assert_int_equal (nopoll_connect (&ctx, true), 0);
+  assert_ptr_equal(NULL, get_global_conn());
+
+  will_return (nopoll_conn_tls_new, NULL);
+  expect_function_call (nopoll_conn_tls_new);
  will_return (checkHostIp, -2);
  expect_function_call (checkHostIp);
-  assert_int_equal (nopoll_connect (&ctx, true), 0);
+  assert_int_equal (nopoll_connect (&ctx, false), 0);
  assert_ptr_equal(NULL, get_global_conn());

  will_return (nopoll_conn_tls_new6, NULL);
  expect_function_call (nopoll_conn_tls_new6);
+  //will_return (checkHostIp, -2);
+  //expect_function_call (checkHostIp);
+  //ctx.connect_timer.start_time.tv_sec -= (15*60);
+  //will_return(kill, 1);
+  //expect_function_call(kill);
+  assert_int_equal (nopoll_connect (&ctx, true), 0);
+  assert_ptr_equal(NULL, get_global_conn());
+
+  will_return (nopoll_conn_tls_new, NULL);
+  expect_function_call (nopoll_conn_tls_new);
  will_return (checkHostIp, -2);
  expect_function_call (checkHostIp);
  ctx.connect_timer.start_time.tv_sec -= (15*60);
  will_return(kill, 1);
  expect_function_call(kill);
-  assert_int_equal (nopoll_connect (&ctx, true), 0);
+  assert_int_equal (nopoll_connect (&ctx, false), 0);
  assert_ptr_equal(NULL, get_global_conn());

  init_expire_timer (&ctx.connect_timer);
@@ -714,8 +736,8 @@ void test_connect_and_wait ()
  test_server.allow_insecure = 0;
  will_return (nopoll_conn_tls_new6, NULL);
  expect_function_call (nopoll_conn_tls_new6);
-  will_return (checkHostIp, 0);
-  expect_function_call (checkHostIp);
+  //will_return (checkHostIp, 0);
+  //expect_function_call (checkHostIp);
  assert_int_equal (connect_and_wait (&ctx), CONN_WAIT_RETRY_DNS);
  
  Cfg.flags = 0;
@@ -723,8 +745,8 @@ void test_connect_and_wait ()

  will_return (nopoll_conn_tls_new6, NULL);
  expect_function_call (nopoll_conn_tls_new6);
-  will_return (checkHostIp, 0);
-  expect_function_call (checkHostIp);
+  //will_return (checkHostIp, 0);
+  //expect_function_call (checkHostIp);
  will_return (nopoll_conn_tls_new, NULL);
  expect_function_call (nopoll_conn_tls_new);
  will_return (checkHostIp, 0);
--- a/tests/test_crud_interface.c
+++ b/tests/test_crud_interface.c
@@ -35,9 +35,11 @@
 /*----------------------------------------------------------------------------*/
 /*                            File Scoped Variables                           */
 /*----------------------------------------------------------------------------*/
+bool g_shutdown  = false;
 extern CrudMsg *crudMsgQ;
 int numLoops = 1;
 wrp_msg_t *temp = NULL;
+
 /*----------------------------------------------------------------------------*/
 /*                                   Mocks                                    */
 /*----------------------------------------------------------------------------*/
--- a/tests/test_crud_internal.c
+++ b/tests/test_crud_internal.c
@@ -165,7 +165,7 @@ void test_retrieveFromMemory()
 	assert_int_equal (ret, 0);
 	ret = retrieveFromMemory("webpa-protocol", &jsonresponse );
 	assert_int_equal (ret, 0);
-	ret = retrieveFromMemory("webpa-inteface-used", &jsonresponse );
+	ret = retrieveFromMemory("webpa-interface-used", &jsonresponse );
 	assert_int_equal (ret, 0);
 	ret = retrieveFromMemory("webpa-backoff-max", &jsonresponse );
 	assert_int_equal (ret, 0);
@@ -200,7 +200,7 @@ void test_retrieveFromMemoryFailure()
 	assert_int_equal (ret, -1);
 	ret = retrieveFromMemory("webpa-protocol", &jsonresponse );
 	assert_int_equal (ret, -1);
-	ret = retrieveFromMemory("webpa-inteface-used", &jsonresponse );
+	ret = retrieveFromMemory("webpa-interface-used", &jsonresponse );
 	assert_int_equal (ret, -1);
 	ret = retrieveFromMemory("webpa-backoff-max", &jsonresponse );
 	assert_int_equal (ret, 0);
--- a/tests/test_downstream.c
+++ b/tests/test_downstream.c
@@ -61,6 +61,10 @@ reg_list_item_t * get_global_node(void)
    return mock_ptr_type(reg_list_item_t *);
 }

+void release_global_node (void)
+{
+}
+
 ssize_t wrp_to_struct( const void *bytes, const size_t length,
                       const enum wrp_format fmt, wrp_msg_t **msg )
 {
@@ -68,7 +72,7 @@ ssize_t wrp_to_struct( const void *bytes, const size_t length,
    function_called();
    *msg = (wrp_msg_t*) malloc(sizeof(wrp_msg_t));
    memset(*msg, 0, sizeof(wrp_msg_t));
-	(*msg)->msg_type = WRP_MSG_TYPE__REQ;
+	(*msg)->msg_type = WRP_MSG_TYPE__REQ;   
 	(*msg)->u.req.dest = (char *) malloc(sizeof(char) *100);
 	(*msg)->u.req.partner_ids = (partners_t *) malloc(sizeof(partners_t));
 	(*msg)->u.req.partner_ids->count = 1;
@@ -79,8 +83,10 @@ ssize_t wrp_to_struct( const void *bytes, const size_t length,
 	{
 			(*msg)->msg_type = WRP_MSG_TYPE__CREATE;
 			parStrncpy((*msg)->u.crud.dest,"mac:1122334455/parodus", 100);
-			(*msg)->u.crud.source = "tag-update";
-			(*msg)->u.crud.transaction_uuid = "1234";
+                        (*msg)->u.crud.source = (char *) malloc(sizeof(char) *40);
+			parStrncpy ((*msg)->u.crud.source, "tag-update", 40);
+                        (*msg)->u.crud.transaction_uuid = (char *) malloc(sizeof(char) *40);
+			parStrncpy ((*msg)->u.crud.transaction_uuid, "1234", 40);
 	}
    return (ssize_t) mock();
 }
--- a/tests/test_downstream_more.c
+++ b/tests/test_downstream_more.c
@@ -244,6 +244,10 @@ reg_list_item_t *get_global_node(void)
    return NULL;
 }

+void release_global_node (void)
+{
+}
+
 void wrp_free_struct( wrp_msg_t *msg )
 {
    if( WRP_MSG_TYPE__EVENT == tests[i].s.msg_type ) {
--- a/tests/test_service_alive.c
+++ b/tests/test_service_alive.c
@@ -33,6 +33,18 @@ static void *keep_alive_thread();
 static void add_client();
 int sock1;
 pthread_t threadId;
+pthread_mutex_t crud_mut=PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t crud_con=PTHREAD_COND_INITIALIZER;
+
+pthread_cond_t *get_global_crud_con(void)
+{
+    return &crud_con;
+}
+
+pthread_mutex_t *get_global_crud_mut(void)
+{
+    return &crud_mut;
+}

 /*----------------------------------------------------------------------------*/
 /*                                   Tests                                    */
@@ -48,12 +60,14 @@ void *CRUDHandlerTask()
 {
 	return NULL;
 }
+
 static void add_client()
 {
 	const wrp_msg_t reg = { .msg_type = WRP_MSG_TYPE__SVC_REGISTRATION,
 	  .u.reg.service_name = "service_client",
 	  .u.reg.url = TEST_SERVICE_URL};
 	  
+	pthread_t test_tid;
 	void *bytes;
 	int size =0;
 	int rv;
@@ -71,7 +85,7 @@ static void add_client()
 	ParodusPrint("decoded service_name:%s\n", message->u.reg.service_name);
 	ParodusPrint("decoded dest:%s\n", message->u.reg.url);
 	
-	StartThread(client_rcv_task);
+	StartThread(client_rcv_task, &test_tid);
 	status = addToList(&message);
 	ParodusPrint("addToList status is %d\n", status);
 	
@@ -134,7 +148,10 @@ static void *keep_alive_thread()
 	//ParodusPrint("keep_alive threadId is %d\n", threadId);
 	sleep(2);
 	ParodusPrint("Starting serviceAliveTask..\n");
-	serviceAliveTask();
+	while (true) {
+	  serviceAliveTask();
+	  sleep (30);
+	}
 	return 0;
 }

--- a/tests/test_spin_thread_e.c
+++ b/tests/test_spin_thread_e.c
@@ -23,6 +23,8 @@
 #include "../src/ParodusInternal.h"
 #include "../src/spin_thread.h"

+pthread_t test_tid;
+
 /*----------------------------------------------------------------------------*/
 /*                                   Mocks                                    */
 /*----------------------------------------------------------------------------*/
@@ -54,7 +56,7 @@ void *_routine(void *v)

 void test_StartThread_error()
 {
-    StartThread(&_routine);
+    StartThread(&_routine, &test_tid);
 }

 void add_suites( CU_pSuite *suite )
--- a/tests/test_spin_thread_s.c
+++ b/tests/test_spin_thread_s.c
@@ -23,6 +23,8 @@
 #include "../src/ParodusInternal.h"
 #include "../src/spin_thread.h"

+pthread_t test_tid;
+
 /*----------------------------------------------------------------------------*/
 /*                                   Mocks                                    */
 /*----------------------------------------------------------------------------*/
@@ -44,7 +46,7 @@ void *_routine(void *v)

 void test_StartThread_success()
 {
-    StartThread(&_routine);
+    StartThread(&_routine, &test_tid);
 }

 void add_suites( CU_pSuite *suite )
--- a/tests/test_thread_tasks.c
+++ b/tests/test_thread_tasks.c
@@ -30,6 +30,7 @@
 /*----------------------------------------------------------------------------*/
 /*                            File Scoped Variables                           */
 /*----------------------------------------------------------------------------*/
+bool g_shutdown  = false;
 ParodusMsg *ParodusMsgQ;
 pthread_mutex_t g_mutex;
 pthread_cond_t g_cond;
--- a/tests/test_token.c
+++ b/tests/test_token.c
@@ -158,6 +158,19 @@ extern void read_key_from_file (const char *fname, char *buf, size_t buflen);
 extern const char *get_tok (const char *src, int delim, char *result, int resultsize);
 extern unsigned int get_algo_mask (const char *algo_str);

+pthread_mutex_t crud_mut=PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t crud_con=PTHREAD_COND_INITIALIZER;
+
+pthread_cond_t *get_global_crud_con(void)
+{
+    return &crud_con;
+}
+
+pthread_mutex_t *get_global_crud_mut(void)
+{
+    return &crud_mut;
+}
+
 void addCRUDmsgToQueue(wrp_msg_t *crudMsg)
 {
 	(void)crudMsg;
--- a/tests/test_token_stub.c
+++ b/tests/test_token_stub.c
@@ -23,7 +23,7 @@
 #include <cmocka.h>
 #include <assert.h>
 #include <wrp-c.h>
-
+#include <pthread.h>
 #include "../src/token.h"


@@ -31,6 +31,20 @@
 /*                                   Mocks                                    */
 /*----------------------------------------------------------------------------*/

+
+pthread_mutex_t crud_mut=PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t crud_con=PTHREAD_COND_INITIALIZER;
+
+pthread_cond_t *get_global_crud_con(void)
+{
+    return &crud_con;
+}
+
+pthread_mutex_t *get_global_crud_mut(void)
+{
+    return &crud_mut;
+}
+
 void addCRUDmsgToQueue(wrp_msg_t *crudMsg)
 {
 	(void)crudMsg;
--- a/tests/test_upstream.c
+++ b/tests/test_upstream.c
@@ -38,10 +38,12 @@
 /*----------------------------------------------------------------------------*/
 static noPollConn *conn;
 static char *reconnect_reason = "webpa_process_starts";
+bool g_shutdown  = false;
 static ParodusCfg parodusCfg;
 extern size_t metaPackSize;
 extern UpStreamMsg *UpStreamMsgQ;
 int numLoops = 1;
+int deviceIDNull =0;
 wrp_msg_t *temp = NULL;
 extern pthread_mutex_t nano_mut;
 extern pthread_cond_t nano_con;
@@ -66,6 +68,10 @@ reg_list_item_t * get_global_node(void)
    return mock_ptr_type(reg_list_item_t *);
 }

+void release_global_node (void)
+{
+}
+
 int get_numOfClients()
 {
    function_called();
@@ -92,8 +98,21 @@ void sendMessage(noPollConn *conn, void *msg, size_t len)
    function_called();
 }

+void set_parodus_cfg(ParodusCfg *cfg)
+{
+    memcpy(&parodusCfg, cfg, sizeof(ParodusCfg));
+}
+
 ParodusCfg *get_parodus_cfg(void) 
 {
+	ParodusCfg cfg;
+	memset(&cfg,0,sizeof(cfg));
+	parStrncpy(cfg.hw_mac , "14cfe2142xxx", sizeof(cfg.hw_mac));
+	if(deviceIDNull)
+	{
+		parStrncpy(cfg.hw_mac , "", sizeof(cfg.hw_mac));
+	}
+	set_parodus_cfg(&cfg);
    return &parodusCfg;
 }

@@ -196,6 +215,13 @@ int nn_shutdown (int s, int how)
    return (int)mock();
 }

+int nn_close (int s)
+{
+    UNUSED(s);
+    function_called();
+    return (int)mock();
+}
+
 int nn_setsockopt (int s, int level, int option, const void *optval, size_t optvallen)
 {
    UNUSED(s); UNUSED(level); UNUSED(option); UNUSED(optval); UNUSED(optvallen);
@@ -241,6 +267,8 @@ void test_handleUpstreamNull()
    UpStreamMsgQ = NULL;
    will_return(nn_socket, 1);
    expect_function_call(nn_socket);
+    will_return(nn_setsockopt, 0);
+    expect_function_call(nn_setsockopt);
    will_return(nn_bind, 1);
    expect_function_call(nn_bind);
    will_return(nn_recv, 12);
@@ -260,6 +288,8 @@ void test_handle_upstream()
    UpStreamMsgQ->next->next = NULL;
    will_return(nn_socket, 1);
    expect_function_call(nn_socket);
+    will_return(nn_setsockopt, 0);
+    expect_function_call(nn_setsockopt);
    will_return(nn_bind, 1);
    expect_function_call(nn_bind);
    will_return(nn_recv, 12);
@@ -273,6 +303,8 @@ void err_handleUpstreamBindFailure()
 {
    will_return(nn_socket, 1);
    expect_function_call(nn_socket);
+    will_return(nn_setsockopt, 0);
+    expect_function_call(nn_setsockopt);
    will_return(nn_bind, -1);
    expect_function_call(nn_bind);
    handle_upstream();
@@ -414,15 +446,18 @@ void test_processUpstreamMessageRegMsg()
    will_return(wrp_to_struct, 12);
    expect_function_call(wrp_to_struct);

-    will_return(get_numOfClients, 1);
-    expect_function_call(get_numOfClients);
-
    will_return(get_global_node, (intptr_t)head);
    expect_function_call(get_global_node);

+    will_return(get_numOfClients, 1);
+    expect_function_call(get_numOfClients);
+
    will_return(nn_shutdown, 1);
    expect_function_call(nn_shutdown);

+    will_return(nn_close, 0);
+    expect_function_call(nn_close);
+
    will_return(nn_socket, 1);
    expect_function_call(nn_socket);

@@ -473,6 +508,9 @@ void test_processUpstreamMessageRegMsgNoClients()
    will_return(wrp_to_struct, 12);
    expect_function_call(wrp_to_struct);

+    will_return(get_global_node, (intptr_t)head);
+    expect_function_call(get_global_node);
+
    will_return(get_numOfClients, 0);
    expect_function_call(get_numOfClients);

@@ -570,21 +608,27 @@ void err_processUpstreamMessageRegMsg()
    will_return(wrp_to_struct, 12);
    expect_function_call(wrp_to_struct);

-    will_return(get_numOfClients, 1);
-    expect_function_call(get_numOfClients);
-
    will_return(get_global_node, (intptr_t)head);
    expect_function_call(get_global_node);

+    will_return(get_numOfClients, 1);
+    expect_function_call(get_numOfClients);
+
    will_return(nn_shutdown, -1);
    expect_function_call(nn_shutdown);

+    will_return(nn_close, 0);
+    expect_function_call(nn_close);
+
    will_return(nn_socket, -1);
    expect_function_call(nn_socket);

    will_return(nn_shutdown, 1);
    expect_function_call(nn_shutdown);

+    will_return(nn_close, 0);
+    expect_function_call(nn_close);
+
    will_return(nn_socket, 1);
    expect_function_call(nn_socket);

@@ -726,16 +770,16 @@ void test_processUpstreamMsg_cloud_status()

 void test_processUpstreamMsg_sendToClient()
 {
-    numLoops = 2;
-    metaPackSize = 20;
+	numLoops = 2;
+	metaPackSize = 20;
 	UpStreamMsgQ = (UpStreamMsg *) malloc(sizeof(UpStreamMsg));
 	UpStreamMsgQ->msg = strdup("First Message");
 	UpStreamMsgQ->len = 13;
 	UpStreamMsgQ->next= NULL;
 	UpStreamMsgQ->next = (UpStreamMsg *) malloc(sizeof(UpStreamMsg));
-    UpStreamMsgQ->next->msg = strdup("Second Message");
-    UpStreamMsgQ->next->len = 15;
-    UpStreamMsgQ->next->next = NULL;
+	UpStreamMsgQ->next->msg = strdup("Second Message");
+	UpStreamMsgQ->next->len = 15;
+	UpStreamMsgQ->next->next = NULL;

 	temp = (wrp_msg_t *) malloc(sizeof(wrp_msg_t));
 	memset(temp,0,sizeof(wrp_msg_t));
@@ -758,86 +802,66 @@ void test_processUpstreamMsg_sendToClient()

 	expect_function_call(wrp_free_struct);
 	processUpstreamMessage();
-    free(temp);
-    free(UpStreamMsgQ);
-    UpStreamMsgQ = NULL;
-}
-void test_processUpstreamMessageNullCheck()
-{
-    numLoops = 1;
-    metaPackSize = 20;
-    UpStreamMsgQ = (UpStreamMsg *) malloc(sizeof(UpStreamMsg));
-    UpStreamMsgQ->msg = strdup("First Message");
-    UpStreamMsgQ->len = 13;
-    UpStreamMsgQ->next= NULL;
-    temp = (wrp_msg_t *) malloc(sizeof(wrp_msg_t));
-    memset(temp,0,sizeof(wrp_msg_t));
-    temp->msg_type = WRP_MSG_TYPE__RETREIVE;
-    temp->u.crud.dest = strdup("mac:14cfe2142xxx/parodus/cloud-status");
-    temp->u.crud.source = strdup("mac:14cfe2142xxx/config");
-    temp->u.crud.transaction_uuid = strdup("123");
-    will_return(wrp_to_struct, 12);
-    expect_function_call(wrp_to_struct);
-    expect_function_call(addCRUDmsgToQueue);
-    will_return(nn_freemsg, 0);
-    expect_function_call(nn_freemsg);
-    expect_function_call(wrp_free_struct);
-    processUpstreamMessage();
-    free(temp);
-    free(UpStreamMsgQ);
-    UpStreamMsgQ = NULL;
-}
-void err_processUpstreamMessageNullCheck()
-{
-    numLoops = 1;
-    metaPackSize = 20;
-    UpStreamMsgQ = (UpStreamMsg *) malloc(sizeof(UpStreamMsg));
-    UpStreamMsgQ->msg = strdup("First Message");
-    UpStreamMsgQ->len = 13;
-    UpStreamMsgQ->next= NULL;
-    temp = (wrp_msg_t *) malloc(sizeof(wrp_msg_t));
-    memset(temp,0,sizeof(wrp_msg_t));
-    temp->msg_type = WRP_MSG_TYPE__RETREIVE;
-    temp->u.crud.dest = strdup("mac:/parodus/cloud-status");
-    temp->u.crud.source = strdup("mac:14cfe2142xxx/config");
-    temp->u.crud.transaction_uuid = strdup("123");
-    will_return(wrp_to_struct, 12);
-    expect_function_call(wrp_to_struct);
-    will_return(nn_freemsg, 0);
-    expect_function_call(nn_freemsg);
-    expect_function_call(wrp_free_struct);
-	
-    processUpstreamMessage();
-    free(temp);
-    free(UpStreamMsgQ);
+	free(temp);
+	free(UpStreamMsgQ);
 	UpStreamMsgQ = NULL;
 }
-void err_processUpstreamMessageWithoutMac()
+
+void test_processUpstreamMsg_serviceNameNULL()
 {
-    numLoops = 1;
-    metaPackSize = 20;
-    UpStreamMsgQ = (UpStreamMsg *) malloc(sizeof(UpStreamMsg));
-    UpStreamMsgQ->msg = strdup("First Message");
-    UpStreamMsgQ->len = 13;
-    UpStreamMsgQ->next= NULL;
-    temp = (wrp_msg_t *) malloc(sizeof(wrp_msg_t));
-    memset(temp,0,sizeof(wrp_msg_t));
-    temp->msg_type = WRP_MSG_TYPE__RETREIVE;
-    temp->u.crud.dest = strdup("/parodus/cloud-status");
-    temp->u.crud.source = strdup("mac:14cfe2142xxx/config");
-    temp->u.crud.transaction_uuid = strdup("123");
-    will_return(wrp_to_struct, 12);
-    expect_function_call(wrp_to_struct);
-    will_return(nn_freemsg, 0);
-    expect_function_call(nn_freemsg);
-    expect_function_call(wrp_free_struct);
-	
-    processUpstreamMessage();
-    free(temp);
-    free(UpStreamMsgQ);
-    UpStreamMsgQ = NULL;
+	numLoops = 1;
+	metaPackSize = 20;
+	UpStreamMsgQ = (UpStreamMsg *) malloc(sizeof(UpStreamMsg));
+	UpStreamMsgQ->msg = strdup("First Message");
+	UpStreamMsgQ->len = 13;
+	UpStreamMsgQ->next= NULL;
+	UpStreamMsgQ->next = (UpStreamMsg *) malloc(sizeof(UpStreamMsg));
+	UpStreamMsgQ->next->msg = strdup("Second Message");
+	UpStreamMsgQ->next->len = 15;
+	UpStreamMsgQ->next->next = NULL;
+
+	temp = (wrp_msg_t *) malloc(sizeof(wrp_msg_t));
+	memset(temp,0,sizeof(wrp_msg_t));
+	temp->msg_type = 6;
+	temp->u.crud.dest = strdup("mac:14cfe2142xxx/");
+	temp->u.crud.source = strdup("mac:14cfe2142xxx/parodus/cloud-status");
+	temp->u.crud.transaction_uuid = strdup("123");
+
+	will_return(wrp_to_struct, 12);
+	expect_function_call(wrp_to_struct);
+	expect_function_call(wrp_free_struct);
+	processUpstreamMessage();
+	free(temp);
+	free(UpStreamMsgQ);
+	UpStreamMsgQ = NULL;
 }

+void err_processUpstreamMsg_deviceID()
+{
+	numLoops = 1;
+	metaPackSize = 20;
+	deviceIDNull = 1;
+	UpStreamMsgQ = (UpStreamMsg *) malloc(sizeof(UpStreamMsg));
+	UpStreamMsgQ->msg = "First Message";
+	UpStreamMsgQ->len = 13;
+	UpStreamMsgQ->next= NULL;
+	temp = (wrp_msg_t *) malloc(sizeof(wrp_msg_t));
+	memset(temp,0,sizeof(wrp_msg_t));
+	temp->msg_type = 6;
+	temp->u.crud.dest = "mac:14cfe2142xxx/parodus/cloud-status";
+	temp->u.crud.source = "mac:14cfe2142xxx/config";
+	temp->u.crud.transaction_uuid = "123";
+
+	will_return(wrp_to_struct, 12);
+	expect_function_call(wrp_to_struct);
+	will_return(nn_freemsg, 0);
+	expect_function_call(nn_freemsg);
+	expect_function_call(wrp_free_struct);
+	processUpstreamMessage();
+	free(temp);
+	free(UpStreamMsgQ);
+	UpStreamMsgQ = NULL;
+}
 /*----------------------------------------------------------------------------*/
 /*                             External Functions                             */
 /*----------------------------------------------------------------------------*/
@@ -870,9 +894,8 @@ int main(void)
        cmocka_unit_test(test_processUpstreamMsgCrud_nnfree),
        cmocka_unit_test(test_processUpstreamMsg_cloud_status),
        cmocka_unit_test(test_processUpstreamMsg_sendToClient),
-	cmocka_unit_test(test_processUpstreamMessageNullCheck),
-	cmocka_unit_test(err_processUpstreamMessageNullCheck),
-	cmocka_unit_test(err_processUpstreamMessageWithoutMac),
+	cmocka_unit_test(test_processUpstreamMsg_serviceNameNULL),
+	cmocka_unit_test(err_processUpstreamMsg_deviceID)
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
Author	SHA1	Message	Date
shilpa24balaji	2bde60e885	Merge pull request #289 from bill1600/camera fix mutex error in service alive	2019-03-17 19:30:34 -07:00
Bill Williams	5d05150249	fix mutex error in service alive	2019-03-17 16:57:20 -07:00
shilpa24balaji	40bf7eeb0e	Merge pull request #287 from bill1600/shutfail add nn_close to nn_shutdown	2019-03-05 15:50:51 -08:00
Bill Williams	fcec26a25f	fix test_upstream test	2019-03-04 15:48:41 -08:00
Bill Williams	1b71082e77	add nn_close to nn_shutdown	2019-03-04 15:28:00 -08:00
shilpa24balaji	4085c56ed6	Merge pull request #284 from sadhyama/master Move auth token request code to separate file	2019-02-18 14:07:15 -08:00
shilpa24balaji	0b700e57ff	Merge pull request #283 from sadhyama/master Add support to use auth token during initial connect to cloud	2019-02-15 12:51:21 -08:00
shilpa24balaji	1b903521d2	Update connection.c	2019-02-15 12:43:14 -08:00
shilpa24balaji	3814f873bc	Update CHANGELOG.md	2019-02-15 12:41:48 -08:00
shilpa24balaji	8a3e4507ef	Update config.c	2019-02-15 12:41:13 -08:00
shilpa24balaji	c7c93254ff	Update README.md	2019-02-15 12:38:45 -08:00
shilpa24balaji	0875751c3f	Update CHANGELOG.md	2019-02-15 12:34:22 -08:00
shilpa24balaji	c2edbbc074	Update CHANGELOG.md	2019-02-15 12:33:41 -08:00
Sadhyama Vengilat	7b03fad90f	Unit tests on auth token request	2019-02-10 11:11:29 +05:30
Sadhyama Vengilat	a5081a5cfa	Move auth jwt request code to separate file	2019-02-10 10:54:56 +05:30
Sadhyama Vengilat	25a6a99c69	Added unit tests for themis curl changes	2019-02-10 01:58:16 +05:30
Sadhyama Vengilat	5a60847e28	Themis JWT token fetch using libcurl	2019-02-09 20:28:27 +05:30
Sadhyama Vengilat	29f00e5850	Remove themis create read scripts command line arguments	2019-02-09 20:25:56 +05:30
Sadhyama Vengilat	4bd9e87125	Add new cmd line argument for client-cert-path and token-server-url	2019-02-09 20:19:06 +05:30
Sadhyama Vengilat	56ab5f13fe	Add libcurl dependency in parodus	2019-02-09 20:12:32 +05:30
shilpa24balaji	57ca4084ce	Update CHANGELOG.md	2019-02-08 16:11:19 -08:00
shilpa24balaji	b001964b71	Merge pull request #281 from sadhyama/parodus-interface To correct the spelling 'webpa-inteface-used' in convey header	2019-02-07 13:05:10 -08:00
Sadhyama Vengilat	c33bb6c1c3	To correct the spelling 'webpa-inteface-used' in convey header	2019-02-07 16:42:42 +05:30
shilpa24balaji	379e63be00	Merge pull request #280 from bill1600/svcalive Svcalive	2019-02-05 16:20:35 -08:00
bill1600	062fdc2ce0	Merge branch 'master' into svcalive	2019-01-28 16:09:08 -08:00
Bill Williams	200522c997	change svc alive back to separate thread. Shut it down with pthread_cond_timedwait	2019-01-28 15:53:29 -08:00
Bill Williams	62540e8db8	fix main loop to keep calling svc_alive_task during cloud disconnect retry	2019-01-25 14:08:27 -08:00
shilpa24balaji	f155dd601c	Merge pull request #278 from sadhyama/master Refactored Upstream Retrieve flow	2019-01-25 12:33:32 -08:00
shilpa24balaji	b9a5770bf9	Merge pull request #277 from gbuddappagari/master To enable valgrind	2019-01-14 10:30:30 -08:00
Sadhyama Vengilat	a717b0a909	Updated changelog	2019-01-12 12:33:58 +05:30
Sadhyama Vengilat	a7b1a145a5	Added unit tests for upstream refactor changes	2019-01-12 12:32:00 +05:30
Sadhyama Vengilat	7bc498b376	Refactor Upstream Retrieve mechanism	2019-01-12 12:15:02 +05:30
Gayathri	fe00e55fff	To enable valgrind	2019-01-11 09:52:55 +05:30
shilpa24balaji	66104dcabc	Merge pull request #275 from gbuddappagari/leak_fix Fixed issues in CRUD message processing	2019-01-10 09:24:24 -08:00
Gayathri	aedd9c972a	To fix memory corruption	2019-01-10 11:03:05 +05:30
shilpa24balaji	99b09179f2	Merge pull request #274 from bill1600/fixleaks Fixleaks	2019-01-08 23:49:35 -08:00
shilpa24balaji	92020ec6ec	Update CMakeLists.txt	2019-01-08 16:57:35 -08:00
shilpa24balaji	9057322fd7	Update CMakeLists.txt	2019-01-08 16:52:39 -08:00
Bill Williams	55c70f3c6f	resolve conflict	2019-01-08 14:49:31 -08:00
Bill Williams	7c07a5dd63	fix test_downstream	2019-01-08 14:38:55 -08:00
Bill Williams	cdd0a9e355	remove unneeded patch, and fix tests	2019-01-08 10:20:34 -08:00
shilpa24balaji	392085b01b	Merge pull request #271 from gbuddappagari/master To fix memory leak in upstream event message flow	2019-01-07 20:12:28 -08:00
Sadhyama Vengilat	bd67050c80	Fix build failure when FEATURE_DNS_QUERY is disabled	2019-01-08 08:56:00 +05:30
Sadhyama Vengilat	cea408a33c	Fix RETRIEVE response processing issue due to mac check	2019-01-08 08:43:19 +05:30
Gayathri	d1522346b4	To fix crash in CRUD request processing	2019-01-09 15:21:13 +05:30
Bill Williams	22feddeadc	properly shut down tasks, and fix memory leaks	2019-01-07 14:24:55 -08:00
Gayathri	df2729084d	To fix memory leak in upstream event message flow	2019-01-04 18:34:27 +05:30
shilpa24balaji	8a61e66456	Merge pull request #267 from bill1600/untask_svc_alive change serviceAlivetask to a function call from main	2018-12-18 14:09:17 -08:00
shilpa24balaji	8a737d6c18	Merge branch 'master' into untask_svc_alive	2018-12-18 14:08:50 -08:00
Bill Williams	905cb3bade	update change log	2018-12-18 13:39:25 -08:00
Shilpa Seshadri	a2d7dfeb95	Log time difference in connect time and boot time only during boot time and not during reconnect	2018-12-17 23:21:04 -08:00
shilpa24balaji	342a8ed250	Merge pull request #268 from bill1600/send_mutex Send mutex. put mutex lock into get_global_node	2018-12-13 15:41:20 -08:00
Bill Williams	97da13ffcc	put mutex lock into get_global_node	2018-12-13 14:07:06 -08:00
Bill Williams	590a43a053	Merge branch 'master' of https://github.com/Comcast/parodus into send_mutex	2018-12-13 13:42:51 -08:00
Bill Williams	0e6e833301	put mutex lock in get_global_node	2018-12-13 13:33:33 -08:00
shilpa24balaji	4525e39de9	Merge pull request #261 from bill1600/send_mutex Send mutex	2018-12-13 11:50:48 -08:00
shilpa24balaji	8d9e9c014a	Merge branch 'master' into send_mutex	2018-12-13 11:49:10 -08:00
Bill Williams	9f6ddb2b78	change serviceAlivetask to a function call from main	2018-12-12 14:23:10 -08:00
Bill Williams	c2f6a64569	Updated change log for send_mutex change	2018-11-30 09:38:41 -08:00
Bill Williams	2f0244af11	make client list and nn_sends thread safe	2018-11-30 09:35:05 -08:00