pceplib: Fixing coverity messages.

Signed-off-by: Javier Garcia <javier.garcia@voltanet.io>

15 files changed, 178 insertions, 41 deletions

diff --git a/pceplib/pcep_msg_messages_encoding.c b/pceplib/pcep_msg_messages_encoding.c
index 23ccef480c..7c8e1b3a1f 100644
--- a/pceplib/pcep_msg_messages_encoding.c
+++ b/pceplib/pcep_msg_messages_encoding.c
@@ -129,7 +129,7 @@ void pcep_encode_message(struct pcep_message *message,
 		message_length +=
 			pcep_encode_object(node->data, versioning,
 					   message_buffer + message_length);
-		if (message_length > PCEP_MESSAGE_LENGTH) {
+		if (message_length >= PCEP_MESSAGE_LENGTH) {
 			message->encoded_message = NULL;
 			message->encoded_message_length = 0;
 			return;
@@ -295,6 +295,14 @@ struct pcep_message *pcep_decode_message(const uint8_t *msg_buf)
 
 	msg_length = pcep_decode_msg_header(msg_buf, &msg_version, &msg_flags,
 					    &msg_type);
+	if (msg_length == 0) {
+		pcep_log(LOG_INFO, "%s: Discarding empty message", __func__);
+		return NULL;
+	}
+	if (msg_length >= PCEP_MESSAGE_LENGTH) {
+		pcep_log(LOG_INFO, "%s: Discarding message too big", __func__);
+		return NULL;
+	}
 
 	struct pcep_message *msg =
 		pceplib_calloc(PCEPLIB_MESSAGES, sizeof(struct pcep_message));
diff --git a/pceplib/pcep_msg_objects_encoding.c b/pceplib/pcep_msg_objects_encoding.c
index d40b840869..c4089ba5ec 100644
--- a/pceplib/pcep_msg_objects_encoding.c
+++ b/pceplib/pcep_msg_objects_encoding.c
@@ -1668,7 +1668,7 @@ struct pcep_object_header *pcep_decode_obj_ro(struct pcep_object_header *hdr,
 
 				ipv6 = pceplib_malloc(PCEPLIB_MESSAGES,
 						      sizeof(struct in6_addr));
-				decode_ipv6(uint32_ptr + LENGTH_4WORDS, ipv6);
+				decode_ipv6(uint32_ptr + 4, ipv6);
 				dll_append(sr_subobj->nai_list, ipv6);
 
 				read_count += LENGTH_8WORDS;
@@ -1684,17 +1684,17 @@ struct pcep_object_header *pcep_decode_obj_ro(struct pcep_object_header *hdr,
 				struct in_addr *ipv4 =
 					pceplib_malloc(PCEPLIB_MESSAGES,
 						       sizeof(struct in_addr));
-				ipv4->s_addr = uint32_ptr[LENGTH_4WORDS];
+				ipv4->s_addr = uint32_ptr[4];
 				dll_append(sr_subobj->nai_list, ipv4);
 
 				ipv6 = pceplib_malloc(PCEPLIB_MESSAGES,
 						      sizeof(struct in6_addr));
-				decode_ipv6(uint32_ptr + LENGTH_5WORDS, ipv6);
+				decode_ipv6(uint32_ptr + 5, ipv6);
 				dll_append(sr_subobj->nai_list, ipv6);
 
 				ipv4 = pceplib_malloc(PCEPLIB_MESSAGES,
 						      sizeof(struct in_addr));
-				ipv4->s_addr = uint32_ptr[LENGTH_9WORDS];
+				ipv4->s_addr = uint32_ptr[9];
 				dll_append(sr_subobj->nai_list, ipv4);
 
 				read_count += LENGTH_10WORDS;
diff --git a/pceplib/pcep_msg_tlvs.c b/pceplib/pcep_msg_tlvs.c
index 890da9517f..9c84e71ee1 100644
--- a/pceplib/pcep_msg_tlvs.c
+++ b/pceplib/pcep_msg_tlvs.c
@@ -401,7 +401,7 @@ pcep_tlv_create_srpag_pol_name(const char *pol_name, uint16_t pol_name_length)
 		(normalize_pcep_tlv_length(pol_name_length) > MAX_POLICY_NAME)
 			? MAX_POLICY_NAME
 			: pol_name_length;
-	memcpy(tlv->name, pol_name, pol_name_length);
+	memcpy(tlv->name, pol_name, length);
 	tlv->name_length = length;
 
 	return tlv;
@@ -456,7 +456,7 @@ pcep_tlv_create_tlv_arbitrary(const char *data, uint16_t data_length,
 	uint16_t length = (data_length > MAX_ARBITRARY_SIZE)
 				  ? MAX_ARBITRARY_SIZE
 				  : data_length;
-	memcpy(tlv->data, data, data_length);
+	memcpy(tlv->data, data, length);
 	tlv->data_length = length;
 	tlv->arbitraty_type = tlv_id;
 
diff --git a/pceplib/pcep_msg_tlvs_encoding.c b/pceplib/pcep_msg_tlvs_encoding.c
index 3322663dc3..967f138143 100644
--- a/pceplib/pcep_msg_tlvs_encoding.c
+++ b/pceplib/pcep_msg_tlvs_encoding.c
@@ -1135,7 +1135,7 @@ struct pcep_object_tlv_header *pcep_decode_tlv_path_setup_type_capability(
 	uint16_t buf_index = normalize_pcep_tlv_length(
 		TLV_HEADER_LENGTH + LENGTH_1WORD + num_psts);
 	while ((tlv->header.encoded_tlv_length - buf_index) > TLV_HEADER_LENGTH
-	       && num_iterations++ > MAX_ITERATIONS) {
+	       && num_iterations++ < MAX_ITERATIONS) {
 		struct pcep_object_tlv_header *sub_tlv =
 			pcep_decode_tlv(tlv_body_buf + buf_index);
 		if (sub_tlv == NULL) {
diff --git a/pceplib/pcep_msg_tools.c b/pceplib/pcep_msg_tools.c
index 1d157ec3f5..e190d2a850 100644
--- a/pceplib/pcep_msg_tools.c
+++ b/pceplib/pcep_msg_tools.c
@@ -93,11 +93,11 @@ static const char *object_class_strs[] = {"NOT_IMPLEMENTED0",
 double_linked_list *pcep_msg_read(int sock_fd)
 {
 	int ret;
-	uint8_t buffer[PCEP_MAX_SIZE] = {0};
+	uint8_t buffer[PCEP_MESSAGE_LENGTH] = {0};
 	uint16_t buffer_read = 0;
 
 
-	ret = read(sock_fd, &buffer, PCEP_MAX_SIZE);
+	ret = read(sock_fd, &buffer, PCEP_MESSAGE_LENGTH);
 
 	if (ret < 0) {
 		pcep_log(
@@ -114,13 +114,13 @@ double_linked_list *pcep_msg_read(int sock_fd)
 	double_linked_list *msg_list = dll_initialize();
 	struct pcep_message *msg = NULL;
 
-	while ((ret - buffer_read) >= MESSAGE_HEADER_LENGTH) {
+	while (((uint16_t)ret - buffer_read) >= MESSAGE_HEADER_LENGTH) {
 
 		/* Get the Message header, validate it, and return the msg
 		 * length */
-		int32_t msg_hdr_length =
+		int32_t msg_length =
 			pcep_decode_validate_msg_header(buffer + buffer_read);
-		if (msg_hdr_length < 0) {
+		if (msg_length < 0 || msg_length > PCEP_MESSAGE_LENGTH) {
 			/* If the message header is invalid, we cant keep
 			 * reading since the length may be invalid */
 			pcep_log(
@@ -130,17 +130,26 @@ double_linked_list *pcep_msg_read(int sock_fd)
 			return msg_list;
 		}
 
-		/* Check if the msg_hdr_length is longer than what was read,
+		/* Check if the msg_length is longer than what was read,
 		 * in which case, we need to read the rest of the message. */
-		if ((ret - buffer_read) < msg_hdr_length) {
-			int read_len = (msg_hdr_length - (ret - buffer_read));
+		if ((ret - buffer_read) < msg_length) {
+			int read_len = (msg_length - (ret - buffer_read));
 			int read_ret = 0;
 			pcep_log(
 				LOG_INFO,
 				"%s: pcep_msg_read: Message not fully read! Trying to read %d bytes more, fd [%d]",
 				__func__, read_len, sock_fd);
 
-			read_ret = read(sock_fd, &buffer[ret], read_len);
+			if (PCEP_MESSAGE_LENGTH - ret - buffer_read >= read_len )
+				read_ret =
+					read(sock_fd, &buffer[ret], read_len);
+			else {
+				pcep_log(
+					LOG_ERR,
+					"%s: Trying to read size (%d) offset (%d) in a buff of size (%d)",
+					__func__, read_len, ret, PCEP_MESSAGE_LENGTH);
+				return msg_list;
+			}
 
 			if (read_ret != read_len) {
 				pcep_log(
@@ -152,7 +161,7 @@ double_linked_list *pcep_msg_read(int sock_fd)
 		}
 
 		msg = pcep_decode_message(buffer + buffer_read);
-		buffer_read += msg_hdr_length;
+		buffer_read += msg_length;
 
 		if (msg == NULL) {
 			return msg_list;
@@ -459,7 +468,12 @@ int pcep_msg_send(int sock_fd, struct pcep_message *msg)
 	if (msg == NULL) {
 		return 0;
 	}
+	int msg_length = ntohs(msg->encoded_message_length);
+	if (msg_length > PCEP_MESSAGE_LENGTH) {
+		pcep_log(LOG_ERR, "%s: Not sended, size(% d) exceed max(% d) ",
+			 __func__, msg_length, PCEP_MESSAGE_LENGTH);
+		return 0;
+	}
 
-	return write(sock_fd, msg->encoded_message,
-		     ntohs(msg->encoded_message_length));
+	return write(sock_fd, msg->encoded_message, msg_length);
 }
diff --git a/pceplib/pcep_pcc.c b/pceplib/pcep_pcc.c
index 2171f883cd..1a702a8b63 100644
--- a/pceplib/pcep_pcc.c
+++ b/pceplib/pcep_pcc.c
@@ -273,6 +273,7 @@ void send_pce_report_message(pcep_session *session)
 		pcep_log(LOG_WARNING,
 			 "%s: send_pce_report_message SRP object was NULL",
 			 __func__);
+			dll_destroy_with_data(report_list);
 		return;
 	}
 	dll_append(report_list, obj);
@@ -313,6 +314,7 @@ void send_pce_report_message(pcep_session *session)
 		pcep_log(LOG_WARNING,
 			 "%s: send_pce_report_message LSP object was NULL",
 			 __func__);
+			dll_destroy_with_data(report_list);
 		return;
 	}
 	dll_append(report_list, obj);
@@ -349,6 +351,7 @@ void send_pce_report_message(pcep_session *session)
 		pcep_log(LOG_WARNING,
 			 "%s: send_pce_report_message ERO object was NULL",
 			 __func__);
+			dll_destroy_with_data(report_list);
 		return;
 	}
 	dll_append(report_list, obj);
diff --git a/pceplib/pcep_session_logic.c b/pceplib/pcep_session_logic.c
index 5e4dae4900..52655914c6 100644
--- a/pceplib/pcep_session_logic.c
+++ b/pceplib/pcep_session_logic.c
@@ -61,7 +61,6 @@ static bool run_session_logic_common()
 	memset(session_logic_handle_, 0, sizeof(pcep_session_logic_handle));
 
 	session_logic_handle_->active = true;
-	session_logic_handle_->session_logic_condition = false;
 	session_logic_handle_->session_list =
 		ordered_list_initialize(pointer_compare_function);
 	session_logic_handle_->session_event_queue = queue_initialize();
@@ -91,6 +90,11 @@ static bool run_session_logic_common()
 		return false;
 	}
 
+	pthread_mutex_lock(&(session_logic_handle_->session_logic_mutex));
+	session_logic_handle_->session_logic_condition = true;
+	pthread_cond_signal(&(session_logic_handle_->session_logic_cond_var));
+	pthread_mutex_unlock(&(session_logic_handle_->session_logic_mutex));
+
 	if (pthread_mutex_init(&(session_logic_handle_->session_list_mutex),
 			       NULL)
 	    != 0) {
@@ -574,24 +578,20 @@ struct pcep_message *create_pcep_open(pcep_session *session)
 		dll_append(
 			tlv_list,
 			pcep_tlv_create_stateful_pce_capability(
+				/* U flag */
 				session->pcc_config
-					.support_stateful_pce_lsp_update, /* U
-									     flag
-									   */
-				session->pcc_config
-					.support_include_db_version, /* S flag
-								      */
-				session->pcc_config
-					.support_lsp_triggered_resync, /* T flag
-									*/
-				session->pcc_config
-					.support_lsp_delta_sync, /* D flag */
-				session->pcc_config
-					.support_pce_triggered_initial_sync, /* F flag */
+					.support_stateful_pce_lsp_update,
+				/* S flag */
+				session->pcc_config.support_include_db_version,
+				/* I flag */
 				session->pcc_config
-					.support_pce_lsp_instantiation)); /* I
-									     flag
-									   */
+					.support_pce_lsp_instantiation,
+			/* T flag */
+			session->pcc_config.support_lsp_triggered_resync,
+			/* D flag */
+			session->pcc_config.support_lsp_delta_sync,
+			/* F flag */
+			session->pcc_config.support_pce_triggered_initial_sync));
 	}
 
 	if (session->pcc_config.support_include_db_version) {
diff --git a/pceplib/pcep_session_logic_loop.c b/pceplib/pcep_session_logic_loop.c
index 5705ff2000..269aa1e07e 100644
--- a/pceplib/pcep_session_logic_loop.c
+++ b/pceplib/pcep_session_logic_loop.c
@@ -98,6 +98,7 @@ int session_logic_msg_ready_handler(void *data, int socket_fd)
 	} else if (msg_list->num_entries == 0) {
 		/* Invalid message received */
 		increment_unknown_message(session);
+		dll_destroy_with_data(msg_list);
 	} else {
 		/* Just logging the first of potentially several messages
 		 * received */
diff --git a/pceplib/pcep_session_logic_states.c b/pceplib/pcep_session_logic_states.c
index e2c3c29591..3beceefad0 100644
--- a/pceplib/pcep_session_logic_states.c
+++ b/pceplib/pcep_session_logic_states.c
@@ -24,6 +24,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
+#include <assert.h>
 
 #include "pcep_msg_encoding.h"
 #include "pcep_session_logic.h"
@@ -461,6 +462,8 @@ void send_reconciled_pcep_open(pcep_session *session,
 	struct pcep_object_open *open_obj =
 		(struct pcep_object_open *)pcep_obj_get(open_msg->obj_list,
 							PCEP_OBJ_CLASS_OPEN);
+	// open_msg can not have empty obj_list
+	assert(open_obj != NULL);
 
 	if (error_open_obj->open_deadtimer
 	    != session->pce_config.dead_timer_seconds) {
diff --git a/pceplib/pcep_socket_comm_loop.c b/pceplib/pcep_socket_comm_loop.c
index 8346c93025..d58409c4f3 100644
--- a/pceplib/pcep_socket_comm_loop.c
+++ b/pceplib/pcep_socket_comm_loop.c
@@ -26,6 +26,7 @@
 #include <stddef.h>
 #include <string.h>
 #include <unistd.h>
+#include <assert.h>
 
 #include "pcep_socket_comm_internals.h"
 #include "pcep_socket_comm_loop.h"
@@ -129,6 +130,9 @@ int build_fd_sets(pcep_socket_comm_handle *socket_comm_handle)
 		comm_session = (pcep_socket_comm_session *)node->data;
 		if (comm_session->socket_fd > max_fd) {
 			max_fd = comm_session->socket_fd;
+		} else if (comm_session->socket_fd < 0) {
+			pcep_log(LOG_ERR, "%s: Negative fd", __func__);
+			assert(comm_session->socket_fd > 0);
 		}
 
 		/*pcep_log(LOG_DEBUG, ld] socket_comm::build_fdSets set
@@ -147,6 +151,9 @@ int build_fd_sets(pcep_socket_comm_handle *socket_comm_handle)
 		comm_session = (pcep_socket_comm_session *)node->data;
 		if (comm_session->socket_fd > max_fd) {
 			max_fd = comm_session->socket_fd;
+		} else if (comm_session->socket_fd < 0) {
+			pcep_log(LOG_ERR, "%s: Negative fd", __func__);
+			assert(comm_session->socket_fd > 0);
 		}
 
 		/*pcep_log(LOG_DEBUG, "%s: [%ld] socket_comm::build_fdSets set
diff --git a/pceplib/test/pcep_msg_messages_test.c b/pceplib/test/pcep_msg_messages_test.c
index 10b678bcec..b8984a42bc 100644
--- a/pceplib/test/pcep_msg_messages_test.c
+++ b/pceplib/test/pcep_msg_messages_test.c
@@ -111,7 +111,7 @@ void test_pcep_msg_create_request()
 	/* Test IPv4 */
 	struct pcep_object_rp *rp_obj =
 		pcep_obj_create_rp(0, false, false, false, false, 10, NULL);
-	struct in_addr src_addr, dst_addr;
+	struct in_addr src_addr={}, dst_addr={};
 	struct pcep_object_endpoints_ipv4 *ipv4_obj =
 		pcep_obj_create_endpoint_ipv4(&src_addr, &dst_addr);
 	message = pcep_msg_create_request(rp_obj, ipv4_obj, NULL);
@@ -375,6 +375,10 @@ void test_pcep_msg_create_update()
 	/* Should return NULL if obj_list is empty */
 	message = pcep_msg_create_update(obj_list);
 	CU_ASSERT_PTR_NULL(message);
+	if (message != NULL) {
+		pcep_msg_free_message(message);
+		message = NULL;
+	}
 
 	struct pcep_object_srp *srp = pcep_obj_create_srp(false, 100, NULL);
 	struct pcep_object_lsp *lsp =
@@ -390,6 +394,10 @@ void test_pcep_msg_create_update()
 	CU_ASSERT_PTR_NULL(message);
 
 	dll_append(obj_list, ero);
+	if (message != NULL) {
+		pcep_msg_free_message(message);
+		message = NULL;
+	}
 	message = pcep_msg_create_update(obj_list);
 	CU_ASSERT_PTR_NOT_NULL(message);
 	pcep_encode_message(message, versioning);
@@ -416,6 +424,10 @@ void test_pcep_msg_create_initiate()
 	/* Should return NULL if obj_list is empty */
 	struct pcep_message *message = pcep_msg_create_initiate(NULL);
 	CU_ASSERT_PTR_NULL(message);
+	if (message != NULL) {
+		pcep_msg_free_message(message);
+		message = NULL;
+	}
 
 	struct pcep_object_srp *srp = pcep_obj_create_srp(false, 100, NULL);
 	struct pcep_object_lsp *lsp =
@@ -428,6 +440,10 @@ void test_pcep_msg_create_initiate()
 	dll_append(obj_list, srp);
 	message = pcep_msg_create_initiate(obj_list);
 	CU_ASSERT_PTR_NULL(message);
+	if (message != NULL) {
+		pcep_msg_free_message(message);
+		message = NULL;
+	}
 
 	dll_append(obj_list, lsp);
 	dll_append(obj_list, ero);
diff --git a/pceplib/test/pcep_msg_tlvs_test.c b/pceplib/test/pcep_msg_tlvs_test.c
index 878e4d62af..6b650f6823 100644
--- a/pceplib/test/pcep_msg_tlvs_test.c
+++ b/pceplib/test/pcep_msg_tlvs_test.c
@@ -106,6 +106,10 @@ void test_pcep_tlv_create_speaker_entity_id()
 	double_linked_list *list = dll_initialize();
 	tlv = pcep_tlv_create_speaker_entity_id(list);
 	CU_ASSERT_PTR_NULL(tlv);
+	if (tlv != NULL) {
+		pceplib_free(PCEPLIB_INFRA, tlv);
+		tlv = NULL;
+	}
 
 	uint32_t *speaker_entity =
 		pceplib_malloc(PCEPLIB_MESSAGES, sizeof(uint32_t));
@@ -172,16 +176,28 @@ void test_pcep_tlv_create_path_setup_type_capability()
 	double_linked_list *pst_list = dll_initialize();
 	tlv = pcep_tlv_create_path_setup_type_capability(pst_list, NULL);
 	CU_ASSERT_PTR_NULL(tlv);
+	if (tlv != NULL) {
+		pcep_obj_free_tlv(&tlv->header);
+		tlv = NULL;
+	}
 
 	/* Should still return NULL if pst_list is NULL */
 	double_linked_list *sub_tlv_list = dll_initialize();
 	tlv = pcep_tlv_create_path_setup_type_capability(NULL, sub_tlv_list);
 	CU_ASSERT_PTR_NULL(tlv);
+	if (tlv != NULL) {
+		pcep_obj_free_tlv(&tlv->header);
+		tlv = NULL;
+	}
 
 	/* Should still return NULL if pst_list is empty */
 	tlv = pcep_tlv_create_path_setup_type_capability(pst_list,
 							 sub_tlv_list);
 	CU_ASSERT_PTR_NULL(tlv);
+	if (tlv != NULL) {
+		pcep_obj_free_tlv(&tlv->header);
+		tlv = NULL;
+	}
 
 	/* Test only populating the pst list */
 	uint8_t *pst1 = pceplib_malloc(PCEPLIB_MESSAGES, 1);
@@ -196,6 +212,10 @@ void test_pcep_tlv_create_path_setup_type_capability()
 	tlv = pcep_tlv_create_path_setup_type_capability(pst_list,
 							 sub_tlv_list);
 	CU_ASSERT_PTR_NOT_NULL(tlv);
+	if (tlv == NULL) {
+		CU_ASSERT_TRUE(tlv != NULL);
+		return;
+	}
 
 	pcep_encode_tlv(&tlv->header, versioning, tlv_buf);
 	CU_ASSERT_EQUAL(tlv->header.type,
diff --git a/pceplib/test/pcep_msg_tools_test.c b/pceplib/test/pcep_msg_tools_test.c
index a1260b1186..ff5fc62390 100644
--- a/pceplib/test/pcep_msg_tools_test.c
+++ b/pceplib/test/pcep_msg_tools_test.c
@@ -24,6 +24,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
 
 #include <CUnit/CUnit.h>
 
@@ -164,7 +167,15 @@ void pcep_tools_test_teardown(void)
 int convert_hexstrs_to_binary(const char *hexbyte_strs[],
 			      uint16_t hexbyte_strs_length)
 {
-	int fd = fileno(tmpfile());
+	mode_t oldumask;
+	oldumask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH);
+	/* Set umask before anything for security */
+	umask(0027);
+	char tmpfile[] = "/tmp/pceplib_XXXXXX";
+	int fd = mkstemp(tmpfile);
+	umask(oldumask);
+	if (fd == -1)
+		return -1;
 
 	int i = 0;
 	for (; i < hexbyte_strs_length; i++) {
@@ -192,6 +203,10 @@ void test_pcep_msg_read_pcep_initiate()
 {
 	int fd = convert_hexstrs_to_binary(pcep_initiate_hexbyte_strs,
 					   pcep_initiate_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 1);
@@ -287,6 +302,10 @@ void test_pcep_msg_read_pcep_initiate2()
 {
 	int fd = convert_hexstrs_to_binary(pcep_initiate2_hexbyte_strs,
 					   pcep_initiate2_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 1);
@@ -370,6 +389,10 @@ void test_pcep_msg_read_pcep_open()
 {
 	int fd = convert_hexstrs_to_binary(pcep_open_odl_hexbyte_strs,
 					   pcep_open_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 1);
@@ -410,6 +433,10 @@ void test_pcep_msg_read_pcep_update()
 {
 	int fd = convert_hexstrs_to_binary(pcep_update_hexbyte_strs,
 					   pcep_update_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 1);
@@ -488,6 +515,10 @@ void test_pcep_msg_read_pcep_open_initiate()
 	int fd = convert_hexstrs_to_binary(
 		pcep_open_initiate_odl_hexbyte_strs,
 		pcep_open_initiate_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 2);
@@ -513,6 +544,10 @@ void test_pcep_msg_read_pcep_open_cisco_pce()
 	int fd = convert_hexstrs_to_binary(
 		pcep_open_cisco_pce_hexbyte_strs,
 		pcep_open_cisco_pce_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 1);
@@ -571,6 +606,10 @@ void test_pcep_msg_read_pcep_update_cisco_pce()
 	int fd = convert_hexstrs_to_binary(
 		pcep_update_cisco_pce_hexbyte_strs,
 		pcep_update_cisco_pce_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 1);
@@ -708,6 +747,10 @@ void test_pcep_msg_read_pcep_report_cisco_pcc()
 	int fd = convert_hexstrs_to_binary(
 		pcep_report_cisco_pcc_hexbyte_strs,
 		pcep_report_cisco_pcc_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 1);
@@ -863,6 +906,10 @@ void test_pcep_msg_read_pcep_initiate_cisco_pcc()
 	int fd = convert_hexstrs_to_binary(
 		pcep_initiate_cisco_pcc_hexbyte_strs,
 		pcep_initiate_cisco_pcc_hexbyte_strs_length);
+	if(fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	double_linked_list *msg_list = pcep_msg_read(fd);
 	CU_ASSERT_PTR_NOT_NULL(msg_list);
 	CU_ASSERT_EQUAL(msg_list->num_entries, 1);
diff --git a/pceplib/test/pcep_session_logic_loop_test.c b/pceplib/test/pcep_session_logic_loop_test.c
index 38fabd4ccd..3a40f59bb9 100644
--- a/pceplib/test/pcep_session_logic_loop_test.c
+++ b/pceplib/test/pcep_session_logic_loop_test.c
@@ -25,6 +25,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 
 #include <CUnit/CUnit.h>
 
@@ -70,7 +72,6 @@ void pcep_session_logic_loop_test_setup()
 		PCEPLIB_INFRA, sizeof(pcep_session_logic_handle));
 	memset(session_logic_handle_, 0, sizeof(pcep_session_logic_handle));
 	session_logic_handle_->active = true;
-	session_logic_handle_->session_logic_condition = false;
 	session_logic_handle_->session_list =
 		ordered_list_initialize(pointer_compare_function);
 	session_logic_handle_->session_event_queue = queue_initialize();
@@ -79,6 +80,11 @@ void pcep_session_logic_loop_test_setup()
 	pthread_mutex_init(&(session_logic_handle_->session_logic_mutex), NULL);
 	pthread_mutex_init(&(session_logic_handle_->session_list_mutex), NULL);
 
+	pthread_mutex_lock(&(session_logic_handle_->session_logic_mutex));
+	session_logic_handle_->session_logic_condition = true;
+	pthread_cond_signal(&(session_logic_handle_->session_logic_cond_var));
+	pthread_mutex_unlock(&(session_logic_handle_->session_logic_mutex));
+
 	session_logic_event_queue_ =
 		pceplib_malloc(PCEPLIB_INFRA, sizeof(pcep_event_queue));
 	memset(session_logic_event_queue_, 0, sizeof(pcep_event_queue));
@@ -128,7 +134,17 @@ void test_session_logic_msg_ready_handler()
 
 	/* Read from an empty file should return 0, thus
 	 * session_logic_msg_ready_handler returns -1 */
-	int fd = fileno(tmpfile());
+	mode_t oldumask;
+	oldumask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH);
+	/* Set umask before anything for security */
+	umask(0027);
+	char tmpfile[] = "/tmp/pceplib_XXXXXX";
+	int fd = mkstemp(tmpfile);
+	umask(oldumask);
+	if (fd == -1){
+		CU_ASSERT_TRUE(fd>=0);
+		return;
+	}
 	pcep_session session;
 	memset(&session, 0, sizeof(pcep_session));
 	session.session_id = 100;
diff --git a/pceplib/test/pcep_timers_event_loop_test.c b/pceplib/test/pcep_timers_event_loop_test.c
index 9fcacaf0f2..ae63601df2 100644
--- a/pceplib/test/pcep_timers_event_loop_test.c
+++ b/pceplib/test/pcep_timers_event_loop_test.c
@@ -130,7 +130,9 @@ void test_walk_and_process_timers_timer_expired()
 	timer->data = timer;
 	// Set the timer to expire 10 seconds ago
 	timer->expire_time = time(NULL) - 10;
+	pthread_mutex_lock(&test_timers_context->timer_list_lock);
 	timer->timer_id = TEST_EVENT_LOOP_TIMER_ID;
+	pthread_mutex_unlock(&test_timers_context->timer_list_lock);
 	ordered_list_add_node(test_timers_context->timer_list, timer);
 
 	walk_and_process_timers(test_timers_context);